细节调整及优化（26.8.3）

# Conflicts:
#	README.md

.gitignore

@@ -7,6 +7,9 @@ yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
 
+# 发布暂存目录
+release_stage/
+
 node_modules
 dist
 dist-ssr

AI_DEV_GUIDE.md

@@ -315,11 +315,11 @@ const status = processStore.getProcessStatus('proxy')
 
 | 命令 | 参数 | 返回值 |
 |------|------|--------|
-| `start_process` | `StartProcessParams` | `ProcessInfo` |
-| `stop_process` | `id: String` | `()` |
-| `get_process_status` | `id: String` | `Option<ProcessInfo>` |
-| `get_all_process_status` | - | `Vec<ProcessInfo>` |
-| `stop_all_processes` | - | `()` |
+| `process_start` | `StartProcessParams` | `ProcessInfo` |
+| `process_stop` | `id: String` | `()` |
+| `process_status` | `id: String` | `Option<ProcessInfo>` |
+| `process_all_status` | - | `Vec<ProcessInfo>` |
+| `process_stop_all` | - | `()` |
 
 ### 事件
 
@@ -388,8 +388,8 @@ rusqlite = { version = "0.30", features = ["bundled"] }
 
 ### Rust 调试
 
-- 使用 `println!()` 输出到终端
-- 使用 `dbg!()` 宏调试变量
+- 使用 `crate::logger::log_info / log_warn / log_error`（或 `log_line`）写入统一日志文件，日志页面可过滤级别
+- 使用 `dbg!()` 宏调试变量（仅临时，提交前删除）
 - 使用 Visual Studio Code 的 Rust 调试插件
 
 ### 构建问题排查

MODULE_DEV_GUIDE.md

@@ -397,7 +397,7 @@ thread::spawn(move || {
 
 ### 后端：内核/二进制下载用流式 + 事件推送
 
-`mihomo_manager.rs` 的 `install_kernel` 确立了"下载二进制资源"的标准模式，未来若有其他模块需要下载外部内核时应复用：
+`mihomo_manager/` 目录（`kernel.rs`）的 `install_kernel` 确立了"下载二进制资源"的标准模式，未来若有其他模块需要下载外部内核时应复用：
 
 - **流式下载**：`reqwest::Response::bytes_stream()` + `futures_util::StreamExt`，避免大文件一次性读入内存
 - **进度事件**：通过 `app.emit("xxx-install-progress", progress)` 推送，事件载荷结构参考 `InstallProgress`
@@ -492,13 +492,13 @@ TitleBar 的关闭按钮实际是 `hide()` 到托盘。webview 快速隐藏时
 
 ### 前端：浮动标签切换器（TabsList 滚动遮挡时在 TitleBar 显示）
 
-模块详情页内容滚动时，顶部 `TabsList` 会被 `TitleBar` 遮挡，导致用户必须滚回顶部才能切换 Tab。已抽取通用 composable `src/lib/useModuleTabs.ts` 自动处理。
+模块详情页内容滚动时，顶部 `TabsList` 会被 `TitleBar` 遮挡，导致用户必须滚回顶部才能切换 Tab。已抽取通用 composable `src/lib/use-module-tabs.ts` 自动处理。
 
 **接入方式**（任何使用 Tabs 的模块都可用，代理/下载器模块已接入）：
 
 ```ts
 // 模块 <script setup> 顶部
-import { useModuleTabs } from '@/lib/useModuleTabs'
+import { useModuleTabs } from '@/lib/use-module-tabs'
 
 const activeTab = ref('overview')
 const tabsListRef = useModuleTabs(activeTab, [
@@ -613,11 +613,6 @@ const formatEta = (seconds: number): string => {
 
 下载任务工具栏的速度/活跃/等待/已完成数量，以及代理概览页的内核状态/版本，从纯文本改为 `Badge variant="secondary"` 或带颜色的 `Badge`（绿色已安装/红色未安装），视觉更醒目。新模块的状态展示建议统一用 Badge。
 
-### 后端：应用退出清理必须覆盖所有退出路径
+### 后端：应用退出清理（单一出口）
 
-`lib.rs` 中应用退出有两种触发路径，**都要**调用 `cleanup_on_exit` + `stop_all`：
-
-1. `quit_app` Tauri 命令（前端 `appWindow.destroy()` 触发）
-2. 系统托盘的退出菜单项
-
-漏掉任何一个都会导致子进程残留（如 mihomo 继续占用端口、系统代理未清除）。新增管理子进程的模块时，检查这两处是否都调用了清理逻辑。
+退出清理已收敛到 `lib.rs` 的 `RunEvent::ExitRequested` 分支（P0-1/V7）：`quit_app` 命令与托盘退出项都只触发 `app.exit(0)`，清理逻辑（`cleanup_on_exit` + `stop_all`）只在该分支执行一次。新增管理子进程的模块时，在 `ExitRequested` 分支注册自己的 `cleanup_on_exit` 即可，不要在命令或托盘路径重复清理。

README.md

@@ -23,15 +23,15 @@ Thing/
 │   ├── components/            # 通用组件
 │   │   ├── layout/            # 布局组件（TitleBar、Sidebar、ModuleContainer）
 │   │   └── ui/                # shadcn-vue UI 组件
-│   ├── lib/                   # 工具库（logger、useModuleTabs、utils）
+│   ├── lib/                   # 工具库（logger、use-module-tabs、calc、constants）
 │   ├── modules/               # 功能模块（每个模块含 index.ts 配置 + Vue 组件）
 │   │   ├── proxy/             # 代理管理模块
 │   │   ├── clipboard/         # 剪贴板增强模块
 │   │   ├── screenshot/        # 截图模块
 │   │   ├── monitor/           # 硬件监控模块
 │   │   ├── downloader/        # 下载器模块
-│   │   ├── finder/            # 文件搜索模块
-│   │   ├── general/           # 通用设置模块
+│   │   ├── quickpanel/        # 快速面板模块（含 providers/ 搜索提供器目录）
+│   │   ├── settings/          # 通用设置模块
 │   │   ├── icons.ts           # 模块图标映射
 │   │   ├── index.ts           # 模块聚合入口
 │   │   └── registry.ts        # 模块注册表单例
@@ -46,12 +46,22 @@ Thing/
 │   ├── icons/                 # 应用图标
 │   ├── resources/             # 打包资源（浏览器扩展等）
 │   ├── src/
-│   │   ├── download_engine/   # 下载引擎（进程内自建，含 engine/storage/http_dl/server 等）
-│   │   ├── logger.rs          # 日志系统
-│   │   ├── mihomo_manager.rs  # mihomo 内核管理（代理模块后端）
+│   │   ├── clipboard/         # 剪贴板模块（reader/monitor/storage/popup）
+│   │   ├── download_engine/   # 下载引擎（进程内自建，含 engine/storage/http_dl 等）
+│   │   ├── mihomo_manager/    # mihomo 内核管理（mod/kernel/profiles/system_proxy/commands 等）
+│   │   ├── quickpanel/        # 快速面板后端（commands/file_index/icon_extractor）
+│   │   ├── screenshot/        # 截图后端（capture/commands）
+│   │   ├── constants.rs       # 双端常量（窗口 label / 事件名）
+│   │   ├── logger.rs          # 日志系统（进程级全局日志器）
+│   │   ├── monitor_kernel.rs  # 硬件监控内核（SSE 订阅）
+│   │   ├── network_monitor.rs # 网速监控
+│   │   ├── osd_window.rs      # OSD 悬浮窗
 │   │   ├── process_manager.rs # 子进程统一管理
+│   │   ├── setup.rs           # 应用初始化
+│   │   ├── tray_menu.rs       # 系统托盘
+│   │   ├── win32_util.rs      # Win32 屏幕/DPI 工具
 │   │   ├── main.rs            # Rust 入口
-│   │   └── lib.rs             # Rust 库入口（命令注册、应用初始化）
+│   │   └── lib.rs             # Rust 库入口（命令注册、事件循环）
 │   ├── Cargo.toml             # Rust 依赖配置
 │   └── tauri.conf.json        # Tauri 配置
 ├── package.json               # 前端依赖配置
@@ -90,7 +100,7 @@ Thing/
 #### 📸 截图
 - [x] 截图及相关
 - [ ] 滚动截图（后续支持）
-- [ ] 贴图（后续支持）
+- [x] 贴图
 
 #### 📊 硬件监控
 - [x] 悬浮窗显示
@@ -108,18 +118,17 @@ Thing/
 
 #### 🔍 快速面板
 - [x] 全局弹窗（快捷键触发）
-- [x] 全局搜索：拼音模糊匹配，正则表达式支持。支持：程序，文件，文件夹，设置项，最近使用，历史命令（全量考虑，不好实现或无法实现则忽略）
-- [x] 快捷命令（例：shutdown,hosts）
-- [x] 计算器 / 转换器（数学表达式，单位转换，时间转换，进制转换）
-- [ ] 后续可能需求的大量快速、便捷入口可能性（开发者利好功能）
+- [x] 全局搜索：拼音模糊匹配，正则表达式支持。支持：程序，文件，文件夹，设置项，最近使用，历史命令
+- [x] 快捷命令（例：shutdown, hosts）
+- [x] 计算器 / 单位换算（数学表达式、单位/货币换算；时间转换、进制转换后续支持）
 
 ### 第三阶段：优化与完善
 
-- [ ] 性能优化
-- [ ] 错误处理与日志完善
-- [ ] 用户体验优化
-- [ ] 自动更新机制
-- [ ] 打包发布
+- [x] 性能优化（P1/P2：轮询随窗口可见性暂停、批量测速限并发、渲染 memo 化等，见 MODULE_REVIEW.md）
+- [x] 错误处理与日志完善（B5 进程级全局日志器、异常兜底）
+- [x] 用户体验优化（混合 DPI 定位、rAF 节流、UI 细节）
+- [x] 自动更新机制
+- [x] 打包发布
 
 ## 模块管理架构
 

ThingHK/HardwareManager.cs

@@ -24,6 +24,9 @@ internal sealed class HardwareManager : IDisposable
     private readonly bool _isAdmin;
     private readonly double _coldStartMs;
     private readonly Stopwatch _startupSw;
+    // 传感器 ID 缓存：避免每秒为每个传感器重复拼接字符串（减少 GC 压力）
+    private readonly Dictionary<ISensor, string> _sensorIdCache = new();
+    private bool _coldStartSent;
     private bool _ready;
     private bool _closed;
     private HardwareConfig _config;
@@ -84,7 +87,7 @@ internal sealed class HardwareManager : IDisposable
 
     /// <summary>
     /// 全量 Update 所有硬件。
-    /// 由 SamplingScheduler 按通道分频调用。
+    /// 仅用于构造函数首轮填充，运行期由调度器分频调用 UpdateFastOnly/UpdateSlowOnly。
     /// </summary>
     public void UpdateAll()
     {
@@ -94,9 +97,24 @@ internal sealed class HardwareManager : IDisposable
         }
     }
 
+    /// <summary>
+    /// 仅 Update 快通道硬件（CPU/GPU/Memory/Network 等）。
+    /// 由调度器快通道 tick 高频调用，避免 SMART 等重查询拖慢采样节奏。
+    /// </summary>
+    public void UpdateFastOnly()
+    {
+        foreach (var hw in _visitor.AllHardware)
+        {
+            if (!IsSlowHardware(hw.HardwareType))
+            {
+                try { hw.Update(); } catch { /* 单个硬件 Update 失败不影响整体 */ }
+            }
+        }
+    }
+
     /// <summary>
     /// 仅 Update 慢通道硬件（Storage/PSU/Battery 等）。
-    /// 快通道硬件（CPU/GPU/Memory/Network）由调度器更高频调用 UpdateAll。
+    /// 快通道硬件（CPU/GPU/Memory/Network）由调度器更高频调用 UpdateFastOnly。
     /// </summary>
     public void UpdateSlowOnly()
     {
@@ -123,10 +141,11 @@ internal sealed class HardwareManager : IDisposable
             Ready = _ready,
         };
 
-        // 首个快照带上冷启动耗时，后续为 0
-        if (_coldStartMs > 0 && snap.Timestamp > 0)
+        // 首个快照带上冷启动耗时，后续为 0（修复：此前每个快照都携带 ColdStartMs）
+        if (_coldStartMs > 0 && !_coldStartSent)
         {
             snap.ColdStartMs = Math.Round(_coldStartMs, 1);
+            _coldStartSent = true;
         }
 
         // 重新遍历以读取最新传感器值（visitor 缓存的是 hardware 引用，sensor 值实时）
@@ -156,7 +175,7 @@ internal sealed class HardwareManager : IDisposable
 
                 g.Sensors.Add(new SensorEntry
                 {
-                    Id = $"{groupId}/{hw.Name}/{s.SensorType}/{s.Name}".Replace(' ', '_').ToLowerInvariant(),
+                    Id = GetSensorId(s, groupId, hw.Name),
                     Name = s.Name,
                     Type = sensorType,
                     Value = s.Value,
@@ -169,6 +188,21 @@ internal sealed class HardwareManager : IDisposable
         return snap;
     }
 
+    /// <summary>
+    /// 获取传感器稳定 ID（带缓存）。
+    /// ID 格式：{groupId}/{hwName}/{sensorType}/{sensorName}，空格转下划线、小写化。
+    /// 缓存命中直接返回，未命中（新传感器）计算后入缓存。
+    /// </summary>
+    private string GetSensorId(ISensor s, string groupId, string hwName)
+    {
+        if (!_sensorIdCache.TryGetValue(s, out var id))
+        {
+            id = $"{groupId}/{hwName}/{s.SensorType}/{s.Name}".Replace(' ', '_').ToLowerInvariant();
+            _sensorIdCache[s] = id;
+        }
+        return id;
+    }
+
     /// <summary>
     /// 为已启用但 LHB 未枚举到的硬件类型预创建空分组。
     /// 场景：用户在设置中勾选了主板/电池/电源等，但 LHB 在当前权限或机型下检测不到对应硬件，
@@ -290,14 +324,14 @@ internal sealed class SnapshotVisitor : IVisitor
 }
 
 /// <summary>
-/// 采样调度器：按快/慢通道分频驱动 HardwareManager.UpdateAll。
+/// 采样调度器：按快/慢通道分频驱动 HardwareManager 的分层 Update。
 /// 使用 Channel 向 SSE 推送层广播快照（解耦：调度器不关心有几个订阅者）。
 ///
 /// 调度策略：
-/// - 快通道 tick：UpdateAll（含慢通道硬件，因 UpdateAll 成本主要在 SMART，已通过慢通道分频减少调用频率）
-///   实际优化：快通道 tick 只 Update 快通道硬件（UpdateFastOnly），慢通道单独按慢节奏 Update
+/// - 快通道 tick：UpdateFastOnly（仅 CPU/GPU/Memory/Network 等轻量硬件），
+///   避免 SMART 等重查询每秒执行拖慢采样节奏
 /// - 慢通道 tick：UpdateSlowOnly（仅 Storage/PSU/Motherboard 等）
-/// - 每个 tick 结束后构建快照并广播
+/// - 快通道每个 tick 结束后构建快照并广播（慢通道更新后的值随下一帧带出）
 /// </summary>
 internal sealed class SamplingScheduler : IDisposable
 {
@@ -352,7 +386,7 @@ internal sealed class SamplingScheduler : IDisposable
         {
             try
             {
-                _hw.UpdateAll();
+                _hw.UpdateFastOnly();
                 var snap = _hw.BuildSnapshot();
                 _cache.Update(snap);
                 _broadcast.Writer.TryWrite(snap);

package.json

@@ -1,12 +1,13 @@
 {
   "name": "thing",
   "private": true,
-  "version": "0.1.0",
+  "version": "26.8.2",
   "type": "module",
   "scripts": {
     "dev": "vite",
     "build": "vue-tsc --noEmit && vite build",
     "preview": "vite preview",
+    "test": "node --test src/modules/quickpanel/engine.test.ts src/lib/calc.test.ts",
     "tauri": "tauri"
   },
   "dependencies": {

scripts/release.bat

@@ -0,0 +1,61 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+set "SCRIPT=%~dp0release.ps1"
+
+echo ================================================
+echo   Thing Build Pubilsh
+echo   发布目标：https://gitea.atie.fun/LFeng/Thing
+echo ================================================
+echo.
+
+:: ---------- 版本号 ----------
+set "VERSION="
+set /p "VERSION=请输入版本号（如 26.8.1，直接回车沿用当前版本）: "
+set "VER_ARG="
+if not "%VERSION%"=="" set "VER_ARG=-Version %VERSION%"
+
+:: ---------- 发布模式 ----------
+echo.
+echo   [1] Build + Pubilsh Gitea
+echo   [2] Build Only
+echo   [3] Pubilsh Gitea
+set "MODE="
+set /p "MODE=请输入数字选择（回车默认 1）: "
+if "%MODE%"=="" set "MODE=1"
+
+set "EXTRA="
+if "%MODE%"=="2" (
+  set "EXTRA=-SkipPush"
+) else if "%MODE%"=="3" (
+  set "EXTRA=-SkipBuild"
+)
+
+:: ---------- Gitea Token（仅完整发布模式需要） ----------
+if "%MODE%"=="1" if not defined GITEA_TOKEN (
+  echo.
+  echo 未检测到环境变量 GITEA_TOKEN，上传到 Gitea 需要它。
+  echo 可在此临时输入（仅本次会话生效），留空则自动改为"只构建不上传"。
+  set /p "GITEA_TOKEN=请输入 Gitea Token: "
+  if "!GITEA_TOKEN!"=="" (
+    set "EXTRA=-SkipPush"
+    set "MODE=2"
+    echo [提示] 已切换为"只构建并整理产物，不上传"。
+  )
+)
+
+echo.
+echo Start：release.ps1 %VER_ARG% %EXTRA%
+echo ------------------------------------------------
+powershell -NoProfile -ExecutionPolicy Bypass -File "%SCRIPT%" %VER_ARG% %EXTRA%
+set "RESULT=%ERRORLEVEL%"
+
+echo.
+if "%RESULT%"=="0" (
+  echo 执行完成。
+) else (
+  echo 执行出错，请查看上方日志。
+)
+echo.
+pause

scripts/release.ps1

@@ -0,0 +1,166 @@
+# ============================================================
+# Thing 构建发布脚本（目标：自建 Gitea release）
+#
+# 用法：
+#   .\scripts\release.ps1 -Version 0.2.0                # 同步版本号 + 构建 + 发布
+#   .\scripts\release.ps1 -Version 0.2.0 -SkipBuild     # 复用现有构建产物，直接发布
+#   .\scripts\release.ps1 -Version 0.2.0 -SkipPush      # 只构建+整理产物，不上传
+#
+# 发布产物（上传到 https://gitea.atie.fun/LFeng/Thing 的 v{Version} release）：
+#   thing_{v}_x64.exe           便携免安装版（无内核）
+#   thing_{v}_x64.msi           安装版 MSI（去掉 tauri 默认的 _en-US 后缀）
+#   thing_{v}_x64-setup.exe     安装版 NSIS
+#   thing-hk_{v}.zip            ThingHK 硬件监控内核（mihomo 继续走代理模块内置的 GitHub 下载）
+#
+# 前提：
+#   - Gitea token 已配置为环境变量 GITEA_TOKEN（-SkipPush 时不需要）
+#   - 可选 -NotesPath 指定 release notes 文件（Markdown 文本），
+#     缺省时使用 scripts/release-notes.md（若存在），否则用简单占位文本
+# ============================================================
+
+param(
+  [string]$Version = '',
+  [switch]$SkipBuild,
+  [switch]$SkipPush,
+  [string]$NotesPath = ''
+)
+
+$ErrorActionPreference = 'Stop'
+
+$Root       = Split-Path -Parent $PSScriptRoot
+$TargetDir  = Join-Path $Root 'src-tauri\target\release'
+$BundleDir  = Join-Path $TargetDir 'bundle'
+$RepoOwner  = 'LFeng'
+$RepoName   = 'Thing'
+$ApiBase    = 'https://gitea.atie.fun/api/v1'
+$Product    = 'thing'
+
+function Write-Step([string]$msg) { Write-Host "`n==> $msg" -ForegroundColor Cyan }
+
+# ---------- 0. 版本号 ----------
+if ([string]::IsNullOrWhiteSpace($Version)) {
+  $conf = Get-Content (Join-Path $Root 'src-tauri\tauri.conf.json') -Raw | ConvertFrom-Json
+  $Version = $conf.version
+  Write-Step "未指定 -Version，沿用现有版本 $Version"
+}
+# 校验 X.Y.Z 格式
+if ($Version -notmatch '^\d+\.\d+\.\d+$') {
+  throw "版本号格式错误（应为 X.Y.Z）：$Version"
+}
+Write-Step "发布版本：v$Version"
+
+# ---------- 1. 同步版本号到三处 ----------
+$tauriConf = Join-Path $Root 'src-tauri\tauri.conf.json'
+$cargoToml = Join-Path $Root 'src-tauri\Cargo.toml'
+$pkgJson   = Join-Path $Root 'package.json'
+
+$t = Get-Content $tauriConf -Raw
+$t = $t -replace '("version"\s*:\s*")[^"]*(")', "`${1}$Version`${2}"
+[System.IO.File]::WriteAllText($tauriConf, $t, (New-Object System.Text.UTF8Encoding($false)))
+
+$c = Get-Content $cargoToml -Raw
+$c = $c -replace '(?m)^(version\s*=\s*")[^"]*(")', "`${1}$Version`${2}"
+[System.IO.File]::WriteAllText($cargoToml, $c, (New-Object System.Text.UTF8Encoding($false)))
+
+$p = Get-Content $pkgJson -Raw
+$p = $p -replace '("version"\s*:\s*")[^"]*(")', "`${1}$Version`${2}"
+[System.IO.File]::WriteAllText($pkgJson, $p, (New-Object System.Text.UTF8Encoding($false)))
+Write-Step "版本号已同步：tauri.conf.json / Cargo.toml / package.json"
+
+# ---------- 2. 构建 ----------
+if (-not $SkipBuild) {
+  Write-Step '开始构建（bun run tauri build）...'
+  Push-Location $Root
+  try { bun run tauri build }
+  finally { Pop-Location }
+  if ($LASTEXITCODE -ne 0) { throw 'tauri build 失败' }
+} else {
+  Write-Step '跳过构建，复用现有产物'
+}
+
+# ---------- 3. 整理产物 ----------
+# 版本号此时已解析，再确定暂存目录
+$StageDir = Join-Path $Root "release_stage\$Version"
+New-Item -ItemType Directory -Force -Path $StageDir | Out-Null
+
+$exeSrc   = Join-Path $TargetDir "$Product.exe"
+$msiSrc   = Join-Path $BundleDir "msi\${Product}_${Version}_x64_en-US.msi"
+$nsisSrc  = Join-Path $BundleDir "nsis\${Product}_${Version}_x64-setup.exe"
+$hkSrc    = Join-Path $Root 'src-tauri\binaries\ThingHK.exe'
+
+$exeOut  = Join-Path $StageDir "${Product}_${Version}_x64.exe"
+$msiOut  = Join-Path $StageDir "${Product}_${Version}_x64.msi"
+$nsisOut = Join-Path $StageDir "${Product}_${Version}_x64-setup.exe"
+$hkZip   = Join-Path $StageDir "thing-hk_${Version}.zip"
+
+if (Test-Path $exeSrc)  { Copy-Item $exeSrc  $exeOut }  else { Write-Warning "缺少便携版：$exeSrc" }
+if (Test-Path $msiSrc)  { Copy-Item $msiSrc  $msiOut }  else { Write-Warning "缺少 MSI（已跳过重命名）：$msiSrc" }
+if (Test-Path $nsisSrc) { Copy-Item $nsisSrc $nsisOut } else { Write-Warning "缺少 NSIS：$nsisSrc" }
+
+if (Test-Path $hkSrc) {
+  $tmp = Join-Path $env:TEMP "thinghk_$([guid]::NewGuid().ToString('N'))"
+  New-Item -ItemType Directory -Force -Path $tmp | Out-Null
+  Copy-Item $hkSrc (Join-Path $tmp 'ThingHK.exe')
+  Compress-Archive -Path (Join-Path $tmp 'ThingHK.exe') -DestinationPath $hkZip -Force
+  Remove-Item -Recurse -Force $tmp
+  Write-Step "ThingHK 内核包：$hkZip"
+} else {
+  Write-Warning "缺少 ThingHK.exe：$hkSrc"
+}
+
+Write-Step "产物已整理到：$StageDir"
+Get-ChildItem $StageDir | Select-Object Name, @{n='Size(MB)';e={[math]::Round($_.Length/1MB,1)}} | Format-Table -AutoSize
+
+# ---------- 4. 上传到 Gitea ----------
+if ($SkipPush) {
+  Write-Step '已跳过上传（-SkipPush）'
+  exit 0
+}
+
+$token = $env:GITEA_TOKEN
+if ([string]::IsNullOrWhiteSpace($token)) {
+  throw '未设置环境变量 GITEA_TOKEN，无法发布到 Gitea（或使用 -SkipPush 跳过上传）'
+}
+$auth = @{ Authorization = "token $token" }
+
+# 4.1 release notes
+if (-not [string]::IsNullOrWhiteSpace($NotesPath)) {
+  $body = Get-Content $NotesPath -Raw
+} elseif (Test-Path (Join-Path $PSScriptRoot 'release-notes.md')) {
+  $body = Get-Content (Join-Path $PSScriptRoot 'release-notes.md') -Raw
+} else {
+  $body = "Thing v$Version"
+}
+
+# 4.2 创建 release（已存在同名 tag 则复用）
+Write-Step "创建 release v$Version ..."
+$releaseUrl = "$ApiBase/repos/$RepoOwner/$RepoName/releases"
+$releasePayload = @{
+  tag_name         = "v$Version"
+  name             = "Thing v$Version"
+  body             = $body
+  draft            = $false
+  prerelease       = $false
+} | ConvertTo-Json
+
+try {
+  $release = Invoke-RestMethod -Method Post -Uri $releaseUrl -Headers $auth -ContentType 'application/json' -Body $releasePayload
+} catch {
+  # tag 已存在：尝试用该 tag 查找现有 release，后续资产上传会追加
+  Write-Warning "创建 release 失败，尝试复用已有 release：$_"
+  $release = Invoke-RestMethod -Method Get -Uri "$releaseUrl/tags/v$Version" -Headers $auth
+}
+$releaseId = $release.id
+Write-Step "release id=$releaseId"
+
+# 4.3 逐个上传资产
+$assets = @($exeOut, $msiOut, $nsisOut, $hkZip) | Where-Object { Test-Path $_ }
+foreach ($file in $assets) {
+  $name = Split-Path $file -Leaf
+  Write-Step "上传 $name ..."
+  $assetUrl = "$releaseUrl/$releaseId/assets?name=$([uri]::EscapeDataString($name))"
+  $resp = Invoke-RestMethod -Method Post -Uri $assetUrl -Headers $auth -ContentType 'application/octet-stream' -InFile $file
+  Write-Host "  -> $($resp.browser_download_url)" -ForegroundColor Green
+}
+
+Write-Step "发布完成：https://gitea.atie.fun/$RepoOwner/$RepoName/releases/tag/v$Version"

src-tauri/Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "Inflector"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
+
 [[package]]
 name = "adler2"
 version = "2.0.1"
@@ -3019,6 +3025,12 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
 [[package]]
 name = "pbkdf2"
 version = "0.12.2"
@@ -4070,6 +4082,58 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "specta"
+version = "2.0.0-rc.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f9a30cbcbb7011f1da7d73483983bf838af123883e45f2b36ed76328df9c50"
+dependencies = [
+ "paste",
+ "rustc_version",
+ "serde_json",
+ "specta-macros",
+]
+
+[[package]]
+name = "specta-macros"
+version = "2.0.0-rc.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ce14957ecc2897f1f848b8255b6531d13ddf49cbcf506b7c2c9fb1d005593bb"
+dependencies = [
+ "Inflector",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "specta-serde"
+version = "0.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee8a72b755ddb8949fd8f17c5db43f0e8a806ea587d9bc602ee3f73240c00029"
+dependencies = [
+ "specta",
+ "specta-macros",
+]
+
+[[package]]
+name = "specta-typescript"
+version = "0.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "639404ee95557f2f8b7e4cb773ffefd45304c7ab8ba21ac83b69051595e083c0"
+dependencies = [
+ "specta",
+]
+
+[[package]]
+name = "specta-util"
+version = "0.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29b1fc02b446f7244a92924fe68c0555921209f1d342990cd1539e9138e69502"
+dependencies = [
+ "specta",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -4304,6 +4368,7 @@ dependencies = [
  "serde_json",
  "serde_repr",
  "serialize-to-javascript",
+ "specta",
  "swift-rs",
  "tauri-build",
  "tauri-macros",
@@ -4577,6 +4642,23 @@ dependencies = [
  "wry",
 ]
 
+[[package]]
+name = "tauri-specta"
+version = "2.0.0-rc.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee080f36d2ac17ce2f3a82fb53f02d664e8345457de51b56dad3c394dacc41a2"
+dependencies = [
+ "heck 0.5.0",
+ "serde",
+ "serde_json",
+ "specta",
+ "specta-serde",
+ "specta-typescript",
+ "specta-util",
+ "tauri",
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "tauri-utils"
 version = "2.9.3"
@@ -4661,7 +4743,7 @@ dependencies = [
 
 [[package]]
 name = "thing"
-version = "0.1.0"
+version = "26.8.2"
 dependencies = [
  "axum",
  "base64 0.22.1",
@@ -4671,11 +4753,14 @@ dependencies = [
  "image",
  "notify",
  "raw-window-handle",
+ "regex",
  "reqwest 0.12.28",
  "rusqlite",
  "serde",
  "serde_json",
  "serde_yaml",
+ "specta",
+ "specta-typescript",
  "sysinfo",
  "tauri",
  "tauri-build",
@@ -4685,9 +4770,11 @@ dependencies = [
  "tauri-plugin-notification",
  "tauri-plugin-opener",
  "tauri-plugin-snap-layout",
+ "tauri-specta",
  "tokio",
  "url",
  "walkdir",
+ "windows 0.52.0",
  "windows-sys 0.52.0",
  "winreg 0.52.0",
  "zip",
@@ -5505,6 +5592,16 @@ dependencies = [
  "windows-version",
 ]
 
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core 0.52.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows"
 version = "0.57.0"
@@ -5537,6 +5634,15 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.57.0"

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "thing"
-version = "0.1.0"
+version = "26.8.2"
 description = "A Tauri App"
 authors = ["you"]
 edition = "2021"
@@ -26,7 +26,11 @@ tauri-plugin-global-shortcut = "2"
 tauri-plugin-notification = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+regex = "1"
 serde_yaml = "0.9"
+specta = { version = "=2.0.0-rc.25", features = ["derive", "function", "serde_json"] }
+specta-typescript = "0.0.12"
+tauri-specta = { version = "=2.0.0-rc.25", features = ["typescript"] }
 chrono = "0.4"
 reqwest = { version = "0.12", features = ["json", "stream"] }
 futures-util = "0.3"
@@ -53,6 +57,7 @@ windows-sys = { version = "0.52", features = [
     "Win32_System_Ole",
     "Win32_System_Memory",
     "Win32_System_DataExchange",
+    "Win32_System_SystemInformation",
     "Win32_UI_WindowsAndMessaging",
     "Win32_UI_Shell",
     "Win32_UI_HiDpi",
@@ -62,6 +67,15 @@ windows-sys = { version = "0.52", features = [
     "Win32_Storage_Xps",
     "Win32_Storage_FileSystem",
 ] }
+# Explorer 蜑榊床逶ｮ蠖墓｣€豬具ｼ・ShellWindows COM・会ｼ壻ｻ・ｼ募・逕ｨ蛻ｰ逧・feature・梧而蛻ｶ郛冶ｯ台ｽ鍋ｧｯ
+windows = { version = "0.52", features = [
+    "Win32_Foundation",
+    "Win32_System_Com",
+    "Win32_System_Ole",
+    "Win32_System_Variant",
+    "Win32_UI_Shell",
+    "Win32_UI_WindowsAndMessaging",
+] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-autostart = "2"

src-tauri/capabilities/clipboard-preview.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "clipboard-preview",
+  "description": "Capability for clipboard independent preview window",
+  "windows": ["clipboard-preview"],
+  "permissions": [
+    "core:default",
+    "core:window:allow-hide",
+    "core:window:allow-show",
+    "core:window:allow-set-focus",
+    "core:window:allow-close",
+    "core:window:allow-set-theme",
+    "core:window:allow-set-effects",
+    "core:window:allow-set-background-color",
+    "core:event:allow-listen",
+    "core:event:allow-emit",
+    "snap-layout:default"
+  ]
+}

src-tauri/capabilities/screenshot.json

@@ -1,8 +1,8 @@
 {
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "screenshot",
-  "description": "Capability for screenshot overlay and editor windows",
-  "windows": ["screenshot-overlay*", "screenshot-editor-*"],
+  "description": "Capability for screenshot overlay, editor and pin windows",
+  "windows": ["screenshot-overlay*", "screenshot-editor-*", "screenshot-pin"],
   "permissions": [
     "core:default",
     "core:window:allow-hide",
@@ -11,6 +11,7 @@
     "core:window:allow-start-dragging",
     "core:window:allow-set-position",
     "core:window:allow-set-size",
+    "core:window:allow-set-resizable",
     "core:window:allow-set-always-on-top",
     "core:window:allow-set-skip-taskbar",
     "core:window:allow-set-decorations",

src-tauri/resources/thing-extension/background.js

@@ -16,7 +16,6 @@ const DEFAULT_CONFIG = {
   interceptDownload: true,
   minSize: 0,
   excludeDomains: [],
-  showNotifications: true,
   // 嗅探开关
   sniffEnabled: true,
   // 嗅探的资源类型：只保留视频/音频/图片/压缩包/种子/安装包
@@ -359,6 +358,11 @@ async function addDownload(url, filename, referer, cookies, headers) {
 }
 
 // ===== 下载拦截 =====
+// 处理中的 URL（防止同一 URL 并发/重入，也避免与引擎去重检查竞态）
+const processingUrls = new Set()
+// 我们自己用 chrome.downloads.download 回退创建的下载 URL（短时间内跳过，防止再次被拦截形成死循环）
+const fallbackUrls = new Map() // url -> 过期时间戳
+
 async function shouldIntercept(downloadItem) {
   const config = await getConfig()
   if (!config.interceptDownload) return false
@@ -374,42 +378,94 @@ async function shouldIntercept(downloadItem) {
   return true
 }
 
-async function handleDownloadCreated(downloadItem) {
-  if (!await shouldIntercept(downloadItem)) return
-
+/**
+ * 判断是否为"历史下载"（安装插件之前就已存在、随后被浏览器恢复的旧下载）
+ * 这类下载一律不接管，交给浏览器原生处理，实现"只接管以后的下载，历史都不管"
+ */
+async function isHistoricalDownload(item) {
+  // 1) canResume=true 表示已存在有效的部分文件，说明浏览器在恢复旧下载
+  if (item.canResume) return true
+  // 2) 开始时间早于插件首次安装时间（浏览器重启后恢复的旧下载会保留原来的开始时间）
   try {
-    await chrome.downloads.cancel(downloadItem.id)
-    await chrome.downloads.erase({ id: downloadItem.id })
+    const start = item.startTime ? new Date(item.startTime).getTime() : 0
+    if (start > 0) {
+      const stored = await chrome.storage.local.get('installTime')
+      const installTime = stored.installTime || 0
+      if (installTime > 0 && start < installTime) return true
+    }
   } catch { /* ignore */ }
+  return false
+}
 
-  const url = downloadItem.finalUrl || downloadItem.url
-  const filename = downloadItem.filename || ''
-
+/**
+ * 查询引擎是否已有同 URL 的非终态任务（活跃/排队/暂停）
+ * 用于防止同一下载被重复转发、重复下载
+ */
+async function hasExistingTask(url) {
   try {
-    const id = await addDownload(url, filename, downloadItem.referrer, '')
-    await notify('已添加到 Thing', `${filename || url}`)
-  } catch (e) {
-    await notify('Thing 添加失败', `${filename || url}\n${e.message}`)
-    try { await chrome.downloads.download({ url }) } catch { /* ignore */ }
+    const tasks = await apiRequest('/api/downloads')
+    return tasks.some(t => {
+      const s = t.status
+      if (s === 'complete' || s === 'error') return false
+      return t.url === url
+    })
+  } catch {
+    return false
   }
 }
 
-// ===== 通知 =====
-async function notify(title, message) {
-  const config = await getConfig()
-  if (!config.showNotifications) return
+async function handleDownloadCreated(downloadItem) {
+  const url = downloadItem.finalUrl || downloadItem.url
+
+  // 回退下载：我们自己用 chrome.downloads.download 创建的，直接跳过，避免无限循环
+  const fbExp = fallbackUrls.get(url)
+  if (fbExp && Date.now() < fbExp) {
+    fallbackUrls.delete(url)
+    return
+  }
+
+  // 历史下载（安装前的旧下载被浏览器恢复）一律不接管
+  if (await isHistoricalDownload(downloadItem)) return
+
+  if (!await shouldIntercept(downloadItem)) return
+
+  // 同一 URL 已在处理中，跳过（防并发/防重复转发）
+  if (processingUrls.has(url)) return
+
+  // 引擎不可达时不接管（保留浏览器原生下载），避免取消后下载无处可去
+  let connected = false
+  try { connected = await testConnection() } catch { connected = false }
+  if (!connected) return
+
+  // 引擎已有同 URL 的非终态任务，不重复转发
+  if (await hasExistingTask(url)) return
+
+  processingUrls.add(url)
   try {
-    await chrome.notifications.create({
-      type: 'basic',
-      iconUrl: 'icons/icon-128.png',
-      title,
-      message
-    })
-  } catch { /* ignore */ }
+    try {
+      await chrome.downloads.cancel(downloadItem.id)
+      await chrome.downloads.erase({ id: downloadItem.id })
+    } catch { /* ignore */ }
+
+    const filename = downloadItem.filename || ''
+    try {
+      await addDownload(url, filename, downloadItem.referrer, '')
+    } catch (e) {
+      // 添加失败：回退为浏览器自带下载，并标记该 URL 短时间内跳过，防止再次被拦截形成死循环
+      fallbackUrls.set(url, Date.now() + 3000)
+      try { await chrome.downloads.download({ url }) } catch { /* ignore */ }
+    }
+  } finally {
+    processingUrls.delete(url)
+  }
 }
 
-// ===== 右键菜单 =====
-chrome.runtime.onInstalled.addListener(() => {
+// ===== 右键菜单 & 安装标记 =====
+chrome.runtime.onInstalled.addListener(async (details) => {
+  // 记录首次安装时间：用于区分"安装前的历史下载"（被浏览器恢复的旧下载）与"安装后的新下载"
+  if (details.reason === 'install') {
+    await chrome.storage.local.set({ installTime: Date.now() })
+  }
   chrome.contextMenus.create({
     id: 'thing-download-link',
     title: '使用 Thing 下载此链接',
@@ -428,10 +484,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
     const filename = url.split('/').pop()?.split('?')[0] || ''
     try {
       await addDownload(url, filename, info.pageUrl, '')
-      await notify('已添加到 Thing', `${filename || url}`)
-    } catch (e) {
-      await notify('Thing 添加失败', `${e.message}`)
-    }
+    } catch (e) { /* 忽略：添加失败时不打扰用户 */ }
   }
 })
 

src-tauri/resources/thing-extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Thing Extension",
-  "version": "0.2.0",
+  "version": "0.30",
   "description": "发送浏览器下载到 Thing 下载引擎，嗅探网页资源。",
   "icons": {
     "16": "icons/icon-16.png",
@@ -11,9 +11,7 @@
   "permissions": [
     "downloads",
     "storage",
-    "notifications",
     "webRequest",
-    "webNavigation",
     "contextMenus",
     "tabs",
     "scripting"

src-tauri/resources/thing-extension/popup.html

@@ -87,11 +87,6 @@
           <span>启用资源嗅探</span>
         </label>
 
-        <label class="checkbox">
-          <input type="checkbox" id="showNotifications" />
-          <span>显示桌面通知</span>
-        </label>
-
         <label class="field">
           <span>下载最小文件大小（字节，0=全部）</span>
           <input type="number" id="minSize" min="0" placeholder="0" />

src-tauri/resources/thing-extension/popup.js

@@ -12,7 +12,6 @@ const DEFAULT_CONFIG = {
   interceptDownload: true,
   minSize: 0,
   excludeDomains: [],
-  showNotifications: true,
   sniffEnabled: true,
   sniffTypes: ['video', 'audio', 'image', 'archive', 'torrent', 'installer'],
   sniffMaxItems: 200,
@@ -57,7 +56,6 @@ function fillForm(config) {
   $('secret').value = config.secret || ''
   $('interceptDownload').checked = config.interceptDownload !== false
   $('sniffEnabled').checked = config.sniffEnabled !== false
-  $('showNotifications').checked = config.showNotifications !== false
   $('minSize').value = config.minSize || 0
   $('sniffMinSize').value = config.sniffMinSize ?? DEFAULT_CONFIG.sniffMinSize
   $('excludeDomains').value = (config.excludeDomains || []).join(',')
@@ -69,7 +67,6 @@ function readForm() {
     secret: $('secret').value.trim(),
     interceptDownload: $('interceptDownload').checked,
     sniffEnabled: $('sniffEnabled').checked,
-    showNotifications: $('showNotifications').checked,
     minSize: parseInt($('minSize').value, 10) || 0,
     sniffMinSize: parseInt($('sniffMinSize').value, 10) || 0,
     excludeDomains: $('excludeDomains').value

src-tauri/src/clipboard/commands.rs

@@ -3,13 +3,14 @@
 use base64::engine::general_purpose::STANDARD;
 use base64::Engine as _;
 use serde::Serialize;
+use specta::Type;
 use tauri::{AppHandle, State};
 
 use super::manager::{ClipboardManager, ClipboardSettings};
-use super::reader::dib_to_png;
+use super::reader::{dib_to_png, dib_to_thumbnail};
 use super::storage::{ClipboardItem, ClipboardItemDetail};
 
-#[derive(Serialize)]
+#[derive(Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct ClipboardStatus {
     pub running: bool,
@@ -21,7 +22,7 @@ fn img_to_base64(b: &[u8]) -> Option<String> {
 }
 
 /// 历史查询结果（含总数，用于分页）
-#[derive(Serialize)]
+#[derive(Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct HistoryPage {
     pub items: Vec<ClipboardItem>,
@@ -29,74 +30,122 @@ pub struct HistoryPage {
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_get_history(
     limit: Option<i64>,
     offset: Option<i64>,
     kind: Option<String>,
     manager: State<'_, ClipboardManager>,
 ) -> Result<HistoryPage, String> {
-    let storage = manager.storage();
+    let storage = manager.storage().clone();
     let kind = kind.unwrap_or_else(|| "all".into());
     let limit = limit.unwrap_or(50);
     let offset = offset.unwrap_or(0);
-    let items = storage.get_history(limit, offset, &kind);
-    let total = storage.count_kind(&kind);
-    Ok(HistoryPage { items, total })
+    // SQLite 查询移出 async runtime 线程
+    tauri::async_runtime::spawn_blocking(move || {
+        let items = storage.get_history(limit, offset, &kind);
+        let total = storage.count_kind(&kind);
+        HistoryPage { items, total }
+    })
+    .await
+    .map_err(|e| format!("查询任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_get_pinned(
     manager: State<'_, ClipboardManager>,
 ) -> Result<Vec<ClipboardItem>, String> {
-    Ok(manager.storage().get_pinned())
+    let storage = manager.storage().clone();
+    tauri::async_runtime::spawn_blocking(move || storage.get_pinned())
+        .await
+        .map_err(|e| format!("查询任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_search(
     query: String,
     limit: Option<i64>,
     offset: Option<i64>,
     manager: State<'_, ClipboardManager>,
 ) -> Result<HistoryPage, String> {
-    let storage = manager.storage();
+    let storage = manager.storage().clone();
     let limit = limit.unwrap_or(50);
     let offset = offset.unwrap_or(0);
-    let items = storage.search(&query, limit, offset);
-    let total = storage.count_search(&query);
-    Ok(HistoryPage { items, total })
+    tauri::async_runtime::spawn_blocking(move || {
+        let items = storage.search(&query, limit, offset);
+        let total = storage.count_search(&query);
+        HistoryPage { items, total }
+    })
+    .await
+    .map_err(|e| format!("查询任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_get_item(
     id: i64,
     manager: State<'_, ClipboardManager>,
 ) -> Result<Option<ClipboardItemDetail>, String> {
-    Ok(manager.storage().get_detail(id, img_to_base64))
+    let storage = manager.storage().clone();
+    // get_detail 内部：锁内取数 + 锁外 base64 编码，整体移出主线程
+    tauri::async_runtime::spawn_blocking(move || storage.get_detail(id, img_to_base64))
+        .await
+        .map_err(|e| format!("查询任务失败: {}", e))
+}
+
+/// 获取图片缩略图 PNG base64（弹窗悬停预览用，避免加载全尺寸图片）
+#[tauri::command]
+#[specta::specta]
+pub async fn clipboard_get_thumb(
+    id: i64,
+    manager: State<'_, ClipboardManager>,
+) -> Result<Option<String>, String> {
+    let storage = manager.storage().clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        storage.get_thumb(id, |dib| dib_to_thumbnail(dib, 256))
+    })
+    .await
+    .map_err(|e| format!("查询任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_set_pinned(
     id: i64,
     pinned: bool,
     manager: State<'_, ClipboardManager>,
 ) -> Result<bool, String> {
-    Ok(manager.storage().set_pinned(id, pinned))
+    let storage = manager.storage().clone();
+    tauri::async_runtime::spawn_blocking(move || storage.set_pinned(id, pinned))
+        .await
+        .map_err(|e| format!("操作任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_delete(
     id: i64,
     manager: State<'_, ClipboardManager>,
 ) -> Result<bool, String> {
-    Ok(manager.storage().delete(id))
+    let storage = manager.storage().clone();
+    tauri::async_runtime::spawn_blocking(move || storage.delete(id))
+        .await
+        .map_err(|e| format!("删除任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_clear(manager: State<'_, ClipboardManager>) -> Result<bool, String> {
-    Ok(manager.storage().clear_non_pinned())
+    let storage = manager.storage().clone();
+    tauri::async_runtime::spawn_blocking(move || storage.clear_non_pinned())
+        .await
+        .map_err(|e| format!("清空任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_copy_back(
     id: i64,
     manager: State<'_, ClipboardManager>,
@@ -105,11 +154,16 @@ pub async fn clipboard_copy_back(
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_count(manager: State<'_, ClipboardManager>) -> Result<i64, String> {
-    Ok(manager.storage().count())
+    let storage = manager.storage().clone();
+    tauri::async_runtime::spawn_blocking(move || storage.count())
+        .await
+        .map_err(|e| format!("查询任务失败: {}", e))
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_get_settings(
     manager: State<'_, ClipboardManager>,
 ) -> Result<ClipboardSettings, String> {
@@ -117,48 +171,75 @@ pub async fn clipboard_get_settings(
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_save_settings(
     settings: ClipboardSettings,
     app: AppHandle,
     manager: State<'_, ClipboardManager>,
 ) -> Result<(), String> {
-    let prev_enabled = manager.get_settings().enabled;
-    let prev_shortcut = manager.get_settings().shortcut.clone();
+    let prev = manager.get_settings();
+    let prev_enabled = prev.enabled;
+    let prev_shortcut = prev.shortcut.clone();
+
+    // 快捷键变化且新值非空：先注册（原子化 + 冲突检测），成功后才保存设置。
+    // 注册失败时恢复旧快捷键并中止保存，避免设置被写入无法生效的组合键、旧键丢失。
+    if settings.shortcut != prev_shortcut && !settings.shortcut.trim().is_empty() {
+        if let Err(e) = crate::shortcut::register_shortcut(&app, "剪贴板", &settings.shortcut, |a| {
+            super::popup::show_popup(a)
+        }) {
+            // register_shortcut 内部已注销旧快捷键，失败时需重新注册旧键以恢复
+            if !prev_shortcut.trim().is_empty() {
+                let _ = crate::shortcut::register_shortcut(&app, "剪贴板", &prev_shortcut, |a| {
+                    super::popup::show_popup(a)
+                });
+            }
+            return Err(e);
+        }
+        // 新快捷键非空时确保弹窗/预览窗口已预创建
+        super::popup::ensure_popup_window(&app);
+        super::popup::ensure_preview_window(&app);
+    }
+
+    // 保存设置
     manager.save_settings(settings.clone());
+
     // 监听开关变化时联动启停
     if settings.enabled && !prev_enabled {
         manager.start(&app);
     } else if !settings.enabled && prev_enabled {
         manager.stop();
     }
-    // 快捷键变化时重新注册
-    if settings.shortcut != prev_shortcut {
-        super::popup::register_shortcut(&app, &settings.shortcut)?;
-        // 新快捷键非空时确保弹窗窗口已预创建
-        if !settings.shortcut.trim().is_empty() {
-            super::popup::ensure_popup_window(&app);
-        }
+
+    // 快捷键改为空字符串（禁用）：注销旧快捷键
+    if settings.shortcut.trim().is_empty() && settings.shortcut != prev_shortcut {
+        crate::shortcut::unregister_shortcut(&app, "剪贴板");
     }
+
     Ok(())
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_status(
     manager: State<'_, ClipboardManager>,
 ) -> Result<ClipboardStatus, String> {
-    Ok(ClipboardStatus {
-        running: manager.is_running(),
-        count: manager.storage().count(),
-    })
+    let storage = manager.storage().clone();
+    let running = manager.is_running();
+    let count = tauri::async_runtime::spawn_blocking(move || storage.count())
+        .await
+        .map_err(|e| format!("查询任务失败: {}", e))?;
+    Ok(ClipboardStatus { running, count })
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_start(app: AppHandle, manager: State<'_, ClipboardManager>) -> Result<(), String> {
     manager.start(&app);
     Ok(())
 }
 
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_stop(manager: State<'_, ClipboardManager>) -> Result<(), String> {
     manager.stop();
     Ok(())
@@ -166,22 +247,27 @@ pub async fn clipboard_stop(manager: State<'_, ClipboardManager>) -> Result<(),
 
 /// 注册（或切换）快捷弹窗全局快捷键
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_register_shortcut(
     shortcut: String,
     app: AppHandle,
 ) -> Result<(), String> {
-    super::popup::register_shortcut(&app, &shortcut)
+    crate::shortcut::register_shortcut(&app, "剪贴板", &shortcut, |a| {
+        super::popup::show_popup(a)
+    })
 }
 
 /// 注销快捷弹窗全局快捷键
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_unregister_shortcut(app: AppHandle) -> Result<(), String> {
-    super::popup::unregister_shortcut(&app);
+    crate::shortcut::unregister_shortcut(&app, "剪贴板");
     Ok(())
 }
 
 /// 手动触发显示快捷弹窗（供 UI 按钮调用）
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_show_popup(app: AppHandle) -> Result<(), String> {
     super::popup::show_popup(&app);
     Ok(())
@@ -189,6 +275,7 @@ pub async fn clipboard_show_popup(app: AppHandle) -> Result<(), String> {
 
 /// 隐藏快捷弹窗
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_hide_popup(app: AppHandle) -> Result<(), String> {
     super::popup::hide_popup(&app);
     Ok(())
@@ -196,6 +283,7 @@ pub async fn clipboard_hide_popup(app: AppHandle) -> Result<(), String> {
 
 /// 显示已创建的弹窗窗口（前端 onMounted 后调用）
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_show_window(app: AppHandle) -> Result<(), String> {
     super::popup::show_window(&app);
     Ok(())
@@ -203,7 +291,57 @@ pub async fn clipboard_show_window(app: AppHandle) -> Result<(), String> {
 
 /// 隐藏弹窗并模拟 Ctrl+V 粘贴到原窗口
 #[tauri::command]
+#[specta::specta]
 pub async fn clipboard_paste_to_target(app: AppHandle) -> Result<(), String> {
     super::popup::paste_to_target(&app);
     Ok(())
 }
+
+/// 在弹窗旁显示独立预览窗口（悬停/键盘选中时调用）
+#[tauri::command]
+#[specta::specta]
+pub async fn clipboard_show_preview(app: AppHandle, id: i64) -> Result<(), String> {
+    super::popup::show_preview(&app, id);
+    Ok(())
+}
+
+/// 隐藏独立预览窗口
+#[tauri::command]
+#[specta::specta]
+pub async fn clipboard_hide_preview(app: AppHandle) -> Result<(), String> {
+    super::popup::hide_preview(&app);
+    Ok(())
+}
+
+/// 按内容自适应调整预览窗大小（逻辑像素）。前端加载内容（文本测高、图片按宽高比）后调用，
+/// 窗口贴合内容消除留白；后端按弹窗所在屏工作区钳制并重新对齐弹窗。
+/// allow_flip：初始落位为 true（优先侧放不下可换侧）；放大/还原为 false（保持原侧）。
+#[tauri::command]
+#[specta::specta]
+pub async fn clipboard_resize_preview(
+    app: AppHandle,
+    width: f64,
+    height: f64,
+    allow_flip: bool,
+) -> Result<(), String> {
+    super::popup::resize_preview(&app, width, height, allow_flip);
+    Ok(())
+}
+
+/// 显示已就绪的预览窗口。前端完成内容加载与 resize 后调用，窗口以最终尺寸出现，
+/// 消除"先以上次尺寸（可能是放大态大窗）显示再缩回"的闪烁。
+#[tauri::command]
+#[specta::specta]
+pub async fn clipboard_reveal_preview(app: AppHandle) -> Result<(), String> {
+    super::popup::reveal_preview(&app);
+    Ok(())
+}
+
+/// 预览窗交互锁定：前端预览窗收到 mousedown（放大/缩小、复制、选择文本）时调用。
+/// 此后弹窗+预览不因失焦/鼠标离开而关闭，仅当点击外部或弹窗重新聚焦时退出锁定。
+#[tauri::command]
+#[specta::specta]
+pub async fn clipboard_preview_interacted(app: AppHandle) -> Result<(), String> {
+    super::popup::preview_interacted(&app);
+    Ok(())
+}

src-tauri/src/clipboard/manager.rs

@@ -7,13 +7,15 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 
 use serde::{Deserialize, Serialize};
+use specta::Type;
 
 use super::monitor::start_monitor;
 use super::reader::{write_dib, write_files, write_text};
 use super::storage::Storage;
+use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber;
 
 /// 剪贴板设置（持久化到 clipboard/settings.json）
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase", default)]
 pub struct ClipboardSettings {
     /// 监听是否启用
@@ -54,7 +56,8 @@ impl Default for ClipboardSettings {
 pub struct ClipboardManager {
     storage: Arc<Storage>,
     settings: Arc<Mutex<ClipboardSettings>>,
-    suppress: Arc<AtomicBool>,
+    /// 本应用 copy_back 写入后的剪贴板序列号，用于跳过自身写入产生的记录
+    suppress: Arc<Mutex<Option<u32>>>,
     monitor_stop: Arc<AtomicBool>,
     monitor_handle: Mutex<Option<JoinHandle<()>>>,
     settings_path: PathBuf,
@@ -66,13 +69,13 @@ impl ClipboardManager {
         let storage = match Storage::new(&clip_dir) {
             Ok(s) => Arc::new(s),
             Err(e) => {
-                eprintln!("[clipboard] 磁盘存储初始化失败，回退内存: {}", e);
+                crate::logger::log_warn("clipboard", &format!("磁盘存储初始化失败，回退内存: {}", e));
                 Arc::new(Storage::new_in_memory())
             }
         };
         let settings_path = clip_dir.join("settings.json");
         let settings = Arc::new(Mutex::new(load_settings(&settings_path)));
-        let suppress = Arc::new(AtomicBool::new(false));
+        let suppress = Arc::new(Mutex::new(None));
         let monitor_stop = Arc::new(AtomicBool::new(true));
         Self {
             storage,
@@ -86,7 +89,7 @@ impl ClipboardManager {
 
     /// 启动监听（若已运行则跳过）
     pub fn start(&self, app: &tauri::AppHandle) {
-        let mut handle = self.monitor_handle.lock().unwrap();
+        let mut handle = self.monitor_handle.lock().unwrap_or_else(|e| e.into_inner());
         if handle.is_some() {
             return;
         }
@@ -99,41 +102,51 @@ impl ClipboardManager {
             self.monitor_stop.clone(),
         );
         *handle = Some(h);
-        eprintln!("[clipboard] 监听已启动");
+        crate::logger::log_info("clipboard", "监听已启动");
     }
 
     /// 停止监听
     pub fn stop(&self) {
         self.monitor_stop.store(true, Ordering::SeqCst);
-        if let Some(h) = self.monitor_handle.lock().unwrap().take() {
-            // 不阻塞等待；轮询线程最迟 800ms 后退出
-            let _ = h.join();
+        if let Some(h) = self
+            .monitor_handle
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .take()
+        {
+            // 后台等待监听线程退出（最迟 800ms），不阻塞调用者。
+            // 剪贴板 stop 命令跑在 async runtime 线程上，直接 join 会卡住 tokio worker。
+            std::thread::spawn(move || {
+                let _ = h.join();
+            });
         }
-        eprintln!("[clipboard] 监听已停止");
+        crate::logger::log_info("clipboard", "监听已停止");
     }
 
     pub fn is_running(&self) -> bool {
-        self.monitor_handle.lock().unwrap().is_some()
+        self.monitor_handle
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .is_some()
     }
 
     pub fn get_settings(&self) -> ClipboardSettings {
-        self.settings.lock().unwrap().clone()
+        self.settings.lock().unwrap_or_else(|e| e.into_inner()).clone()
     }
 
     pub fn save_settings(&self, s: ClipboardSettings) {
         {
-            *self.settings.lock().unwrap() = s.clone();
+            *self.settings.lock().unwrap_or_else(|e| e.into_inner()) = s.clone();
         }
         save_settings(&self.settings_path, &s);
     }
 
-    /// 将某条历史写回剪贴板。写回前置 suppress 标志以避免再次记录。
+    /// 将某条历史写回剪贴板。写回成功后记录剪贴板序列号，供监听跳过自身写入。
     pub fn copy_back(&self, id: i64) -> Result<(), String> {
         let (kind, content, blob) = self
             .storage
             .get_raw_for_copy(id)
             .ok_or_else(|| "条目不存在".to_string())?;
-        self.suppress.store(true, Ordering::SeqCst);
         let ok = match kind.as_str() {
             "text" => content.as_deref().map(write_text).unwrap_or(false),
             "image" => blob.as_deref().map(write_dib).unwrap_or(false),
@@ -151,10 +164,12 @@ impl ClipboardManager {
             _ => false,
         };
         if ok {
+            // 绑定到写入完成后的剪贴板序列号：仅跳过本次写入产生的记录，
+            // 用户后续复制（序列号不同）不会被误吞。
+            let seq = unsafe { GetClipboardSequenceNumber() };
+            *self.suppress.lock().unwrap_or_else(|e| e.into_inner()) = Some(seq);
             Ok(())
         } else {
-            // 写入失败也清除 suppress，避免误吞下次复制
-            self.suppress.store(false, Ordering::SeqCst);
             Err("写回剪贴板失败".into())
         }
     }

src-tauri/src/clipboard/mod.rs

@@ -9,9 +9,12 @@ pub mod storage;
 
 pub use commands::{
     clipboard_clear, clipboard_copy_back, clipboard_count, clipboard_delete, clipboard_get_history,
-    clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_hide_popup,
-    clipboard_paste_to_target, clipboard_register_shortcut, clipboard_save_settings, clipboard_search,
-    clipboard_set_pinned, clipboard_show_popup, clipboard_show_window, clipboard_start,
+    clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_get_thumb,
+    clipboard_hide_popup, clipboard_hide_preview, clipboard_paste_to_target,
+    clipboard_preview_interacted, clipboard_register_shortcut,
+    clipboard_reveal_preview,
+    clipboard_save_settings, clipboard_search, clipboard_set_pinned, clipboard_resize_preview,
+    clipboard_show_popup, clipboard_show_preview, clipboard_show_window, clipboard_start,
     clipboard_status, clipboard_stop, clipboard_unregister_shortcut,
 };
 pub use manager::ClipboardManager;

src-tauri/src/clipboard/monitor.rs

@@ -1,7 +1,7 @@
 //! 剪贴板监听线程：基于 GetClipboardSequenceNumber 轮询
 //!
 //! 选用轮询而非 AddClipboardFormatListener 消息窗口：实现更简单、无需消息循环，
-//! 800ms 间隔对剪贴板场景延迟可接受，且 GetClipboardSequenceNumber 不需要 OpenClipboard，开销极小。
+//! 250ms 间隔兼顾响应速度与开销，且 GetClipboardSequenceNumber 不需要 OpenClipboard，开销极小。
 
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
@@ -15,18 +15,19 @@ use super::storage::{NewItem, Storage};
 use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber;
 
 /// 启动监听线程，返回 JoinHandle。
+/// `suppress` 记录本应用 copy_back 写入后的剪贴板序列号，用于跳过自身写入产生的记录。
 pub fn start_monitor(
     storage: Arc<Storage>,
     app: AppHandle,
     settings: Arc<Mutex<super::manager::ClipboardSettings>>,
-    suppress: Arc<AtomicBool>,
+    suppress: Arc<Mutex<Option<u32>>>,
     stop: Arc<AtomicBool>,
 ) -> thread::JoinHandle<()> {
     thread::spawn(move || loop {
         if stop.load(Ordering::SeqCst) {
             break;
         }
-        thread::sleep(Duration::from_millis(800));
+        thread::sleep(Duration::from_millis(250));
         if stop.load(Ordering::SeqCst) {
             break;
         }
@@ -40,13 +41,16 @@ pub fn start_monitor(
         if seq == last {
             continue;
         }
-        // 序列号变化，处理一次
-        if suppress.swap(false, Ordering::SeqCst) {
-            // 由本应用 copy_back 触发，跳过记录
-            continue;
+        // 序列号变化：仅当变化来自本应用 copy_back（序列号精确匹配）时跳过，
+        // 避免旧布尔标志在用户后续复制时被误吞。
+        if let Ok(mut s) = suppress.lock() {
+            if *s == Some(seq) {
+                *s = None;
+                continue;
+            }
         }
         let (rec_text, rec_image, rec_files, max_items, max_image_kb, dedup) = {
-            let s = settings.lock().unwrap();
+            let s = settings.lock().unwrap_or_else(|e| e.into_inner());
             (
                 s.record_text,
                 s.record_image,
@@ -85,7 +89,7 @@ pub fn start_monitor(
         };
         if let Some(_id) = storage.insert_or_touch(item, dedup) {
             storage.prune_to_max(max_items);
-            let _ = app.emit("clipboard-changed", ());
+            let _ = app.emit(crate::constants::events::CLIPBOARD_CHANGED, ());
         }
     })
 }
@@ -99,6 +103,7 @@ fn build_text_item(t: &str) -> NewItem {
         kind: "text".into(),
         content: Some(t.to_string()),
         blob: None,
+        thumb: None,
         preview: make_preview(t, 200),
         size: t.len() as i64,
         hash: hash_str(t),
@@ -110,6 +115,7 @@ fn build_image_item(dib: &[u8], w: u32, h: u32) -> NewItem {
         kind: "image".into(),
         content: None,
         blob: Some(dib.to_vec()),
+        thumb: super::reader::dib_to_thumbnail(dib, 256),
         preview: format!("图片 {}×{}", w, h),
         size: dib.len() as i64,
         hash: hash_bytes(dib),
@@ -132,6 +138,7 @@ fn build_files_item(files: &[String]) -> NewItem {
         kind: "files".into(),
         content: Some(content),
         blob: None,
+        thumb: None,
         preview,
         size: files.iter().map(|f| f.len()).sum::<usize>() as i64,
         hash,

src-tauri/src/clipboard/popup.rs

@@ -10,68 +10,77 @@
 
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::{Duration, Instant};
 use tauri::{AppHandle, Manager, WebviewUrl, WebviewWindowBuilder, Emitter};
 use tauri::window::{Effect, EffectsBuilder};
-use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
 
 /// 弹窗窗口标签
 pub const POPUP_LABEL: &str = "clipboard-popup";
 
-/// 当前注册的快捷键（用于注销旧快捷键）
-static CURRENT_SHORTCUT: Mutex<Option<String>> = Mutex::new(None);
+/// 预览窗口标签（悬停/键盘选中条目时在弹窗旁显示内容）
+pub const PREVIEW_LABEL: &str = "clipboard-preview";
+
+/// 预览窗口初始逻辑尺寸（后续由前端按内容自适应调整，见 resize_preview）
+const PREVIEW_W: f64 = 340.0;
+const PREVIEW_H: f64 = 300.0;
+
+/// 预览窗口最小逻辑尺寸（防止内容过小时窗口退化）
+const PREVIEW_MIN_W: f64 = 240.0;
+const PREVIEW_MIN_H: f64 = 160.0;
+
+/// 弹窗与预览窗之间的可视间距（逻辑像素，左右对称）
+const PREVIEW_GAP: f64 = 12.0;
 
 /// 标志：show_popup 兜底创建路径设为 true，前端 onMounted 回调 show_window 时据此判断是否显示。
 /// 预创建路径不设置，避免应用启动时弹窗自动弹出。
 static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
 
-/// 解析快捷键字符串为 Shortcut（格式如 "Alt+V"、"Ctrl+Shift+V"）
-/// 失败返回 None。
-pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
-    s.trim().parse::<Shortcut>().ok()
+/// 兜底创建路径下 show_popup 计算出的待显示位置（物理坐标），供 show_window 应用，
+/// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。
+static PENDING_POS: Mutex<Option<(f64, f64)>> = Mutex::new(None);
+
+/// 弹窗当前是否可见（同步单一事实来源）。
+/// show_preview 用它代替 popup.is_visible()：后者在 hide 异步在途时可能返回过期 true，
+/// 导致"弹窗已隐藏但残留的悬停/键盘请求重新弹出孤立预览窗"。该标志在隐藏路径
+/// 同步置 false，任何在途请求都会直接拒绝。
+static POPUP_VISIBLE: AtomicBool = AtomicBool::new(false);
+
+/// 预览窗当前是否可见（同步标志，与 POPUP_VISIBLE 同理：预览窗以原生
+/// SW_SHOWNOACTIVATE 显示，Tauri 的 is_visible() 可能与其真实状态不同步，
+/// 故用该标志代替 is_visible 判断预览交互状态）。
+static PREVIEW_VISIBLE: AtomicBool = AtomicBool::new(false);
+
+/// 弹窗因预览交互（光标位于预览窗内）而推迟隐藏的标记：
+/// 点击预览窗（选择/复制文本、放大图片）时，弹窗会收到 Focused(false)，但用户正在
+/// 预览窗内交互，此时不应隐藏弹窗。置该标记后保持弹窗显示，待用户离开预览窗
+/// （hide_preview）时再连同弹窗一起隐藏，避免"点击预览即关闭弹窗"导致无法交互。
+static POPUP_DEFER_HIDE: AtomicBool = AtomicBool::new(false);
+
+/// 失焦隐藏的宽限期：WebView2 透明窗口在 show 后激活期间焦点可能短暂弹跳
+/// （与快速面板同因），导致 Focused(false) 紧跟在 show 之后触发并立即隐藏刚显示的弹窗。
+const SHOW_GRACE: Duration = Duration::from_millis(500);
+
+/// 最近一次 show 的时间，用于失焦宽限期判断。
+static LAST_SHOWN: Mutex<Option<Instant>> = Mutex::new(None);
+
+/// 标记"已发起显示"，并记录时间供失焦宽限期使用。
+fn mark_shown() {
+    if let Ok(mut t) = LAST_SHOWN.lock() {
+        *t = Some(Instant::now());
+    }
+    POPUP_VISIBLE.store(true, Ordering::SeqCst);
+    // 重新显示弹窗时复位推迟隐藏标记（上一轮预览交互的遗留状态不应影响本轮）
+    POPUP_DEFER_HIDE.store(false, Ordering::SeqCst);
 }
 
-/// 注册全局快捷键。重复调用会先注销旧快捷键。
-/// 传入空字符串则仅注销不注册。
-pub fn register_shortcut(app: &AppHandle, shortcut_str: &str) -> Result<(), String> {
-    // 先注销旧快捷键
-    unregister_shortcut(app);
-
-    if shortcut_str.trim().is_empty() {
-        return Ok(());
-    }
-
-    let shortcut = parse_shortcut(shortcut_str)
-        .ok_or_else(|| format!("无效的快捷键: {}", shortcut_str))?;
-
-    let app_handle = app.clone();
-    app.global_shortcut()
-        .on_shortcut(shortcut, move |_app, _shortcut, event| {
-            // 仅在按下时触发（松开不触发）
-            if event.state == ShortcutState::Pressed {
-                show_popup(&app_handle);
-            }
-        })
-        .map_err(|e| format!("注册快捷键失败: {}", e))?;
-
-    if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
-        *cur = Some(shortcut_str.to_string());
-    }
-    eprintln!("[clipboard] 已注册快捷键: {}", shortcut_str);
-    Ok(())
-}
-
-/// 注销当前快捷键
-pub fn unregister_shortcut(app: &AppHandle) {
-    if let Ok(cur) = CURRENT_SHORTCUT.lock() {
-        if let Some(ref s) = *cur {
-            if let Some(shortcut) = parse_shortcut(s) {
-                let _ = app.global_shortcut().unregister(shortcut);
-            }
-        }
-    }
-    if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
-        *cur = None;
-    }
+/// 判断距上次 show 是否仍在宽限期内（是则忽略失焦自动隐藏）。
+fn within_show_grace() -> bool {
+    LAST_SHOWN
+        .lock()
+        .ok()
+        .and_then(|t| *t)
+        .map(|t| t.elapsed() < SHOW_GRACE)
+        .unwrap_or(false)
 }
 
 /// 创建弹窗窗口（隐藏状态）并注册失焦监听。
@@ -99,22 +108,50 @@ fn create_popup_window(app: &AppHandle) {
     {
         Ok(w) => w,
         Err(e) => {
-            eprintln!("[clipboard] 创建弹窗失败: {}", e);
+            crate::logger::log_error("clipboard", &format!("创建弹窗失败: {}", e));
             return;
         }
     };
 
-    // 监听窗口失焦：自动隐藏
+    // 监听窗口失焦：自动隐藏（同时隐藏预览窗）
     let app_handle = app.clone();
     let win_handle = win.clone();
     win.on_window_event(move |event| {
-        if let tauri::WindowEvent::Focused(false) = event {
-            let _ = win_handle.hide();
-            let _ = app_handle.emit("clipboard-popup-hide", ());
+        match event {
+            tauri::WindowEvent::Focused(false) => {
+                // 失焦宽限期：show 后激活期间的焦点弹跳不隐藏弹窗，避免弹窗刚显示就被隐藏
+                if within_show_grace() {
+                    return;
+                }
+                // 交互锁定模式（点击过预览窗）：弹窗与预览保持显示，仅由看护线程在
+                // "点击外部"时关闭；此处的失焦是点击预览窗（NoActivate）所致，不隐藏。
+                if POPUP_INTERACTED.load(Ordering::SeqCst) {
+                    return;
+                }
+                // 鼠标当前位于预览窗或弹窗内（用户正在交互：选择/复制文本、放大图片、或
+                // 已移回弹窗准备继续浏览）：弹窗失焦是点击预览窗或焦点反弹所致，不应隐藏弹窗。
+                // 置推迟标记保持弹窗显示，待用户离开整个区域（hide_preview / 再次失焦）再隐藏。
+                if is_cursor_in_preview(&app_handle) || is_cursor_in_popup(&app_handle) {
+                    POPUP_DEFER_HIDE.store(true, Ordering::SeqCst);
+                    return;
+                }
+                // 先同步标记弹窗不可见，再隐藏窗口/预览：异步 hide 在途时，残留的
+                // show_preview 请求会因该标志为 false 而拒绝，预览窗不会孤立残留。
+                POPUP_VISIBLE.store(false, Ordering::SeqCst);
+                POPUP_DEFER_HIDE.store(false, Ordering::SeqCst);
+                let _ = win_handle.hide();
+                hide_preview(&app_handle);
+                let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ());
+            }
+            tauri::WindowEvent::Focused(true) => {
+                // 弹窗重新获得焦点（用户点击/移回弹窗）：取消推迟隐藏状态
+                POPUP_DEFER_HIDE.store(false, Ordering::SeqCst);
+            }
+            _ => {}
         }
     });
 
-    eprintln!("[clipboard] 弹窗窗口已预创建（隐藏状态）");
+    crate::logger::log_info("clipboard", "弹窗窗口已预创建（隐藏状态）");
 }
 
 /// 应用启动时预创建弹窗窗口（隐藏）。
@@ -136,7 +173,7 @@ pub fn show_popup(app: &AppHandle) {
         None => return,
     };
 
-    // 窗口尺寸（逻辑像素）
+    // 窗口尺寸（物理像素，由光标所在屏 DPI 换算）
     let w = 380.0_f64;
     let h = 460.0_f64;
 
@@ -144,36 +181,36 @@ pub fn show_popup(app: &AppHandle) {
     let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx, my)
         .unwrap_or((0, 0, 1920, 1040));
 
-    // 获取光标所在显示器的 DPI，将物理坐标转为逻辑坐标（DIP）
+    // 光标所在显示器的 DPI：窗口尺寸需按物理像素放大
     let dpi = get_dpi_for_point(mx, my).unwrap_or(96);
     let scale = dpi as f64 / 96.0;
+    let w_px = w * scale;
+    let h_px = h * scale;
 
-    let mx_l = mx as f64 / scale;
-    let my_l = my as f64 / scale;
-    let wa_left_l = wa_left as f64 / scale;
-    let wa_top_l = wa_top as f64 / scale;
-    let wa_right_l = wa_right as f64 / scale;
-    let wa_bottom_l = wa_bottom as f64 / scale;
-
-    // 逻辑坐标 clamping（窗口尺寸 w/h 也是逻辑像素）
-    let x = mx_l.max(wa_left_l).min(wa_right_l - w);
-    let y = my_l.max(wa_top_l).min(wa_bottom_l - h);
+    // 直接以物理坐标 clamping（光标位置 + 工作区均为物理像素，避免混合 DPI 下
+    // 手动"物理→逻辑"换算后 Tauri 再按窗口所在屏解释导致的定位偏移）
+    let x = (mx as f64).max(wa_left as f64).min(wa_right as f64 - w_px);
+    let y = (my as f64).max(wa_top as f64).min(wa_bottom as f64 - h_px);
 
     // 窗口已存在：移动 + 显示 + 请求焦点
     if let Some(win) = app.get_webview_window(POPUP_LABEL) {
-        let _ = win.set_position(tauri::Position::Logical(tauri::LogicalPosition {
-            x,
-            y,
+        let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
+            x: x as i32,
+            y: y as i32,
         }));
         let _ = win.show();
+        mark_shown();
         let _ = win.set_focus();
         // 通知前端刷新数据
-        let _ = app.emit("clipboard-popup-show", ());
+        let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
         return;
     }
 
     // 兜底：窗口被销毁时重新创建（隐藏），等前端 onMounted 回调 show_window
     POPUP_PENDING_SHOW.store(true, Ordering::SeqCst);
+    if let Ok(mut pos) = PENDING_POS.lock() {
+        *pos = Some((x, y));
+    }
     create_popup_window(app);
 }
 
@@ -185,18 +222,36 @@ pub fn show_window(app: &AppHandle) {
         return;
     }
     if let Some(win) = app.get_webview_window(POPUP_LABEL) {
+        // 应用 show_popup 计算的兜底位置（物理坐标），避免停留在屏幕外
+        let pos = PENDING_POS.lock().ok().and_then(|p| *p);
+        if let Some((x, y)) = pos {
+            let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
+                x: x as i32,
+                y: y as i32,
+            }));
+        }
         let _ = win.show();
+        mark_shown();
         let _ = win.set_focus();
         // 通知前端刷新数据
-        let _ = app.emit("clipboard-popup-show", ());
+        let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
     }
 }
 
-/// 隐藏弹窗（不销毁，保留复用）
+/// 隐藏弹窗（不销毁，保留复用），并通知前端清理悬停定时器/预览。
 pub fn hide_popup(app: &AppHandle) {
+    // 复位推迟隐藏标记（先于 hide_preview，避免 hide_preview 重入 hide_popup 形成递归）
+    POPUP_DEFER_HIDE.store(false, Ordering::SeqCst);
+    // 复位交互锁定：弹窗关闭后下次呼出恢复"失焦即隐藏"的常规模式
+    POPUP_INTERACTED.store(false, Ordering::SeqCst);
+    // 同步标记弹窗不可见，拒绝此后在途的 show_preview 请求
+    POPUP_VISIBLE.store(false, Ordering::SeqCst);
+    hide_preview(app);
     if let Some(win) = app.get_webview_window(POPUP_LABEL) {
         let _ = win.hide();
     }
+    // 通知前端：取消悬停定时器并隐藏预览，避免弹窗隐藏后残留定时器重新弹出预览窗
+    let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ());
 }
 
 /// 隐藏弹窗后延迟模拟 Ctrl+V 粘贴到之前聚焦的窗口。
@@ -250,83 +305,434 @@ fn simulate_paste() {
     // 非 Windows 平台暂不支持自动粘贴
 }
 
-// ===== Win32 API：获取鼠标位置和工作区 =====
+// ===== 独立预览窗口 =====
 
-#[cfg(windows)]
-mod win_api {
-    use windows_sys::Win32::Foundation::POINT;
-    use windows_sys::Win32::UI::WindowsAndMessaging::{GetCursorPos, SystemParametersInfoW, SPI_GETWORKAREA};
+/// 创建预览窗口（隐藏状态），应用 NoActivate 样式避免抢焦点。
+fn create_preview_window(app: &AppHandle) {
+    let win = match WebviewWindowBuilder::new(
+        app,
+        PREVIEW_LABEL,
+        WebviewUrl::App("index.html#clipboard-preview".into()),
+    )
+    .title("预览")
+    .inner_size(PREVIEW_W, PREVIEW_H)
+    .position(-10000.0, -10000.0) // 屏幕外，避免隐藏时一闪
+    .decorations(false)
+    .transparent(true)
+    .shadow(true)
+    .always_on_top(true)
+    .skip_taskbar(true)
+    .resizable(false)
+    .visible(false)
+    .focused(false) // 不抢占焦点
+    .effects(EffectsBuilder::new().effects(vec![Effect::Mica]).build())
+    .build()
+    {
+        Ok(w) => w,
+        Err(e) => {
+            crate::logger::log_error("clipboard", &format!("创建预览窗失败: {}", e));
+            return;
+        }
+    };
 
-    /// 获取鼠标位置（屏幕坐标，物理像素）
-    pub fn get_cursor_pos() -> Option<(i32, i32)> {
-        let mut pt = POINT { x: 0, y: 0 };
-        unsafe {
-            if GetCursorPos(&mut pt) != 0 {
-                Some((pt.x, pt.y))
-            } else {
-                None
+    // NoActivate：预览窗可交互但不激活，弹窗保持前台（键盘导航/粘贴不受影响）
+    // 圆角：NoActivate 悬浮窗系统不自动圆角，显式指定 DWMWCP_ROUND 与弹窗外观统一
+    #[cfg(windows)]
+    if let Ok(hwnd) = win.hwnd() {
+        crate::win32_util::apply_no_activate(hwnd.0 as isize);
+        crate::win32_util::apply_rounded_corners(hwnd.0 as isize);
+    }
+
+    crate::logger::log_info("clipboard", "预览窗口已预创建（隐藏状态）");
+}
+
+/// 应用启动时预创建预览窗口（隐藏），随弹窗一起就绪。
+pub fn ensure_preview_window(app: &AppHandle) {
+    if app.get_webview_window(PREVIEW_LABEL).is_some() {
+        return;
+    }
+    create_preview_window(app);
+}
+
+/// 预览当前所在侧（default=右，left=左），供放大/还原重定位沿用同侧。
+#[derive(Clone, Copy, PartialEq)]
+enum PreviewSide {
+    Right,
+    Left,
+}
+
+static PREVIEW_SIDE: Mutex<Option<PreviewSide>> = Mutex::new(None);
+
+/// 最近一次显示预览时的鼠标 Y 锚点（物理像素）。预览窗垂直中线对齐该位置
+/// （贴近鼠标所悬停的条目），resize（切换条目/放大还原）时沿用，保持中线稳定不跳变。
+static PREVIEW_ANCHOR_Y: Mutex<Option<i32>> = Mutex::new(None);
+
+/// 弹窗离开看护线程是否已在运行（防重入，见 spawn_popup_leave_watch）。
+static POPUP_LEAVE_WATCH: AtomicBool = AtomicBool::new(false);
+
+/// 交互锁定模式：用户点击过预览窗（放大/缩小、复制文本等）后置位。
+/// 该模式下弹窗与预览不因失焦/鼠标离开而关闭，仅当点击弹窗+预览之外的
+/// 区域（看护线程检测鼠标按下沿）或弹窗重新聚焦（恢复正常模式）时才复位。
+static POPUP_INTERACTED: AtomicBool = AtomicBool::new(false);
+
+/// 重新定位预览窗口（物理像素）。preferred 指定优先放置侧，返回实际落位侧。
+/// anchor_y 为鼠标 Y 锚点：预览窗垂直中线对齐该位置（贴近悬停条目），
+/// 上下 clamp 到工作区；None 时退回弹窗顶部对齐。
+///
+/// 无边框+阴影窗口（tao 实现）的外框矩形在客户区四周各留一条不可见边框
+/// （SM_CXSIZEFRAME+SM_CXPADDEDBORDER，典型 8px）：outer_position/outer_size 均含该边框，
+/// 而可视内容仅占客户区。若直接用外框尺寸计算右侧落位，右侧可视间距会比左侧多出
+/// 两侧边框之和（约 16px）。这里以"可视边缘"对齐：frame = (外框宽 - 客户区宽) / 2，
+/// 左右两侧使用同一 GAP，保证两侧可视间距一致。
+fn reposition_preview(
+    popup: &tauri::WebviewWindow,
+    win: &tauri::WebviewWindow,
+    vw: i32,
+    vh: i32,
+    preferred: PreviewSide,
+    anchor_y: Option<i32>,
+    allow_flip: bool,
+) -> PreviewSide {
+    // 弹窗当前物理位置与尺寸（外框，含不可见边框）
+    let Ok(pos) = popup.outer_position() else { return preferred };
+    let Ok(osz) = popup.outer_size() else { return preferred };
+    let Ok(isz) = popup.inner_size() else { return preferred };
+    let (px, py) = (pos.x, pos.y);
+    let pw = osz.width as i32;
+    // 不可见边框宽度（外框与客户区之差的一半；无阴影窗口为 0）
+    let frame = ((osz.width.saturating_sub(isz.width)) / 2) as i32;
+
+    // 弹窗所在显示器工作区
+    let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(px, py)
+        .unwrap_or((0, 0, 1920, 1040));
+
+    let gap = (PREVIEW_GAP * popup.scale_factor().unwrap_or(1.0)).round() as i32;
+
+    // 可视边缘对齐：
+    // 右侧落位 = 弹窗可视右缘(px+pw-frame) + GAP - 预览窗自身左边框(frame)
+    // 左侧落位 = 弹窗可视左缘(px+frame) - GAP - 预览可视宽(vw) - 预览窗左边框(frame)
+    //           （frame 两两抵消，与旧公式一致）
+    let right_x = px + pw - 2 * frame + gap;
+    let left_x = px - gap - vw;
+    // 可视区域（含预览窗自身边框偏移）不越工作区
+    let fits_right = right_x + frame + vw <= wa_right;
+    let fits_left = left_x + frame >= wa_left;
+    let mut x = match preferred {
+        PreviewSide::Right => right_x,
+        PreviewSide::Left => left_x,
+    };
+    // 仅初始落位（allow_flip=true）允许换侧：优先侧放不下时切到另一侧。
+    // 内容尺寸变化（放大/还原，allow_flip=false）不允许换侧：窗口跳到另一侧会使
+    // 鼠标瞬间落在窗外，误触发 mouseleave 而关闭预览/弹窗；此时保持原侧并靠
+    // 工作区 clamp（大图可能覆盖弹窗边缘，属合理取舍，鼠标仍在预览窗内可交互）。
+    if allow_flip {
+        match preferred {
+            PreviewSide::Right => {
+                if !fits_right {
+                    x = left_x;
+                }
+            }
+            PreviewSide::Left => {
+                if !fits_left {
+                    x = right_x;
+                }
             }
         }
     }
+    x = (x + frame).max(wa_left).min(wa_right - vw) - frame;
+    // 仅初始落位（allow_flip）按最终位置更新所在侧（换侧时位置在弹窗另一侧，判定正确）；
+    // 放大/还原（不允许换侧）时即使被工作区 clamp 覆盖到弹窗上方，语义上仍属原侧，
+    // 必须沿用 preferred——否则 clamp 后按位置误判为另一侧并存档，缩小后会跳侧。
+    let side = if allow_flip {
+        if x + vw <= px { PreviewSide::Left } else { PreviewSide::Right }
+    } else {
+        preferred
+    };
+    // 垂直定位：预览窗中线对齐鼠标 Y 锚点（贴近悬停条目），上下 clamp 到工作区；
+    // 无锚点时退回弹窗顶部对齐
+    let y = match anchor_y {
+        Some(ay) => (ay - vh / 2).max(wa_top).min(wa_bottom - vh),
+        None => py.max(wa_top).min(wa_bottom - vh),
+    };
 
-    /// 获取主屏工作区尺寸（排除任务栏，物理像素）
-    pub fn get_work_area() -> Option<(f64, f64)> {
-        use windows_sys::Win32::Foundation::RECT;
-        let mut rect = RECT { left: 0, top: 0, right: 0, bottom: 0 };
-        unsafe {
-            if SystemParametersInfoW(SPI_GETWORKAREA, 0, &mut rect as *mut _ as *mut _, 0) != 0 {
-                Some(((rect.right - rect.left) as f64, (rect.bottom - rect.top) as f64))
-            } else {
-                None
-            }
+    let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition { x, y }));
+    if let Ok(mut s) = PREVIEW_SIDE.lock() {
+        *s = Some(side);
+    }
+    side
+}
+
+/// 通知预览前端加载指定条目。窗口此时保持隐藏：前端测得内容尺寸后先调用
+/// resize_preview（隐藏状态下完成尺寸/位置调整）再 reveal_preview 显示，
+/// 避免"先以上次尺寸（可能是放大态大窗）显示再缩回"的闪烁。
+pub fn show_preview(app: &AppHandle, id: i64) {
+    // 弹窗已隐藏（或隐藏中）时拒绝显示预览：同步标志消除 is_visible() 的异步时序竞态，
+    // 保证"弹窗失焦消失后预览窗不会孤立残留"。
+    if !POPUP_VISIBLE.load(Ordering::SeqCst) {
+        return;
+    }
+    if app.get_webview_window(PREVIEW_LABEL).is_none() {
+        return;
+    }
+    let Some(popup) = app.get_webview_window(POPUP_LABEL) else {
+        return;
+    };
+    // 弹窗不可见时不显示预览：避免弹窗隐藏后仍在途的悬停请求重新弹出孤立的预览窗
+    if !popup.is_visible().unwrap_or(false) {
+        return;
+    }
+
+    // 记录鼠标 Y 锚点：预览窗中线对齐鼠标所悬停的条目位置；resize 时沿用
+    if let Some((_, y)) = get_cursor_pos() {
+        if let Ok(mut a) = PREVIEW_ANCHOR_Y.lock() {
+            *a = Some(y);
         }
     }
 
-    /// 获取指定点所在显示器的工作区（排除任务栏），返回 (left, top, right, bottom) 物理像素。
-    /// 使用 MonitorFromPoint 支持多显示器环境。
-    pub fn get_work_area_at_point(x: i32, y: i32) -> Option<(i32, i32, i32, i32)> {
-        use windows_sys::Win32::Graphics::Gdi::{
-            GetMonitorInfoW, MonitorFromPoint, MONITORINFO, MONITOR_DEFAULTTONEAREST,
-        };
-        let pt = POINT { x, y };
-        let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
-        let mut mi: MONITORINFO = unsafe { std::mem::zeroed() };
-        mi.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
-        unsafe {
-            if GetMonitorInfoW(hmon, &mut mi) != 0 {
-                let rc = mi.rcWork;
-                Some((rc.left, rc.top, rc.right, rc.bottom))
-            } else {
-                None
-            }
-        }
-    }
+    // 通知前端加载条目内容（前端完成后自行 resize + reveal）
+    let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_SHOW, id);
+}
 
-    /// 获取指定点所在显示器的有效 DPI。
-    /// scale factor = dpi / 96。
-    pub fn get_dpi_for_point(x: i32, y: i32) -> Option<u32> {
-        use windows_sys::Win32::Graphics::Gdi::{MonitorFromPoint, MONITOR_DEFAULTTONEAREST};
-        use windows_sys::Win32::UI::HiDpi::{GetDpiForMonitor, MDT_EFFECTIVE_DPI};
-        let pt = POINT { x, y };
-        let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
-        let mut dpi_x: u32 = 0;
-        let mut dpi_y: u32 = 0;
-        unsafe {
-            if GetDpiForMonitor(hmon, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == 0 {
-                Some(dpi_x)
-            } else {
-                None
-            }
-        }
+/// 显示已就绪的预览窗口（前端完成内容加载与 resize 后调用）。
+/// 显示前重查弹窗可见性，消除内容加载期间弹窗已隐藏的竞态。
+pub fn reveal_preview(app: &AppHandle) {
+    // 弹窗已隐藏：在途请求作废
+    if !POPUP_VISIBLE.load(Ordering::SeqCst) {
+        return;
+    }
+    // 已可见则跳过（放大/还原触发的重复 reveal）
+    if PREVIEW_VISIBLE.load(Ordering::SeqCst) {
+        return;
+    }
+    let Some(win) = app.get_webview_window(PREVIEW_LABEL) else {
+        return;
+    };
+
+    // 同步标记预览窗可见（以原生方式显示，Tauri 的 is_visible 可能不同步）
+    PREVIEW_VISIBLE.store(true, Ordering::SeqCst);
+    // 不激活显示（SW_SHOWNOACTIVATE），弹窗保持前台
+    #[cfg(windows)]
+    if let Ok(hwnd) = win.hwnd() {
+        crate::win32_util::show_no_activate(hwnd.0 as isize);
+    }
+    #[cfg(not(windows))]
+    let _ = win.show();
+
+    // 显示期间弹窗可能已被隐藏（失焦/关闭）：立即收回预览。
+    // 关闭初次检查与真正 show 之间的竞态——失焦处理器先置 POPUP_VISIBLE=false
+    // 再隐藏，这里 show 之后重查一次，若已被隐藏则收回预览，避免孤立残留。
+    if !POPUP_VISIBLE.load(Ordering::SeqCst) {
+        PREVIEW_VISIBLE.store(false, Ordering::SeqCst);
+        let _ = win.hide();
     }
 }
 
-#[cfg(not(windows))]
-mod win_api {
-    pub fn get_cursor_pos() -> Option<(i32, i32)> { None }
-    pub fn get_work_area() -> Option<(f64, f64)> { None }
-    pub fn get_work_area_at_point(_x: i32, _y: i32) -> Option<(i32, i32, i32, i32)> { None }
-    pub fn get_dpi_for_point(_x: i32, _y: i32) -> Option<u32> { None }
+/// 按内容自适应调整预览窗大小（逻辑像素），位置沿用当前所在侧并重新对齐弹窗。
+/// 前端加载/切换内容（文本测高、图片按宽高比）后调用，窗口贴合内容消除留白。
+/// allow_flip：初始落位为 true（优先侧放不下可换侧）；放大/还原为 false
+/// （保持原侧靠工作区 clamp，避免窗口跳侧使鼠标落在窗外误触发隐藏）。
+pub fn resize_preview(app: &AppHandle, width: f64, height: f64, allow_flip: bool) {
+    // 弹窗不可见时忽略（无对齐基准）
+    if !POPUP_VISIBLE.load(Ordering::SeqCst) {
+        return;
+    }
+    let Some(win) = app.get_webview_window(PREVIEW_LABEL) else {
+        return;
+    };
+    let Some(popup) = app.get_webview_window(POPUP_LABEL) else {
+        return;
+    };
+
+    let scale = popup.scale_factor().unwrap_or(1.0);
+    // 以弹窗所在屏工作区为上限钳制（逻辑像素），并保证不小于最小可视尺寸
+    let (wa_left, wa_top, wa_right, wa_bottom) = popup
+        .outer_position()
+        .ok()
+        .and_then(|p| get_work_area_at_point(p.x, p.y))
+        .unwrap_or((0, 0, 1920, 1040));
+    let max_w = ((wa_right - wa_left).max(0) as f64 / scale).floor().max(PREVIEW_MIN_W);
+    let max_h = ((wa_bottom - wa_top).max(0) as f64 / scale).floor().max(PREVIEW_MIN_H);
+    let w = width.clamp(PREVIEW_MIN_W, max_w);
+    let h = height.clamp(PREVIEW_MIN_H, max_h);
+    let vw = (w * scale).round() as i32;
+    let vh = (h * scale).round() as i32;
+
+    let side = PREVIEW_SIDE.lock().ok().and_then(|s| *s).unwrap_or(PreviewSide::Right);
+    // 沿用最近一次的鼠标 Y 锚点：高度变化时中线保持对齐悬停条目，不产生跳变
+    let anchor_y = PREVIEW_ANCHOR_Y.lock().ok().and_then(|a| *a);
+    reposition_preview(&popup, &win, vw, vh, side, anchor_y, allow_flip);
+    let _ = win.set_size(tauri::Size::Physical(tauri::PhysicalSize { width: vw as u32, height: vh as u32 }));
 }
 
-pub use win_api::{get_cursor_pos, get_work_area, get_work_area_at_point, get_dpi_for_point};
+/// 交互锁定模式入口：前端预览窗收到 mousedown（放大/缩小、复制、选择文本）时调用。
+/// 置位锁定标志并启动看护线程：此后弹窗+预览不因失焦/鼠标离开而关闭，
+/// 仅当点击弹窗+预览之外的区域或弹窗重新聚焦时退出锁定。
+pub fn preview_interacted(app: &AppHandle) {
+    POPUP_INTERACTED.store(true, Ordering::SeqCst);
+    // 交互锁定取代推迟隐藏模式：清除可能残留的 DEFER 标记，
+    // 避免后续取消钉住时 hide_preview 走 DEFER 分支误关弹窗
+    POPUP_DEFER_HIDE.store(false, Ordering::SeqCst);
+    spawn_popup_leave_watch(app.clone());
+}
+
+/// 隐藏预览窗口（保留复用），并通知前端清空内容。
+pub fn hide_preview(app: &AppHandle) {
+    // 交互锁定模式：弹窗仍显示时预览保持（生命周期由看护线程管理，点击外部才
+    // 随弹窗一起关闭），忽略常规隐藏请求（条目离开、键盘切换等）。
+    if POPUP_INTERACTED.load(Ordering::SeqCst) && POPUP_VISIBLE.load(Ordering::SeqCst) {
+        return;
+    }
+    POPUP_INTERACTED.store(false, Ordering::SeqCst);
+    // 若此前因预览交互推迟了弹窗隐藏（弹窗已失焦但保持显示），现在用户离开预览窗，
+    // 需判断去向：光标已回到弹窗内（继续浏览弹窗）→ 仅隐藏预览、保持弹窗显示；
+    // 光标在弹窗之外（离开整个区域）→ 连同弹窗一起隐藏。
+    // （hide_popup 会先复位该标记，故此处 swap(false) 后调用不会递归重入）
+    if POPUP_DEFER_HIDE.swap(false, Ordering::SeqCst) {
+        if !is_cursor_in_popup(app) {
+            hide_popup(app);
+            return;
+        }
+        // 光标已回到弹窗内。若弹窗仍持有焦点（曾点击弹窗重新激活），仅隐藏预览即可，
+        // 后续失焦仍走 Focused(false) 正常关闭；若弹窗已失焦（点击预览窗所致），
+        // 它不会再收到 Focused(false) 事件——光标一旦离开弹窗区域，弹窗将永远
+        // 无法关闭（无焦点残留窗口）。启动看护线程兜底关闭。
+        let focused = app
+            .get_webview_window(POPUP_LABEL)
+            .map(|w| w.is_focused().unwrap_or(false))
+            .unwrap_or(false);
+        if !focused {
+            spawn_popup_leave_watch(app.clone());
+        }
+    }
+    PREVIEW_VISIBLE.store(false, Ordering::SeqCst);
+    if let Some(win) = app.get_webview_window(PREVIEW_LABEL) {
+        let _ = win.hide();
+        // 预览窗以原生 SW_SHOWNOACTIVATE 方式显示，Tauri 内部可见性状态可能与其
+        // 不同步；补一次原生 SW_HIDE，确保任何路径下都被可靠隐藏。
+        #[cfg(windows)]
+        if let Ok(hwnd) = win.hwnd() {
+            crate::win32_util::hide_window(hwnd.0 as isize);
+        }
+    }
+    let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_HIDE, ());
+}
+
+/// 弹窗失焦但保持显示时的看护线程（防重入单例）。
+///
+/// 两种工作模式（每轮动态读取 POPUP_INTERACTED，可中途切换）：
+/// - 常规模式（未点击过预览窗）：光标连续 ~300ms 既不在弹窗也不在预览窗内
+///   （连续计数防"穿越弹窗-预览间隙"时的瞬时离开误判）→ 关闭弹窗；
+/// - 交互锁定模式（点击过预览窗的放大/缩小/复制等）：弹窗已失焦不会再收到
+///   Focused(false)，检测"鼠标按下沿且按下位置在弹窗+预览之外"→ 点击外部，关闭弹窗。
+///
+/// 公共退出条件：弹窗已隐藏/销毁（其他路径关闭）；弹窗重新获得焦点（用户点击
+/// 弹窗，恢复正常失焦关闭路径，并复位交互锁定）；超时兜底防线程泄漏
+/// （常规 30s；交互锁定为事件驱动，放宽至 10min）。
+fn spawn_popup_leave_watch(app: AppHandle) {
+    // 防重入：已有看护在运行则跳过
+    if POPUP_LEAVE_WATCH.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    std::thread::spawn(move || {
+        let start = Instant::now();
+        let mut outside = 0u32;
+        let mut was_down = false;
+        loop {
+            std::thread::sleep(Duration::from_millis(30));
+            // 弹窗已隐藏或被销毁：看护结束
+            if !POPUP_VISIBLE.load(Ordering::SeqCst)
+                || app.get_webview_window(POPUP_LABEL).is_none()
+            {
+                break;
+            }
+            // 弹窗重新获得焦点（用户点击弹窗）：恢复正常失焦关闭路径，复位交互锁定
+            if app
+                .get_webview_window(POPUP_LABEL)
+                .map(|w| w.is_focused().unwrap_or(false))
+                .unwrap_or(false)
+            {
+                POPUP_INTERACTED.store(false, Ordering::SeqCst);
+                break;
+            }
+            let interacted = POPUP_INTERACTED.load(Ordering::SeqCst);
+            // 超长兜底：避免异常路径下看护线程无限轮询
+            let timeout = if interacted {
+                Duration::from_secs(600)
+            } else {
+                Duration::from_secs(30)
+            };
+            if start.elapsed() > timeout {
+                hide_popup(&app);
+                break;
+            }
+            let cursor_in = is_cursor_in_popup(&app) || is_cursor_in_preview(&app);
+            if interacted {
+                // 交互锁定：左键按下沿发生在弹窗+预览之外 → 点击外部，关闭弹窗+预览。
+                // 按下沿判定（上一轮未按下、本轮按下）配合 30ms 轮询，可捕获常规点击；
+                // 在弹窗/预览内按下后拖出再松开不算外部点击（以按下位置为准）。
+                let down = crate::win32_util::is_left_button_down();
+                if down && !was_down && !cursor_in {
+                    hide_popup(&app);
+                    break;
+                }
+                was_down = down;
+            } else if cursor_in {
+                outside = 0;
+            } else {
+                outside += 1;
+                // 连续 ~300ms 不在弹窗/预览区域（排除穿越间隙的瞬时状态）才关闭
+                if outside >= 10 {
+                    hide_popup(&app);
+                    break;
+                }
+            }
+        }
+        POPUP_LEAVE_WATCH.store(false, Ordering::SeqCst);
+    });
+}
+
+/// 鼠标当前是否位于弹窗矩形内（弹窗可见且光标在其窗口范围内）。
+/// 用于 hide_preview 判断"用户是回到弹窗继续浏览，还是离开整个区域"。
+fn is_cursor_in_popup(app: &AppHandle) -> bool {
+    if !POPUP_VISIBLE.load(Ordering::SeqCst) {
+        return false;
+    }
+    let Some(win) = app.get_webview_window(POPUP_LABEL) else {
+        return false;
+    };
+    let Ok(pos) = win.outer_position() else { return false };
+    let Ok(size) = win.outer_size() else { return false };
+    let Some((cx, cy)) = crate::win32_util::get_cursor_pos() else {
+        return false;
+    };
+    let x = pos.x;
+    let y = pos.y;
+    let w = size.width as i32;
+    let h = size.height as i32;
+    cx >= x && cx <= x + w && cy >= y && cy <= y + h
+}
+
+/// 鼠标当前是否位于预览窗矩形内（预览窗可见且光标在其窗口范围内）。
+/// 用于弹窗失焦时判断是否因预览交互所致，决定是否推迟隐藏弹窗。
+fn is_cursor_in_preview(app: &AppHandle) -> bool {
+    if !PREVIEW_VISIBLE.load(Ordering::SeqCst) {
+        return false;
+    }
+    let Some(win) = app.get_webview_window(PREVIEW_LABEL) else {
+        return false;
+    };
+    let Ok(pos) = win.outer_position() else { return false };
+    let Ok(size) = win.outer_size() else { return false };
+    let Some((cx, cy)) = crate::win32_util::get_cursor_pos() else {
+        return false;
+    };
+    let x = pos.x;
+    let y = pos.y;
+    let w = size.width as i32;
+    let h = size.height as i32;
+    cx >= x && cx <= x + w && cy >= y && cy <= y + h
+}
+
+// ===== 屏幕/光标/DPI 工具已迁移至 crate::win32_util（跨模块共享） =====
+
+use crate::win32_util::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};

src-tauri/src/clipboard/reader.rs

@@ -295,3 +295,29 @@ pub fn dib_to_png(dib: &[u8]) -> Option<Vec<u8>> {
         .ok()?;
     Some(buf)
 }
+
+/// 生成缩略图 PNG（最长边不超过 max_dim 像素）。
+/// 小图直接复用 `dib_to_png` 结果；大图降采样后重新编码，供弹窗悬停预览使用。
+pub fn dib_to_thumbnail(dib: &[u8], max_dim: u32) -> Option<Vec<u8>> {
+    use image::codecs::png::PngEncoder;
+    use image::GenericImageView;
+    use image::ImageEncoder;
+
+    let png = dib_to_png(dib)?;
+    let img = image::load_from_memory(&png).ok()?;
+    let (w, h) = img.dimensions();
+    if w.max(h) <= max_dim {
+        return Some(png); // 小图直接使用，避免重复编码
+    }
+    // 让 image 库在 max_dim×max_dim 边界内自动等比缩放，避免手算 nw/nh 与库内部
+    // resize_dimensions 的取整不一致（如手算 256x10 而库实际输出 250x10），
+    // 否则 write_image 的缓冲区长度断言会失败。
+    let resized = img.resize(max_dim, max_dim, image::imageops::FilterType::Triangle);
+    let (rw, rh) = resized.dimensions();
+    let rgba = resized.to_rgba8();
+    let mut buf = Vec::new();
+    let enc = PngEncoder::new(&mut buf);
+    enc.write_image(rgba.as_raw(), rw, rh, image::ExtendedColorType::Rgba8)
+        .ok()?;
+    Some(buf)
+}

src-tauri/src/clipboard/storage.rs

@@ -2,13 +2,15 @@
 //!
 //! 表结构见 `init_db`。所有方法线程安全（内部 Mutex 包裹 Connection）。
 
+use base64::Engine as _;
 use rusqlite::{params, Connection, OptionalExtension};
+use specta::Type;
 use std::fs;
 use std::path::PathBuf;
 use std::sync::Mutex;
 
 /// 列表项（不含大字段，用于历史/搜索结果）
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct ClipboardItem {
     pub id: i64,
@@ -21,7 +23,7 @@ pub struct ClipboardItem {
 }
 
 /// 详情（含文本内容或图片 base64）
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct ClipboardItemDetail {
     #[serde(flatten)]
@@ -37,6 +39,8 @@ pub struct NewItem {
     pub kind: String,
     pub content: Option<String>,
     pub blob: Option<Vec<u8>>,
+    /// 图片缩略图 PNG（仅 image 类型，供弹窗悬停预览）
+    pub thumb: Option<Vec<u8>>,
     pub preview: String,
     pub size: i64,
     pub hash: String,
@@ -87,6 +91,19 @@ impl Storage {
             CREATE INDEX IF NOT EXISTS idx_hash ON clipboard_history(hash);
             CREATE INDEX IF NOT EXISTS idx_kind ON clipboard_history(kind);",
         );
+        // 迁移：老库无 thumb 列（图片缩略图，供弹窗悬停预览），补列
+        let has_thumb = conn
+            .prepare("PRAGMA table_info(clipboard_history)")
+            .ok()
+            .map(|mut stmt| {
+                stmt.query_map([], |r| r.get::<_, String>(1))
+                    .map(|rows| rows.filter_map(|c| c.ok()).any(|c| c == "thumb"))
+                    .unwrap_or(false)
+            })
+            .unwrap_or(false);
+        if !has_thumb {
+            let _ = conn.execute("ALTER TABLE clipboard_history ADD COLUMN thumb BLOB", []);
+        }
     }
 
     /// 插入新条目；若 dedup 为 true 且 hash 已存在则仅更新 created_at，返回条目 id。
@@ -119,12 +136,13 @@ impl Storage {
         let now = now_ms();
         let res = conn.execute(
             "INSERT INTO clipboard_history
-                (kind, content, blob, preview, size, hash, pinned, pinned_order, created_at)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, 0, NULL, ?7)",
+                (kind, content, blob, thumb, preview, size, hash, pinned, pinned_order, created_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, 0, NULL, ?8)",
             params![
                 item.kind,
                 item.content,
                 item.blob.as_deref(),
+                item.thumb.as_deref(),
                 item.preview,
                 item.size,
                 item.hash,
@@ -206,10 +224,11 @@ impl Storage {
     }
 
     /// 获取详情（含文本/图片预览 base64）
+    /// 先锁内查询数据，释放锁后再执行耗时编码（DIB→PNG + base64），避免长时间占用连接锁
     pub fn get_detail(&self, id: i64, image_to_base64: impl Fn(&[u8]) -> Option<String>) -> Option<ClipboardItemDetail> {
-        let conn = self.conn.lock().ok()?;
-        let row = conn
-            .query_row(
+        let (item, content, blob) = {
+            let conn = self.conn.lock().ok()?;
+            conn.query_row(
                 "SELECT id, kind, preview, size, pinned, pinned_order, created_at, content, blob
                  FROM clipboard_history WHERE id = ?1",
                 params![id],
@@ -232,8 +251,9 @@ impl Storage {
                     ))
                 },
             )
-            .ok()?;
-        let (item, content, blob) = row;
+            .ok()?
+        };
+        // conn 已在此处释放，以下编码不占用连接锁
         let image_base64 = if item.kind == "image" {
             blob.as_deref().and_then(|b| image_to_base64(b))
         } else {
@@ -246,6 +266,26 @@ impl Storage {
         })
     }
 
+    /// 获取图片缩略图 PNG base64（弹窗悬停预览用）。
+    /// 老数据无缩略图时回退为 `thumb_from_dib` 现场生成。
+    pub fn get_thumb(&self, id: i64, thumb_from_dib: impl Fn(&[u8]) -> Option<Vec<u8>>) -> Option<String> {
+        let (thumb, blob) = {
+            let conn = self.conn.lock().ok()?;
+            conn.query_row(
+                "SELECT thumb, blob FROM clipboard_history WHERE id = ?1 AND kind = 'image'",
+                params![id],
+                |r| Ok((r.get::<_, Option<Vec<u8>>>(0)?, r.get::<_, Option<Vec<u8>>>(1)?)),
+            )
+            .ok()?
+        };
+        // conn 已在此处释放
+        let png = match thumb {
+            Some(t) if !t.is_empty() => Some(t),
+            _ => blob.as_deref().and_then(|b| thumb_from_dib(b)),
+        };
+        png.map(|p| base64::engine::general_purpose::STANDARD.encode(&p))
+    }
+
     /// 获取原始字段供 copy_back 写回（避免 base64 转换开销）
     pub fn get_raw_for_copy(&self, id: i64) -> Option<(String, Option<String>, Option<Vec<u8>>)> {
         let conn = self.conn.lock().ok()?;
@@ -342,6 +382,7 @@ impl Storage {
     }
 
     /// 按搜索关键词统计匹配的非固定条目总数
+    /// 与 `search` 保持一致的匹配字段（preview + content），避免分页总数错误
     pub fn count_search(&self, query: &str) -> i64 {
         let conn = match self.conn.lock() {
             Ok(c) => c,
@@ -349,7 +390,8 @@ impl Storage {
         };
         let pattern = format!("%{}%", query);
         conn.query_row(
-            "SELECT COUNT(*) FROM clipboard_history WHERE pinned = 0 AND preview LIKE ?1",
+            "SELECT COUNT(*) FROM clipboard_history
+             WHERE pinned = 0 AND (preview LIKE ?1 OR content LIKE ?1)",
             params![pattern],
             |r| r.get(0),
         )

src-tauri/src/constants.rs

@@ -0,0 +1,65 @@
+//! 全局常量集中定义。
+//! 窗口 label / Tauri 事件名，避免魔法字符串散布各处。
+//! 与前端 `src/lib/constants.ts` 保持对应。
+
+/// 窗口 label（对应 capabilities/*.json 与前端 constants::WINDOWS）
+pub mod windows {
+    pub const MAIN: &str = "main";
+    // 以下窗口由前端创建，Rust 侧仅作双端对应声明（无直接引用）
+    #[allow(dead_code)]
+    pub const OSD_OVERLAY: &str = "osd-overlay";
+    #[allow(dead_code)]
+    pub const SCREENSHOT_OVERLAY: &str = "screenshot-overlay";
+    #[allow(dead_code)]
+    pub const SCREENSHOT_PIN: &str = "screenshot-pin";
+}
+
+/// Tauri 事件名（与前端 constants::EVENTS 对应）
+pub mod events {
+    // 托盘菜单
+    pub const TRAY_MENU_SHOW: &str = "tray-menu-show";
+    pub const TRAY_MENU_STATE_UPDATED: &str = "tray-menu-state-updated";
+    pub const TRAY_TOGGLE_OSD: &str = "tray:toggle-osd";
+    pub const TRAY_NEW_DOWNLOAD: &str = "tray:new-download";
+    pub const TRAY_OPEN_SETTINGS: &str = "tray:open-settings";
+    // 剪贴板
+    pub const CLIPBOARD_CHANGED: &str = "clipboard-changed";
+    pub const CLIPBOARD_POPUP_SHOW: &str = "clipboard-popup-show";
+    pub const CLIPBOARD_POPUP_HIDE: &str = "clipboard-popup-hide";
+    pub const CLIPBOARD_PREVIEW_SHOW: &str = "clipboard-preview-show";
+    pub const CLIPBOARD_PREVIEW_HIDE: &str = "clipboard-preview-hide";
+    // 快速面板
+    pub const QUICKPANEL_SHOW: &str = "quickpanel-show";
+    pub const QUICKPANEL_HIDE: &str = "quickpanel-hide";
+    pub const QUICKPANEL_EXTRACT_PROGRESS: &str = "quickpanel-extract-progress";
+    /// 文件索引构建完成（闲时自动建立/重建、手动构建），负载为条目数
+    pub const QUICKPANEL_INDEX_UPDATED: &str = "quickpanel-index-updated";
+    // 监控
+    pub const MONITOR_DATA: &str = "monitor-data";
+    pub const MONITOR_NETWORK: &str = "monitor-network";
+    pub const MONITOR_ERROR: &str = "monitor-error";
+    pub const MONITOR_LOADING: &str = "monitor-loading";
+    pub const MONITOR_READY: &str = "monitor-ready";
+    pub const MONITOR_DISCONNECTED: &str = "monitor-disconnected";
+    // OSD 窗口
+    pub const OSD_SYSTEM_UI_ACTIVE: &str = "osd-system-ui-active";
+    pub const OSD_SYSTEM_UI_INACTIVE: &str = "osd-system-ui-inactive";
+    pub const OSD_START_DRAG: &str = "osd-start-drag";
+    pub const OSD_END_DRAG: &str = "osd-end-drag";
+    // 截图
+    pub const SCREENSHOT_SHORTCUT: &str = "screenshot-shortcut";
+    pub const SCREENSHOT_PIN_SHORTCUT: &str = "screenshot-pin-shortcut";
+    // 内核安装进度
+    pub const KERNEL_INSTALL_PROGRESS: &str = "kernel-install-progress";
+    // 后端自动切换节点完成（前端据以刷新节点列表并提示）
+    pub const PROXY_AUTO_SWITCH: &str = "proxy-auto-switch";
+    // 应用更新进度
+    pub const UPDATE_PROGRESS: &str = "update-progress";
+    // 进程与下载
+    pub const PROCESS_STATUS_CHANGED: &str = "process-status-changed";
+    pub const DOWNLOAD_ADDED: &str = "download-added";
+    /// 任务被删除（浏览器扩展通过 HTTP API 删除任务时发出，前端据此刷新任务列表）
+    pub const DOWNLOAD_REMOVED: &str = "download-removed";
+    /// 浏览器扩展通过 HTTP API 新增下载（前端需置前主窗口并跳到下载画面）
+    pub const DOWNLOAD_EXTENSION_ADDED: &str = "download-extension-added";
+}

src-tauri/src/download_engine/commands.rs

@@ -8,12 +8,14 @@ use super::task::{DownloadTask, DownloaderSettings};
 
 /// 获取所有任务
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_get_tasks(engine: State<'_, DownloadEngine>) -> Vec<DownloadTask> {
     engine.get_tasks()
 }
 
 /// 检查 URL 重复性并探测文件信息（添加下载前调用）
 #[tauri::command]
+#[specta::specta]
 pub async fn downloader_check_url(
     engine: State<'_, DownloadEngine>,
     url: String,
@@ -47,6 +49,7 @@ pub async fn downloader_check_url(
 
 /// 添加下载任务
 #[tauri::command]
+#[specta::specta]
 pub async fn downloader_add_task(
     engine: State<'_, DownloadEngine>,
     url: String,
@@ -60,18 +63,21 @@ pub async fn downloader_add_task(
 
 /// 暂停任务
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_pause_task(engine: State<'_, DownloadEngine>, id: String) -> Result<(), String> {
     engine.pause_task(&id)
 }
 
 /// 恢复任务
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_resume_task(engine: State<'_, DownloadEngine>, id: String) -> Result<(), String> {
     engine.resume_task(&id)
 }
 
 /// 移除任务
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_remove_task(
     engine: State<'_, DownloadEngine>,
     id: String,
@@ -82,12 +88,14 @@ pub fn downloader_remove_task(
 
 /// 获取设置
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_get_settings(engine: State<'_, DownloadEngine>) -> DownloaderSettings {
     engine.get_settings()
 }
 
 /// 保存设置
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_save_settings(
     engine: State<'_, DownloadEngine>,
     settings: DownloaderSettings,
@@ -118,6 +126,7 @@ pub fn downloader_get_extension_info(engine: State<'_, DownloadEngine>) -> serde
 
 /// 用系统资源管理器打开目录
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_open_dir(app: AppHandle, path: String) -> Result<(), String> {
     app.opener()
         .open_path(path, None::<&str>)
@@ -126,6 +135,7 @@ pub fn downloader_open_dir(app: AppHandle, path: String) -> Result<(), String> {
 
 /// 用系统默认浏览器打开 URL
 #[tauri::command]
+#[specta::specta]
 pub fn downloader_open_url(app: AppHandle, url: String) -> Result<(), String> {
     app.opener()
         .open_url(url, None::<&str>)

src-tauri/src/download_engine/engine.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
@@ -10,9 +10,10 @@ use super::http_dl::{HttpDownloader, split_segments};
 use super::rate_limit::RateLimiter;
 use super::storage::{EngineState, Storage};
 use super::task::{DownloadTask, DownloaderSettings, ProbeResult, Segment, TaskStatus};
+use specta::Type;
 
 /// 重复类型
-#[derive(Debug, Clone, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub enum DuplicateKind {
     /// 无重复
@@ -26,7 +27,7 @@ pub enum DuplicateKind {
 }
 
 /// 已存在的任务信息（用于前端展示）
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct ExistingTaskInfo {
     pub id: String,
@@ -35,7 +36,7 @@ pub struct ExistingTaskInfo {
 }
 
 /// check_url 命令返回的结果
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct CheckUrlResult {
     /// 探测是否成功
@@ -63,6 +64,8 @@ pub struct ProgressPayload {
     pub total_size: u64,
     pub speed: u64,
     pub status: TaskStatus,
+    /// 每个分段的已下载字节（与任务 segments 一一对应，供前端详情弹窗实时展示）
+    pub segments: Vec<u64>,
 }
 
 /// 完成事件载荷（发给前端 download-complete 事件）
@@ -77,6 +80,9 @@ pub struct CompletePayload {
 
 /// 活跃下载句柄
 struct TaskHandle {
+    /// 代际号：同一任务每次 start_download 递增。
+    /// 旧代际任务完成时不删除新任务句柄、不覆盖新任务状态（防 pause→resume 竞态）
+    gen: u64,
     cancel: Arc<AtomicBool>,
     /// 每个分段的已下载字节（与 segments 一一对应）
     progress: Vec<Arc<std::sync::atomic::AtomicU64>>,
@@ -103,10 +109,15 @@ struct EngineInner {
     global_limiter: Arc<RateLimiter>,
     /// HTTP 下载器
     http: HttpDownloader,
+    /// 下载是否使用代理（true=尊重系统代理，false=强制直连）
+    /// 独立于 settings 存储，避免下载过程中反复锁 settings；save_settings 时同步更新
+    use_proxy: AtomicBool,
     /// Tauri 应用句柄（用于发事件）
     app_handle: AppHandle,
     /// 引擎是否已启动
     started: AtomicBool,
+    /// 任务代际计数器（每次 start_download 递增，分配给新句柄）
+    next_gen: AtomicU64,
     /// 持久化节流：上次保存时间
     last_save: Mutex<Instant>,
 }
@@ -138,6 +149,8 @@ impl DownloadEngine {
             0
         };
         let global_limiter = Arc::new(RateLimiter::new(global_limit));
+        // 在 settings 移入 Mutex 前读取代理开关
+        let use_proxy = settings.use_proxy;
 
         let engine = Self {
             inner: Arc::new(EngineInner {
@@ -147,8 +160,10 @@ impl DownloadEngine {
                 settings: Mutex::new(settings),
                 global_limiter,
                 http: HttpDownloader::new(),
+                use_proxy: AtomicBool::new(use_proxy),
                 app_handle,
                 started: AtomicBool::new(false),
+                next_gen: AtomicU64::new(0),
                 last_save: Mutex::new(Instant::now()),
             }),
         };
@@ -181,8 +196,9 @@ impl DownloadEngine {
         dir: Option<&str>,
         headers: &HashMap<String, String>,
     ) -> (Result<ProbeResult, String>, DuplicateKind, Option<ExistingTaskInfo>) {
-        let probe = self.inner.http.probe(url, headers).await;
-        let settings = self.inner.settings.lock().unwrap().clone();
+        let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
+        let probe = self.inner.http.probe(url, headers, use_proxy).await;
+        let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
         let task_dir = dir.map(|d| d.to_string()).unwrap_or_else(|| settings.download_dir.clone());
 
         let filename = probe.as_ref().ok()
@@ -199,7 +215,7 @@ impl DownloadEngine {
         let mut existing: Option<ExistingTaskInfo> = None;
 
         {
-            let tasks = self.inner.tasks.lock().unwrap();
+            let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             for t in tasks.values() {
                 // URL 完全相同
                 if t.url == url {
@@ -243,11 +259,30 @@ impl DownloadEngine {
     }
 
     /// 生成不冲突的文件名（同名时追加 (1)、(2)...）
+    /// 冲突来源：磁盘已有同名最终文件、已存在同名临时文件（其他任务正在下载该名）、
+    /// 以及任务列表中已有任务占用同名（即使最终文件尚未落盘，避免共用同一 .thingdl 临时文件）
     fn generate_unique_filename(&self, dir: &str, filename: &str) -> String {
-        let path = PathBuf::from(dir).join(filename);
-        if !path.exists() {
+        // 任务列表中已占用的文件名（同一目录下）
+        let taken: std::collections::HashSet<String> = {
+            let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+            tasks
+                .values()
+                .filter(|t| t.dir == dir)
+                .map(|t| t.filename.clone())
+                .collect()
+        };
+
+        // 磁盘最终文件 / 临时文件 / 任务占用，三者任一冲突即视为被占用
+        let used = |name: &str| {
+            taken.contains(name)
+                || PathBuf::from(dir).join(name).exists()
+                || PathBuf::from(dir).join(format!("{}.thingdl", name)).exists()
+        };
+
+        if !used(filename) {
             return filename.to_string();
         }
+        let path = PathBuf::from(dir).join(filename);
         let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("download");
         let ext = path.extension().and_then(|s| s.to_str());
         for i in 1..1000 {
@@ -255,8 +290,7 @@ impl DownloadEngine {
                 Some(e) => format!("{} ({}).{}", stem, i, e),
                 None => format!("{} ({})", stem, i),
             };
-            let new_path = PathBuf::from(dir).join(&new_name);
-            if !new_path.exists() {
+            if !used(&new_name) {
                 return new_name;
             }
         }
@@ -278,9 +312,10 @@ impl DownloadEngine {
         auto_rename: bool,
     ) -> Result<String, String> {
         // 探测资源信息
-        let probe = self.inner.http.probe(&url, &headers).await;
+        let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
+        let probe = self.inner.http.probe(&url, &headers, use_proxy).await;
 
-        let settings = self.inner.settings.lock().unwrap().clone();
+        let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
         let task_dir = dir.unwrap_or_else(|| settings.download_dir.clone());
 
         // 确定文件名
@@ -347,14 +382,14 @@ impl DownloadEngine {
         };
 
         {
-            let mut tasks = self.inner.tasks.lock().unwrap();
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             tasks.insert(id.clone(), task);
         }
         self.persist_now();
 
         // 如果探测成功，尝试调度
         let should_schedule = {
-            let tasks = self.inner.tasks.lock().unwrap();
+            let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             tasks.get(&id).map(|t| t.status == TaskStatus::Queued).unwrap_or(false)
         };
         if should_schedule {
@@ -362,7 +397,7 @@ impl DownloadEngine {
         }
 
         // 通知前端有新任务加入（扩展通过 HTTP API 添加时，前端需要刷新）
-        let _ = self.inner.app_handle.emit("download-added", serde_json::json!({ "id": id }));
+        let _ = self.inner.app_handle.emit(crate::constants::events::DOWNLOAD_ADDED, serde_json::json!({ "id": id }));
 
         Ok(id)
     }
@@ -371,7 +406,7 @@ impl DownloadEngine {
     pub fn pause_task(&self, id: &str) -> Result<(), String> {
         // 1. 设置取消标志 + 读取进度（锁 handles）
         let progress_values: Vec<u64> = {
-            let handles = self.inner.handles.lock().unwrap();
+            let handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
             if let Some(handle) = handles.get(id) {
                 handle.cancel.store(true, Ordering::SeqCst);
                 handle.progress.iter().map(|p| p.load(Ordering::Relaxed)).collect()
@@ -382,7 +417,7 @@ impl DownloadEngine {
 
         // 2. 更新任务状态 + 同步进度（锁 tasks，不嵌套锁 handles）
         {
-            let mut tasks = self.inner.tasks.lock().unwrap();
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             if let Some(task) = tasks.get_mut(id) {
                 if task.status == TaskStatus::Active || task.status == TaskStatus::Queued {
                     task.status = TaskStatus::Paused;
@@ -407,13 +442,13 @@ impl DownloadEngine {
     /// 恢复任务
     pub fn resume_task(&self, id: &str) -> Result<(), String> {
         {
-            let mut tasks = self.inner.tasks.lock().unwrap();
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             if let Some(task) = tasks.get_mut(id) {
                 if task.status != TaskStatus::Paused && task.status != TaskStatus::Error {
                     return Err("任务不在可恢复状态".to_string());
                 }
-                // 如果不支持断点续传，从头开始
-                if !task.supports_resume {
+                // 如果不支持断点续传，或文件大小未知（无法定位续传起点，需从头下载），从头开始
+                if !task.supports_resume || task.total_size == 0 {
                     task.completed_size = 0;
                     for seg in &mut task.segments {
                         seg.completed = 0;
@@ -434,7 +469,7 @@ impl DownloadEngine {
     pub fn remove_task(&self, id: &str, delete_files: bool) -> Result<(), String> {
         // 1. 设置取消标志 + abort join handle（锁 handles）
         {
-            let mut handles = self.inner.handles.lock().unwrap();
+            let mut handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
             if let Some(handle) = handles.remove(id) {
                 handle.cancel.store(true, Ordering::SeqCst);
                 if let Ok(mut join) = handle.join.lock() {
@@ -447,7 +482,7 @@ impl DownloadEngine {
 
         // 2. 从任务列表移除（锁 tasks）
         let task = {
-            let mut tasks = self.inner.tasks.lock().unwrap();
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             tasks.remove(id)
         };
 
@@ -466,12 +501,12 @@ impl DownloadEngine {
 
     /// 获取所有任务
     pub fn get_tasks(&self) -> Vec<DownloadTask> {
-        self.inner.tasks.lock().unwrap().values().cloned().collect()
+        self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner()).values().cloned().collect()
     }
 
     /// 获取设置
     pub fn get_settings(&self) -> DownloaderSettings {
-        self.inner.settings.lock().unwrap().clone()
+        self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone()
     }
 
     /// 保存设置
@@ -484,8 +519,13 @@ impl DownloadEngine {
         };
         self.inner.global_limiter.set_limit(new_limit);
 
+        // 同步代理开关（新任务/探测立即生效，正在下载的任务不受影响）
+        self.inner
+            .use_proxy
+            .store(settings.use_proxy, Ordering::SeqCst);
+
         {
-            let mut s = self.inner.settings.lock().unwrap();
+            let mut s = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner());
             *s = settings;
         }
         self.persist_now();
@@ -500,7 +540,7 @@ impl DownloadEngine {
     pub fn cleanup_on_exit(&self) {
         // 取消所有活跃下载
         {
-            let handles = self.inner.handles.lock().unwrap();
+            let handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
             for handle in handles.values() {
                 handle.cancel.store(true, Ordering::SeqCst);
             }
@@ -508,7 +548,7 @@ impl DownloadEngine {
 
         // 将 Active 任务标记为 Paused
         {
-            let mut tasks = self.inner.tasks.lock().unwrap();
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             for task in tasks.values_mut() {
                 if task.status == TaskStatus::Active {
                     task.status = TaskStatus::Paused;
@@ -528,10 +568,10 @@ impl DownloadEngine {
 
     /// 调度：如果活跃任务数 < max_concurrent，启动排队任务
     fn schedule(&self) {
-        let max_concurrent = self.inner.settings.lock().unwrap().max_concurrent as usize;
+        let max_concurrent = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).max_concurrent as usize;
 
         let (active_count, queued_ids) = {
-            let tasks = self.inner.tasks.lock().unwrap();
+            let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             let active = tasks.values().filter(|t| t.status == TaskStatus::Active).count();
             let mut queued: Vec<_> = tasks
                 .values()
@@ -554,7 +594,7 @@ impl DownloadEngine {
     /// 启动单个下载任务
     fn start_download(&self, id: String) {
         let task = {
-            let mut tasks = self.inner.tasks.lock().unwrap();
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             match tasks.get_mut(&id) {
                 Some(task) if task.status == TaskStatus::Queued => {
                     task.status = TaskStatus::Active;
@@ -565,6 +605,9 @@ impl DownloadEngine {
             }
         };
 
+        // 分配代际号（同一任务每次重启递增）
+        let gen = self.inner.next_gen.fetch_add(1, Ordering::SeqCst) + 1;
+
         // 创建取消标志和进度计数器
         let cancel = Arc::new(AtomicBool::new(false));
         let progress: Vec<Arc<std::sync::atomic::AtomicU64>> = task
@@ -573,13 +616,22 @@ impl DownloadEngine {
             .map(|s| Arc::new(std::sync::atomic::AtomicU64::new(s.completed)))
             .collect();
 
-        // 存储句柄
-        let handle = TaskHandle {
-            cancel: cancel.clone(),
-            progress: progress.iter().map(|p| p.clone()).collect(),
-            join: Mutex::new(None),
-        };
-        self.inner.handles.lock().unwrap().insert(id.clone(), handle);
+        // 存储句柄：先取消旧代际（若存在），确保旧任务尽快退出，避免新旧并发写同一临时文件
+        {
+            let mut handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
+            if let Some(old) = handles.get(&id) {
+                old.cancel.store(true, Ordering::SeqCst);
+            }
+            handles.insert(
+                id.clone(),
+                TaskHandle {
+                    gen,
+                    cancel: cancel.clone(),
+                    progress: progress.iter().map(|p| p.clone()).collect(),
+                    join: Mutex::new(None),
+                },
+            );
+        }
 
         // 生成下载 future
         let engine = self.clone();
@@ -594,71 +646,97 @@ impl DownloadEngine {
         let temp_file_path = task.temp_file_path();
         let final_file_path = task.file_path();
         let http = self.inner.http.clone();
+        let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
 
         let join = tauri::async_runtime::spawn(async move {
+            let my_gen = gen;
             let result = http
-                .download(&url, &headers, &segments, &temp_file_path, cancel_clone, &progress_clone, limiter)
+                .download(&url, &headers, &segments, &temp_file_path, cancel_clone, &progress_clone, limiter, use_proxy)
                 .await;
 
-            // 下载结束，更新任务状态
-            let final_status = match &result {
-                Ok(()) => TaskStatus::Complete,
-                Err(e) if e == "已取消" => TaskStatus::Paused,
-                Err(_) => TaskStatus::Error,
+            // 代际守卫：仅最新代际的任务能更新状态 / 移除句柄 / 发完成事件。
+            // pause→resume 后旧代际任务才退出，此时句柄已被新代际替换，
+            // 若仍按旧逻辑执行会覆盖新任务状态并误删新句柄（pause/remove 失效）
+            let is_current = {
+                let handles = engine.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
+                handles.get(&id_clone).map(|h| h.gen == my_gen).unwrap_or(false)
             };
 
-            // 下载成功后，将临时文件重命名为最终文件名
-            if final_status == TaskStatus::Complete {
-                let _ = tokio::fs::rename(&temp_file_path, &final_file_path).await;
-            }
+            if is_current {
+                // 下载结束，更新任务状态
+                let mut final_status = match &result {
+                    Ok(()) => TaskStatus::Complete,
+                    Err(e) if e == "已取消" => TaskStatus::Paused,
+                    Err(_) => TaskStatus::Error,
+                };
+                let mut final_error: Option<String> = match &result {
+                    Err(e) if e != "已取消" => Some(e.clone()),
+                    _ => None,
+                };
 
-            // 同步最终进度到任务
-            {
-                let mut tasks = engine.inner.tasks.lock().unwrap();
-                if let Some(task) = tasks.get_mut(&id_clone) {
-                    for (i, prog) in progress_clone.iter().enumerate() {
-                        if let Some(seg) = task.segments.get_mut(i) {
-                            seg.completed = prog.load(Ordering::Relaxed);
-                        }
-                    }
-                    task.recalc_completed();
-                    task.speed = 0;
-                    task.status = final_status.clone();
-                    if let Err(e) = &result {
-                        if e != "已取消" {
-                            task.error = Some(e.clone());
-                        }
-                    }
-                    if final_status == TaskStatus::Complete {
-                        task.completed_size = task.total_size.max(task.completed_size);
+                // 下载成功后，将临时文件重命名为最终文件名
+                if final_status == TaskStatus::Complete {
+                    if let Err(e) = tokio::fs::rename(&temp_file_path, &final_file_path).await {
+                        // 重命名失败（如目标被占用/路径不可写）→ 置 Error，
+                        // 避免"标记完成但文件缺失"的状态不一致
+                        final_status = TaskStatus::Error;
+                        final_error = Some(format!("移动文件到最终路径失败: {}", e));
                     }
                 }
+
+                // 同步最终进度到任务
+                {
+                    let mut tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+                    if let Some(task) = tasks.get_mut(&id_clone) {
+                        for (i, prog) in progress_clone.iter().enumerate() {
+                            if let Some(seg) = task.segments.get_mut(i) {
+                                seg.completed = prog.load(Ordering::Relaxed);
+                            }
+                        }
+                        task.recalc_completed();
+                        task.speed = 0;
+                        task.status = final_status.clone();
+                        if let Some(e) = final_error {
+                            task.error = Some(e);
+                        }
+                        if final_status == TaskStatus::Complete {
+                            task.completed_size = task.total_size.max(task.completed_size);
+                        }
+                    }
+                }
+
+                // 从活跃句柄中移除（仅移除自己代际的句柄）
+                {
+                    let mut handles = engine.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
+                    if let Some(h) = handles.get(&id_clone) {
+                        if h.gen == my_gen {
+                            handles.remove(&id_clone);
+                        }
+                    }
+                }
+
+                // 发送完成事件
+                let task = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner()).get(&id_clone).cloned();
+                if let Some(task) = task {
+                    let _ = engine.inner.app_handle.emit(
+                        "download-complete",
+                        CompletePayload {
+                            id: id_clone.clone(),
+                            filename: task.filename.clone(),
+                            status: task.status.clone(),
+                            error: task.error.clone(),
+                        },
+                    );
+                }
+
+                // 持久化 + 调度下一个
+                engine.persist_now();
+                engine.schedule();
             }
-
-            // 从活跃句柄中移除
-            engine.inner.handles.lock().unwrap().remove(&id_clone);
-
-            // 发送完成事件
-            let task = engine.inner.tasks.lock().unwrap().get(&id_clone).cloned();
-            if let Some(task) = task {
-                let _ = engine.inner.app_handle.emit(
-                    "download-complete",
-                    CompletePayload {
-                        id: id_clone.clone(),
-                        filename: task.filename.clone(),
-                        status: task.status.clone(),
-                        error: task.error.clone(),
-                    },
-                );
-            }
-
-            // 持久化 + 调度下一个
-            engine.persist_now();
-            engine.schedule();
         });
 
         // 存储 JoinHandle
-        if let Some(h) = self.inner.handles.lock().unwrap().get_mut(&id) {
+        if let Some(h) = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner()).get_mut(&id) {
             if let Ok(mut join_guard) = h.join.lock() {
                 *join_guard = Some(join);
             }
@@ -670,6 +748,7 @@ impl DownloadEngine {
         let progress_monitor = progress;
         let cancel_monitor = cancel;
         tauri::async_runtime::spawn(async move {
+            let my_gen = gen;
             // 初始化为当前已下载量，避免恢复下载时首次计算速度异常
             let mut last_completed: u64 = progress_monitor
                 .iter()
@@ -681,9 +760,17 @@ impl DownloadEngine {
 
             loop {
                 interval.tick().await;
+                // 代际守卫：pause→resume 后旧监控立即退出，避免用过期进度覆盖新任务
+                let is_current = {
+                    let handles = engine.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
+                    handles.get(&id_monitor).map(|h| h.gen == my_gen).unwrap_or(false)
+                };
+                if !is_current {
+                    break;
+                }
                 // 如果任务已不在活跃状态，停止监控
                 let is_active = {
-                    let tasks = engine.inner.tasks.lock().unwrap();
+                    let tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
                     tasks.get(&id_monitor).map(|t| t.status == TaskStatus::Active).unwrap_or(false)
                 };
                 if !is_active || cancel_monitor.load(Ordering::SeqCst) {
@@ -695,6 +782,11 @@ impl DownloadEngine {
                     .iter()
                     .map(|p| p.load(Ordering::Relaxed))
                     .sum();
+                // 各分段实时进度（供前端详情弹窗分段条展示）
+                let segment_completed: Vec<u64> = progress_monitor
+                    .iter()
+                    .map(|p| p.load(Ordering::Relaxed))
+                    .collect();
 
                 // 计算速度
                 let now = Instant::now();
@@ -708,8 +800,8 @@ impl DownloadEngine {
                 last_time = now;
 
                 // 更新任务状态 + 发送进度事件
-                let total_size = {
-                    let mut tasks = engine.inner.tasks.lock().unwrap();
+                let (total_size, live_status) = {
+                    let mut tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
                     if let Some(task) = tasks.get_mut(&id_monitor) {
                         task.completed_size = completed;
                         task.speed = speed;
@@ -718,7 +810,10 @@ impl DownloadEngine {
                                 seg.completed = prog.load(Ordering::Relaxed);
                             }
                         }
-                        task.total_size
+                        // 读取任务实时状态而非硬编码 Active：
+                        // 暂停后监控循环 break 前可能发出的最后一次事件
+                        // 必须携带 Paused，否则前端会把任务状态覆盖回"下载中"
+                        (task.total_size, task.status.clone())
                     } else {
                         break;
                     }
@@ -731,7 +826,8 @@ impl DownloadEngine {
                         completed_size: completed,
                         total_size,
                         speed,
-                        status: TaskStatus::Active,
+                        status: live_status,
+                        segments: segment_completed,
                     },
                 );
             }
@@ -743,7 +839,7 @@ impl DownloadEngine {
     /// 节流持久化（至少间隔 3 秒）
     fn persist_throttled(&self) {
         let should_save = {
-            let last = self.inner.last_save.lock().unwrap();
+            let last = self.inner.last_save.lock().unwrap_or_else(|e| e.into_inner());
             last.elapsed() >= Duration::from_secs(3)
         };
         if should_save {
@@ -751,19 +847,30 @@ impl DownloadEngine {
         }
     }
 
-    /// 立即持久化
+    /// 立即持久化。
+    /// 保存失败（磁盘不可写/rename 失败）时把进行中任务标记为 Error，
+    /// 防止用户误以为任务已持久化而关闭应用导致数据丢失。
     fn persist_now(&self) {
         let tasks: Vec<DownloadTask> = {
-            let tasks = self.inner.tasks.lock().unwrap();
+            let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
             tasks.values().cloned().collect()
         };
-        let settings = self.inner.settings.lock().unwrap().clone();
+        let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
         let state = EngineState {
             tasks,
             settings,
             next_id: 0, // storage.save 会从 id_counter 读取
         };
-        self.inner.storage.save(state);
-        *self.inner.last_save.lock().unwrap() = Instant::now();
+        if let Err(e) = self.inner.storage.save(state) {
+            crate::logger::log_error("download", &format!("状态持久化失败，进行中任务标记为 Error: {}", e));
+            let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
+            for task in tasks.values_mut() {
+                if task.status == TaskStatus::Active {
+                    task.status = TaskStatus::Error;
+                }
+            }
+            return; // 不更新 last_save，下次定时器会重试
+        }
+        *self.inner.last_save.lock().unwrap_or_else(|e| e.into_inner()) = Instant::now();
     }
 }

src-tauri/src/download_engine/http_dl.rs

@@ -12,18 +12,44 @@ use tokio::task::JoinSet;
 use super::rate_limit::RateLimiter;
 use super::task::{ProbeResult, Segment};
 
+/// 请求超时：连接 + 响应头必须在 30s 内就绪（分段请求若无超时，
+/// 服务器挂死时任务将永久卡在 Active，pause→resume 会出现新旧任务并发写同一临时文件）
+const REQUEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
+/// 分块读取停滞超时：30s 内无任何数据视为连接挂死，主动中断（配合取消标志及时退出）
+const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
+
 /// HTTP/HTTPS 下载器
 #[derive(Clone)]
 pub struct HttpDownloader {
-    client: Client,
+    /// 默认客户端：尊重系统代理（reqwest 默认行为，mihomo 开启系统代理时经其转发）
+    system_client: Client,
+    /// 直连客户端：强制禁用系统代理（no_proxy）
+    direct_client: Client,
 }
 
 impl HttpDownloader {
     pub fn new() -> Self {
-        let client = Client::builder()
+        let system_client = Client::builder()
             .build()
             .unwrap_or_else(|_| Client::new());
-        Self { client }
+        let direct_client = Client::builder()
+            // 强制直连：即使系统代理已开启，下载也不经过代理
+            .no_proxy()
+            .build()
+            .unwrap_or_else(|_| Client::new());
+        Self {
+            system_client,
+            direct_client,
+        }
+    }
+
+    /// 根据 use_proxy 选择客户端
+    fn client(&self, use_proxy: bool) -> &Client {
+        if use_proxy {
+            &self.system_client
+        } else {
+            &self.direct_client
+        }
     }
 
     /// 探测下载资源信息（大小、是否支持 Range、文件名）
@@ -32,10 +58,11 @@ impl HttpDownloader {
         &self,
         url: &str,
         headers: &HashMap<String, String>,
+        use_proxy: bool,
     ) -> Result<ProbeResult, String> {
+        let client = self.client(use_proxy);
         // 先尝试 Range 请求（能同时判断 Accept-Ranges 和获取大小）
-        let mut req = self
-            .client
+        let mut req = client
             .get(url)
             .header("Range", "bytes=0-0")
             .header("User-Agent", "Thing-Download-Engine/1.0");
@@ -43,7 +70,10 @@ impl HttpDownloader {
             req = req.header(k, v);
         }
 
-        match req.send().await {
+        match tokio::time::timeout(REQUEST_TIMEOUT, req.send())
+            .await
+            .map_err(|_| "探测超时（30s 内未收到响应头）".to_string())?
+        {
             Ok(resp) => {
                 let status = resp.status();
                 let headers_map = resp.headers().clone();
@@ -88,13 +118,13 @@ impl HttpDownloader {
             }
             Err(_) => {
                 // GET 失败，尝试 HEAD 作为回退
-                let mut head_req = self.client.head(url);
+                let mut head_req = client.head(url);
                 for (k, v) in headers {
                     head_req = head_req.header(k, v);
                 }
-                let resp = head_req
-                    .send()
+                let resp = tokio::time::timeout(REQUEST_TIMEOUT, head_req.send())
                     .await
+                    .map_err(|_| "探测超时（HEAD 30s 内未收到响应头）".to_string())?
                     .map_err(|e| format!("探测失败（GET 和 HEAD 均失败）: {}", e))?;
                 let headers_map = resp.headers().clone();
                 let total_size = headers_map
@@ -123,6 +153,7 @@ impl HttpDownloader {
     /// - `cancel`: 取消标志
     /// - `progress`: 每个分段的已下载字节（AtomicU64，与 segments 一一对应）
     /// - `limiter`: 全局限速器
+    /// - `use_proxy`: 是否使用系统代理（false=强制直连）
     pub async fn download(
         &self,
         url: &str,
@@ -132,7 +163,9 @@ impl HttpDownloader {
         cancel: Arc<AtomicBool>,
         progress: &[Arc<AtomicU64>],
         limiter: Arc<RateLimiter>,
+        use_proxy: bool,
     ) -> Result<(), String> {
+        let client = self.client(use_proxy);
         let total_size = segments.iter().map(|s| s.len()).sum();
 
         // 预分配文件（若已知大小）
@@ -158,7 +191,7 @@ impl HttpDownloader {
             // 单线程下载（不支持 Range 或文件太小）
             let seg = &segments[0];
             let prog = &progress[0];
-            self.download_segment(url, headers, seg, file_path, cancel.clone(), prog.clone(), limiter)
+            self.download_segment(url, headers, seg, file_path, cancel.clone(), prog.clone(), limiter, client)
                 .await?;
             return Ok(());
         }
@@ -178,7 +211,7 @@ impl HttpDownloader {
                 .unwrap_or_default();
             let limiter = limiter.clone();
             let file_path = file_path.to_path_buf();
-            let client = self.client.clone();
+            let client = client.clone();
 
             join_set.spawn(async move {
                 download_segment_with_client(
@@ -232,9 +265,10 @@ impl HttpDownloader {
         cancel: Arc<AtomicBool>,
         progress: Arc<AtomicU64>,
         limiter: Arc<RateLimiter>,
+        client: &Client,
     ) -> Result<(), String> {
         download_segment_with_client(
-            &self.client,
+            client,
             url,
             headers,
             seg,
@@ -295,14 +329,26 @@ async fn download_segment_with_client(
         req = req.header(k, v);
     }
 
-    let resp = req
-        .send()
+    let resp = tokio::time::timeout(REQUEST_TIMEOUT, req.send())
         .await
+        .map_err(|_| "请求超时（30s 内未收到响应头）".to_string())?
         .map_err(|e| format!("请求失败: {}", e))?;
 
     let status = resp.status();
-    if !status.is_success() && status.as_u16() != 206 {
-        return Err(format!("服务器返回 HTTP {}", status));
+    if unknown_size {
+        // 未知大小：未发送 Range 头，接受任意 2xx
+        if !status.is_success() {
+            return Err(format!("服务器返回 HTTP {}", status));
+        }
+    } else {
+        // 已发送 Range 头：必须返回 206。若服务器忽略 Range 返回 200 全文，
+        // 按 range_start 偏移写入会错位 → 静默损坏文件；此处直接中断。
+        if status.as_u16() != 206 {
+            return Err(format!(
+                "服务器未按分段请求响应（期望 206，实际 {}），已中断以避免文件损坏",
+                status
+            ));
+        }
     }
 
     // 流式读取并写入文件
@@ -315,8 +361,9 @@ async fn download_segment_with_client(
             return Err("已取消".to_string());
         }
 
-        match stream.next().await {
-            Some(Ok(chunk)) => {
+        // 停滞超时：30s 无数据即中断，确保 cancel 标志能及时被感知（配合代际句柄防并发写）
+        match tokio::time::timeout(READ_STALL_TIMEOUT, stream.next()).await {
+            Ok(Some(Ok(chunk))) => {
                 buf.extend_from_slice(&chunk);
                 // 接收到数据立即更新进度（避免监控周期内进度无变化导致速度显示为 0）
                 local_completed += chunk.len() as u64;
@@ -331,10 +378,10 @@ async fn download_segment_with_client(
                     buf.clear();
                 }
             }
-            Some(Err(e)) => {
+            Ok(Some(Err(e))) => {
                 return Err(format!("读取数据失败: {}", e));
             }
-            None => {
+            Ok(None) => {
                 // 流结束，写入剩余数据
                 if !buf.is_empty() {
                     file.write_all(&buf)
@@ -344,8 +391,20 @@ async fn download_segment_with_client(
                     limiter.consume(buf.len() as u64).await;
                     buf.clear();
                 }
+                // 校验：已知大小的分段若流提前结束（收到的字节数不足分段长度），
+                // 说明服务器提前断开或返回不完整内容，不能标记为完成，否则文件会被截断
+                if !unknown_size && local_completed < seg.len() {
+                    return Err(format!(
+                        "文件不完整：已接收 {} / {} 字节，服务器提前结束连接",
+                        local_completed,
+                        seg.len()
+                    ));
+                }
                 break;
             }
+            Err(_) => {
+                return Err("读取超时（30s 无数据，已中断下载）".to_string());
+            }
         }
     }
 
@@ -436,10 +495,11 @@ fn percent_decode(s: &str) -> String {
 /// 将文件大小划分为 N 个分段
 pub fn split_segments(total_size: u64, num_connections: u32) -> Vec<Segment> {
     if total_size == 0 || num_connections == 0 {
+        // 空文件或未指定连接数：单段覆盖整个文件（end 按 total_size 推导，不能硬编码 0）
         return vec![Segment {
             index: 0,
             start: 0,
-            end: 0,
+            end: total_size.saturating_sub(1),
             completed: 0,
         }];
     }
@@ -473,3 +533,86 @@ pub fn split_segments(total_size: u64, num_connections: u32) -> Vec<Segment> {
 
     segments
 }
+
+#[cfg(test)]
+mod split_segments_tests {
+    use super::*;
+
+    /// 分段必须完整覆盖 [0, total_size)，且相互连续无重叠
+    fn assert_contiguous(segments: &[Segment], total_size: u64) {
+        assert!(!segments.is_empty());
+        let mut prev_end: i64 = -1;
+        for seg in segments {
+            assert_eq!(seg.start as i64, prev_end + 1, "分段不连续");
+            assert!(seg.end >= seg.start, "分段 start > end");
+            prev_end = seg.end as i64;
+        }
+        assert_eq!(
+            segments.last().unwrap().end,
+            total_size - 1,
+            "末段未覆盖文件末尾"
+        );
+    }
+
+    #[test]
+    fn zero_size_returns_single_segment() {
+        let segs = split_segments(0, 4);
+        assert_eq!(segs.len(), 1);
+        assert_eq!(segs[0].start, 0);
+        assert_eq!(segs[0].end, 0);
+    }
+
+    #[test]
+    fn zero_connections_covers_whole_file() {
+        let segs = split_segments(1024, 0);
+        assert_eq!(segs.len(), 1);
+        assert_eq!(segs[0].start, 0);
+        assert_eq!(segs[0].end, 1023);
+    }
+
+    #[test]
+    fn divides_evenly_with_contiguous_coverage() {
+        // 10MB / 4 连接 → 4 段完整覆盖
+        let total = 10 * 1024 * 1024;
+        let segs = split_segments(total, 4);
+        assert_eq!(segs.len(), 4);
+        assert_contiguous(&segs, total);
+    }
+
+    #[test]
+    fn clamps_connections_by_min_segment_size() {
+        // 2MB 文件请求 8 连接 → 受 1MB 最小分段限制，实际 ≤ 2 段
+        let total = 2 * 1024 * 1024;
+        let segs = split_segments(total, 8);
+        assert!(segs.len() <= 2, "连接数未按最小分段收敛: {}", segs.len());
+        assert_contiguous(&segs, total);
+    }
+
+    #[test]
+    fn respects_requested_connection_count() {
+        // 大文件按请求连接数切分
+        let total = 100 * 1024 * 1024;
+        let segs = split_segments(total, 3);
+        assert_eq!(segs.len(), 3);
+        assert_contiguous(&segs, total);
+        // 每段大小均匀
+        for seg in &segs {
+            let seg_len = seg.end - seg.start + 1;
+            assert!(
+                seg_len >= total / 3,
+                "分段大小不均: {} 段只有 {} 字节",
+                seg.index,
+                seg_len
+            );
+        }
+    }
+
+    #[test]
+    fn tiny_file_single_segment() {
+        // 小于 1MB 的文件始终单段
+        let total = 100;
+        let segs = split_segments(total, 4);
+        assert_eq!(segs.len(), 1);
+        assert_contiguous(&segs, total);
+    }
+}

src-tauri/src/download_engine/rate_limit.rs

@@ -38,7 +38,7 @@ impl RateLimiter {
         // 尝试在当前窗口消费（用作用域确保 MutexGuard 在 await 前释放）
         let over_limit = {
             let now = std::time::Instant::now();
-            let mut start = self.window_start.lock().unwrap();
+            let mut start = self.window_start.lock().unwrap_or_else(|e| e.into_inner());
             let elapsed = now.duration_since(*start);
 
             // 窗口过期，重置
@@ -72,3 +72,64 @@ impl Clone for RateLimiter {
         Self::new(self.limit.load(Ordering::Relaxed))
     }
 }
+
+#[cfg(test)]
+mod rate_limiter_tests {
+    use super::*;
+    use std::time::Instant;
+
+    #[tokio::test]
+    async fn zero_limit_never_blocks() {
+        let limiter = RateLimiter::new(0);
+        let start = Instant::now();
+        limiter.consume(1024 * 1024).await;
+        limiter.consume(u64::MAX).await;
+        assert!(start.elapsed() < Duration::from_millis(50));
+    }
+
+    #[tokio::test]
+    async fn under_limit_returns_immediately() {
+        let limiter = RateLimiter::new(100_000); // 100KB/s
+        let start = Instant::now();
+        limiter.consume(1024).await;
+        assert!(start.elapsed() < Duration::from_millis(50));
+    }
+
+    #[tokio::test]
+    async fn exceeding_limit_waits_proportionally() {
+        // 限速 200 B/s：先消耗 100 未超限，再消耗 150 → 超限 50 → 等待约 250ms
+        let limiter = RateLimiter::new(200);
+        limiter.consume(100).await;
+        let start = Instant::now();
+        limiter.consume(150).await;
+        let elapsed = start.elapsed();
+        assert!(
+            elapsed >= Duration::from_millis(200),
+            "等待时间不足: {:?}",
+            elapsed
+        );
+        assert!(elapsed < Duration::from_millis(1100));
+    }
+
+    #[tokio::test]
+    async fn window_resets_after_one_second() {
+        // 限速 100 B/s：第一窗口耗尽后，1.1s 窗口重置，再消耗 100 不应阻塞
+        let limiter = RateLimiter::new(100);
+        limiter.consume(100).await;
+        tokio::time::sleep(Duration::from_millis(1100)).await;
+        let start = Instant::now();
+        limiter.consume(100).await;
+        assert!(start.elapsed() < Duration::from_millis(100));
+    }
+
+    #[tokio::test]
+    async fn set_limit_takes_effect_dynamically() {
+        let limiter = RateLimiter::new(0);
+        limiter.consume(1024).await; // 不限速
+        limiter.set_limit(100);
+        limiter.consume(100).await;
+        let start = Instant::now();
+        limiter.consume(100).await; // 累计 200 > 100 → 等待 1000ms
+        assert!(start.elapsed() >= Duration::from_millis(900));
+    }
+}

src-tauri/src/download_engine/server.rs

@@ -9,9 +9,10 @@ use axum::{
     Router,
 };
 use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Emitter};
 
 use super::engine::DownloadEngine;
-use super::task::DownloadTask;
+use super::task::{DownloadTask, TaskStatus};
 
 /// 扩展 HTTP API 服务器
 pub struct ExtensionServer;
@@ -45,27 +46,31 @@ struct ErrorResponse {
 
 impl ExtensionServer {
     /// 启动 HTTP API 服务器（绑定到 127.0.0.1:port）
-    pub async fn start(engine: DownloadEngine, port: u16, secret: String) {
+    pub async fn start(engine: DownloadEngine, port: u16, secret: String, app_handle: AppHandle) {
         let addr: SocketAddr = format!("127.0.0.1:{}", port).parse().expect("无效端口");
 
         let app = Router::new()
             .route("/health", get(health))
             .route("/api/downloads", post(create_download).get(list_downloads))
             .route("/api/downloads/:id", axum::routing::delete(remove_download))
-            .with_state(AppState { engine, secret });
+            .with_state(AppState {
+                engine,
+                secret,
+                app_handle,
+            });
 
         let listener = match tokio::net::TcpListener::bind(&addr).await {
             Ok(l) => l,
             Err(e) => {
-                eprintln!("[download_engine] 扩展 HTTP 服务启动失败 ({}): {}", addr, e);
+                crate::logger::log_error("download", &format!("扩展 HTTP 服务启动失败 ({}): {}", addr, e));
                 return;
             }
         };
 
-        eprintln!("[download_engine] 扩展 HTTP 服务已启动: http://{}", addr);
+        crate::logger::log_info("download", &format!("扩展 HTTP 服务已启动: http://{}", addr));
 
         if let Err(e) = axum::serve(listener, app).await {
-            eprintln!("[download_engine] 扩展 HTTP 服务异常: {}", e);
+            crate::logger::log_error("download", &format!("扩展 HTTP 服务异常: {}", e));
         }
     }
 }
@@ -74,6 +79,7 @@ impl ExtensionServer {
 struct AppState {
     engine: DownloadEngine,
     secret: String,
+    app_handle: AppHandle,
 }
 
 /// 鉴权检查：如果配置了 secret，校验 Bearer token
@@ -108,8 +114,23 @@ async fn create_download(
         return Err((StatusCode::UNAUTHORIZED, Json(ErrorResponse { error: "未授权".into() })));
     }
 
+    // 去重：同 URL 已有非终态任务（活跃/排队/暂停）时直接返回既有任务，
+    // 避免浏览器重复转发同一下载造成重复下载
+    if let Some(existing) = state.engine.get_tasks().into_iter().find(|t| {
+        matches!(t.status, TaskStatus::Active | TaskStatus::Queued | TaskStatus::Paused) && t.url == req.url
+    }) {
+        return Ok(Json(CreateDownloadResponse { id: existing.id }));
+    }
+
     match state.engine.add_task(req.url, req.filename, req.dir, req.headers, true).await {
-        Ok(id) => Ok(Json(CreateDownloadResponse { id })),
+        Ok(id) => {
+            // 浏览器扩展发起下载：置前主窗口并通知前端跳到下载画面（替代原桌面通知）
+            crate::tray_menu::focus_main_window(&state.app_handle);
+            let _ = state
+                .app_handle
+                .emit(crate::constants::events::DOWNLOAD_EXTENSION_ADDED, ());
+            Ok(Json(CreateDownloadResponse { id }))
+        }
         Err(e) => Err((StatusCode::BAD_REQUEST, Json(ErrorResponse { error: e }))),
     }
 }
@@ -133,7 +154,11 @@ async fn remove_download(
         return Err((StatusCode::UNAUTHORIZED, Json(ErrorResponse { error: "未授权".into() })));
     }
     match state.engine.remove_task(&id, false) {
-        Ok(()) => Ok(StatusCode::NO_CONTENT),
+        Ok(()) => {
+            // 通知前端刷新任务列表（扩展删除时前端无从感知，否则列表残留已删除任务）
+            let _ = state.app_handle.emit(crate::constants::events::DOWNLOAD_REMOVED, serde_json::json!({ "id": id }));
+            Ok(StatusCode::NO_CONTENT)
+        }
         Err(e) => Err((StatusCode::NOT_FOUND, Json(ErrorResponse { error: e }))),
     }
 }

src-tauri/src/download_engine/storage.rs

@@ -40,7 +40,7 @@ impl Storage {
     pub fn new(data_dir: PathBuf) -> Self {
         // 确保数据目录存在（首次启动或目录被删除时自动创建）
         if let Err(e) = fs::create_dir_all(&data_dir) {
-            eprintln!("[download_engine] 创建数据目录失败: {} ({})", data_dir.display(), e);
+            crate::logger::log_error("download", &format!("创建数据目录失败: {} ({})", data_dir.display(), e));
         }
         let state_path = data_dir.join("engine_state.json");
         let existing = Self::load_raw(&state_path);
@@ -68,23 +68,24 @@ impl Storage {
         Self::load_raw(&self.state_path).unwrap_or_default()
     }
 
-    /// 保存状态到磁盘
-    pub fn save(&self, mut state: EngineState) {
+    /// 保存状态到磁盘（原子写：先写 .tmp 再 rename 覆盖，
+    /// 避免进程崩溃时产生半写/截断的状态文件导致任务列表丢失）
+    /// 失败返回 Err，由调用方决定是否将任务置为 Error（防止"看似已保存"的假象）。
+    pub fn save(&self, mut state: EngineState) -> Result<(), String> {
         // 同步 ID 计数器
         state.next_id = self.id_counter.load(Ordering::SeqCst);
-        match serde_json::to_string_pretty(&state) {
-            Ok(json) => {
-                // 兜底：若父目录被外部删除则在写入前重建
-                if let Some(parent) = self.state_path.parent() {
-                    let _ = fs::create_dir_all(parent);
-                }
-                if let Err(e) = fs::write(&self.state_path, json) {
-                    eprintln!("[download_engine] 保存状态失败: {}", e);
-                }
-            }
-            Err(e) => {
-                eprintln!("[download_engine] 序列化状态失败: {}", e);
-            }
+        let json = serde_json::to_string_pretty(&state)
+            .map_err(|e| format!("序列化状态失败: {}", e))?;
+        // 兜底：若父目录被外部删除则在写入前重建
+        if let Some(parent) = self.state_path.parent() {
+            let _ = fs::create_dir_all(parent);
         }
+        let tmp_path = PathBuf::from(format!("{}.tmp", self.state_path.display()));
+        fs::write(&tmp_path, json).map_err(|e| format!("保存状态失败: {}", e))?;
+        fs::rename(&tmp_path, &self.state_path).map_err(|e| {
+            let _ = fs::remove_file(&tmp_path);
+            format!("替换状态文件失败: {}", e)
+        })?;
+        Ok(())
     }
 }

src-tauri/src/download_engine/task.rs

@@ -1,8 +1,9 @@
 use serde::{Deserialize, Serialize};
+use specta::Type;
 use std::collections::HashMap;
 
 /// 任务状态
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Type)]
 #[serde(rename_all = "lowercase")]
 pub enum TaskStatus {
     /// 排队等待（并发数已满）
@@ -18,7 +19,7 @@ pub enum TaskStatus {
 }
 
 /// 下载分段（多线程 Range 下载 / 断点续传用）
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct Segment {
     /// 分段索引
@@ -36,14 +37,23 @@ impl Segment {
     pub fn len(&self) -> u64 {
         self.end.saturating_sub(self.start) + 1
     }
+    /// 是否为未知大小哨兵段（start=0, end=0，表示不支持 Range 或未探测到大小）
+    pub fn is_unknown_size(&self) -> bool {
+        self.start == 0 && self.end == 0
+    }
     /// 是否已完成
     pub fn is_done(&self) -> bool {
+        // 未知大小段无法用长度判断是否完成，由流结束（Ok(None)）判定；
+        // 若按 len()=1 判断，暂停/恢复后 completed>=1 会误判为已完成，导致文件被截断
+        if self.is_unknown_size() {
+            return false;
+        }
         self.completed >= self.len()
     }
 }
 
 /// 下载任务
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct DownloadTask {
     /// 任务 ID（自增 hex 字符串）
@@ -98,7 +108,7 @@ impl DownloadTask {
 }
 
 /// 下载设置
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct DownloaderSettings {
     /// 下载目录
@@ -128,6 +138,9 @@ pub struct DownloaderSettings {
     /// 添加下载前检查重复（URL 或文件名重复时询问）
     #[serde(default = "default_true")]
     pub check_duplicate: bool,
+    /// 下载是否使用代理：true=尊重系统代理（mihomo 开启系统代理时经其转发），false=强制直连
+    #[serde(default = "default_true")]
+    pub use_proxy: bool,
 }
 
 fn default_max_concurrent() -> u32 {
@@ -166,6 +179,7 @@ impl Default for DownloaderSettings {
             extension_secret: String::new(),
             delete_files_on_remove: false,
             check_duplicate: true,
+            use_proxy: true,
         }
     }
 }

src-tauri/src/lib.rs

@@ -1,8 +1,7 @@
-use std::sync::Arc;
-use tauri::Emitter;
 use tauri::Manager;
 
 mod clipboard;
+mod constants;
 mod download_engine;
 mod logger;
 mod mihomo_manager;
@@ -12,98 +11,156 @@ mod osd_window;
 mod process_manager;
 mod quickpanel;
 mod screenshot;
+mod setup;
+mod shortcut;
 mod snap_fix;
 mod tray_menu;
+mod updater;
+mod win32_util;
 
 use download_engine::{
-    DownloadEngine, ExtensionServer,
+    DownloadEngine,
     downloader_add_task, downloader_check_url, downloader_get_extension_info, downloader_get_settings, downloader_get_tasks,
     downloader_open_dir, downloader_open_url, downloader_pause_task, downloader_remove_task,
     downloader_resume_task, downloader_save_settings, downloader_status,
 };
 use logger::{
-    clear_logs, get_log_info, get_logs, log_message, LogManager,
+    log_clear, log_info_state, log_list, log_message,
 };
 use mihomo_manager::{
-    proxy_activate_profile, proxy_check_kernel_update, proxy_clear_system_proxy, proxy_close_connection, proxy_delete_profile,
-    proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy,
-    proxy_import_profile, proxy_install_kernel, proxy_kernel_info, proxy_patch_configs, proxy_restart, proxy_save_settings,
+    proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
+    proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy,
+    proxy_import_profile, proxy_kernel_info, proxy_patch_configs, proxy_restart, proxy_save_settings,
     proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop,
-    proxy_test_delay, proxy_update_kernel, proxy_update_profile, proxy_version, MihomoManager,
+    proxy_test_delay, proxy_update_profile, proxy_version, MihomoManager,
 };
 use monitor_kernel::{
-    monitor_elevate_self, monitor_get_elevate_on_launch, monitor_get_hardware_config,
-    monitor_get_snapshot, monitor_get_status, monitor_kernel_info, monitor_set_elevate_on_launch,
-    monitor_set_hardware_config, monitor_start, monitor_start_elevated, monitor_status,
-    monitor_stop, MonitorKernel,
+    monitor_elevate_self, monitor_get_auto_start, monitor_get_elevate_on_launch,
+    monitor_get_hardware_config, monitor_get_snapshot, monitor_get_status, monitor_kernel_info,
+    monitor_set_auto_start, monitor_set_elevate_on_launch, monitor_set_hardware_config,
+    monitor_start, monitor_start_elevated, monitor_status, monitor_stop, MonitorKernel,
 };
-use network_monitor::{network_monitor_status, NetworkMonitor};
+use network_monitor::network_status;
 use osd_window::{
-    osd_apply_overlay_style, osd_begin_drag, osd_set_click_through, osd_set_topmost,
-    osd_start_drag_watch, osd_start_topmost_watch, osd_stop_watch,
+    osd_apply_overlay_style, osd_begin_drag, osd_set_bounds, osd_set_click_through,
+    osd_set_topmost, osd_start_drag_watch, osd_start_topmost_watch, osd_stop_watch,
 };
 use process_manager::{
-    get_all_process_status, get_process_status, start_monitoring_thread, start_process,
-    stop_all_processes, stop_process, ProcessManager,
+    process_all_status, process_start, process_status,
+    process_stop, process_stop_all, ProcessManager,
 };
 use screenshot::commands::{
     screenshot_capture_fullscreen, screenshot_capture_window, screenshot_clear_fullscreen,
     screenshot_compose_copy, screenshot_copy_image, screenshot_crop_copy_stored,
-    screenshot_crop_stored, screenshot_cursor_pos, screenshot_disable_transitions,
-    screenshot_enum_windows, screenshot_fullscreen_png, screenshot_get_editor_image,
-    screenshot_get_fullscreen_bmp, screenshot_register_shortcut, screenshot_save_png,
-    screenshot_set_editor_image, screenshot_unregister_shortcut, screenshot_window_from_point,
+    screenshot_crop_stored, screenshot_cursor_pos, screenshot_delete_cache,
+    screenshot_disable_transitions, screenshot_enum_windows, screenshot_fullscreen_png,
+    screenshot_get_editor_image, screenshot_get_fullscreen_bmp, screenshot_load_cache,
+    screenshot_load_cache_raw, screenshot_pick_list, screenshot_register_pin_shortcut,
+    screenshot_register_shortcut,
+    screenshot_save_cache, screenshot_save_png, screenshot_set_editor_image,
+    screenshot_show_overlay, screenshot_unregister_pin_shortcut,
+    screenshot_unregister_shortcut,
 };
 use clipboard::{
     ClipboardManager,
     clipboard_clear, clipboard_copy_back, clipboard_count, clipboard_delete, clipboard_get_history,
-    clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_hide_popup,
-    clipboard_paste_to_target, clipboard_register_shortcut, clipboard_save_settings, clipboard_search,
-    clipboard_set_pinned, clipboard_show_popup, clipboard_show_window, clipboard_start,
+    clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_get_thumb,
+    clipboard_hide_popup, clipboard_hide_preview, clipboard_paste_to_target,
+    clipboard_preview_interacted, clipboard_register_shortcut,
+    clipboard_reveal_preview,
+    clipboard_save_settings, clipboard_search, clipboard_set_pinned, clipboard_resize_preview,
+    clipboard_show_popup, clipboard_show_preview, clipboard_show_window, clipboard_start,
     clipboard_status, clipboard_stop, clipboard_unregister_shortcut,
 };
 use quickpanel::{
-    quickpanel_build_file_index, quickpanel_clear_app_icon_cache, quickpanel_delete_file,
+    quickpanel_apply_rename, quickpanel_batch_extract, quickpanel_build_file_index,
+    quickpanel_clear_app_icon_cache, quickpanel_delete_file, quickpanel_delete_files,
     quickpanel_file_index_stats, quickpanel_get_app_icon, quickpanel_get_settings,
     quickpanel_get_special_locations, quickpanel_hide_popup, quickpanel_init_file_index,
-    quickpanel_lock_screen, quickpanel_open_file, quickpanel_open_special,
-    quickpanel_register_shortcut, quickpanel_reveal_in_explorer, quickpanel_run_custom_command,
-    quickpanel_run_system_command, quickpanel_save_settings, quickpanel_scan_apps,
-    quickpanel_search_files, quickpanel_show_popup, quickpanel_show_window,
-    quickpanel_unregister_shortcut,
+    quickpanel_list_archives, quickpanel_list_dir, quickpanel_lock_screen, quickpanel_open_file,
+    quickpanel_open_special, quickpanel_preview_rename, quickpanel_register_shortcut,
+    quickpanel_reveal_in_explorer, quickpanel_run_custom_command, quickpanel_run_system_command,
+    quickpanel_save_settings, quickpanel_scan_apps, quickpanel_search_files, quickpanel_show_popup,
+    quickpanel_show_window, quickpanel_unregister_shortcut, quickpanel_focus_main_window,
 };
 use tray_menu::{tray_menu_action, tray_menu_hide, tray_menu_ready};
+use updater::{app_version, update_check, update_install, update_thinghk};
 
 #[tauri::command]
-fn greet(name: &str) -> String {
-    format!("Hello, {}! You've been greeted from Rust!", name)
+fn quit_app(app: tauri::AppHandle) {
+    // 资源清理统一收敛到 RunEvent::ExitRequested（覆盖所有退出路径），此处仅请求退出
+    app.exit(0);
 }
 
-#[tauri::command]
-fn quit_app(
-    state: tauri::State<'_, ProcessManager>,
-    mihomo: tauri::State<'_, MihomoManager>,
-    engine: tauri::State<'_, DownloadEngine>,
-    monitor: tauri::State<'_, MonitorKernel>,
-    clipboard: tauri::State<'_, ClipboardManager>,
-    app: tauri::AppHandle,
-) {
-    // 退出前清理系统代理，避免遗留导致网络问题
-    mihomo.cleanup_on_exit();
-    // 退出前保存下载引擎状态
-    engine.cleanup_on_exit();
-    // 停止提权 Kernel（普通权限由 stop_all 统一清理，提权 Kernel 需通过 /shutdown）
-    tauri::async_runtime::block_on(monitor.cleanup_on_exit(&app));
-    // 停止剪贴板监听线程
-    clipboard.stop();
-    // 停止所有子进程（同步 kill + 带超时的 wait，确保进程真正终止）
-    state.stop_all();
-    // 通过 app.exit 触发 RunEvent::ExitRequested，统一退出路径
-    app.exit(0);
+/// 导出 tauri-specta 生成的 TypeScript 类型与命令绑定（仅 debug 构建，开发时自动刷新）。
+/// 覆盖 proxy / quickpanel / clipboard / download_engine / screenshot 五个模块；
+/// 豁免清单（返回 serde_json::Value 或 tauri::ipc::Response/Request，specta 无法生成）：
+/// proxy_version / proxy_get_proxies / proxy_get_connections / proxy_patch_configs、
+/// downloader_status / downloader_get_extension_info、
+/// screenshot_get_fullscreen_bmp（返回 ipc::Response）/ screenshot_compose_copy（接收 ipc::Request）。
+#[cfg(debug_assertions)]
+fn export_bindings() {
+    use specta_typescript::Typescript;
+    use tauri_specta::{Builder, ErrorHandlingMode, collect_commands};
+
+    Builder::<tauri::Wry>::new()
+        // 全局把 u64/i64 映射为 number（项目取值均在 JS 安全整数范围：大小/时间戳/limit）
+        .dangerously_cast_bigints_to_number()
+        // 生成命令失败时直接 throw，与原生 invoke 一致，前端无需解包 helper
+        .error_handling(ErrorHandlingMode::Throw)
+        .commands(collect_commands![
+            // 应用更新（4）
+            app_version, update_check, update_install, update_thinghk,
+            // proxy（20）
+            proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
+            proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_settings,
+            proxy_get_system_proxy, proxy_import_profile, proxy_kernel_info,
+            proxy_restart, proxy_save_settings,
+            proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop,
+            proxy_test_delay, proxy_update_profile,
+            // quickpanel（22）
+            quickpanel_get_settings, quickpanel_save_settings, quickpanel_register_shortcut,
+            quickpanel_unregister_shortcut, quickpanel_show_popup, quickpanel_hide_popup,
+            quickpanel_show_window, quickpanel_lock_screen, quickpanel_init_file_index,
+            quickpanel_build_file_index, quickpanel_search_files, quickpanel_file_index_stats,
+            quickpanel_scan_apps, quickpanel_get_app_icon, quickpanel_clear_app_icon_cache,
+            quickpanel_reveal_in_explorer, quickpanel_open_file, quickpanel_get_special_locations,
+            quickpanel_open_special, quickpanel_delete_file, quickpanel_run_custom_command,
+            quickpanel_run_system_command, quickpanel_list_archives, quickpanel_list_dir,
+            quickpanel_batch_extract, quickpanel_preview_rename, quickpanel_apply_rename,
+            quickpanel_delete_files, quickpanel_focus_main_window,
+            // clipboard（23）
+            clipboard_get_history, clipboard_get_pinned, clipboard_search, clipboard_get_item,
+            clipboard_get_thumb, clipboard_set_pinned, clipboard_delete, clipboard_clear,
+            clipboard_copy_back, clipboard_count, clipboard_get_settings, clipboard_save_settings,
+            clipboard_status, clipboard_start, clipboard_stop, clipboard_register_shortcut,
+            clipboard_unregister_shortcut, clipboard_show_popup, clipboard_hide_popup,
+            clipboard_show_window, clipboard_paste_to_target, clipboard_show_preview,
+            clipboard_hide_preview, clipboard_resize_preview, clipboard_reveal_preview,
+            clipboard_preview_interacted,
+            // download_engine（10，豁免 2）
+            downloader_get_tasks, downloader_check_url, downloader_add_task, downloader_pause_task,
+            downloader_resume_task, downloader_remove_task, downloader_get_settings,
+            downloader_save_settings, downloader_open_dir, downloader_open_url,
+            // screenshot（22，豁免 3：get_fullscreen_bmp / load_cache_raw 返回 ipc::Response、compose_copy 接收 ipc::Request）
+            screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut,
+            screenshot_unregister_shortcut, screenshot_register_pin_shortcut,
+            screenshot_unregister_pin_shortcut, screenshot_capture_fullscreen,
+            screenshot_fullscreen_png, screenshot_clear_fullscreen, screenshot_crop_stored,
+            screenshot_crop_copy_stored, screenshot_pick_list, screenshot_cursor_pos,
+            screenshot_enum_windows, screenshot_capture_window, screenshot_set_editor_image,
+            screenshot_get_editor_image, screenshot_copy_image, screenshot_save_png,
+            screenshot_save_cache, screenshot_load_cache, screenshot_delete_cache,
+        ])
+        .export(Typescript::default(), "../src/lib/bindings.ts")
+        .expect("failed to export bindings");
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    #[cfg(debug_assertions)]
+    export_bindings();
+
     tauri::Builder::default()
         .plugin(tauri_plugin_autostart::Builder::new().build())
         .plugin(tauri_plugin_opener::init())
@@ -119,23 +176,27 @@ pub fn run() {
         )
         .manage(ProcessManager::new())
         .invoke_handler(tauri::generate_handler![
-            greet,
             quit_app,
-            start_process,
-            stop_process,
-            get_process_status,
-            get_all_process_status,
-            stop_all_processes,
+            app_version,
+            update_check,
+            update_install,
+            update_thinghk,
+            process_start,
+            process_stop,
+            process_status,
+            process_all_status,
+            process_stop_all,
             log_message,
-            get_logs,
-            clear_logs,
-            get_log_info,
+            log_list,
+            log_clear,
+            log_info_state,
             proxy_get_settings,
             proxy_save_settings,
             proxy_kernel_info,
             proxy_check_kernel_update,
-            proxy_update_kernel,
-            proxy_install_kernel,
+            proxy_apply_kernel_update,
+            proxy_cancel_kernel_install,
+            proxy_confirm_install,
             proxy_status,
             proxy_start,
             proxy_stop,
@@ -164,11 +225,14 @@ pub fn run() {
             monitor_get_snapshot,
             monitor_get_elevate_on_launch,
             monitor_set_elevate_on_launch,
+            monitor_get_auto_start,
+            monitor_set_auto_start,
             monitor_get_hardware_config,
             monitor_set_hardware_config,
-            network_monitor_status,
+            network_status,
             osd_apply_overlay_style,
             osd_begin_drag,
+            osd_set_bounds,
             osd_set_click_through,
             osd_set_topmost,
             osd_start_drag_watch,
@@ -190,6 +254,7 @@ pub fn run() {
             clipboard_get_pinned,
             clipboard_search,
             clipboard_get_item,
+            clipboard_get_thumb,
             clipboard_set_pinned,
             clipboard_delete,
             clipboard_clear,
@@ -206,6 +271,11 @@ pub fn run() {
             clipboard_show_window,
             clipboard_hide_popup,
             clipboard_paste_to_target,
+            clipboard_show_preview,
+            clipboard_hide_preview,
+            clipboard_resize_preview,
+            clipboard_reveal_preview,
+            clipboard_preview_interacted,
             quickpanel_get_settings,
             quickpanel_save_settings,
             quickpanel_register_shortcut,
@@ -224,10 +294,17 @@ pub fn run() {
             quickpanel_reveal_in_explorer,
             quickpanel_open_file,
             quickpanel_delete_file,
+            quickpanel_delete_files,
             quickpanel_run_custom_command,
             quickpanel_run_system_command,
             quickpanel_get_special_locations,
             quickpanel_open_special,
+            quickpanel_list_archives,
+            quickpanel_list_dir,
+            quickpanel_batch_extract,
+            quickpanel_preview_rename,
+            quickpanel_apply_rename,
+            quickpanel_focus_main_window,
             tray_menu_action,
             tray_menu_hide,
             tray_menu_ready,
@@ -238,7 +315,8 @@ pub fn run() {
             screenshot_clear_fullscreen,
             screenshot_crop_stored,
             screenshot_crop_copy_stored,
-            screenshot_window_from_point,
+            screenshot_pick_list,
+            screenshot_show_overlay,
             screenshot_cursor_pos,
             screenshot_enum_windows,
             screenshot_capture_window,
@@ -246,127 +324,26 @@ pub fn run() {
             screenshot_get_editor_image,
             screenshot_copy_image,
             screenshot_save_png,
+            screenshot_save_cache,
+            screenshot_load_cache,
+            screenshot_load_cache_raw,
+            screenshot_delete_cache,
             screenshot_register_shortcut,
             screenshot_unregister_shortcut,
+            screenshot_register_pin_shortcut,
+            screenshot_unregister_pin_shortcut,
             screenshot_disable_transitions,
             screenshot_compose_copy
         ])
-        .setup(|app| {
-            // 初始化日志系统，日志目录: {app_data_dir}/logs/
-            let log_dir = app
-                .path()
-                .app_data_dir()
-                .unwrap_or_else(|_| std::path::PathBuf::from("."))
-                .join("logs");
-            app.manage(LogManager::new(log_dir));
-
-            // 初始化 MihomoManager，数据目录: {app_data_dir}/proxy/
-            let app_data_dir = app
-                .path()
-                .app_data_dir()
-                .unwrap_or_else(|_| std::path::PathBuf::from("."));
-
-            // 永久提权检查：如果标志已设置且当前非管理员，以管理员权限重启自身并退出
-            // 必须在所有模块初始化之前执行（此时无资源需要清理）
-            if monitor_kernel::check_and_relaunch_if_needed(&app_data_dir) {
-                std::process::exit(0);
-            }
-
-            let mihomo = MihomoManager::new(app_data_dir.clone());
-            app.manage(mihomo);
-
-            // 初始化 MonitorKernel，数据目录: {app_data_dir}/monitor/
-            let monitor = MonitorKernel::new(app_data_dir.clone());
-            app.manage(monitor);
-
-            // 初始化 NetworkMonitor（网速监控，独立于 ThingHK Kernel）
-            // 网速采样不依赖提权，应用启动即开始
-            let network_monitor = Arc::new(NetworkMonitor::new());
-            app.manage(network_monitor.clone());
-            network_monitor.start(app.handle().clone());
-
-            // 初始化 DownloadEngine，数据目录: {app_data_dir}/downloader/
-            let engine = DownloadEngine::new(
-                app_data_dir.join("downloader"),
-                app.handle().clone(),
-            );
-            let settings = engine.get_settings();
-            app.manage(engine.clone());
-
-            // 启动扩展 HTTP API 服务器
-            let server_engine = engine.clone();
-            let server_port = settings.extension_port;
-            let server_secret = settings.extension_secret.clone();
-            tauri::async_runtime::spawn(async move {
-                ExtensionServer::start(server_engine, server_port, server_secret).await;
-            });
-
-            // 初始化 ClipboardManager，数据目录: {app_data_dir}/clipboard/
-            let clipboard = ClipboardManager::new(app_data_dir.clone());
-            // 应用启动时若已启用则自动开始监听
-            if clipboard.get_settings().enabled {
-                clipboard.start(&app.handle());
-            }
-            // 应用启动时注册快捷弹窗全局快捷键
-            let shortcut = clipboard.get_settings().shortcut.clone();
-            if !shortcut.trim().is_empty() {
-                let app_handle = app.handle().clone();
-                if let Err(e) = clipboard::popup::register_shortcut(&app_handle, &shortcut) {
-                    eprintln!("[clipboard] 快捷键注册失败: {}", e);
-                }
-                // 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
-                clipboard::popup::ensure_popup_window(&app_handle);
-            }
-            app.manage(clipboard);
-
-            // 快速面板：应用启动时注册全局快捷键 + 预创建隐藏窗口。
-            // defaultEnabled:true 假设启用；用户在设置页禁用模块时由前端 onDisable 钩子注销快捷键。
-            let qp_settings = quickpanel::load_settings(&app.handle());
-            if !qp_settings.shortcut.trim().is_empty() {
-                let app_handle = app.handle().clone();
-                if let Err(e) = quickpanel::register_shortcut(&app_handle, &qp_settings.shortcut) {
-                    eprintln!("[quickpanel] 快捷键注册失败: {}", e);
-                }
-                // 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
-                quickpanel::ensure_window(&app_handle);
-            }
-            // 初始化文件索引数据库（不立即构建，由前端设置页或首次唤起时触发）
-            quickpanel::file_index::init(&app.handle());
-
-            // 自定义托盘菜单（代理/OSD/Kernel/下载/设置/退出）
-            tray_menu::create_tray_menu(app.handle())?;
-
-            // 启动进程监控线程
-            start_monitoring_thread(app.handle().clone());
-
-            // 应用启动时自动启动 mihomo（如果用户在设置中开启了自动启动）
-            if let Some(mihomo) = app.try_state::<MihomoManager>() {
-                if let Some(pm) = app.try_state::<ProcessManager>() {
-                    mihomo.auto_start_on_launch(app.handle(), &pm);
-                }
-            }
-
-            // 应用启动时自动启动 monitor Kernel（硬件监控默认启用，被动读取无副作用）
-            if let Some(monitor) = app.try_state::<MonitorKernel>() {
-                let monitor = monitor.inner().clone();
-                let app_handle = app.handle().clone();
-                tauri::async_runtime::spawn(async move {
-                    match monitor.start_with_subscription(&app_handle).await {
-                        Ok(info) => eprintln!("[monitor] 自动启动成功, pid={:?}", info.pid),
-                        Err(e) => eprintln!("[monitor] 自动启动跳过: {}", e),
-                    }
-                });
-            }
-
-            // 截图快捷键由前端 screenshotStore 启动时调用 screenshot_register_shortcut 注册
-            // （支持自定义，默认 Ctrl+Alt+A），此处不再硬编码注册
-
-            Ok(())
-        })
+        .setup(setup::init)
         .on_window_event(|window, event| {
-            if let tauri::WindowEvent::CloseRequested { api, .. } = event {
-                window.hide().ok();
-                api.prevent_close();
+            // 仅主窗口拦截关闭（隐藏到托盘）。其他窗口（截图编辑器/OSD 等）
+            // 调用 close() 是真实销毁语义，全局拦截会导致隐藏窗口累积泄漏。
+            if window.label() == constants::windows::MAIN {
+                if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+                    window.hide().ok();
+                    api.prevent_close();
+                }
             }
         })
         .build(tauri::generate_context!())
@@ -380,7 +357,19 @@ pub fn run() {
                     engine.cleanup_on_exit();
                 }
                 if let Some(monitor) = app.try_state::<MonitorKernel>() {
-                    tauri::async_runtime::block_on(monitor.cleanup_on_exit(app));
+                    // cleanup_on_exit 是 async；在事件循环回调中直接 block_on 有 panic 风险且阻塞退出，
+                    // 放到独立 OS 线程执行并通过 channel 限时等待 3s，超时放弃等待直接退出
+                    // （进程终止时 OS 回收残留资源），避免清理挂起导致退出卡死。
+                    let app_clone = app.clone();
+                    let monitor_clone = monitor.inner().clone();
+                    let (tx, rx) = std::sync::mpsc::channel::<()>();
+                    std::thread::spawn(move || {
+                        tauri::async_runtime::block_on(async move {
+                            monitor_clone.cleanup_on_exit(&app_clone).await;
+                        });
+                        let _ = tx.send(());
+                    });
+                    let _ = rx.recv_timeout(std::time::Duration::from_secs(3));
                 }
                 if let Some(clip) = app.try_state::<ClipboardManager>() {
                     clip.stop();

src-tauri/src/logger.rs

@@ -1,8 +1,9 @@
 use chrono::Local;
 use serde::{Deserialize, Serialize};
 use std::fs::{self, File, OpenOptions};
-use std::io::{BufRead, BufReader, Write};
-use std::path::PathBuf;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex, OnceLock};
 
 /// 日志级别
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -34,11 +35,14 @@ pub struct LogInfo {
 }
 
 /// 日志管理器 —— 负责文件轮转、写入、查询
+/// 所有写/轮转/读操作通过 write_lock 串行化，防止并发写交错与轮转竞争
+#[derive(Clone)]
 pub struct LogManager {
     log_dir: PathBuf,
     max_file_size: u64,
     max_files: u32,
     base_name: String,
+    write_lock: Arc<Mutex<()>>,
 }
 
 impl LogManager {
@@ -48,12 +52,14 @@ impl LogManager {
             log_dir,
             max_file_size: 5 * 1024 * 1024,
             max_files: 5,
-            base_name: "thing".to_string(),
+            base_name: "Thing".to_string(),
+            write_lock: Arc::new(Mutex::new(())),
         }
     }
 
-    /// 写入一条日志
+    /// 写入一条日志（写 + 轮转在锁内串行执行）
     pub fn log(&self, level: LogLevel, module: &str, message: &str) {
+        let _guard = self.write_lock.lock().unwrap_or_else(|e| e.into_inner());
         let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
         let level_str = match level {
             LogLevel::Debug => "DEBUG",
@@ -114,56 +120,57 @@ impl LogManager {
     }
 
     /// 读取日志（支持按模块/级别过滤、条数限制）
+    /// 从最新文件向旧文件倒序遍历，每个文件从末尾向前读取，达到 limit 即停止，
+    /// 避免将全部日志读入内存后再排序截断
     pub fn get_logs(
         &self,
         module: Option<&str>,
         level: Option<LogLevel>,
         limit: Option<usize>,
     ) -> Vec<LogEntry> {
+        let limit = limit.unwrap_or(100);
+        // 与写入共用同一把锁，避免读到轮转半途/写入半行的状态
+        let _guard = self.write_lock.lock().unwrap_or_else(|e| e.into_inner());
+
         let mut entries: Vec<LogEntry> = Vec::new();
 
-        // 收集所有日志文件（包括轮转文件）
-        let mut log_files: Vec<PathBuf> = Vec::new();
+        // 收集日志文件（最新在前：thing.log → thing.1.log → …）
+        let mut paths: Vec<PathBuf> = Vec::new();
         let current = self.log_dir.join(format!("{}.log", self.base_name));
         if current.exists() {
-            log_files.push(current);
+            paths.push(current);
         }
         for i in 1..=self.max_files {
             let rotated = self
                 .log_dir
                 .join(format!("{}.{}.log", self.base_name, i));
             if rotated.exists() {
-                log_files.push(rotated);
+                paths.push(rotated);
             }
         }
 
-        for path in &log_files {
-            if let Ok(file) = File::open(path) {
-                for line in BufReader::new(file).lines().flatten() {
-                    if let Some(entry) = Self::parse_line(&line) {
-                        if let Some(ref m) = module {
-                            if entry.module != *m {
-                                continue;
-                            }
+        'outer: for path in &paths {
+            // 每文件返回最近 limit 行（从新到旧），收集满即整体停止
+            for line in read_tail_lines(path, limit) {
+                if let Some(entry) = Self::parse_line(&line) {
+                    if let Some(ref m) = module {
+                        if entry.module != *m {
+                            continue;
                         }
-                        if let Some(ref l) = level {
-                            if entry.level != *l {
-                                continue;
-                            }
+                    }
+                    if let Some(ref l) = level {
+                        if entry.level != *l {
+                            continue;
                         }
-                        entries.push(entry);
+                    }
+                    entries.push(entry);
+                    if entries.len() >= limit {
+                        break 'outer;
                     }
                 }
             }
         }
 
-        // 按时间戳降序（最新在前）
-        entries.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
-
-        if let Some(n) = limit {
-            entries.truncate(n);
-        }
-
         entries
     }
 
@@ -212,6 +219,7 @@ impl LogManager {
 
     /// 清空所有日志文件
     pub fn clear_logs(&self) -> Result<(), String> {
+        let _guard = self.write_lock.lock().unwrap_or_else(|e| e.into_inner());
         let current = self.log_dir.join(format!("{}.log", self.base_name));
         fs::remove_file(&current).map_err(|e| e.to_string())?;
         for i in 1..=self.max_files {
@@ -259,6 +267,63 @@ impl LogManager {
 
 // ===== Tauri 命令 =====
 
+/// 从文件末尾向前读取日志行（返回时间从新到旧的最近 max_lines 行）。
+/// 按 8KB 块向前 seek 读取并拼接跨块半行，只读取文件尾部，避免全量读入
+fn read_tail_lines(path: &Path, max_lines: usize) -> Vec<String> {
+    let mut file = match File::open(path) {
+        Ok(f) => f,
+        Err(_) => return Vec::new(),
+    };
+    let file_len = match file.metadata() {
+        Ok(m) => m.len(),
+        Err(_) => return Vec::new(),
+    };
+    const CHUNK: u64 = 8192;
+
+    // tail 保存"当前块更靠后的半行"，下一轮（更早的块）拼在其前
+    let mut tail = String::new();
+    let mut lines: Vec<String> = Vec::new();
+    let mut pos = file_len;
+
+    while pos > 0 && lines.len() < max_lines {
+        let start = pos.saturating_sub(CHUNK);
+        let len = (pos - start) as usize;
+        let mut bytes = vec![0u8; len];
+        if file.seek(SeekFrom::Start(start)).is_err() || file.read_exact(&mut bytes).is_err() {
+            break;
+        }
+        pos = start;
+
+        let mut text = String::from_utf8_lossy(&bytes).into_owned();
+        text.push_str(&tail);
+
+        // 最后一段未以 \n 结尾 → 半行，作为下一轮 tail（与本块之前的内容拼接）
+        let mut parts: Vec<&str> = text.split('\n').collect();
+        tail = parts.pop().unwrap_or("").to_string();
+
+        // 从后往前（新到旧）取完整行
+        for part in parts.iter().rev() {
+            let trimmed = part.trim();
+            if !trimmed.is_empty() {
+                lines.push(trimmed.to_string());
+                if lines.len() >= max_lines {
+                    break;
+                }
+            }
+        }
+    }
+
+    // 文件头残余（pos == 0 时 tail 里可能是文件第一行）
+    if pos == 0 {
+        let trimmed = tail.trim();
+        if !trimmed.is_empty() && lines.len() < max_lines {
+            lines.push(trimmed.to_string());
+        }
+    }
+
+    lines
+}
+
 #[tauri::command]
 pub fn log_message(
     state: tauri::State<'_, LogManager>,
@@ -278,12 +343,12 @@ pub fn log_message(
 }
 
 #[tauri::command]
-pub fn get_logs(
+pub async fn log_list(
     state: tauri::State<'_, LogManager>,
     module: Option<String>,
     level: Option<String>,
     limit: Option<usize>,
-) -> Vec<LogEntry> {
+) -> Result<Vec<LogEntry>, String> {
     let level = level.and_then(|l| match l.as_str() {
         "debug" => Some(LogLevel::Debug),
         "info" => Some(LogLevel::Info),
@@ -291,15 +356,203 @@ pub fn get_logs(
         "error" => Some(LogLevel::Error),
         _ => None,
     });
-    state.get_logs(module.as_deref(), level, limit)
+    // 文件读取（含 seek 尾部扫描）移出 async runtime 线程
+    let manager = state.inner().clone();
+    tauri::async_runtime::spawn_blocking(move || manager.get_logs(module.as_deref(), level, limit))
+        .await
+        .map_err(|e| format!("读取日志任务失败: {}", e))
 }
 
 #[tauri::command]
-pub fn clear_logs(state: tauri::State<'_, LogManager>) -> Result<(), String> {
+pub fn log_clear(state: tauri::State<'_, LogManager>) -> Result<(), String> {
     state.clear_logs()
 }
 
 #[tauri::command]
-pub fn get_log_info(state: tauri::State<'_, LogManager>) -> LogInfo {
+pub fn log_info_state(state: tauri::State<'_, LogManager>) -> LogInfo {
     state.get_info()
 }
+
+// ===== 进程级全局日志器 =====
+// 后端模块（无 AppHandle 上下文）通过 log_line 写入统一的日志文件，
+// 与 Tauri 命令 log_message 共用同一 LogManager（write_lock 串行化），
+// 消除 eprintln!/println! 双轨并行问题。
+
+static GLOBAL_LOGGER: OnceLock<LogManager> = OnceLock::new();
+
+/// 在 setup 中注册全局日志器（与 app.manage 注册的实例共享同一把 write_lock）
+pub fn install_global(manager: LogManager) {
+    let _ = GLOBAL_LOGGER.set(manager);
+}
+
+/// 写一条后端模块日志。未注册全局日志器时回退到 stderr（如测试环境）。
+pub fn log_line(module: &str, level: LogLevel, message: &str) {
+    match GLOBAL_LOGGER.get() {
+        Some(m) => m.log(level, module, message),
+        None => eprintln!("[{}] {}", module, message),
+    }
+}
+
+/// 便捷：INFO 级别
+pub fn log_info(module: &str, message: &str) {
+    log_line(module, LogLevel::Info, message);
+}
+
+/// 便捷：WARN 级别
+pub fn log_warn(module: &str, message: &str) {
+    log_line(module, LogLevel::Warn, message);
+}
+
+/// 便捷：ERROR 级别
+pub fn log_error(module: &str, message: &str) {
+    log_line(module, LogLevel::Error, message);
+}
+
+#[cfg(test)]
+mod logger_tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU32, Ordering};
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    static TEST_COUNTER: AtomicU32 = AtomicU32::new(0);
+
+    /// 创建唯一临时目录（进程内多次调用不冲突），测试结束自动清理
+    fn temp_dir(tag: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let pid = std::process::id();
+        let seq = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!(
+            "thing_log_test_{}_{}_{}_{}",
+            tag, pid, nanos, seq
+        ));
+        fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    struct TempGuard(PathBuf);
+    impl Drop for TempGuard {
+        fn drop(&mut self) {
+            let _ = fs::remove_dir_all(&self.0);
+        }
+    }
+
+    #[test]
+    fn parse_line_roundtrip() {
+        let line = "[2026-08-05 10:00:00] [INFO] [downloader] 下载完成";
+        let entry = LogManager::parse_line(line).expect("标准行应能解析");
+        assert_eq!(entry.timestamp, "2026-08-05 10:00:00");
+        assert_eq!(entry.level, LogLevel::Info);
+        assert_eq!(entry.module, "downloader");
+        assert_eq!(entry.message, "下载完成");
+
+        // 非法行返回 None
+        assert!(LogManager::parse_line("not a log line").is_none());
+        assert!(LogManager::parse_line("").is_none());
+        assert!(LogManager::parse_line("[bad] [INFO] [m] msg").is_none());
+        assert!(LogManager::parse_line("[2026-08-05 10:00:00] [NOPE] [m] msg").is_none());
+        // 时间戳不做格式校验：仅按方括号切分，日期形式同样可解析
+        assert!(LogManager::parse_line("[2026-08-05] [INFO] [m] msg").is_some());
+    }
+
+    #[test]
+    fn rotate_shifts_files_and_caps_count() {
+        let dir = temp_dir("rotate");
+        let _guard = TempGuard(dir.clone());
+        let mgr = LogManager::new(dir.clone());
+
+        let current = dir.join("thing.log");
+        fs::write(&current, "content-0").unwrap();
+        mgr.rotate();
+        // thing.log → thing.1.log
+        assert!(!current.exists());
+        assert_eq!(
+            fs::read_to_string(dir.join("thing.1.log")).unwrap(),
+            "content-0"
+        );
+
+        // 第二次轮转：thing.1.log → thing.2.log，新 thing.log → thing.1.log
+        fs::write(&current, "content-1").unwrap();
+        mgr.rotate();
+        assert_eq!(
+            fs::read_to_string(dir.join("thing.2.log")).unwrap(),
+            "content-0"
+        );
+        assert_eq!(
+            fs::read_to_string(dir.join("thing.1.log")).unwrap(),
+            "content-1"
+        );
+
+        // 轮转超过 max_files(5) 后最旧文件被删除，文件数量不超上限
+        for i in 0..6 {
+            fs::write(&current, format!("content-{}", i)).unwrap();
+            mgr.rotate();
+        }
+        let files: Vec<String> = fs::read_dir(&dir)
+            .unwrap()
+            .filter_map(|e| e.ok().map(|e| e.file_name().to_string_lossy().into_owned()))
+            .filter(|n| n.ends_with(".log"))
+            .collect();
+        assert!(files.len() <= 5, "轮转文件数量超上限: {:?}", files);
+        assert!(dir.join("thing.1.log").exists(), "最新的旋转文件应存在");
+    }
+
+    #[test]
+    fn log_writes_and_get_logs_filters() {
+        let dir = temp_dir("query");
+        let _guard = TempGuard(dir.clone());
+        let mgr = LogManager::new(dir.clone());
+
+        mgr.log(LogLevel::Info, "downloader", "任务开始");
+        mgr.log(LogLevel::Error, "downloader", "任务失败");
+        mgr.log(LogLevel::Info, "proxy", "节点切换");
+
+        // 全部（新到旧）
+        let all = mgr.get_logs(None, None, None);
+        assert_eq!(all.len(), 3);
+        assert_eq!(all[0].message, "节点切换");
+        assert_eq!(all[2].message, "任务开始");
+
+        // 按模块过滤
+        let dl = mgr.get_logs(Some("downloader"), None, None);
+        assert_eq!(dl.len(), 2);
+        assert!(dl.iter().all(|e| e.module == "downloader"));
+
+        // 按级别过滤
+        let errs = mgr.get_logs(None, Some(LogLevel::Error), None);
+        assert_eq!(errs.len(), 1);
+        assert_eq!(errs[0].message, "任务失败");
+
+        // 条数限制
+        let limited = mgr.get_logs(None, None, Some(2));
+        assert_eq!(limited.len(), 2);
+    }
+
+    #[test]
+    fn auto_rotate_triggers_on_size() {
+        let dir = temp_dir("auto");
+        let _guard = TempGuard(dir.clone());
+        let mgr = LogManager::new(dir.clone());
+
+        // 写满 5MB 触发自动轮转（meta.len() >= max_file_size）
+        let current = dir.join("thing.log");
+        let mut f = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&current)
+            .unwrap();
+        let big = "x".repeat(5 * 1024 * 1024);
+        f.write_all(big.as_bytes()).unwrap();
+        drop(f);
+
+        mgr.log(LogLevel::Info, "test", "触发轮转");
+        assert!(dir.join("thing.1.log").exists(), "应自动轮转出 thing.1.log");
+        // 轮转后旧文件（5MB）被重命名为 thing.1.log，当前文件只含新追加的一行
+        let rotated_len = fs::metadata(dir.join("thing.1.log")).unwrap().len();
+        assert_eq!(rotated_len, 5 * 1024 * 1024, "轮转出的文件应保留完整旧内容");
+        let cur_len = fs::metadata(&current).unwrap().len();
+        assert!(cur_len < 100, "轮转后的当前文件应只含新行: {}", cur_len);
+    }
+}

src-tauri/src/mihomo_manager/autoswitch.rs

@@ -0,0 +1,192 @@
+//! 自动切换节点：后端调度，独立于前端模块是否处于激活状态。
+//! 应用启动后由 `setup.rs` 启动后台任务，按用户设置的间隔周期性测速并切换到当前最优节点，
+//! 切换完成后通过 `proxy-auto-switch` 事件通知前端刷新界面。
+//! 节点候选（目标组 + 地区筛选 + 伪节点过滤）与择优逻辑对前端、后台调度、托盘三处保持一致。
+
+use futures_util::future::join_all;
+use serde_json::{Map, Value};
+use std::time::{Duration, Instant};
+use tauri::{AppHandle, Emitter, Manager, State};
+
+use super::{MihomoManager, ProxySettings};
+use crate::constants::events::PROXY_AUTO_SWITCH;
+use crate::process_manager::{ProcessManager, ProcessStatus};
+
+/// 测速目标（同前端/托盘），用于判断节点可用性
+const TEST_URL: &str = "http://www.gstatic.com/generate_204";
+/// 单节点测速超时（毫秒）
+const TEST_TIMEOUT: u32 = 5000;
+/// 调度轮询粒度（秒）
+const CHECK_INTERVAL: u64 = 30;
+
+/// 后端启动自动切换调度任务（幂等，可安全多次调用）。
+/// 仅在用户开启「自动切换节点」且 mihomo 运行时才会真正执行测速与切换。
+pub fn start_auto_switch_loop(app: AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        let mut last_run: Option<Instant> = None;
+        loop {
+            tokio::time::sleep(Duration::from_secs(CHECK_INTERVAL)).await;
+
+            let enabled = app
+                .try_state::<MihomoManager>()
+                .map(|m: State<'_, MihomoManager>| m.load_settings().auto_switch_enabled)
+                .unwrap_or(false);
+            if !enabled {
+                last_run = None;
+                continue;
+            }
+
+            let interval_secs = app
+                .try_state::<MihomoManager>()
+                .map(|m: State<'_, MihomoManager>| m.load_settings().auto_switch_interval.max(1) as u64)
+                .unwrap_or(5)
+                * 60;
+
+            let due = match last_run {
+                Some(t) => t.elapsed().as_secs() >= interval_secs,
+                None => true,
+            };
+            if !due {
+                continue;
+            }
+
+            if let Some((group, name, delay)) = perform_auto_switch(&app).await {
+                let _ = app.emit(
+                    PROXY_AUTO_SWITCH,
+                    serde_json::json!({
+                        "switched": true,
+                        "group": group,
+                        "name": name,
+                        "delay": delay,
+                    }),
+                );
+            }
+            last_run = Some(Instant::now());
+        }
+    });
+}
+
+/// 执行一次自动切换：若当前不是最优节点则切换并返回 `(组名, 节点名, 延迟)`，否则返回 `None`。
+/// 供后台调度任务使用（模块内私有）。
+async fn perform_auto_switch(app: &AppHandle) -> Option<(String, String, u32)> {
+    let mihomo = app.state::<MihomoManager>();
+    let pm = app.state::<ProcessManager>();
+
+    // 仅在 mihomo 运行时执行
+    let running = matches!(
+        pm.get_status("proxy").map(|p| p.status),
+        Some(ProcessStatus::Running)
+    );
+    if !running {
+        return None;
+    }
+
+    let settings = mihomo.load_settings();
+    if !settings.auto_switch_enabled {
+        return None;
+    }
+
+    let (group, name, delay, now) = pick_best(&mihomo, &settings).await.ok()??;
+
+    if name != now && mihomo.select_proxy(&group, &name).await.is_ok() {
+        return Some((group, name, delay));
+    }
+    None
+}
+
+/// 按自动切换设置确定候选组与地区，并发测速并返回当前最优节点（不执行切换）。
+/// `Some((组名, 最优节点, 延迟, 当前节点))`；无候选或全部超时返回 `Ok(None)`。
+/// 当自动切换关闭时自动切换目标组为空、地区为空，故退化为「主组 + 全部节点」全量择优，
+/// 托盘「开启代理」与调度任务复用此函数保证行为一致。
+pub async fn pick_best(
+    mihomo: &MihomoManager,
+    settings: &ProxySettings,
+) -> Result<Option<(String, String, u32, String)>, String> {
+    let proxies = mihomo.get_proxies().await?;
+    let map = proxies
+        .get("proxies")
+        .and_then(|v| v.as_object())
+        .cloned()
+        .ok_or_else(|| "无法解析代理数据".to_string())?;
+
+    let group_name = if !settings.auto_switch_group.is_empty() {
+        settings.auto_switch_group.clone()
+    } else {
+        match main_selector_group(&map) {
+            Some(g) => g,
+            None => return Ok(None),
+        }
+    };
+
+    let group = match map.get(&group_name) {
+        Some(g) => g,
+        None => return Ok(None),
+    };
+    let now = group
+        .get("now")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    let mut nodes: Vec<String> = group
+        .get("all")
+        .and_then(|v| v.as_array())
+        .map(|arr| arr.iter().filter_map(|n| n.as_str().map(|s| s.to_string())).collect())
+        .unwrap_or_default();
+    if nodes.is_empty() {
+        return Ok(None);
+    }
+
+    // 过滤伪节点（DIRECT、REJECT、流量、套餐等）
+    nodes.retain(|n| !super::is_pseudo_node(n));
+    // 地区筛选
+    if !settings.auto_switch_region.is_empty() {
+        let region = settings.auto_switch_region.clone();
+        nodes.retain(|n| extract_region(n) == region);
+    }
+    if nodes.is_empty() {
+        return Ok(None);
+    }
+
+    // 并发测速
+    let futures = nodes.iter().map(|name| async move {
+        let d = mihomo.test_delay(name, TEST_URL, TEST_TIMEOUT).await.ok();
+        (name.clone(), d)
+    }).collect::<Vec<_>>();
+    let results = join_all(futures).await;
+    let best = results
+        .into_iter()
+        .filter_map(|(n, d)| d.filter(|x| *x > 0).map(|x| (n, x)))
+        .min_by_key(|(_, d)| *d);
+
+    Ok(best.map(|(name, delay)| (group_name, name, delay, now)))
+}
+
+/// 主选择分组：选取名为 PROXY/Proxy/节点选择/代理 的 Selector 组；找不到时回退到第一个 Selector 组
+fn main_selector_group(map: &Map<String, Value>) -> Option<String> {
+    let mut preferred: Option<String> = None;
+    let mut first_selector: Option<String> = None;
+    for (name, val) in map {
+        let kind = val.get("type").and_then(|v| v.as_str()).unwrap_or("");
+        if kind != "Selector" {
+            continue;
+        }
+        if first_selector.is_none() {
+            first_selector = Some(name.clone());
+        }
+        if preferred.is_none() && ["PROXY", "Proxy", "节点选择", "代理"].contains(&name.as_str()) {
+            preferred = Some(name.clone());
+        }
+    }
+    preferred.or(first_selector)
+}
+
+/// 提取节点地区（与前端 extractRegion 保持一致）：取名称中第一个数字/符号分隔符之前的文本
+fn extract_region(name: &str) -> String {
+    for (idx, ch) in name.char_indices() {
+        if ch.is_ascii_digit() || matches!(ch, '|' | '-' | '－' | '—' | '（' | '(' | '【') {
+            return name[..idx].trim().to_string();
+        }
+    }
+    name.trim().to_string()
+}

src-tauri/src/mihomo_manager/commands.rs

@@ -0,0 +1,332 @@
+//! 代理模块 Tauri 命令层。
+
+use tauri::{AppHandle, State};
+
+use super::system_proxy::{clear_system_proxy_windows, get_system_proxy_windows, set_system_proxy_windows};
+use super::{
+    KernelInfo, KernelUpdateInfo, MihomoManager, ProfileMeta, ProxySettings, ProxyStatus,
+};
+
+use crate::process_manager::{ProcessInfo, ProcessManager, ProcessStatus};
+
+/// 判断 mihomo 进程是否处于运行状态
+fn mihomo_running(pm: &ProcessManager) -> bool {
+    matches!(
+        pm.get_status("proxy").map(|p| p.status),
+        Some(ProcessStatus::Running)
+    )
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_get_settings(state: State<'_, MihomoManager>) -> ProxySettings {
+    state.load_settings()
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_save_settings(
+    state: State<'_, MihomoManager>,
+    settings: ProxySettings,
+) -> Result<(), String> {
+    state.save_settings(&settings)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_kernel_info(
+    state: State<'_, MihomoManager>,
+    app: AppHandle,
+) -> Result<KernelInfo, String> {
+    state.prepare_kernel(&app)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_check_kernel_update(
+    state: State<'_, MihomoManager>,
+) -> Result<KernelUpdateInfo, String> {
+    state.check_kernel_update().await
+}
+
+/// 取消内核下载/安装（设置取消标志，下载循环轮询后中止）
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_cancel_kernel_install(state: State<'_, MihomoManager>) -> Result<(), String> {
+    state.cancel_kernel_install();
+    Ok(())
+}
+
+/// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换。
+/// （下载阶段允许 mihomo 运行以便走系统代理，解压替换前必须停止 mihomo，否则 exe 被占用）
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_confirm_install(state: State<'_, MihomoManager>) -> Result<(), String> {
+    state.confirm_install();
+    Ok(())
+}
+
+/// 应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_apply_kernel_update(
+    state: State<'_, MihomoManager>,
+    app: AppHandle,
+    zip_path: String,
+) -> Result<KernelInfo, String> {
+    let path = std::path::PathBuf::from(zip_path);
+    state.apply_kernel_update(&app, path).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_status(pm: State<'_, ProcessManager>) -> ProxyStatus {
+    match pm.get_status("proxy") {
+        Some(p) => ProxyStatus {
+            running: matches!(p.status, crate::process_manager::ProcessStatus::Running),
+            pid: p.pid,
+            restart_count: p.restart_count,
+        },
+        None => ProxyStatus {
+            running: false,
+            pid: None,
+            restart_count: 0,
+        },
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_start(
+    state: State<'_, MihomoManager>,
+    pm: State<'_, ProcessManager>,
+    app: AppHandle,
+) -> Result<ProcessInfo, String> {
+    let params = state.prepare_for_start(&app)?;
+    let info = pm.start(params)?;
+    // 手动启动也遵循「启动时自动开启系统代理」设置
+    state.apply_auto_system_proxy();
+    Ok(info)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_stop(state: State<'_, MihomoManager>, pm: State<'_, ProcessManager>) -> Result<(), String> {
+    // 关闭 mihomo 时同步关闭系统代理（若开启），避免系统代理指向已停止的端口导致断网
+    if get_system_proxy_windows() {
+        let _ = state.disable_system_proxy();
+    }
+    pm.stop("proxy")
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_restart(
+    state: State<'_, MihomoManager>,
+    pm: State<'_, ProcessManager>,
+    app: AppHandle,
+) -> Result<ProcessInfo, String> {
+    let _ = pm.stop("proxy");
+    // 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟），在阻塞线程池中 sleep 避免阻塞主线程
+    tauri::async_runtime::spawn_blocking(|| {
+        std::thread::sleep(std::time::Duration::from_millis(800));
+    })
+    .await
+    .map_err(|e| format!("sleep 失败: {}", e))?;
+
+    // 启动并等待 API 就绪，带有限重试（共 3 次）：
+    // - 冷加载大订阅（首次解析 + geo 下载）可能远超过前端 waitForApi 的 10s 预算，
+    //   这里在命令内等满就绪，避免重启成功后仍被前端误判为「重启失败」导致节点不刷新。
+    // - 偶发的端口未及时释放 / 启动瞬间退出，通过重试自愈。
+    let mut last_err = "mihomo 启动失败".to_string();
+    for _ in 0..3 {
+        match start_and_wait(state.inner(), pm.inner(), &app).await {
+            Ok(info) => return Ok(info),
+            Err(e) => {
+                last_err = e;
+                // 上个实例刚退出，多等一会儿释放端口再重试
+                tauri::async_runtime::spawn_blocking(|| {
+                    std::thread::sleep(std::time::Duration::from_millis(1200));
+                })
+                .await
+                .map_err(|x| format!("sleep 失败: {}", x))?;
+            }
+        }
+    }
+    // 所有启动尝试均失败：mihomo 已停止，同步关闭系统代理（若开启），避免代理指向已停止端口导致断网
+    if get_system_proxy_windows() {
+        let _ = state.disable_system_proxy();
+    }
+    Err(last_err)
+}
+
+/// 启动 mihomo 并等待其 HTTP API 就绪（最多 20s）。
+/// - 若启动后进程立即退出，快速返回（不白等满预算），便于外层尽早重试。
+/// - 若 pm.start 返回「已在运行中」，说明崩溃监控已抢先拉起进程，同样等待其 API 就绪即可。
+async fn start_and_wait(
+    state: &MihomoManager,
+    pm: &ProcessManager,
+    app: &AppHandle,
+) -> Result<ProcessInfo, String> {
+    let params = state.prepare_for_start(app)?;
+    if let Err(e) = pm.start(params) {
+        // "已在运行中" = 崩溃监控已拉起，不算失败；其余为上抛
+        if !e.contains("运行中") {
+            return Err(e);
+        }
+    }
+
+    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(20);
+    loop {
+        // 进程已退出且 API 未就绪 → 启动失败（快速失败，交外层重试）
+        if let Some(st) = pm.get_status("proxy") {
+            if !matches!(st.status, ProcessStatus::Running) {
+                return Err("mihomo 启动后立即退出".to_string());
+            }
+        }
+        if state.get_version().await.is_ok() {
+            return pm.get_status("proxy").ok_or_else(|| "mihomo 进程不存在".to_string());
+        }
+        if tokio::time::Instant::now() >= deadline {
+            return Err("mihomo 启动超时，API 无响应".to_string());
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+    }
+}
+
+#[tauri::command]
+pub async fn proxy_version(state: State<'_, MihomoManager>) -> Result<serde_json::Value, String> {
+    state.get_version().await
+}
+
+#[tauri::command]
+pub async fn proxy_get_proxies(state: State<'_, MihomoManager>) -> Result<serde_json::Value, String> {
+    state.get_proxies().await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_select_proxy(
+    state: State<'_, MihomoManager>,
+    group: String,
+    name: String,
+) -> Result<(), String> {
+    state.select_proxy(&group, &name).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_test_delay(
+    state: State<'_, MihomoManager>,
+    name: String,
+    url: Option<String>,
+    timeout: Option<u32>,
+) -> Result<u32, String> {
+    state
+        .test_delay(
+            &name,
+            url.as_deref().unwrap_or("https://www.gstatic.com/generate_204"),
+            timeout.unwrap_or(5000),
+        )
+        .await
+}
+
+#[tauri::command]
+pub async fn proxy_get_connections(
+    state: State<'_, MihomoManager>,
+) -> Result<serde_json::Value, String> {
+    state.get_connections().await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_close_connection(
+    state: State<'_, MihomoManager>,
+    id: String,
+) -> Result<(), String> {
+    state.close_connection(&id).await
+}
+
+#[tauri::command]
+pub async fn proxy_patch_configs(
+    state: State<'_, MihomoManager>,
+    body: serde_json::Value,
+) -> Result<(), String> {
+    state.patch_configs(body).await
+}
+
+// ---------- 订阅 ----------
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_import_profile(
+    state: State<'_, MihomoManager>,
+    url: String,
+    name: String,
+) -> Result<ProfileMeta, String> {
+    state.import_profile(&url, &name).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_update_profile(
+    state: State<'_, MihomoManager>,
+    id: String,
+) -> Result<ProfileMeta, String> {
+    state.update_profile(&id).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_delete_profile(
+    state: State<'_, MihomoManager>,
+    id: String,
+) -> Result<(), String> {
+    state.delete_profile(&id)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_activate_profile(
+    state: State<'_, MihomoManager>,
+    id: String,
+) -> Result<(), String> {
+    state.activate_profile(&id)
+}
+
+// ---------- 系统代理 ----------
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_set_system_proxy(
+    state: State<'_, MihomoManager>,
+    pm: State<'_, ProcessManager>,
+) -> Result<(), String> {
+    // 停机时禁止开启系统代理：否则系统代理指向已停止的端口，会导致所有网络请求失败
+    if !mihomo_running(&pm) {
+        return Err("mihomo 未运行，无法开启系统代理".into());
+    }
+    let settings = state.load_settings();
+    let addr = format!("127.0.0.1:{}", settings.mixed_port);
+    set_system_proxy_windows(&addr)?;
+    let mut settings = settings;
+    settings.system_proxy = true;
+    state.save_settings(&settings)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_clear_system_proxy(
+    state: State<'_, MihomoManager>,
+) -> Result<(), String> {
+    clear_system_proxy_windows()?;
+    let mut settings = state.load_settings();
+    settings.system_proxy = false;
+    state.save_settings(&settings)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn proxy_get_system_proxy() -> bool {
+    get_system_proxy_windows()
+}

src-tauri/src/mihomo_manager/kernel.rs

@@ -0,0 +1,406 @@
+//! 内核（mihomo.exe）安装 / 更新 / 版本查询。
+//! 子模块通过 `impl super::MihomoManager` 为管理器追加方法，可访问父模块私有字段。
+
+use std::fs;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use std::sync::atomic::Ordering;
+use tauri::{AppHandle, Emitter, Manager};
+
+use crate::constants::events::KERNEL_INSTALL_PROGRESS;
+use super::{InstallProgress, KernelInfo, KernelUpdateInfo, MihomoManager};
+
+/// 用户主动取消下载的标记错误信息（前端据此静默处理，不弹错误 toast）
+const KERNEL_CANCELLED: &str = "下载已取消";
+
+impl MihomoManager {
+    // ---------- 内核 ----------
+    pub fn kernel_info(&self) -> KernelInfo {
+        let path = self.kernel_path();
+        let exists = path.exists();
+        let version = if exists {
+            let mut cmd = std::process::Command::new(&path);
+            cmd.arg("-v");
+            // 隐藏控制台窗口（mihomo.exe -v 也会弹窗）
+            crate::process_manager::setup_creation_flags(&mut cmd);
+            // 重定向 stdio，避免继承主进程控制台
+            cmd.stdout(std::process::Stdio::piped())
+                .stderr(std::process::Stdio::null())
+                .stdin(std::process::Stdio::null());
+            cmd.output()
+                .ok()
+                .and_then(|o| String::from_utf8(o.stdout).ok())
+                .and_then(|s| {
+                    s.lines()
+                        .find(|l| l.contains("Mihomo Meta") || l.contains("mihomo"))
+                        .map(|l| l.trim().to_string())
+                })
+        } else {
+            None
+        };
+        KernelInfo {
+            path: path.to_string_lossy().to_string(),
+            exists,
+            version,
+        }
+    }
+
+    /// 确保内核就位：若 cores/ 无内核，尝试从 resource 目录复制
+    pub fn prepare_kernel(&self, app: &AppHandle) -> Result<KernelInfo, String> {
+        let kernel = self.kernel_path();
+        if !kernel.exists() {
+            if let Ok(res) = app.path().resolve("binaries/mihomo.exe", tauri::path::BaseDirectory::Resource) {
+                if res.exists() {
+                    fs::copy(&res, &kernel).map_err(|e| format!("复制内核失败: {}", e))?;
+                }
+            }
+        }
+        Ok(self.kernel_info())
+    }
+
+    /// 检查 GitHub 上的最新 mihomo 版本
+    /// 策略：优先用 API（能拿到完整资产列表，命名变化时更健壮），
+    ///       失败时回退到重定向解析（不受 API rate limit 限制）
+    pub async fn check_kernel_update(&self) -> Result<KernelUpdateInfo, String> {
+        match self.fetch_latest_via_api().await {
+            Ok(info) => Ok(info),
+            Err(api_err) => {
+                crate::logger::log_warn("mihomo", &format!("API 查询失败，回退到重定向解析: {}", api_err));
+                self.fetch_latest_via_redirect().await
+            }
+        }
+    }
+
+    /// 通过 GitHub API 查询最新版本（受 rate limit 限制：未认证 60次/小时/IP）
+    async fn fetch_latest_via_api(&self) -> Result<KernelUpdateInfo, String> {
+        let resp = self
+            .client
+            .get("https://api.github.com/repos/MetaCubeX/mihomo/releases/latest")
+            .header("User-Agent", "thing-app")
+            .timeout(std::time::Duration::from_secs(15))
+            .send()
+            .await
+            .map_err(|e| format!("请求 GitHub API 失败: {}", e))?;
+        let status = resp.status();
+        if !status.is_success() {
+            let body = resp.text().await.unwrap_or_default();
+            // 按字符边界截断，避免切在多字节字符中间导致 panic
+            let preview: String = body.chars().take(300).collect();
+            return Err(format!(
+                "GitHub API 返回 HTTP {}：{}{}",
+                status.as_u16(),
+                preview,
+                if body.chars().count() > 300 { "..." } else { "" }
+            ));
+        }
+        let resp: serde_json::Value = resp
+            .json()
+            .await
+            .map_err(|e| format!("解析 GitHub 响应失败: {}", e))?;
+
+        let latest_version = resp
+            .get("tag_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("unknown")
+            .to_string();
+
+        let assets_arr = resp.get("assets").and_then(|a| a.as_array());
+
+        // 收集所有 windows amd64 zip 候选资产（排除 compatible/arm64/386）
+        let candidates: Vec<(String, String)> = assets_arr
+            .map(|assets| {
+                assets.iter().filter_map(|asset| {
+                    let name = asset.get("name")?.as_str()?;
+                    let url = asset.get("browser_download_url")?.as_str()?;
+                    if name.starts_with("mihomo-windows-amd64-")
+                        && name.ends_with(".zip")
+                        && !name.contains("compatible")
+                        && !name.contains("arm64")
+                        && !name.contains("386")
+                    {
+                        Some((name.to_string(), url.to_string()))
+                    } else {
+                        None
+                    }
+                }).collect()
+            })
+            .unwrap_or_default();
+
+        // 按优先级匹配：v3 标准 > v3-go124 > v3-go123 > v3 其他 > v2 > v1 > 旧命名
+        let download_url = candidates
+            .iter().find(|(n, _)| n.contains("-v3-v") && !n.contains("-go"))
+            .or_else(|| candidates.iter().find(|(n, _)| n.contains("-v3-go124-")))
+            .or_else(|| candidates.iter().find(|(n, _)| n.contains("-v3-go123-")))
+            .or_else(|| candidates.iter().find(|(n, _)| n.contains("-v3-go")))
+            .or_else(|| candidates.iter().find(|(n, _)| n.contains("-v2-v")))
+            .or_else(|| candidates.iter().find(|(n, _)| n.contains("-v1-v")))
+            .or_else(|| candidates.iter().find(|(n, _)| {
+                !n.contains("-v1-") && !n.contains("-v2-") && !n.contains("-v3-")
+            }))
+            .map(|(_, u)| u.clone())
+            .ok_or_else(|| {
+                let candidates_str = candidates.iter()
+                    .map(|(n, _)| n.as_str())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("API 未找到适用的 Windows amd64 内核资产。候选：[{}]", candidates_str)
+            })?;
+
+        Ok(self.build_update_info(latest_version, download_url))
+    }
+
+    /// 通过 releases/latest 重定向解析版本号（不受 API rate limit 限制）
+    /// 访问 https://github.com/MetaCubeX/mihomo/releases/latest 会 302 到
+    /// https://github.com/MetaCubeX/mihomo/releases/tag/v1.19.13
+    /// 从最终 URL 提取版本号后，按 v1.19+ 稳定命名规则构造下载 URL
+    async fn fetch_latest_via_redirect(&self) -> Result<KernelUpdateInfo, String> {
+        let resp = self
+            .client
+            .get("https://github.com/MetaCubeX/mihomo/releases/latest")
+            .header("User-Agent", "thing-app")
+            .timeout(std::time::Duration::from_secs(15))
+            .send()
+            .await
+            .map_err(|e| format!("请求 GitHub releases 页面失败: {}", e))?;
+
+        // 从重定向后的最终 URL 提取版本号
+        let final_url = resp.url().to_string();
+        let latest_version = final_url
+            .rsplit('/')
+            .next()
+            .filter(|s| s.starts_with('v') && s.chars().any(|c| c == '.'))
+            .ok_or_else(|| format!("无法从重定向 URL 提取版本号: {}", final_url))?
+            .to_string();
+
+        // 构造下载 URL：mihomo v1.19+ 稳定使用 -v3-vX.X.X.zip 命名（CPU level v3）
+        let download_url = format!(
+            "https://github.com/MetaCubeX/mihomo/releases/download/{}/mihomo-windows-amd64-v3-{}.zip",
+            latest_version, latest_version
+        );
+
+        crate::logger::log_info(
+            "mihomo",
+            &format!("重定向解析成功: version={}, url={}", latest_version, download_url),
+        );
+        Ok(self.build_update_info(latest_version, download_url))
+    }
+
+    /// 根据最新版本和下载 URL 构造更新信息（含当前版本比较）
+    fn build_update_info(&self, latest_version: String, download_url: String) -> KernelUpdateInfo {
+        let current = self.kernel_info().version;
+        let has_update = match &current {
+            Some(c) => {
+                let cur_ver = c
+                    .split_whitespace()
+                    .find(|s| s.starts_with('v') && s.chars().filter(|c| *c == '.').count() >= 2)
+                    .unwrap_or("");
+                cur_ver != latest_version && !latest_version.is_empty()
+            }
+            None => true,
+        };
+        KernelUpdateInfo {
+            current_version: current,
+            latest_version,
+            download_url,
+            has_update,
+        }
+    }
+
+    /// 应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。
+    /// zip_path: 下载模块下载完成的 zip 文件路径。
+    /// 任何阶段失败都会 emit error 事件，避免前端进度卡住。
+    pub async fn apply_kernel_update(&self, app: &AppHandle, zip_path: PathBuf) -> Result<KernelInfo, String> {
+        self.kernel_cancel.store(false, Ordering::SeqCst);
+        let _ = self.kernel_cancel_tx.send(false);
+        let result = self.apply_kernel_inner(app, zip_path).await;
+        if let Err(ref e) = result {
+            if e != KERNEL_CANCELLED {
+                let _ = app.emit(
+                    KERNEL_INSTALL_PROGRESS,
+                    InstallProgress {
+                        stage: "error".into(),
+                        percent: 0,
+                        downloaded_bytes: 0,
+                        total_bytes: None,
+                        message: e.clone(),
+                    },
+                );
+            }
+        }
+        self.kernel_cancel.store(false, Ordering::SeqCst);
+        let _ = self.kernel_cancel_tx.send(false);
+        result
+    }
+
+    async fn apply_kernel_inner(&self, app: &AppHandle, zip_path: PathBuf) -> Result<KernelInfo, String> {
+        let extract_dir = self.cores_dir().join("mihomo-update-tmp");
+
+        // 检查 zip 文件是否存在
+        if !zip_path.exists() {
+            return Err(format!("下载文件不存在: {}", zip_path.display()));
+        }
+
+        // 解压替换前需要等待前端确认 mihomo 已停止（否则 exe 文件被占用）
+        if self.kernel_cancel.load(Ordering::SeqCst) {
+            return Err(KERNEL_CANCELLED.to_string());
+        }
+        let _ = app.emit(
+            KERNEL_INSTALL_PROGRESS,
+            InstallProgress {
+                stage: "need_stop".into(),
+                percent: 90,
+                downloaded_bytes: 0,
+                total_bytes: None,
+                message: "需要停止 mihomo 才能继续安装".into(),
+            },
+        );
+        // 创建 oneshot 通道等待前端确认
+        let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();
+        *self.install_confirm.lock().unwrap() = Some(tx);
+        let mut cancel_rx = self.kernel_cancel_tx.subscribe();
+        loop {
+            if self.kernel_cancel.load(Ordering::SeqCst) {
+                *self.install_confirm.lock().unwrap() = None;
+                return Err(KERNEL_CANCELLED.to_string());
+            }
+            tokio::select! {
+                _ = &mut rx => break,
+                _ = cancel_rx.changed() => {}
+            }
+        }
+
+        // 解压阶段
+        let _ = app.emit(
+            KERNEL_INSTALL_PROGRESS,
+            InstallProgress {
+                stage: "extracting".into(),
+                percent: 92,
+                downloaded_bytes: 0,
+                total_bytes: None,
+                message: "正在解压...".into(),
+            },
+        );
+        if extract_dir.exists() {
+            fs::remove_dir_all(&extract_dir).ok();
+        }
+        fs::create_dir_all(&extract_dir).map_err(|e| e.to_string())?;
+        if let Err(e) = self.extract_zip(&zip_path, &extract_dir) {
+            let _ = app.emit(
+                KERNEL_INSTALL_PROGRESS,
+                InstallProgress {
+                    stage: "error".into(),
+                    percent: 0,
+                    downloaded_bytes: 0,
+                    total_bytes: None,
+                    message: format!("解压失败：{}", e),
+                },
+            );
+            return Err(e);
+        }
+
+        // 在解压目录中递归查找 exe 文件
+        let new_exe = self
+            .find_exe_in_dir(&extract_dir)
+            .ok_or_else(|| "解压后未找到任何 .exe 文件".to_string())?;
+
+        // 替换阶段
+        let _ = app.emit(
+            KERNEL_INSTALL_PROGRESS,
+            InstallProgress {
+                stage: "replacing".into(),
+                percent: 96,
+                downloaded_bytes: 0,
+                total_bytes: None,
+                message: "正在替换内核...".into(),
+            },
+        );
+        let kernel = self.kernel_path();
+        if kernel.exists() {
+            let bak = self.cores_dir().join("mihomo.exe.bak");
+            fs::remove_file(&bak).ok();
+            fs::rename(&kernel, &bak).map_err(|e| format!("备份旧内核失败: {}", e))?;
+        }
+        fs::rename(&new_exe, &kernel).map_err(|e| format!("替换内核失败: {}", e))?;
+
+        // 清理临时文件
+        fs::remove_file(&zip_path).ok();
+        fs::remove_dir_all(&extract_dir).ok();
+
+        let final_info = self.kernel_info();
+        let _ = app.emit(
+            KERNEL_INSTALL_PROGRESS,
+            InstallProgress {
+                stage: "done".into(),
+                percent: 100,
+                downloaded_bytes: 0,
+                total_bytes: None,
+                message: format!(
+                    "安装完成 ({})",
+                    final_info.version.as_deref().unwrap_or("unknown")
+                ),
+            },
+        );
+        Ok(final_info)
+    }
+
+    /// 用 zip crate 解压（纯 Rust，避免 PowerShell 执行策略问题）
+    fn extract_zip(&self, zip_path: &PathBuf, dest: &PathBuf) -> Result<(), String> {
+        let file = fs::File::open(zip_path).map_err(|e| format!("打开 zip 失败: {}", e))?;
+        let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("读取 zip 失败: {}", e))?;
+        for i in 0..archive.len() {
+            let mut entry = archive
+                .by_index(i)
+                .map_err(|e| format!("读取条目失败: {}", e))?;
+            let outpath = match entry.enclosed_name() {
+                Some(p) => dest.join(p),
+                None => continue,
+            };
+            if entry.is_dir() {
+                fs::create_dir_all(&outpath).map_err(|e| e.to_string())?;
+            } else {
+                if let Some(parent) = outpath.parent() {
+                    fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+                }
+                let mut outfile = fs::File::create(&outpath).map_err(|e| e.to_string())?;
+                let mut buf = [0u8; 8192];
+                loop {
+                    let n = entry.read(&mut buf).map_err(|e| e.to_string())?;
+                    if n == 0 {
+                        break;
+                    }
+                    outfile.write_all(&buf[..n]).map_err(|e| e.to_string())?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// 递归查找目录中的 .exe 文件
+    /// mihomo zip 内的 exe 名字不固定（可能含版本号、CPU level 等），
+    /// 策略：收集所有 .exe，优先返回名字含 "mihomo" 的，否则返回第一个
+    fn find_exe_in_dir(&self, dir: &PathBuf) -> Option<PathBuf> {
+        let mut exes: Vec<PathBuf> = Vec::new();
+        self.collect_exes(dir, &mut exes);
+        if exes.is_empty() {
+            return None;
+        }
+        // 优先选名字含 mihomo 的
+        exes.iter()
+            .find(|p| p.file_name().and_then(|n| n.to_str()).map(|s| s.to_lowercase().contains("mihomo")).unwrap_or(false))
+            .or_else(|| exes.first())
+            .cloned()
+    }
+
+    fn collect_exes(&self, dir: &PathBuf, out: &mut Vec<PathBuf>) {
+        if let Ok(entries) = fs::read_dir(dir) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    self.collect_exes(&path, out);
+                } else if path.extension().and_then(|e| e.to_str()).map(|s| s.eq_ignore_ascii_case("exe")).unwrap_or(false) {
+                    out.push(path);
+                }
+            }
+        }
+    }
+}

src-tauri/src/mihomo_manager/mod.rs

@@ -0,0 +1,479 @@
+//! 代理模块（mihomo 管理器）：按功能域拆分子模块。
+//!
+//! - [`MihomoManager`]：核心状态与目录/设置/配置/API 方法
+//! - [`kernel`]：内核安装与更新
+//! - [`profiles`]：订阅管理
+//! - [`system_proxy`]：Windows 系统代理开关
+//! - [`commands`]：Tauri 命令层
+
+mod autoswitch;
+mod commands;
+mod kernel;
+mod profiles;
+mod pseudo;
+mod system_proxy;
+mod types;
+
+pub use autoswitch::{pick_best, start_auto_switch_loop};
+pub use pseudo::is_pseudo_node;
+pub use system_proxy::get_system_proxy_windows;
+pub use types::{InstallProgress, KernelInfo, KernelUpdateInfo, ProfileMeta, ProxySettings, ProxyStatus};
+pub use commands::{
+    proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
+    proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies,
+    proxy_get_settings, proxy_get_system_proxy, proxy_import_profile, proxy_kernel_info,
+    proxy_patch_configs, proxy_restart, proxy_save_settings, proxy_select_proxy, proxy_set_system_proxy,
+    proxy_start, proxy_status, proxy_stop, proxy_test_delay, proxy_update_profile, proxy_version,
+};
+
+use reqwest::Client;
+use serde_yaml::Value as YamlValue;
+use std::fs;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+use tauri::AppHandle;
+
+use crate::process_manager::{ProcessManager, StartProcessParams};
+
+// ===================== MihomoManager =====================
+
+/// settings 内存缓存条目（短时复用，避免高频状态轮询反复读盘）
+struct SettingsCacheEntry {
+    read_at: Instant,
+    settings: ProxySettings,
+}
+
+pub struct MihomoManager {
+    root: PathBuf,
+    client: Client,
+    settings_cache: Mutex<Option<SettingsCacheEntry>>,
+    /// 内核安装/更新的取消标志（前端「停止下载」置位，下载循环轮询后中止）
+    kernel_cancel: Arc<AtomicBool>,
+    /// 取消唤醒通道：让停滞在流式读取（stream.next 最多等 30s）中的下载立即感知取消，
+    /// 否则旧任务会残留最长 30s，期间可能与新任务并发写临时文件/互相重置取消标志
+    kernel_cancel_tx: tokio::sync::watch::Sender<bool>,
+    /// 下载完成后解压替换前的确认通道：mihomo 运行时下载不受影响，但解压替换前
+    /// 必须等前端确认已停止 mihomo（否则 exe 文件被占用）。前端确认后通过
+    /// proxy_confirm_install 命令发送信号唤醒等待。
+    /// 用 std Mutex 而非 tokio Mutex：锁只短暂存取 sender，不跨 await 持有。
+    install_confirm: std::sync::Mutex<Option<tokio::sync::oneshot::Sender<()>>>,
+}
+
+impl MihomoManager {
+    pub fn new(app_data_dir: PathBuf) -> Self {
+        let root = app_data_dir.join("proxy");
+        for d in ["cores", "mihomo", "profiles", "logs"] {
+            fs::create_dir_all(root.join(d)).ok();
+        }
+        Self {
+            root,
+            client: Client::builder()
+                // 默认 30s 兜底超时，防止遗漏显式 timeout 的请求永久悬挂
+                .timeout(std::time::Duration::from_secs(30))
+                .build()
+                .unwrap_or_else(|_| Client::new()),
+            settings_cache: Mutex::new(None),
+            kernel_cancel: Arc::new(AtomicBool::new(false)),
+            kernel_cancel_tx: tokio::sync::watch::channel(false).0,
+            install_confirm: std::sync::Mutex::new(None),
+        }
+    }
+
+    /// 请求取消内核安装/更新（由 proxy_cancel_kernel_install 命令调用）
+    pub fn cancel_kernel_install(&self) {
+        self.kernel_cancel.store(true, Ordering::SeqCst);
+        // 唤醒停滞的流式下载循环，使其立即中止而不是等 30s 超时
+        let _ = self.kernel_cancel_tx.send(true);
+    }
+
+    /// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换（由 proxy_confirm_install 命令调用）
+    pub fn confirm_install(&self) {
+        if let Some(tx) = self.install_confirm.lock().unwrap().take() {
+            let _ = tx.send(());
+        }
+    }
+
+    fn cores_dir(&self) -> PathBuf {
+        self.root.join("cores")
+    }
+    pub fn kernel_path(&self) -> PathBuf {
+        self.cores_dir().join("mihomo.exe")
+    }
+    fn mihomo_dir(&self) -> PathBuf {
+        self.root.join("mihomo")
+    }
+    fn config_path(&self) -> PathBuf {
+        self.mihomo_dir().join("config.yaml")
+    }
+    fn profiles_dir(&self) -> PathBuf {
+        self.root.join("profiles")
+    }
+    #[allow(dead_code)]
+    fn logs_dir(&self) -> PathBuf {
+        self.root.join("logs")
+    }
+    fn settings_path(&self) -> PathBuf {
+        self.root.join("settings.json")
+    }
+
+    // ---------- 设置 ----------
+    pub fn load_settings(&self) -> ProxySettings {
+        // 内存缓存：500ms 内复用（高频调用如状态轮询/测速避免反复读盘）
+        if let Ok(cache) = self.settings_cache.lock() {
+            if let Some(entry) = cache.as_ref() {
+                if entry.read_at.elapsed() < Duration::from_millis(500) {
+                    return entry.settings.clone();
+                }
+            }
+        }
+
+        let mut settings = fs::read_to_string(self.settings_path())
+            .ok()
+            .and_then(|s| serde_json::from_str::<ProxySettings>(&s).ok())
+            .unwrap_or_default();
+        // 恢复机制：扫描磁盘 profile 文件，补全 settings.profiles
+        // 防止 settings.json 损坏（如反序列化失败被 default 覆盖）导致订阅丢失
+        if self.reconcile_profiles(&mut settings) {
+            let _ = self.save_settings(&settings);
+        }
+
+        // 刷新缓存
+        if let Ok(mut cache) = self.settings_cache.lock() {
+            *cache = Some(SettingsCacheEntry {
+                read_at: Instant::now(),
+                settings: settings.clone(),
+            });
+        }
+
+        settings
+    }
+
+    /// 扫描磁盘 profile 文件，补全 settings.profiles 中缺失的条目。
+    /// 返回 true 表示有变化需要保存。
+    fn reconcile_profiles(&self, settings: &mut ProxySettings) -> bool {
+        let mut changed = false;
+        let existing_ids: std::collections::HashSet<String> =
+            settings.profiles.iter().map(|p| p.id.clone()).collect();
+
+        if let Ok(entries) = fs::read_dir(self.profiles_dir()) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.extension().and_then(|e| e.to_str()) != Some("yaml") {
+                    continue;
+                }
+                let Some(id) = path
+                    .file_stem()
+                    .and_then(|s| s.to_str())
+                    .map(|s| s.to_string())
+                else {
+                    continue;
+                };
+                if existing_ids.contains(&id) {
+                    continue;
+                }
+                let size = fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
+                let updated_at = fs::metadata(&path)
+                    .and_then(|m| m.modified())
+                    .ok()
+                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                    .and_then(|d| chrono::DateTime::from_timestamp(d.as_secs() as i64, 0))
+                    .map(|dt| dt.format("%Y-%m-%d %H:%M:%S").to_string())
+                    .unwrap_or_default();
+                settings.profiles.push(ProfileMeta {
+                    added_at: updated_at.clone(),
+                    id: id.clone(),
+                    name: id,
+                    url: String::new(),
+                    updated_at,
+                    size,
+                });
+                changed = true;
+            }
+        }
+
+        // 如果 currentProfile 为 null 但有 profile，设置为第一个
+        if settings.current_profile.is_none() && !settings.profiles.is_empty() {
+            settings.current_profile = Some(settings.profiles[0].id.clone());
+            changed = true;
+        }
+
+        changed
+    }
+
+    pub fn save_settings(&self, settings: &ProxySettings) -> Result<(), String> {
+        let s = serde_json::to_string_pretty(settings).map_err(|e| e.to_string())?;
+        fs::write(self.settings_path(), s).map_err(|e| e.to_string())?;
+        // 写盘成功后同步刷新内存缓存（避免旧缓存被后续 load_settings 复用）
+        if let Ok(mut cache) = self.settings_cache.lock() {
+            *cache = Some(SettingsCacheEntry {
+                read_at: Instant::now(),
+                settings: settings.clone(),
+            });
+        }
+        Ok(())
+    }
+
+    // ---------- 配置生成 ----------
+    /// 合并 profile + 控制器设置，生成运行时 config.yaml
+    pub fn generate_config(&self) -> Result<(), String> {
+        let settings = self.load_settings();
+        let mut value: YamlValue = if let Some(id) = &settings.current_profile {
+            let path = self.profiles_dir().join(format!("{}.yaml", id));
+            if path.exists() {
+                let content = fs::read_to_string(&path).map_err(|e| e.to_string())?;
+                serde_yaml::from_str(&content).unwrap_or(YamlValue::Mapping(serde_yaml::Mapping::new()))
+            } else {
+                YamlValue::Mapping(serde_yaml::Mapping::new())
+            }
+        } else {
+            YamlValue::Mapping(serde_yaml::Mapping::new())
+        };
+
+        if !value.is_mapping() {
+            value = YamlValue::Mapping(serde_yaml::Mapping::new());
+        }
+        let m = value.as_mapping_mut().unwrap();
+        m.insert(YamlValue::String("mixed-port".into()), YamlValue::Number(settings.mixed_port.into()));
+        m.insert(
+            YamlValue::String("external-controller".into()),
+            YamlValue::String(settings.external_controller.clone()),
+        );
+        if !settings.secret.is_empty() {
+            m.insert(YamlValue::String("secret".into()), YamlValue::String(settings.secret.clone()));
+        }
+        m.insert(YamlValue::String("mode".into()), YamlValue::String(settings.mode.clone()));
+        m.insert(
+            YamlValue::String("log-level".into()),
+            YamlValue::String(settings.log_level.clone()),
+        );
+        m.insert(YamlValue::String("allow-lan".into()), YamlValue::Bool(settings.allow_lan));
+
+        // 日志写入文件，便于排查问题
+        let log_file = self.logs_dir().join("mihomo.log");
+        m.insert(
+            YamlValue::String("log-file".into()),
+            YamlValue::String(log_file.to_string_lossy().to_string()),
+        );
+
+        // Geo 数据库下载源（使用 jsdelivr 国内可访问镜像，避免无代理时 GitHub 超时）
+        let mut geox = serde_yaml::Mapping::new();
+        geox.insert(
+            YamlValue::String("mmdb".into()),
+            YamlValue::String("https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/country.mmdb".into()),
+        );
+        geox.insert(
+            YamlValue::String("geosite".into()),
+            YamlValue::String("https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite.dat".into()),
+        );
+        geox.insert(
+            YamlValue::String("asn".into()),
+            YamlValue::String("https://cdn.jsdelivr.net/gh/xishang0128/bdg@master/GeoLite2-ASN.mmdb".into()),
+        );
+        m.insert(YamlValue::String("geox-url".into()), YamlValue::Mapping(geox));
+
+        let yaml = serde_yaml::to_string(&value).map_err(|e| e.to_string())?;
+        fs::write(self.config_path(), yaml).map_err(|e| e.to_string())?;
+        Ok(())
+    }
+
+    /// 构建启动 mihomo 所需的进程参数（含 prepare + config 生成）
+    pub fn prepare_for_start(&self, app: &AppHandle) -> Result<StartProcessParams, String> {
+        let info = self.prepare_kernel(app)?;
+        if !info.exists {
+            return Err(format!(
+                "mihomo 内核未安装。请将 mihomo.exe 放置到 src-tauri/binaries/ 后重新运行，或直接放到：\n{}",
+                self.cores_dir().to_string_lossy()
+            ));
+        }
+        self.generate_config()?;
+        Ok(StartProcessParams {
+            id: "proxy".into(),
+            executable: self.kernel_path().to_string_lossy().to_string(),
+            args: vec![
+                "-d".into(),
+                self.mihomo_dir().to_string_lossy().to_string(),
+                "-f".into(),
+                self.config_path().to_string_lossy().to_string(),
+            ],
+            cwd: Some(self.mihomo_dir().to_string_lossy().to_string()),
+            name: "mihomo".into(),
+            restart_on_crash: true,
+            max_restarts: 3,
+        })
+    }
+
+    /// mihomo 启动成功后，若配置了「启动时自动开启系统代理」且当前未开，则开启系统代理。
+    /// 手动启动与 App 自启共用，保证设置语义一致（mihomo 运行期间自动跟随系统代理）。
+    pub fn apply_auto_system_proxy(&self) {
+        let settings = self.load_settings();
+        if settings.auto_system_proxy && !settings.system_proxy && !system_proxy::get_system_proxy_windows() {
+            let addr = format!("127.0.0.1:{}", settings.mixed_port);
+            if let Err(e) = system_proxy::set_system_proxy_windows(&addr) {
+                crate::logger::log_warn("mihomo", &format!("自动开启系统代理失败: {}", e));
+                return;
+            }
+            let mut s = settings;
+            s.system_proxy = true;
+            let _ = self.save_settings(&s);
+        }
+    }
+
+    /// 应用启动时检查是否需要自动启动 mihomo 和系统代理
+    pub fn auto_start_on_launch(&self, app: &AppHandle, pm: &ProcessManager) {
+        let settings = self.load_settings();
+        if !settings.auto_start {
+            return;
+        }
+        match self.prepare_for_start(app) {
+            Ok(params) => {
+                if let Err(e) = pm.start(params) {
+                    crate::logger::log_error("mihomo", &format!("自动启动失败: {}", e));
+                } else {
+                    // 启动成功后按「启动时自动开启系统代理」设置决定是否开启系统代理
+                    self.apply_auto_system_proxy();
+                }
+            }
+            Err(e) => {
+                crate::logger::log_warn("mihomo", &format!("自动启动跳过: {}", e));
+            }
+        }
+    }
+
+    /// 应用退出时清理：关闭系统代理
+    pub fn cleanup_on_exit(&self) {
+        let settings = self.load_settings();
+        if settings.system_proxy || settings.auto_system_proxy {
+            let _ = system_proxy::clear_system_proxy_windows();
+        }
+    }
+
+    // ---------- mihomo API ----------
+    fn api_url(&self, path: &str) -> String {
+        let s = self.load_settings();
+        format!("http://{}{}", s.external_controller, path)
+    }
+
+    fn api_bearer(&self) -> Option<String> {
+        let s = self.load_settings();
+        if s.secret.is_empty() {
+            None
+        } else {
+            Some(format!("Bearer {}", s.secret))
+        }
+    }
+
+    async fn api_get(&self, path: &str) -> Result<serde_json::Value, String> {
+        let mut req = self.client.get(self.api_url(path));
+        if let Some(b) = self.api_bearer() {
+            req = req.header("Authorization", b);
+        }
+        // 显式超时：mihomo 卡死/未响应时命令立即返回，避免前端按钮永久转圈
+        let resp = req
+            .timeout(std::time::Duration::from_secs(10))
+            .send()
+            .await
+            .map_err(|e| format!("请求 mihomo 失败: {}", e))?;
+        if !resp.status().is_success() {
+            return Err(format!("mihomo API 错误: {}", resp.status()));
+        }
+        resp.json().await.map_err(|e| e.to_string())
+    }
+
+    async fn api_request(
+        &self,
+        method: reqwest::Method,
+        path: &str,
+        body: Option<serde_json::Value>,
+    ) -> Result<(), String> {
+        let mut req = self.client.request(method, self.api_url(path));
+        if let Some(b) = self.api_bearer() {
+            req = req.header("Authorization", b);
+        }
+        if let Some(b) = body {
+            req = req.json(&b);
+        }
+        let resp = req
+            .timeout(std::time::Duration::from_secs(10))
+            .send()
+            .await
+            .map_err(|e| format!("请求 mihomo 失败: {}", e))?;
+        if !resp.status().is_success() {
+            return Err(format!("mihomo API 错误: {}", resp.status()));
+        }
+        Ok(())
+    }
+
+    pub async fn get_version(&self) -> Result<serde_json::Value, String> {
+        self.api_get("/version").await
+    }
+
+    pub async fn get_proxies(&self) -> Result<serde_json::Value, String> {
+        self.api_get("/proxies").await
+    }
+
+    pub async fn select_proxy(&self, group: &str, name: &str) -> Result<(), String> {
+        self.api_request(
+            reqwest::Method::PUT,
+            &format!("/proxies/{}", url_encode(group)),
+            Some(serde_json::json!({ "name": name })),
+        )
+        .await
+    }
+
+    pub async fn test_delay(&self, name: &str, url: &str, timeout: u32) -> Result<u32, String> {
+        let path = format!(
+            "/proxies/{}/delay?timeout={}&url={}",
+            url_encode(name),
+            timeout,
+            url_encode(url)
+        );
+        let v = self.api_get(&path).await?;
+        v.get("delay")
+            .and_then(|d| d.as_u64())
+            .map(|d| d as u32)
+            .ok_or_else(|| {
+                v.get("message")
+                    .and_then(|m| m.as_str())
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| "测速失败".into())
+            })
+    }
+
+    #[allow(dead_code)]
+    pub async fn get_rules(&self) -> Result<serde_json::Value, String> {
+        self.api_get("/rules").await
+    }
+
+    pub async fn get_connections(&self) -> Result<serde_json::Value, String> {
+        self.api_get("/connections").await
+    }
+
+    pub async fn close_connection(&self, id: &str) -> Result<(), String> {
+        self.api_request(
+            reqwest::Method::DELETE,
+            &format!("/connections/{}", url_encode(id)),
+            None,
+        )
+        .await
+    }
+
+    pub async fn patch_configs(&self, body: serde_json::Value) -> Result<(), String> {
+        self.api_request(reqwest::Method::PATCH, "/configs", Some(body)).await
+    }
+}
+
+fn url_encode(s: &str) -> String {
+    // 仅对路径段做最小编码，避免引入额外依赖
+    let mut out = String::with_capacity(s.len());
+    for b in s.bytes() {
+        match b {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                out.push(b as char);
+            }
+            _ => out.push_str(&format!("%{:02X}", b)),
+        }
+    }
+    out
+}

src-tauri/src/mihomo_manager/profiles.rs

@@ -0,0 +1,112 @@
+//! 订阅（profile）管理：导入 / 更新 / 删除 / 激活。
+
+use chrono::Local;
+use std::fs;
+
+use super::{MihomoManager, ProfileMeta};
+
+impl MihomoManager {
+    // ---------- 订阅管理 ----------
+    pub async fn import_profile(&self, url: &str, name: &str) -> Result<ProfileMeta, String> {
+        // 先读取当前 settings（此时新 profile 文件还未写入，reconcile 不会误添加）
+        let mut settings = self.load_settings();
+
+        let resp = self
+            .client
+            .get(url)
+            .header("User-Agent", "clash.meta/thing")
+            .timeout(std::time::Duration::from_secs(30))
+            .send()
+            .await
+            .map_err(|e| format!("下载订阅失败: {}", e))?;
+        if !resp.status().is_success() {
+            return Err(format!("订阅下载失败: HTTP {}", resp.status()));
+        }
+        let content = resp.text().await.map_err(|e| e.to_string())?;
+        if !content.contains("proxies") && !content.contains("Proxy") {
+            return Err("订阅内容不像有效的 Clash/mihomo 配置".into());
+        }
+        let id = format!("profile-{}", Local::now().format("%Y%m%d%H%M%S"));
+        let path = self.profiles_dir().join(format!("{}.yaml", id));
+        fs::write(&path, &content).map_err(|e| e.to_string())?;
+        let now = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
+        let meta = ProfileMeta {
+            id: id.clone(),
+            name: name.to_string(),
+            url: url.to_string(),
+            added_at: now.clone(),
+            updated_at: now,
+            size: content.len() as u64,
+        };
+        // 去重保护：避免 reconcile 已添加同 id（理论上不会，因为文件刚写入）
+        if !settings.profiles.iter().any(|p| p.id == id) {
+            settings.profiles.push(meta.clone());
+        }
+        if settings.current_profile.is_none() {
+            settings.current_profile = Some(id);
+        }
+        self.save_settings(&settings)?;
+        Ok(meta)
+    }
+
+    pub async fn update_profile(&self, id: &str) -> Result<ProfileMeta, String> {
+        let mut settings = self.load_settings();
+        let meta = settings
+            .profiles
+            .iter()
+            .find(|p| p.id == id)
+            .cloned()
+            .ok_or_else(|| "订阅不存在".to_string())?;
+        let resp = self
+            .client
+            .get(&meta.url)
+            .header("User-Agent", "clash.meta/thing")
+            .timeout(std::time::Duration::from_secs(30))
+            .send()
+            .await
+            .map_err(|e| format!("更新订阅失败: {}", e))?;
+        if !resp.status().is_success() {
+            return Err(format!("更新订阅失败: HTTP {}", resp.status()));
+        }
+        let content = resp.text().await.map_err(|e| e.to_string())?;
+        let path = self.profiles_dir().join(format!("{}.yaml", id));
+        fs::write(&path, &content).map_err(|e| e.to_string())?;
+        let now = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
+        let size = content.len() as u64;
+        if let Some(p) = settings.profiles.iter_mut().find(|p| p.id == id) {
+            p.updated_at = now.clone();
+            p.size = size;
+        }
+        self.save_settings(&settings)?;
+        Ok(ProfileMeta {
+            id: id.to_string(),
+            name: meta.name,
+            url: meta.url,
+            added_at: meta.added_at,
+            updated_at: now,
+            size,
+        })
+    }
+
+    pub fn delete_profile(&self, id: &str) -> Result<(), String> {
+        let path = self.profiles_dir().join(format!("{}.yaml", id));
+        fs::remove_file(&path).ok();
+        let mut settings = self.load_settings();
+        settings.profiles.retain(|p| p.id != id);
+        if settings.current_profile.as_deref() == Some(id) {
+            settings.current_profile = settings.profiles.first().map(|p| p.id.clone());
+        }
+        self.save_settings(&settings)?;
+        Ok(())
+    }
+
+    pub fn activate_profile(&self, id: &str) -> Result<(), String> {
+        let mut settings = self.load_settings();
+        if !settings.profiles.iter().any(|p| p.id == id) {
+            return Err("订阅不存在".into());
+        }
+        settings.current_profile = Some(id.to_string());
+        self.save_settings(&settings)?;
+        self.generate_config()
+    }
+}

src-tauri/src/mihomo_manager/pseudo.rs

@@ -0,0 +1,71 @@
+// ===================== 伪节点过滤 =====================
+// 单点定义：托盘菜单、自动切换、前端显示过滤（ProxyModule.vue 的 PSEUDO_NODE_KEYWORDS
+// 与之对应）统一引用此处，避免多份关键词列表漂移。
+
+/// 订阅节点名中常见的营销/占位关键词（订阅页插入的非真实节点）
+const PSEUDO_KEYWORDS: &[&str] = &[
+    "DIRECT",
+    "REJECT",
+    "PASS",
+    "COMPATIBLE",
+    "流量",
+    "套餐",
+    "到期",
+    "续费",
+    "官网",
+    "网站",
+    "刷新",
+    "更新",
+    "⭐",
+    "★",
+    "☆",
+    "✕",
+    "✖",
+    "×",
+];
+
+/// 判断节点名是否为伪节点（DIRECT/REJECT 等内置策略或订阅营销占位）
+pub fn is_pseudo_node(name: &str) -> bool {
+    let upper = name.trim().to_uppercase();
+    if upper == "DIRECT" || upper == "REJECT" || upper == "PASS" || upper == "GLOBAL" {
+        return true;
+    }
+    PSEUDO_KEYWORDS.iter().any(|kw| name.contains(kw))
+}
+
+#[cfg(test)]
+mod pseudo_node_tests {
+    use super::*;
+
+    #[test]
+    fn builtin_policies_are_pseudo() {
+        assert!(is_pseudo_node("DIRECT"));
+        assert!(is_pseudo_node("REJECT"));
+        assert!(is_pseudo_node("PASS"));
+        assert!(is_pseudo_node("GLOBAL"));
+    }
+
+    #[test]
+    fn case_insensitive_and_trims_whitespace() {
+        assert!(is_pseudo_node("direct"));
+        assert!(is_pseudo_node("  Reject  "));
+    }
+
+    #[test]
+    fn marketing_keywords_are_pseudo() {
+        assert!(is_pseudo_node("香港流量套餐"));
+        assert!(is_pseudo_node("官网专线"));
+        assert!(is_pseudo_node("VIP到期续费"));
+        assert!(is_pseudo_node("每月更新"));
+        assert!(is_pseudo_node("★香港节点"));
+    }
+
+    #[test]
+    fn real_nodes_are_not_pseudo() {
+        assert!(!is_pseudo_node("HK-01"));
+        assert!(!is_pseudo_node("美国洛杉矶 01"));
+        assert!(!is_pseudo_node("JP Tokyo 2G"));
+        assert!(!is_pseudo_node(""));
+        assert!(!is_pseudo_node("Node-2024"));
+    }
+}

src-tauri/src/mihomo_manager/system_proxy.rs

@@ -0,0 +1,92 @@
+//! Windows 系统代理开关。
+
+use super::MihomoManager;
+
+// ===================== 系统代理（Windows） =====================
+
+#[cfg(windows)]
+pub(crate) fn set_system_proxy_windows(addr: &str) -> Result<(), String> {
+    use winreg::enums::*;
+    use winreg::RegKey;
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    let (settings, _) = hkcu
+        .create_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
+        .map_err(|e| e.to_string())?;
+    settings
+        .set_value("ProxyEnable", &1u32)
+        .map_err(|e| e.to_string())?;
+    settings
+        .set_value("ProxyServer", &addr)
+        .map_err(|e| e.to_string())?;
+    notify_wininet();
+    Ok(())
+}
+
+#[cfg(windows)]
+pub(crate) fn clear_system_proxy_windows() -> Result<(), String> {
+    use winreg::enums::*;
+    use winreg::RegKey;
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    let (settings, _) = hkcu
+        .create_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
+        .map_err(|e| e.to_string())?;
+    settings
+        .set_value("ProxyEnable", &0u32)
+        .map_err(|e| e.to_string())?;
+    notify_wininet();
+    Ok(())
+}
+
+#[cfg(windows)]
+pub fn get_system_proxy_windows() -> bool {
+    use winreg::enums::*;
+    use winreg::RegKey;
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    hkcu.open_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
+        .ok()
+        .and_then(|s| s.get_value::<u32, _>("ProxyEnable").ok())
+        .map(|v| v != 0)
+        .unwrap_or(false)
+}
+
+#[cfg(windows)]
+fn notify_wininet() {
+    unsafe {
+        use windows_sys::Win32::Networking::WinInet::*;
+        InternetSetOptionW(std::ptr::null(), INTERNET_OPTION_SETTINGS_CHANGED, std::ptr::null(), 0);
+        InternetSetOptionW(std::ptr::null(), INTERNET_OPTION_REFRESH, std::ptr::null(), 0);
+    }
+}
+
+#[cfg(not(windows))]
+pub(crate) fn set_system_proxy_windows(_addr: &str) -> Result<(), String> {
+    Err("系统代理仅支持 Windows".into())
+}
+#[cfg(not(windows))]
+pub(crate) fn clear_system_proxy_windows() -> Result<(), String> {
+    Err("系统代理仅支持 Windows".into())
+}
+#[cfg(not(windows))]
+pub fn get_system_proxy_windows() -> bool {
+    false
+}
+
+impl MihomoManager {
+    /// 开启系统代理（托盘菜单调用）
+    pub fn enable_system_proxy(&self) -> Result<(), String> {
+        let settings = self.load_settings();
+        let addr = format!("127.0.0.1:{}", settings.mixed_port);
+        set_system_proxy_windows(&addr)?;
+        let mut s = settings;
+        s.system_proxy = true;
+        self.save_settings(&s)
+    }
+
+    /// 关闭系统代理（托盘菜单调用）
+    pub fn disable_system_proxy(&self) -> Result<(), String> {
+        clear_system_proxy_windows()?;
+        let mut s = self.load_settings();
+        s.system_proxy = false;
+        self.save_settings(&s)
+    }
+}

src-tauri/src/mihomo_manager/types.rs

@@ -0,0 +1,140 @@
+// ===================== 数据结构 =====================
+// 代理模块的设置 / 订阅元信息 / 内核信息 / 安装进度等共享类型。
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+#[derive(Serialize, Deserialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ProxySettings {
+    #[serde(default = "default_mixed_port")]
+    pub mixed_port: u16,
+    #[serde(default = "default_external_controller")]
+    pub external_controller: String,
+    #[serde(default)]
+    pub secret: String,
+    #[serde(default = "default_mode")]
+    pub mode: String,
+    #[serde(default = "default_log_level")]
+    pub log_level: String,
+    #[serde(default)]
+    pub allow_lan: bool,
+    #[serde(default)]
+    pub system_proxy: bool,
+    #[serde(default)]
+    pub auto_start: bool,
+    #[serde(default)]
+    pub auto_system_proxy: bool,
+    #[serde(default)]
+    pub current_profile: Option<String>,
+    #[serde(default)]
+    pub profiles: Vec<ProfileMeta>,
+    #[serde(default)]
+    pub auto_switch_enabled: bool,
+    #[serde(default = "default_auto_switch_interval")]
+    pub auto_switch_interval: u32,
+    #[serde(default)]
+    pub auto_switch_group: String,
+    #[serde(default)]
+    pub auto_switch_region: String,
+    /// 内核下载镜像源列表（前缀拼接到 GitHub URL 前）。
+    /// 空字符串 = 直连 GitHub，其余为镜像站前缀（含尾斜杠）。
+    #[serde(default = "default_kernel_mirrors")]
+    pub kernel_mirrors: Vec<String>,
+}
+
+fn default_mixed_port() -> u16 { 7890 }
+fn default_external_controller() -> String { "127.0.0.1:9090".into() }
+fn default_mode() -> String { "rule".into() }
+fn default_log_level() -> String { "info".into() }
+fn default_auto_switch_interval() -> u32 { 5 }
+/// 默认镜像源：空串=直连 GitHub 优先，后续为公益镜像（按稳定性排序）
+fn default_kernel_mirrors() -> Vec<String> {
+    vec![
+        String::new(),
+        "https://ghproxy.net/".into(),
+        "https://gh-proxy.com/".into(),
+        "https://ghfast.top/".into(),
+    ]
+}
+
+impl Default for ProxySettings {
+    fn default() -> Self {
+        Self {
+            mixed_port: 7890,
+            external_controller: "127.0.0.1:9090".into(),
+            secret: String::new(),
+            mode: "rule".into(),
+            log_level: "info".into(),
+            allow_lan: false,
+            system_proxy: false,
+            auto_start: false,
+            auto_system_proxy: false,
+            current_profile: None,
+            profiles: Vec::new(),
+            auto_switch_enabled: false,
+            auto_switch_interval: 5,
+            auto_switch_group: String::new(),
+            auto_switch_region: String::new(),
+            kernel_mirrors: default_kernel_mirrors(),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ProfileMeta {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default)]
+    pub url: String,
+    #[serde(default)]
+    pub added_at: String,
+    #[serde(default)]
+    pub updated_at: String,
+    #[serde(default)]
+    #[specta(type = f64)]
+    pub size: u64,
+}
+
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct KernelInfo {
+    pub path: String,
+    pub exists: bool,
+    pub version: Option<String>,
+}
+
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct KernelUpdateInfo {
+    pub current_version: Option<String>,
+    pub latest_version: String,
+    pub download_url: String,
+    pub has_update: bool,
+}
+
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ProxyStatus {
+    pub running: bool,
+    pub pid: Option<u32>,
+    pub restart_count: u32,
+}
+
+/// 内核安装进度事件载荷
+/// - stage: downloading | extracting | replacing | done | error
+/// - percent: 0-100（无 total_bytes 时为 0，前端按 downloadedBytes 显示）
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct InstallProgress {
+    pub stage: String,
+    pub percent: u8,
+    #[specta(type = f64)]
+    pub downloaded_bytes: u64,
+    #[specta(type = Option<f64>)]
+    pub total_bytes: Option<u64>,
+    pub message: String,
+}

src-tauri/src/monitor_kernel.rs

@@ -132,6 +132,41 @@ pub fn is_thing_elevated() -> bool {
     false
 }
 
+// ===================== 监控设置持久化 =====================
+
+/// 监控模块设置（存储于 {app_data_dir}/monitor/settings.json）
+/// 参照代理模块 ProxySettings 的模式，仅包含需要持久化的运行时开关。
+#[derive(Serialize, Deserialize, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct MonitorSettings {
+    /// 应用启动时自动启动监控内核（默认 false）
+    #[serde(default)]
+    pub auto_start: bool,
+}
+
+/// 监控设置文件路径: {app_data_dir}/monitor/settings.json
+fn settings_path(app_data_dir: &std::path::Path) -> PathBuf {
+    app_data_dir.join("monitor").join("settings.json")
+}
+
+/// 读取监控设置（文件不存在或解析失败时返回默认值）
+pub fn load_monitor_settings(app_data_dir: &std::path::Path) -> MonitorSettings {
+    fs::read_to_string(settings_path(app_data_dir))
+        .ok()
+        .and_then(|s| serde_json::from_str::<MonitorSettings>(&s).ok())
+        .unwrap_or_default()
+}
+
+/// 写入监控设置
+pub fn save_monitor_settings(app_data_dir: &std::path::Path, settings: &MonitorSettings) -> Result<(), String> {
+    let path = settings_path(app_data_dir);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {}", e))?;
+    }
+    let content = serde_json::to_string_pretty(settings).map_err(|e| format!("序列化设置失败: {}", e))?;
+    fs::write(path, content).map_err(|e| format!("写入设置失败: {}", e))
+}
+
 // ===================== 永久提权标志持久化 =====================
 
 /// 永久提权标志文件路径: {app_data_dir}/monitor/elevate.json
@@ -175,11 +210,11 @@ pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
         Ok(e) => e,
         Err(_) => return false,
     };
-    eprintln!("[monitor] 检测到永久提权标志，以管理员权限重启 Thing");
+    crate::logger::log_info("monitor", "检测到永久提权标志，以管理员权限重启 Thing");
     match shell_execute_elevated(&exe.to_string_lossy(), "", None) {
         Ok(()) => true,
         Err(e) => {
-            eprintln!("[monitor] 永久提权重启失败（用户可能取消了 UAC）: {}", e);
+            crate::logger::log_warn("monitor", &format!("永久提权重启失败（用户可能取消了 UAC）: {}", e));
             false
         }
     }
@@ -247,6 +282,17 @@ pub struct MonitorKernel {
     listener_ids: Arc<Mutex<Vec<tauri::EventId>>>,
     /// 是否以管理员权限运行（提权模式下进程不受 ProcessManager 管控，停止走 /shutdown）
     elevated: Arc<AtomicBool>,
+    /// SSE 订阅循环活跃标志（重入守卫，防止并发/重复订阅导致双 emit monitor-data）
+    subscribing: Arc<AtomicBool>,
+}
+
+/// SSE 订阅循环标志守卫：Drop 时复位 subscribing，覆盖所有 return / abort 路径
+struct SubGuard(Arc<AtomicBool>);
+
+impl Drop for SubGuard {
+    fn drop(&mut self) {
+        self.0.store(false, Ordering::SeqCst);
+    }
 }
 
 impl MonitorKernel {
@@ -265,6 +311,7 @@ impl MonitorKernel {
             sub_handle: Arc::new(Mutex::new(None)),
             listener_ids: Arc::new(Mutex::new(Vec::new())),
             elevated: Arc::new(AtomicBool::new(false)),
+            subscribing: Arc::new(AtomicBool::new(false)),
         }
     }
 
@@ -283,6 +330,32 @@ impl MonitorKernel {
         write_elevate_flag(&self.root.join("elevate.json"), enabled)
     }
 
+    /// 读取监控设置（auto_start 等）
+    pub fn load_settings(&self) -> MonitorSettings {
+        load_monitor_settings(&self.root.parent().unwrap_or(&self.root).to_path_buf())
+    }
+
+    /// 写入监控设置
+    pub fn save_settings(&self, settings: &MonitorSettings) -> Result<(), String> {
+        save_monitor_settings(&self.root.parent().unwrap_or(&self.root).to_path_buf(), settings)
+    }
+
+    /// 应用启动时检查是否需要自动启动监控内核
+    pub fn auto_start_on_launch(&self, app: &AppHandle) {
+        let settings = self.load_settings();
+        if !settings.auto_start {
+            return;
+        }
+        let monitor = self.clone();
+        let app_handle = app.clone();
+        tauri::async_runtime::spawn(async move {
+            match monitor.start_with_subscription(&app_handle).await {
+                Ok(info) => crate::logger::log_info("monitor", &format!("自动启动成功, pid={:?}", info.pid)),
+                Err(e) => crate::logger::log_warn("monitor", &format!("自动启动跳过: {}", e)),
+            }
+        });
+    }
+
     fn cores_dir(&self) -> PathBuf {
         self.root.join("cores")
     }
@@ -381,10 +454,18 @@ impl MonitorKernel {
     /// 流程：轮询 /status 等 ready → 订阅 /stream → 解析 SSE 事件 → emit "monitor-data"
     /// 写入熔断：SSE 断开后停止 emit，等待外部调用 reconnect 或 process-status-changed 触发重连
     pub async fn start_subscription(self: Self, app: AppHandle) {
+        // 重入守卫：已有订阅循环在运行则跳过，防止并发/重复订阅（双 emit monitor-data）
+        if self.subscribing.swap(true, Ordering::SeqCst) {
+            crate::logger::log_warn("monitor", "已有 SSE 订阅循环运行中，跳过重复订阅");
+            return;
+        }
+        // Drop 时复位标志，覆盖所有 return 路径（含 stop 时 abort 取消）
+        let _guard = SubGuard(self.subscribing.clone());
+
         // 1. 轮询等待 Kernel ready（冷启动约 5s）
         if let Err(e) = self.wait_for_ready(&app).await {
-            eprintln!("[monitor] 等待 Kernel ready 失败，订阅不启动: {}", e);
-            let _ = app.emit("monitor-error", serde_json::json!({ "stage": "ready", "message": e }));
+            crate::logger::log_warn("monitor", &format!("等待 Kernel ready 失败，订阅不启动: {}", e));
+            let _ = app.emit(crate::constants::events::MONITOR_ERROR, serde_json::json!({ "stage": "ready", "message": e }));
             return;
         }
 
@@ -409,7 +490,7 @@ impl MonitorKernel {
                     match resp.json::<KernelStatus>().await {
                         Ok(s) if s.ready => {
                             let _ = app.emit(
-                                "monitor-ready",
+                                crate::constants::events::MONITOR_READY,
                                 serde_json::json!({
                                     "isAdmin": s.is_admin,
                                     "sensorCount": s.sensor_count,
@@ -426,8 +507,10 @@ impl MonitorKernel {
                 Err(e) => last_err = e.to_string(),
             }
             // 通知前端正在加载（前端可显示 "Kernel 启动中..."）
-            let elapsed = READY_TIMEOUT_MS.saturating_sub(deadline.duration_since(std::time::Instant::now()).as_millis() as u64);
-            let _ = app.emit("monitor-loading", serde_json::json!({ "elapsedMs": elapsed }));
+            // 用 saturating_duration_since：now 超过 deadline 时返回 0，避免 duration_since panic
+            let remaining = deadline.saturating_duration_since(std::time::Instant::now()).as_millis() as u64;
+            let elapsed = READY_TIMEOUT_MS.saturating_sub(remaining);
+            let _ = app.emit(crate::constants::events::MONITOR_LOADING, serde_json::json!({ "elapsedMs": elapsed }));
             tokio::time::sleep(Duration::from_millis(READY_POLL_INTERVAL_MS)).await;
         }
         Err(format!("Kernel 在 {}ms 内未就绪: {}", READY_TIMEOUT_MS, last_err))
@@ -441,24 +524,24 @@ impl MonitorKernel {
             match self.subscribe_once(&url, &app).await {
                 // 正常结束（客户端取消或服务端关闭）
                 Ok(()) => {
-                    eprintln!("[monitor] SSE 流正常结束");
+                    crate::logger::log_info("monitor", "SSE 流正常结束");
                     break;
                 }
                 Err(e) => {
-                    eprintln!("[monitor] SSE 流异常断开: {}，3s 后重试", e);
+                    crate::logger::log_warn("monitor", &format!("SSE 流异常断开: {}，3s 后重试", e));
                     let _ = app.emit(
-                        "monitor-disconnected",
+                        crate::constants::events::MONITOR_DISCONNECTED,
                         serde_json::json!({ "message": e }),
                     );
                     tokio::time::sleep(Duration::from_secs(3)).await;
                     // 重连前先确认 Kernel 是否还活着（可能已被 stop）
                     if !self.is_kernel_alive().await {
-                        eprintln!("[monitor] Kernel 已停止，退出 SSE 循环");
+                        crate::logger::log_info("monitor", "Kernel 已停止，退出 SSE 循环");
                         // 提权模式下 Kernel 崩溃/退出后重置 elevated 标志，
                         // 否则 monitor_status 会一直认为提权模式但 Kernel 已死，用户无法重启
                         if self.is_elevated() {
                             self.elevated.store(false, Ordering::SeqCst);
-                            eprintln!("[monitor] 提权 Kernel 已退出，重置 elevated 标志");
+                            crate::logger::log_info("monitor", "提权 Kernel 已退出，重置 elevated 标志");
                         }
                         break;
                     }
@@ -497,7 +580,7 @@ impl MonitorKernel {
 
                 if let Some(json_str) = parse_sse_data(&event_str) {
                     if let Ok(snap) = serde_json::from_str::<SensorSnapshot>(&json_str) {
-                        let _ = app.emit("monitor-data", snap);
+                        let _ = app.emit(crate::constants::events::MONITOR_DATA, snap);
                     }
                 }
             }
@@ -519,9 +602,11 @@ impl MonitorKernel {
 
     /// 停止 SSE 订阅（进程由 ProcessManager.stop 负责）
     pub async fn stop_subscription(&self, app: &AppHandle) {
-        // 取消 SSE 任务
+        // 取消 SSE 任务并等待其退出，确保 subscribing 重入守卫复位。
+        // 否则 stop 后立即 start 时旧任务仍在 Drop，新订阅会被守卫误跳过。
         if let Some(handle) = self.sub_handle.lock().await.take() {
             handle.abort();
+            let _ = handle.await;
         }
         // 取消 process-status-changed 监听
         let ids = self.listener_ids.lock().await.drain(..).collect::<Vec<_>>();
@@ -552,7 +637,7 @@ impl MonitorKernel {
                         let this = this.clone();
                         let app = app_clone.clone();
                         tauri::async_runtime::spawn(async move {
-                            eprintln!("[monitor] 检测到 Kernel 重启恢复，重新订阅 SSE");
+                            crate::logger::log_info("monitor", "检测到 Kernel 重启恢复，重新订阅 SSE");
                             // 重启后需要重新等待 ready（冷启动约 5s）
                             this.clone().start_subscription(app).await;
                         });
@@ -585,20 +670,23 @@ impl MonitorKernel {
             if status.ready {
                 if thing_elevated {
                     // Thing 是管理员：停止已有 Kernel（无论什么权限），用 ProcessManager 重启以继承权限
-                    eprintln!("[monitor] Thing 已提权，重启 ThingHK 以继承管理员权限");
+                    crate::logger::log_info("monitor", "Thing 已提权，重启 ThingHK 以继承管理员权限");
                     let _ = self.shutdown_kernel().await;
                     tokio::time::sleep(Duration::from_millis(500)).await;
                 } else if status.is_admin {
                     // Thing 非管理员，但已有提权 Kernel：直接接管
-                    eprintln!("[monitor] 检测到已有提权 Kernel 运行中，直接接管");
+                    crate::logger::log_info("monitor", "检测到已有提权 Kernel 运行中，直接接管");
                     self.elevated.store(true, Ordering::SeqCst);
                     let kernel = self.clone();
                     kernel.clone().register_auto_reconnect(app.clone()).await;
-                    let app_clone = app.clone();
-                    let handle = tauri::async_runtime::spawn(async move {
-                        kernel.start_subscription(app_clone).await;
-                    });
-                    *self.sub_handle.lock().await = Some(handle);
+                    // 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
+                    if !kernel.subscribing.load(Ordering::SeqCst) {
+                        let app_clone = app.clone();
+                        let handle = tauri::async_runtime::spawn(async move {
+                            kernel.start_subscription(app_clone).await;
+                        });
+                        *self.sub_handle.lock().await = Some(handle);
+                    }
                     // 提权模式下无 ProcessInfo，返回一个占位的
                     return Ok(crate::process_manager::ProcessInfo {
                         id: PROCESS_ID.into(),
@@ -609,7 +697,7 @@ impl MonitorKernel {
                     });
                 } else {
                     // Thing 非管理员，已有普通 Kernel：先停止
-                    eprintln!("[monitor] 检测到已有普通权限 Kernel 运行中，先停止再重启");
+                    crate::logger::log_info("monitor", "检测到已有普通权限 Kernel 运行中，先停止再重启");
                     let _ = self.shutdown_kernel().await;
                     tokio::time::sleep(Duration::from_millis(500)).await;
                 }
@@ -623,7 +711,7 @@ impl MonitorKernel {
         // Thing 是管理员时，ThingHK 继承权限，标记 elevated（仍由 ProcessManager 管理）
         if thing_elevated {
             self.elevated.store(true, Ordering::SeqCst);
-            eprintln!("[monitor] ThingHK 已以管理员权限启动（继承自 Thing）");
+            crate::logger::log_info("monitor", "ThingHK 已以管理员权限启动（继承自 Thing）");
         }
 
         // 用 self 的 clone（共享 Arc<Mutex> 状态）启动订阅，
@@ -631,11 +719,14 @@ impl MonitorKernel {
         // stop_subscription 时才能正确清理 listener。
         let kernel = self.clone();
         kernel.clone().register_auto_reconnect(app.clone()).await;
-        let app_clone = app.clone();
-        let handle = tauri::async_runtime::spawn(async move {
-            kernel.start_subscription(app_clone).await;
-        });
-        *self.sub_handle.lock().await = Some(handle);
+        // 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
+        if !kernel.subscribing.load(Ordering::SeqCst) {
+            let app_clone = app.clone();
+            let handle = tauri::async_runtime::spawn(async move {
+                kernel.start_subscription(app_clone).await;
+            });
+            *self.sub_handle.lock().await = Some(handle);
+        }
 
         Ok(info)
     }
@@ -703,17 +794,20 @@ impl MonitorKernel {
         }
 
         self.elevated.store(true, Ordering::SeqCst);
-        eprintln!("[monitor] 提权启动已发起，等待 Kernel ready");
+        crate::logger::log_info("monitor", "提权启动已发起，等待 Kernel ready");
 
         // 5. 启动 SSE 订阅（提权模式不注册 register_auto_reconnect：
         //    提权进程不归 ProcessManager 管，process-status-changed 事件不会触发，
         //    注册了反而可能在其他进程状态变化时误触发 SSE 重连）
         let kernel = self.clone();
         let app_clone = app.clone();
-        let handle = tauri::async_runtime::spawn(async move {
-            kernel.start_subscription(app_clone).await;
-        });
-        *self.sub_handle.lock().await = Some(handle);
+        // 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
+        if !kernel.subscribing.load(Ordering::SeqCst) {
+            let handle = tauri::async_runtime::spawn(async move {
+                kernel.start_subscription(app_clone).await;
+            });
+            *self.sub_handle.lock().await = Some(handle);
+        }
 
         Ok(())
     }
@@ -745,7 +839,7 @@ impl MonitorKernel {
         self.stop_subscription(app).await;
         // 仅当 ThingHK 提权但 Thing 未提权时才需要 /shutdown（ProcessManager 无法 kill 管理员进程）
         if self.is_elevated() && !is_thing_elevated() {
-            eprintln!("[monitor] 退出清理：停止提权 Kernel（/shutdown）");
+            crate::logger::log_info("monitor", "退出清理：停止提权 Kernel（/shutdown）");
             let _ = self.shutdown_kernel().await;
             self.elevated.store(false, Ordering::SeqCst);
         }
@@ -852,13 +946,13 @@ pub async fn monitor_elevate_self(
 
         if is_thing_elevated() {
             // 已是管理员，只需设置标志，无需重启
-            eprintln!("[monitor] Thing 已是管理员，仅设置永久提权标志");
+            crate::logger::log_info("monitor", "Thing 已是管理员，仅设置永久提权标志");
             return Ok(());
         }
 
         let exe = std::env::current_exe().map_err(|e| format!("获取当前路径失败: {}", e))?;
         let exe_str = exe.to_string_lossy().to_string();
-        eprintln!("[monitor] 永久提权：以管理员权限重启 Thing");
+        crate::logger::log_info("monitor", "永久提权：以管理员权限重启 Thing");
         shell_execute_elevated(&exe_str, "", None)?;
         // 退出当前进程（非提权），新的提权进程会接管
         app.exit(0);
@@ -917,6 +1011,25 @@ pub fn monitor_set_elevate_on_launch(
     state.set_elevate_on_launch(enabled)
 }
 
+/// 查询"应用启动时自动启动监控内核"是否已启用
+#[tauri::command]
+pub fn monitor_get_auto_start(
+    state: tauri::State<'_, MonitorKernel>,
+) -> bool {
+    state.load_settings().auto_start
+}
+
+/// 设置/清除"应用启动时自动启动监控内核"开关
+#[tauri::command]
+pub fn monitor_set_auto_start(
+    state: tauri::State<'_, MonitorKernel>,
+    enabled: bool,
+) -> Result<(), String> {
+    let mut settings = state.load_settings();
+    settings.auto_start = enabled;
+    state.save_settings(&settings)
+}
+
 /// 查询硬件监控配置（透传 Kernel GET /config/hardware）。
 /// 返回当前配置 + 可用硬件/传感器类型清单，供前端 Dialog 渲染。
 #[tauri::command]

src-tauri/src/network_monitor.rs

@@ -95,9 +95,9 @@ impl NetworkMonitor {
                 };
 
                 // emit 给前端（失败忽略：窗口可能未就绪）
-                let _ = app.emit("monitor-network", &speed);
+                let _ = app.emit(crate::constants::events::MONITOR_NETWORK, &speed);
             }
-            eprintln!("[network] 网速采样任务已退出");
+            crate::logger::log_info("network", "网速采样任务已退出");
         });
     }
 
@@ -116,7 +116,7 @@ impl Default for NetworkMonitor {
 
 /// Tauri 命令：获取网速监控是否运行
 #[tauri::command]
-pub fn network_monitor_status(
+pub fn network_status(
     state: tauri::State<'_, NetworkMonitor>,
 ) -> bool {
     state.running.load(Ordering::SeqCst)

src-tauri/src/osd_window.rs

@@ -6,8 +6,8 @@
 //! - 任务栏覆盖检测：轮询 GetForegroundWindow，检测系统 UI 出现时暂时取消置顶
 
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, OnceLock};
-use std::thread;
+use std::sync::{Arc, Mutex, OnceLock};
+use std::thread::{self, JoinHandle};
 use std::time::{Duration, Instant};
 use tauri::{AppHandle, Emitter};
 
@@ -15,6 +15,9 @@ use tauri::{AppHandle, Emitter};
 static DRAG_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
 /// 任务栏覆盖监视线程停止标志
 static TOPMOST_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
+/// 监视线程句柄（用于停止时 join，避免 sleep 猜测式等待 + 线程泄漏）
+static DRAG_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
+static TOPMOST_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
 
 fn drag_stop() -> &'static Arc<AtomicBool> {
     DRAG_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
@@ -24,6 +27,30 @@ fn topmost_stop() -> &'static Arc<AtomicBool> {
     TOPMOST_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
 }
 
+/// 停止右键拖动监视线程并等待其退出（标志置位后线程最迟一个轮询周期退出）
+fn stop_drag_thread() {
+    drag_stop().store(true, Ordering::SeqCst);
+    if let Some(h) = DRAG_HANDLE
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .take()
+    {
+        let _ = h.join();
+    }
+}
+
+/// 停止任务栏覆盖监视线程并等待其退出
+fn stop_topmost_thread() {
+    topmost_stop().store(true, Ordering::SeqCst);
+    if let Some(h) = TOPMOST_HANDLE
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .take()
+    {
+        let _ = h.join();
+    }
+}
+
 #[cfg(windows)]
 mod win_api {
     use tauri::{AppHandle, Manager};
@@ -33,8 +60,8 @@ mod win_api {
         GetClassNameW, GetCursorPos, GetForegroundWindow, GetWindowLongPtrW,
         GetWindowRect, SendMessageW, SetWindowLongPtrW, SetWindowPos,
         GWL_EXSTYLE, HTCAPTION, HWND_NOTOPMOST, HWND_TOPMOST, SWP_NOACTIVATE, SWP_NOMOVE,
-        SWP_NOSIZE, SWP_SHOWWINDOW, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
-        WS_EX_TRANSPARENT,
+        SWP_NOSIZE, SWP_NOZORDER, SWP_SHOWWINDOW, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE,
+        WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT,
     };
 
     /// windows-sys 的 HWND 类型别名（isize）
@@ -163,6 +190,24 @@ mod win_api {
         }
     }
 
+    /// 原子设置窗口位置与尺寸（物理像素）
+    ///
+    /// 一次 SetWindowPos 调用同时更新 x/y/w/h，避免 setSize + setPosition
+    /// 两次调用之间出现"宽度已变、位置未动"的中间帧（视觉闪烁）。
+    pub fn set_bounds(hwnd: Hwnd, x: i32, y: i32, w: i32, h: i32) {
+        unsafe {
+            SetWindowPos(
+                hwnd,
+                0, // 不改 Z 序
+                x,
+                y,
+                w,
+                h,
+                SWP_NOACTIVATE | SWP_NOZORDER,
+            );
+        }
+    }
+
     /// 判断窗口类名是否为系统 UI（任务栏、开始菜单、通知区域等）
     pub fn is_system_ui_class(class_name: &str) -> bool {
         matches!(
@@ -186,7 +231,7 @@ pub fn osd_apply_overlay_style(label: String, app: AppHandle) -> Result<(), Stri
         let hwnd = win_api::get_hwnd(&label, &app)
             .ok_or_else(|| format!("窗口 {} 不存在", label))?;
         win_api::apply_no_activate(hwnd);
-        eprintln!("[osd] 已应用 NoActivate 样式到窗口 {}", label);
+        crate::logger::log_info("osd", &format!("已应用 NoActivate 样式到窗口 {}", label));
     }
     Ok(())
 }
@@ -198,15 +243,14 @@ pub fn osd_apply_overlay_style(label: String, app: AppHandle) -> Result<(), Stri
 /// 右键释放后发出 `osd-end-drag` 事件。
 #[tauri::command]
 pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String> {
-    // 停止旧线程，等待退出
-    drag_stop().store(true, Ordering::SeqCst);
-    thread::sleep(Duration::from_millis(50));
+    // 停止旧线程，等待其退出后再启动新线程（避免新旧线程并存）
+    stop_drag_thread();
     let stop_flag = drag_stop().clone();
     stop_flag.store(false, Ordering::SeqCst);
 
     let app_handle = app.clone();
 
-    thread::spawn(move || {
+    let handle = thread::spawn(move || {
         let mut rbutton_was_down = false;
         let mut press_start: Option<Instant> = None;
         let mut drag_emitted = false;
@@ -234,7 +278,7 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
                                         (win_api::get_cursor_pos(), win_api::get_window_rect(hwnd))
                                     {
                                         if win_api::point_in_rect(pt, rect) {
-                                            let _ = app_handle.emit("osd-start-drag", ());
+                                            let _ = app_handle.emit(crate::constants::events::OSD_START_DRAG, ());
                                             drag_emitted = true;
                                         }
                                     }
@@ -245,7 +289,7 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
                 } else if !rbutton_down && rbutton_was_down {
                     // 右键释放
                     if drag_emitted {
-                        let _ = app_handle.emit("osd-end-drag", ());
+                        let _ = app_handle.emit(crate::constants::events::OSD_END_DRAG, ());
                     }
                     press_start = None;
                     drag_emitted = false;
@@ -258,6 +302,10 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
         }
     });
 
+    if let Ok(mut guard) = DRAG_HANDLE.lock() {
+        *guard = Some(handle);
+    }
+
     Ok(())
 }
 
@@ -268,14 +316,14 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
 /// 系统 UI 关闭后发出 `osd-system-ui-inactive` 事件恢复置顶。
 #[tauri::command]
 pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
-    topmost_stop().store(true, Ordering::SeqCst);
-    thread::sleep(Duration::from_millis(50));
+    // 停止旧线程，等待其退出后再启动新线程
+    stop_topmost_thread();
     let stop_flag = topmost_stop().clone();
     stop_flag.store(false, Ordering::SeqCst);
 
     let app_handle = app.clone();
 
-    thread::spawn(move || {
+    let handle = thread::spawn(move || {
         let mut last_foreground: isize = 0;
         let mut system_ui_active = false;
 
@@ -293,15 +341,15 @@ pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
                         if win_api::is_system_ui_class(&class) {
                             if !system_ui_active {
                                 system_ui_active = true;
-                                let _ = app_handle.emit("osd-system-ui-active", ());
+                                let _ = app_handle.emit(crate::constants::events::OSD_SYSTEM_UI_ACTIVE, ());
                             }
                         } else if system_ui_active {
                             system_ui_active = false;
-                            let _ = app_handle.emit("osd-system-ui-inactive", ());
+                            let _ = app_handle.emit(crate::constants::events::OSD_SYSTEM_UI_INACTIVE, ());
                         }
                     } else if system_ui_active {
                         system_ui_active = false;
-                        let _ = app_handle.emit("osd-system-ui-inactive", ());
+                        let _ = app_handle.emit(crate::constants::events::OSD_SYSTEM_UI_INACTIVE, ());
                     }
                 }
             }
@@ -310,14 +358,18 @@ pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
         }
     });
 
+    if let Ok(mut guard) = TOPMOST_HANDLE.lock() {
+        *guard = Some(handle);
+    }
+
     Ok(())
 }
 
 /// 停止所有 OSD 监视线程
 #[tauri::command]
 pub fn osd_stop_watch() {
-    drag_stop().store(true, Ordering::SeqCst);
-    topmost_stop().store(true, Ordering::SeqCst);
+    stop_drag_thread();
+    stop_topmost_thread();
 }
 
 /// 设置点击穿透（Rust 侧原生 WS_EX_TRANSPARENT，比 JS setIgnoreCursorEvents 更可靠）
@@ -344,6 +396,28 @@ pub fn osd_set_topmost(label: String, topmost: bool, app: AppHandle) -> Result<(
     Ok(())
 }
 
+/// 原子设置窗口位置与尺寸（物理像素）
+///
+/// 一次调用同时更新位置和尺寸，避免 setSize + setPosition 两次 IPC 之间的
+/// 中间帧（宽度已变、位置未动 → 视觉闪烁）。前端传入物理像素坐标。
+#[tauri::command]
+pub fn osd_set_bounds(
+    label: String,
+    x: i32,
+    y: i32,
+    w: i32,
+    h: i32,
+    app: AppHandle,
+) -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        let hwnd = win_api::get_hwnd(&label, &app)
+            .ok_or_else(|| format!("窗口 {} 不存在", label))?;
+        win_api::set_bounds(hwnd, x, y, w, h);
+    }
+    Ok(())
+}
+
 /// 启动原生拖动（右键长按触发）
 ///
 /// 同步关闭点击穿透（WS_EX_TRANSPARENT），然后在独立线程中调用

src-tauri/src/process_manager.rs

@@ -1,4 +1,5 @@
 use serde::Serialize;
+use specta::Type;
 use std::collections::HashMap;
 use std::process::{Child, Command, Stdio};
 use std::sync::Mutex;
@@ -80,7 +81,7 @@ fn get_job_handle() -> Option<winapi::HANDLE> {
         unsafe {
             let h = winapi::CreateJobObjectW(std::ptr::null_mut(), std::ptr::null());
             if h.is_null() {
-                eprintln!("[ProcessManager] CreateJobObjectW 失败，异常退出时子进程可能残留");
+                crate::logger::log_error("process", "CreateJobObjectW 失败，异常退出时子进程可能残留");
                 return 0;
             }
             // 设置 KILL_ON_JOB_CLOSE：主进程退出时自动终止所有子进程
@@ -93,7 +94,7 @@ fn get_job_handle() -> Option<winapi::HANDLE> {
                 std::mem::size_of::<winapi::JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
             );
             if ok == 0 {
-                eprintln!("[ProcessManager] SetInformationJobObject 失败");
+                crate::logger::log_error("process", "SetInformationJobObject 失败");
                 return 0;
             }
             h as usize
@@ -136,7 +137,7 @@ fn assign_to_job(child: &Child) {
 fn assign_to_job(_child: &Child) {}
 
 /// 进程状态枚举
-#[derive(Serialize, Clone, Debug)]
+#[derive(Serialize, Clone, Debug, Type)]
 #[serde(rename_all = "lowercase")]
 pub enum ProcessStatus {
     Running,
@@ -147,7 +148,8 @@ pub enum ProcessStatus {
 }
 
 /// 进程信息（返回给前端）
-#[derive(Serialize, Clone)]
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
 pub struct ProcessInfo {
     pub id: String,
     pub name: String,
@@ -291,7 +293,7 @@ impl ProcessManager {
                         Ok(Some(_)) => break,
                         Ok(None) => {
                             if std::time::Instant::now() >= deadline {
-                                println!("[ProcessManager] 进程 {} 等待退出超时（3s），放弃等待", id);
+                                crate::logger::log_warn("process", &format!("进程 {} 等待退出超时（3s），放弃等待", id));
                                 break;
                             }
                             std::thread::sleep(Duration::from_millis(50));
@@ -299,7 +301,7 @@ impl ProcessManager {
                         Err(_) => break,
                     }
                 }
-                println!("[ProcessManager] 已停止进程: {}", id);
+                crate::logger::log_info("process", &format!("已停止进程: {}", id));
             }
         }
     }
@@ -351,18 +353,24 @@ impl ProcessManager {
 
     /// 检查所有进程，处理崩溃的进程（自动重启或移除）
     /// 返回状态发生变化的进程列表
+    /// 注意：kill/wait/sleep(800ms) 等阻塞操作一律在锁外执行，
+    /// 锁内仅做非阻塞的 try_wait 判定，避免阻塞其他进程的状态查询
     pub fn check_and_cleanup(&self) -> Vec<ProcessInfo> {
         let mut changes = Vec::new();
+        // 需要重启的条目（锁外执行 kill + sleep + spawn）
+        let mut restarts: Vec<(String, ProcessEntry)> = Vec::new();
 
-        let mut processes = match self.processes.lock() {
-            Ok(p) => p,
-            Err(_) => return changes,
-        };
+        // 阶段 1：锁内快速判定（仅非阻塞 try_wait），收集重启/移除决策
+        {
+            let mut processes = match self.processes.lock() {
+                Ok(p) => p,
+                Err(_) => return changes,
+            };
 
-        let ids: Vec<String> = processes.keys().cloned().collect();
+            let ids: Vec<String> = processes.keys().cloned().collect();
 
-        for id in ids {
-            if let Some(entry) = processes.get_mut(&id) {
+            for id in ids {
+                let Some(entry) = processes.get_mut(&id) else { continue };
                 match entry.child.try_wait() {
                     Ok(None) => {
                         // 仍在运行，无需处理
@@ -373,58 +381,10 @@ impl ProcessManager {
                             && (entry.max_restarts == 0
                                 || entry.restart_count < entry.max_restarts)
                         {
-                            // 自动重启
-                            let restart_count = entry.restart_count + 1;
-                            let executable = entry.executable.clone();
-                            let args = entry.args.clone();
-                            let cwd = entry.cwd.clone();
-                            let name = entry.name.clone();
-
-                            // 先终止旧进程
-                            let _ = entry.child.kill();
-                            let _ = entry.child.wait();
-                            // 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟）
-                            std::thread::sleep(std::time::Duration::from_millis(800));
-
-                            // 重新启动
-                            let mut cmd = Command::new(&executable);
-                            cmd.args(&args);
-                            if let Some(ref dir) = cwd {
-                                cmd.current_dir(dir);
-                            }
-                            cmd.stdout(Stdio::null())
-                                .stderr(Stdio::null())
-                                .stdin(Stdio::null());
-                            setup_creation_flags(&mut cmd);
-
-                            match cmd.spawn() {
-                                Ok(new_child) => {
-                                    let pid = new_child.id();
-                                    entry.child = new_child;
-                                    entry.restart_count = restart_count;
-
-                                    changes.push(ProcessInfo {
-                                        id: id.clone(),
-                                        name: name.clone(),
-                                        status: ProcessStatus::Running,
-                                        pid: Some(pid),
-                                        restart_count,
-                                    });
-                                }
-                                Err(e) => {
-                                    eprintln!(
-                                        "[ProcessManager] 重启进程 '{}' 失败: {}",
-                                        id, e
-                                    );
-                                    processes.remove(&id);
-                                    changes.push(ProcessInfo {
-                                        id: id.clone(),
-                                        name,
-                                        status: ProcessStatus::Crashed,
-                                        pid: None,
-                                        restart_count,
-                                    });
-                                }
+                            // 需要自动重启：从 map 移除，锁外执行
+                            if let Some(mut e) = processes.remove(&id) {
+                                e.restart_count += 1;
+                                restarts.push((id.clone(), e));
                             }
                         } else {
                             // 不自动重启，移除记录
@@ -455,6 +415,58 @@ impl ProcessManager {
                     }
                 }
             }
+        } // 锁在此释放
+
+        // 阶段 2：锁外执行重启（kill + wait + 端口释放等待 + spawn，不阻塞进程状态查询）
+        for (id, mut entry) in restarts {
+            // 先终止旧进程
+            let _ = entry.child.kill();
+            let _ = entry.child.wait();
+            // 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟）
+            std::thread::sleep(std::time::Duration::from_millis(800));
+
+            // 重新启动
+            let mut cmd = Command::new(&entry.executable);
+            cmd.args(&entry.args);
+            if let Some(ref dir) = entry.cwd {
+                cmd.current_dir(dir);
+            }
+            cmd.stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .stdin(Stdio::null());
+            setup_creation_flags(&mut cmd);
+
+            let name = entry.name.clone();
+            let restart_count = entry.restart_count;
+            match cmd.spawn() {
+                Ok(new_child) => {
+                    let pid = new_child.id();
+                    entry.child = new_child;
+                    if let Ok(mut processes) = self.processes.lock() {
+                        processes.insert(id.clone(), entry);
+                    }
+                    changes.push(ProcessInfo {
+                        id: id.clone(),
+                        name,
+                        status: ProcessStatus::Running,
+                        pid: Some(pid),
+                        restart_count,
+                    });
+                }
+                Err(e) => {
+                    crate::logger::log_error(
+                        "process",
+                        &format!("重启进程 '{}' 失败: {}", id, e),
+                    );
+                    changes.push(ProcessInfo {
+                        id: id.clone(),
+                        name,
+                        status: ProcessStatus::Crashed,
+                        pid: None,
+                        restart_count,
+                    });
+                }
+            }
         }
 
         changes
@@ -464,7 +476,7 @@ impl ProcessManager {
 // ===== Tauri 命令 =====
 
 #[tauri::command]
-pub fn start_process(
+pub fn process_start(
     state: tauri::State<'_, ProcessManager>,
     params: StartProcessParams,
 ) -> Result<ProcessInfo, String> {
@@ -472,7 +484,7 @@ pub fn start_process(
 }
 
 #[tauri::command]
-pub fn stop_process(
+pub fn process_stop(
     state: tauri::State<'_, ProcessManager>,
     id: String,
 ) -> Result<(), String> {
@@ -480,7 +492,7 @@ pub fn stop_process(
 }
 
 #[tauri::command]
-pub fn get_process_status(
+pub fn process_status(
     state: tauri::State<'_, ProcessManager>,
     id: String,
 ) -> Option<ProcessInfo> {
@@ -488,14 +500,14 @@ pub fn get_process_status(
 }
 
 #[tauri::command]
-pub fn get_all_process_status(
+pub fn process_all_status(
     state: tauri::State<'_, ProcessManager>,
 ) -> Vec<ProcessInfo> {
     state.get_all_status()
 }
 
 #[tauri::command]
-pub fn stop_all_processes(state: tauri::State<'_, ProcessManager>) {
+pub fn process_stop_all(state: tauri::State<'_, ProcessManager>) {
     state.stop_all()
 }
 
@@ -509,7 +521,7 @@ pub fn start_monitoring_thread(app: AppHandle) {
             let changes = state.check_and_cleanup();
 
             for change in changes {
-                let _ = app.emit("process-status-changed", &change);
+                let _ = app.emit(crate::constants::events::PROCESS_STATUS_CHANGED, &change);
             }
         }
     });

src-tauri/src/quickpanel/actions.rs

@@ -0,0 +1,344 @@
+//! 快速面板：基于 7-Zip（binaries/7z.exe）的批量文件操作。
+//!
+//! - 批量解压：逐文件调用 7z 控制台，支持一次传入统一密码（`-p`），
+//!   每完成一个文件通过事件推送进度，前端可实时展示。
+//! - 批量重命名：`regex` 匹配文件名生成预览，确认后执行 `fs::rename`。
+//! - 目录列表：供前端展示当前目录的压缩包 / 文件列表。
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use tauri::{AppHandle, Emitter, Manager};
+
+use crate::constants::events::QUICKPANEL_EXTRACT_PROGRESS;
+
+/// 7z 可执行文件名（与 7z.dll 同目录，位于 resources/binaries）。
+const _7Z_EXE: &str = "binaries/7z.exe";
+
+/// 支持的压缩包扩展名（解压面板中列出）。
+const ARCHIVE_EXTS: &[&str] = &[
+    ".zip", ".7z", ".rar", ".tar", ".gz", ".tgz", ".bz2", ".tbz", ".xz", ".txz", ".zst",
+    ".tzst", ".cab", ".lzma",
+];
+
+/// 定位 7z 可执行文件（resources/binaries/7z.exe）。
+fn locate_7z(app: &AppHandle) -> Option<PathBuf> {
+    let path = app
+        .path()
+        .resolve(_7Z_EXE, tauri::path::BaseDirectory::Resource)
+        .ok()?;
+    if path.exists() {
+        Some(path)
+    } else {
+        None
+    }
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ArchiveInfo {
+    pub name: String,
+    pub path: String,
+    pub size: u64,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct FileEntry {
+    pub name: String,
+    pub path: String,
+    pub is_dir: bool,
+    pub size: u64,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtractResult {
+    pub name: String,
+    pub path: String,
+    pub ok: bool,
+    pub error: String,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtractProgress {
+    pub done: usize,
+    pub total: usize,
+    pub current: String,
+    pub ok: bool,
+    pub error: String,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct RenamePreview {
+    pub path: String,
+    pub old_name: String,
+    pub new_name: String,
+    pub error: String,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct RenameItem {
+    pub path: String,
+    pub old_name: String,
+    pub new_name: String,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct RenameResult {
+    pub old_name: String,
+    pub new_name: String,
+    pub ok: bool,
+    pub error: String,
+}
+
+fn is_archive(name: &str) -> bool {
+    let lower = name.to_lowercase();
+    ARCHIVE_EXTS.iter().any(|ext| lower.ends_with(ext))
+}
+
+/// 列出目录下的压缩包文件（供批量解压面板使用）。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_list_archives(dir: String) -> Result<Vec<ArchiveInfo>, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let d = Path::new(&dir);
+        if !d.is_dir() {
+            return Err(format!("目录不存在: {dir}"));
+        }
+        let mut out = Vec::new();
+        for entry in std::fs::read_dir(d).map_err(|e| format!("读取目录失败: {e}"))? {
+            let Ok(entry) = entry else { continue };
+            let path = entry.path();
+            if !path.is_file() {
+                continue;
+            }
+            let name = path
+                .file_name()
+                .map(|s| s.to_string_lossy().to_string())
+                .unwrap_or_default();
+            if is_archive(&name) {
+                let size = path.metadata().map(|m| m.len()).unwrap_or(0);
+                out.push(ArchiveInfo {
+                    name,
+                    path: path.to_string_lossy().to_string(),
+                    size,
+                });
+            }
+        }
+        out.sort_by(|a, b| a.name.cmp(&b.name));
+        Ok(out)
+    })
+    .await
+    .map_err(|e| format!("读取压缩包失败: {e}"))?
+}
+
+/// 列出目录下的全部条目（供批量重命名/删除面板使用，不含子目录递归）。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_list_dir(dir: String) -> Result<Vec<FileEntry>, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let d = Path::new(&dir);
+        if !d.is_dir() {
+            return Err(format!("目录不存在: {dir}"));
+        }
+        let mut out = Vec::new();
+        for entry in std::fs::read_dir(d).map_err(|e| format!("读取目录失败: {e}"))? {
+            let Ok(entry) = entry else { continue };
+            let path = entry.path();
+            let is_dir = path.is_dir();
+            let name = path
+                .file_name()
+                .map(|s| s.to_string_lossy().to_string())
+                .unwrap_or_default();
+            let size = if is_dir {
+                0
+            } else {
+                path.metadata().map(|m| m.len()).unwrap_or(0)
+            };
+            out.push(FileEntry {
+                name,
+                path: path.to_string_lossy().to_string(),
+                is_dir,
+                size,
+            });
+        }
+        out.sort_by(|a, b| {
+            b.is_dir
+                .cmp(&a.is_dir)
+                .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+        });
+        Ok(out)
+    })
+    .await
+    .map_err(|e| format!("读取目录失败: {e}"))?
+}
+
+fn extract_one(
+    exe: &Path,
+    archive: &str,
+    dest: &str,
+    password: Option<&str>,
+    into_subfolder: bool,
+) -> Result<(), String> {
+    let archive_path = Path::new(archive);
+    let mut cmd = Command::new(exe);
+    cmd.arg("x").arg(archive_path);
+    if into_subfolder {
+        // 解压到「压缩包同名子文件夹」，避免文件散落在当前目录。
+        let sub = archive_path
+            .file_stem()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_else(|| "extracted".into());
+        let sub_dir = Path::new(dest).join(&sub);
+        std::fs::create_dir_all(&sub_dir).map_err(|e| format!("创建目录 {sub} 失败: {e}"))?;
+        cmd.arg(format!("-o{}", sub_dir.display()));
+    } else {
+        cmd.arg(format!("-o{}", dest));
+    }
+    cmd.arg("-y"); // 全自动覆盖确认
+    if let Some(p) = password.filter(|p| !p.is_empty()) {
+        cmd.arg(format!("-p{p}"));
+    }
+    // 静默普通输出，仅错误进 stderr，逐文件粒度足够时无需 -bsp1 进度。
+    cmd.arg("-bso0").arg("-bse1").arg("-bsp0");
+    // 以 7z.exe 所在目录为工作目录，确保同目录的 7z.dll 可被加载。
+    if let Some(dir) = exe.parent() {
+        cmd.current_dir(dir);
+    }
+    let output = cmd.output().map_err(|e| format!("启动 7-Zip 失败: {e}"))?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        let msg = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        let code = output.status.code().unwrap_or(-1);
+        Err(if msg.is_empty() {
+            format!("退出码 {code}")
+        } else {
+            msg
+        })
+    }
+}
+
+/// 批量解压。`files` 为压缩包路径列表，`dest_dir` 为目标目录，
+/// `password` 为统一解压密码（可空），`into_subfolder` 是否解压到同名子文件夹。
+/// 每完成一个文件通过 `quickpanel-extract-progress` 事件推送进度。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_batch_extract(
+    app: AppHandle,
+    files: Vec<String>,
+    dest_dir: String,
+    password: Option<String>,
+    into_subfolder: bool,
+) -> Result<Vec<ExtractResult>, String> {
+    let exe = locate_7z(&app).ok_or("未找到 7-Zip 组件（binaries/7z.exe），请重新安装")?;
+    let total = files.len();
+    let results = tauri::async_runtime::spawn_blocking(move || {
+        let mut results = Vec::with_capacity(total);
+        for (idx, file) in files.iter().enumerate() {
+            let err = extract_one(&exe, file, &dest_dir, password.as_deref(), into_subfolder);
+            let name = Path::new(file)
+                .file_name()
+                .map(|s| s.to_string_lossy().to_string())
+                .unwrap_or_else(|| file.clone());
+            let (ok, error) = match err {
+                Ok(()) => (true, String::new()),
+                Err(e) => (false, e),
+            };
+            results.push(ExtractResult {
+                name,
+                path: file.clone(),
+                ok,
+                error: error.clone(),
+            });
+            let _ = app.emit(
+                QUICKPANEL_EXTRACT_PROGRESS,
+                ExtractProgress {
+                    done: idx + 1,
+                    total,
+                    current: results[idx].name.clone(),
+                    ok,
+                    error,
+                },
+            );
+        }
+        results
+    })
+    .await
+    .map_err(|e| format!("解压任务异常终止: {e}"))?;
+    Ok(results)
+}
+
+/// 正则批量重命名预览：对每个文件名应用 `pattern → replacement`，
+/// 仅返回有匹配的文件，`newName` 为替换结果。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_preview_rename(
+    files: Vec<String>,
+    pattern: String,
+    replacement: String,
+) -> Result<Vec<RenamePreview>, String> {
+    let re = regex::Regex::new(&pattern).map_err(|e| format!("正则表达式无效: {e}"))?;
+    let mut out = Vec::new();
+    for file in files {
+        let name = Path::new(&file)
+            .file_name()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_default();
+        if !re.is_match(&name) {
+            continue;
+        }
+        let new_name = re.replace_all(&name, replacement.as_str()).to_string();
+        let error = if new_name.is_empty() || new_name == name {
+            "名称未变化".to_string()
+        } else {
+            String::new()
+        };
+        out.push(RenamePreview {
+            path: file,
+            old_name: name,
+            new_name,
+            error,
+        });
+    }
+    Ok(out)
+}
+
+/// 执行重命名。同一目录下若目标已存在则跳过该项。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_apply_rename(items: Vec<RenameItem>) -> Result<Vec<RenameResult>, String> {
+    let mut out = Vec::new();
+    for item in items {
+        let result = (|| -> Result<(), String> {
+            if item.new_name.is_empty() {
+                return Err("新文件名为空".into());
+            }
+            if item.new_name.contains(['/', '\\', ':', '*', '?', '"', '<', '>', '|']) {
+                return Err("文件名包含非法字符".into());
+            }
+            let old = Path::new(&item.path);
+            let parent = old.parent().unwrap_or(Path::new("."));
+            let new_path = parent.join(&item.new_name);
+            if new_path.exists() {
+                return Err("目标已存在".into());
+            }
+            std::fs::rename(old, &new_path).map_err(|e| format!("重命名失败: {e}"))?;
+            Ok(())
+        })();
+        out.push(RenameResult {
+            old_name: item.old_name,
+            new_name: item.new_name,
+            ok: result.is_ok(),
+            error: result.err().unwrap_or_default(),
+        });
+    }
+    Ok(out)
+}

src-tauri/src/quickpanel/app_scanner.rs

@@ -8,7 +8,9 @@ use std::path::PathBuf;
 use serde::Serialize;
 use walkdir::WalkDir;
 
-#[derive(Debug, Clone, Serialize)]
+use specta::Type;
+
+#[derive(Debug, Clone, Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct AppRecord {
     pub name: String,

src-tauri/src/quickpanel/commands.rs

@@ -1,53 +1,77 @@
 //! Tauri 命令：快速面板模块
 
-use tauri::AppHandle;
+use tauri::{AppHandle, Emitter, Manager};
 
 use super::popup::{self, QuickPanelSettings};
 use super::{file_index, app_scanner, icon_extractor};
 
+/// 批量删除单个条目的结果。
+#[derive(serde::Serialize, serde::Deserialize, specta::Type, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DeleteResult {
+    pub name: String,
+    pub path: String,
+    pub ok: bool,
+    pub error: String,
+}
+
 /// 读取快速面板设置（快捷键等）
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_get_settings(app: AppHandle) -> Result<QuickPanelSettings, String> {
     Ok(popup::load_settings(&app))
 }
 
-/// 保存快速面板设置；快捷键变化时自动重新注册 + 预创建窗口
+/// 保存快速面板设置；快捷键变化时自动重新注册 + 预创建窗口，
+/// 索引目录变化时闲时自动重建索引。
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_save_settings(
     settings: QuickPanelSettings,
     app: AppHandle,
 ) -> Result<(), String> {
-    let prev_shortcut = popup::load_settings(&app).shortcut;
+    let prev = popup::load_settings(&app);
+    let prev_shortcut = prev.shortcut.clone();
+    let dirs_changed = prev.index_dirs != settings.index_dirs;
     popup::save_settings(&app, &settings)?;
-    // 快捷键变化时重新注册
+    // 快捷键变化时重新注册（共享工具模块，原子化 + 冲突检测）
     if settings.shortcut != prev_shortcut {
-        popup::register_shortcut(&app, &settings.shortcut)?;
+        crate::shortcut::register_shortcut(&app, "快速面板", &settings.shortcut, |a| {
+            popup::show_popup(a)
+        })?;
         // 新快捷键非空时确保弹窗窗口已预创建
         if !settings.shortcut.trim().is_empty() {
             popup::ensure_window(&app);
         }
     }
+    // 索引目录变更：闲时自动重建（新增/移除路径后无需手动点"构建索引"）
+    if dirs_changed {
+        schedule_auto_build(app, true);
+    }
     Ok(())
 }
 
 /// 注册（或切换）快速面板全局快捷键
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_register_shortcut(
     shortcut: String,
     app: AppHandle,
 ) -> Result<(), String> {
-    popup::register_shortcut(&app, &shortcut)
+    crate::shortcut::register_shortcut(&app, "快速面板", &shortcut, |a| popup::show_popup(a))
 }
 
 /// 注销快速面板全局快捷键
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_unregister_shortcut(app: AppHandle) -> Result<(), String> {
-    popup::unregister_shortcut(&app);
+    crate::shortcut::unregister_shortcut(&app, "快速面板");
     Ok(())
 }
 
 /// 手动触发显示快速面板（供 UI 按钮调用）
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_show_popup(app: AppHandle) -> Result<(), String> {
     popup::show_popup(&app);
     Ok(())
@@ -55,6 +79,7 @@ pub async fn quickpanel_show_popup(app: AppHandle) -> Result<(), String> {
 
 /// 隐藏快速面板
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_hide_popup(app: AppHandle) -> Result<(), String> {
     popup::hide_popup(&app);
     Ok(())
@@ -62,13 +87,35 @@ pub async fn quickpanel_hide_popup(app: AppHandle) -> Result<(), String> {
 
 /// 显示已创建的弹窗窗口（前端 onMounted 后调用）
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_show_window(app: AppHandle) -> Result<(), String> {
     popup::show_window(&app);
     Ok(())
 }
 
+/// 显示主窗口并强制置为前台。
+/// Tauri 的 set_focus 在 Windows 上受前台锁定限制，主窗口被其他应用遮挡时无法到前台；
+/// 改用原生 SetForegroundWindow + BringWindowToTop（模拟 Alt 键重置前台锁定）。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_focus_main_window(app: AppHandle) -> Result<(), String> {
+    use crate::constants::windows::MAIN;
+    if let Some(window) = app.get_webview_window(MAIN) {
+        window.show().map_err(|e| e.to_string())?;
+        window.unminimize().map_err(|e| e.to_string())?;
+        match window.hwnd() {
+            Ok(hwnd) => crate::win32_util::force_foreground(hwnd.0 as isize),
+            Err(_) => {
+                window.set_focus().ok();
+            }
+        }
+    }
+    Ok(())
+}
+
 /// 锁定屏幕（Windows: rundll32 user32.dll,LockWorkStation，CREATE_NO_WINDOW 避免黑窗）
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_lock_screen() -> Result<(), String> {
     #[cfg(windows)]
     {
@@ -85,55 +132,156 @@ pub fn quickpanel_lock_screen() -> Result<(), String> {
     Ok(())
 }
 
-/// 初始化文件索引数据库（应用启动时调用）
+/// 闲时自动建立索引的启动延迟（秒）：避开应用启动/模块加载的 IO 高峰
+const AUTO_BUILD_START_DELAY: u64 = 6;
+/// 判定"系统空闲"的阈值（毫秒）：用户停止输入超过该时长才执行构建
+const AUTO_BUILD_IDLE_MS: u64 = 3000;
+/// 等待系统空闲的最长轮询次数（每次间隔 2s，约 60s 上限，超时后不再等待直接构建）
+const AUTO_BUILD_MAX_WAIT_ITERS: u32 = 30;
+
+/// 解析要索引的目录：设置为空时用默认（桌面/文档/下载）
+fn resolve_index_dirs(app: &AppHandle) -> Vec<String> {
+    let settings = popup::load_settings(app);
+    if settings.index_dirs.is_empty() {
+        popup::QuickPanelSettings::default().index_dirs
+    } else {
+        settings.index_dirs
+    }
+}
+
+/// 闲时自动建立/重建文件索引。
+/// - `force=false`：仅首次（从未构建过）自动建立
+/// - `force=true`：忽略是否已构建，直接重建（索引目录变更后调用）
+///
+/// 流程：先延迟避开启动 IO 高峰，再轮询等待系统空闲（用户停止输入），
+/// 空闲后才开始构建，避免与应用运行/用户操作抢 IO 导致卡顿。
+/// 构建完成后向前端广播 `quickpanel-index-updated` 事件（负载为条目数），
+/// 供设置页刷新统计、弹窗启用文件搜索。
+fn schedule_auto_build(app: AppHandle, force: bool) {
+    tauri::async_runtime::spawn(async move {
+        // 1. 启动延迟：避开应用启动、模块加载等 IO 高峰
+        tokio::time::sleep(std::time::Duration::from_secs(AUTO_BUILD_START_DELAY)).await;
+        // 2. 轮询等待系统空闲（判定阈值见 AUTO_BUILD_IDLE_MS）
+        for _ in 0..AUTO_BUILD_MAX_WAIT_ITERS {
+            if crate::win32_util::get_idle_time_ms() >= AUTO_BUILD_IDLE_MS {
+                break;
+            }
+            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+        }
+        // 3. 非强制模式：已构建过则跳过（幂等，避免每次启动重建）
+        if !force {
+            file_index::ensure_initialized(&app);
+            let stats = file_index::stats();
+            if stats.last_built_at > 0 && !stats.last_built_dirs.is_empty() {
+                return;
+            }
+        }
+        // 4. 构建（build_index 内部有并发保护，重复调度/手动构建并发时幂等跳过）
+        let dirs = resolve_index_dirs(&app);
+        match tauri::async_runtime::spawn_blocking(move || file_index::build_index(&dirs)).await {
+            Ok(Ok(count)) => {
+                crate::logger::log_info(
+                    "quickpanel",
+                    &format!("闲时自动索引完成，共 {} 条", count),
+                );
+                let _ = app.emit(crate::constants::events::QUICKPANEL_INDEX_UPDATED, count);
+            }
+            _ => {
+                crate::logger::log_error("quickpanel", "闲时自动索引失败");
+            }
+        }
+    });
+}
+
+/// 初始化文件索引数据库（应用启动时调用）。
+/// 若存在上次构建的索引（last_built_dirs 非空），自动恢复 notify 增量监听，
+/// 无需重建即可继续自动同步文件变更。
+/// 若从未构建过（首次运行），闲时自动建立索引，无需用户手动点"构建索引"。
 #[tauri::command]
-pub fn quickpanel_init_file_index(app: AppHandle) -> Result<(), String> {
-    file_index::init(&app);
+#[specta::specta]
+pub async fn quickpanel_init_file_index(app: AppHandle) -> Result<(), String> {
+    let app_for_build = app.clone();
+    let need_auto_build = tauri::async_runtime::spawn_blocking(move || {
+        file_index::init(&app_for_build);
+        let stats = file_index::stats();
+        if stats.last_built_at > 0 && !stats.last_built_dirs.is_empty() {
+            file_index::start_watcher(&stats.last_built_dirs);
+        }
+        // 从未构建过索引 → 需要闲时自动建立
+        stats.last_built_at == 0 || stats.last_built_dirs.is_empty()
+    })
+    .await
+    .map_err(|e| format!("索引初始化任务失败: {}", e))?;
+
+    if need_auto_build {
+        schedule_auto_build(app, false);
+    }
     Ok(())
 }
 
 /// 构建文件索引（全量重建，阻塞操作建议在 spawn_blocking 调用）
 #[tauri::command]
+#[specta::specta]
 pub async fn quickpanel_build_file_index(app: AppHandle) -> Result<i64, String> {
-    let settings = popup::load_settings(&app);
-    let dirs = if settings.index_dirs.is_empty() {
-        popup::QuickPanelSettings::default().index_dirs
-    } else {
-        settings.index_dirs
-    };
+    let dirs = resolve_index_dirs(&app);
+    // 懒加载：首次构建时自动初始化 DB 连接
+    file_index::ensure_initialized(&app);
     // 阻塞操作放到 spawn_blocking
     tauri::async_runtime::spawn_blocking(move || file_index::build_index(&dirs))
         .await
         .map_err(|e| format!("索引任务失败: {}", e))?
 }
 
-/// 搜索文件索引
+/// 搜索文件索引（SQLite 查询移出主线程）
 #[tauri::command]
-pub fn quickpanel_search_files(query: String, limit: Option<i64>) -> Vec<file_index::FileRecord> {
-    file_index::search(&query, limit.unwrap_or(50))
+#[specta::specta]
+pub async fn quickpanel_search_files(
+    query: String,
+    limit: Option<i64>,
+    app: AppHandle,
+) -> Result<Vec<file_index::FileRecord>, String> {
+    // 懒加载：首次搜索时自动初始化 DB 连接
+    file_index::ensure_initialized(&app);
+    tauri::async_runtime::spawn_blocking(move || file_index::search(&query, limit.unwrap_or(50)))
+        .await
+        .map_err(|e| format!("搜索任务失败: {}", e))
 }
 
 /// 获取索引状态
 #[tauri::command]
-pub fn quickpanel_file_index_stats() -> file_index::IndexStats {
+#[specta::specta]
+pub async fn quickpanel_file_index_stats(app: AppHandle) -> file_index::IndexStats {
+    // 懒加载：查询状态前确保 DB 已初始化（未初始化时 stats 返回全 0）
+    file_index::ensure_initialized(&app);
     file_index::stats()
 }
 
-/// 扫描已安装应用
+/// 扫描已安装应用（遍历开始菜单/桌面/磁盘，移出主线程）
 #[tauri::command]
-pub fn quickpanel_scan_apps() -> Vec<app_scanner::AppRecord> {
-    app_scanner::scan_apps()
+#[specta::specta]
+pub async fn quickpanel_scan_apps() -> Result<Vec<app_scanner::AppRecord>, String> {
+    tauri::async_runtime::spawn_blocking(app_scanner::scan_apps)
+        .await
+        .map_err(|e| format!("扫描应用任务失败: {}", e))
 }
 
 /// 获取应用图标（data URL）。命中内存/磁盘缓存时零 Windows API 调用。
 /// 前端按需为可见项调用，避免一次性加载全部图标。
+/// 未命中缓存时 SHGetFileInfoW + 编码 + 落盘为阻塞操作，移出主线程。
 #[tauri::command]
-pub fn quickpanel_get_app_icon(app: AppHandle, path: String) -> Option<String> {
-    icon_extractor::get_icon_data_url(&app, &path)
+#[specta::specta]
+pub async fn quickpanel_get_app_icon(
+    app: AppHandle,
+    path: String,
+) -> Result<Option<String>, String> {
+    tauri::async_runtime::spawn_blocking(move || icon_extractor::get_icon_data_url(&app, &path))
+        .await
+        .map_err(|e| format!("图标提取任务失败: {}", e))
 }
 
 /// 清理图标缓存（磁盘 + 内存）
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_clear_app_icon_cache(app: AppHandle) -> Result<(), String> {
     icon_extractor::clear_cache(&app);
     Ok(())
@@ -141,6 +289,7 @@ pub fn quickpanel_clear_app_icon_cache(app: AppHandle) -> Result<(), String> {
 
 /// 在资源管理器中显示文件（选中）
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_reveal_in_explorer(path: String) -> Result<(), String> {
     #[cfg(windows)]
     {
@@ -192,18 +341,21 @@ pub fn quickpanel_reveal_in_explorer(path: String) -> Result<(), String> {
 /// - 目录：explorer.exe 直接打开（修复索引目录点击后未打开的问题）
 /// - 文件：ShellExecuteW open，无关联应用时自动 fallback 到「打开方式」对话框（verb: openas）
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_open_file(path: String) -> Result<(), String> {
     super::special_locations::open_path(&path)
 }
 
 /// 获取 Windows 常用快捷位置（hosts、回收站、此电脑、用户目录、系统管理工具等）
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_get_special_locations() -> Vec<super::special_locations::SpecialLocation> {
     super::special_locations::get_special_locations()
 }
 
 /// 打开快捷位置（kind: file | shell | cmd）
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_open_special(
     kind: String,
     target: String,
@@ -216,13 +368,21 @@ pub fn quickpanel_open_special(
     }
 }
 
-/// 删除文件（移到回收站）
+/// 删除文件（移到回收站，PowerShell 阻塞等待移出主线程）
 #[tauri::command]
-pub fn quickpanel_delete_file(path: String) -> Result<(), String> {
+#[specta::specta]
+pub async fn quickpanel_delete_file(path: String) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || delete_file_impl(&path))
+        .await
+        .map_err(|e| format!("删除任务失败: {}", e))?
+}
+
+/// 删除文件实现：PowerShell + Microsoft.VisualBasic 移到回收站
+fn delete_file_impl(path: &str) -> Result<(), String> {
     #[cfg(windows)]
     {
         use crate::process_manager::setup_creation_flags;
-        let p = std::path::Path::new(&path);
+        let p = std::path::Path::new(path);
         let is_dir = p.is_dir();
         // 用 PowerShell + Microsoft.VisualBasic 移到回收站
         let script = if is_dir {
@@ -255,9 +415,73 @@ pub fn quickpanel_delete_file(path: String) -> Result<(), String> {
     Ok(())
 }
 
+/// 批量删除文件/目录。`force=false` 时移动至回收站；`force=true` 时先递归清除
+/// 只读属性再永久删除（可绕过只读/部分占用导致的删除失败，但被其他进程真正
+/// 锁定的文件仍会失败并返回原因）。
+#[tauri::command]
+#[specta::specta]
+pub async fn quickpanel_delete_files(
+    paths: Vec<String>,
+    force: bool,
+) -> Result<Vec<DeleteResult>, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let mut out = Vec::new();
+        for path in paths {
+            let name = std::path::Path::new(&path)
+                .file_name()
+                .map(|s| s.to_string_lossy().to_string())
+                .unwrap_or_else(|| path.clone());
+            let result = if force {
+                delete_force_impl(&path)
+            } else {
+                delete_file_impl(&path)
+            };
+            out.push(DeleteResult {
+                name,
+                path: path.clone(),
+                ok: result.is_ok(),
+                error: result.err().unwrap_or_default(),
+            });
+        }
+        Ok(out)
+    })
+    .await
+    .map_err(|e| format!("删除任务失败: {e}"))?
+}
+
+/// 强行删除：递归清除只读属性后永久删除（不经过回收站）。
+fn delete_force_impl(path: &str) -> Result<(), String> {
+    let p = std::path::Path::new(path);
+    clear_readonly(p);
+    if p.is_dir() {
+        std::fs::remove_dir_all(p).map_err(|e| format!("删除失败: {e}"))
+    } else {
+        std::fs::remove_file(p).map_err(|e| format!("删除失败: {e}"))
+    }
+}
+
+/// 递归清除只读属性（只读文件/目录无法直接删除）。
+fn clear_readonly(path: &std::path::Path) {
+    if let Ok(meta) = std::fs::metadata(path) {
+        if meta.permissions().readonly() {
+            let mut perms = meta.permissions();
+            perms.set_readonly(false);
+            let _ = std::fs::set_permissions(path, perms);
+        }
+        if meta.is_dir() {
+            if let Ok(rd) = std::fs::read_dir(path) {
+                for entry in rd.flatten() {
+                    clear_readonly(&entry.path());
+                }
+            }
+        }
+    }
+}
+
 /// 运行自定义命令（执行可执行文件 + 参数）
 /// .lnk 快捷方式不能直接 spawn（os error 193），需通过 cmd /C 启动
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_run_custom_command(command: String, args: Vec<String>) -> Result<(), String> {
     use crate::process_manager::setup_creation_flags;
     let is_lnk = command
@@ -282,6 +506,7 @@ pub fn quickpanel_run_custom_command(command: String, args: Vec<String>) -> Resu
 /// 运行系统命令（不设置 CREATE_NO_WINDOW，使 cmd/powershell/regedit 等显示自身窗口）
 /// 适用于内置系统工具：regedit、shutdown、cmd、powershell、taskmgr 等。
 #[tauri::command]
+#[specta::specta]
 pub fn quickpanel_run_system_command(command: String, args: Vec<String>) -> Result<(), String> {
     let mut cmd = std::process::Command::new(&command);
     cmd.args(&args);

src-tauri/src/quickpanel/explorer.rs

@@ -0,0 +1,139 @@
+//! 快速面板：检测前台 Explorer 窗口的当前目录。
+//!
+//! 必须在快捷键回调（`show_popup`）内调用：此时前台窗口仍是资源管理器，
+//! 面板尚未取得焦点，`GetForegroundWindow` 拿到的才是 Explorer 主窗口；
+//! 若等面板显示后再调用，前台就变成面板自身了。
+//!
+//! 思路（Listary / PowerToys Run 同款）：前台窗口 HWND 匹配 `IShellWindows`
+//! 中某个 Shell 窗口 → 取其 `LocationURL`（file:///...）→ 转成本地路径。
+//!
+//! Win11 多选项卡：同一顶层窗口下每个选项卡都是独立的 `IShellWindows` 条目，
+//! 共享顶层 HWND。活动选项卡的内容窗口（`ShellTabWindowClass`）在子窗口
+//! z-order 顶层，用 `IID_IShellBrowser` 作为 `QueryService` 的 service ID 获取
+//! 每个选项卡自己的 `IShellBrowser`（而非 `SID_STopLevelBrowser` 返回的顶层
+//! browser），再通过 `GetWindow()` 拿到该选项卡的内容窗口句柄，与活动选项卡
+//! 的内容窗口比对，从而定位当前正在浏览的选项卡（`IsWindowVisible` 对所有
+//! 选项卡都成立，不可用）。
+
+use std::path::Path;
+
+#[cfg(windows)]
+use windows::core::ComInterface;
+#[cfg(windows)]
+use windows::Win32::Foundation::HWND;
+#[cfg(windows)]
+use windows::Win32::System::Com::{
+    CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_ALL, COINIT_APARTMENTTHREADED,
+    IServiceProvider,
+};
+#[cfg(windows)]
+use windows::Win32::System::Variant::{VARIANT, VT_I4};
+#[cfg(windows)]
+use windows::Win32::UI::Shell::{
+    IWebBrowserApp, IShellBrowser, IShellWindows, ShellWindows,
+};
+#[cfg(windows)]
+use windows::Win32::UI::WindowsAndMessaging::{
+    GetClassNameW, GetForegroundWindow, GetWindow, GW_CHILD, GW_HWNDNEXT,
+};
+
+/// 检测前台 Explorer 窗口的当前目录。
+/// 返回 `None`：前台不是 Explorer / COM 初始化失败 / URL 无法转路径。
+#[cfg(windows)]
+pub fn detect_explorer_folder() -> Option<String> {
+    // 首次 COM 初始化失败（例如已在 MTA 线程）时，后续 COM 调用一般仍可用，忽略错误继续。
+    let _ = unsafe { CoInitializeEx(None, COINIT_APARTMENTTHREADED) };
+    let fg = unsafe { GetForegroundWindow() };
+    let result = if fg.0 == 0 {
+        None
+    } else {
+        unsafe { find_folder_for_hwnd(fg) }
+    };
+    unsafe { CoUninitialize() };
+    result
+}
+
+#[cfg(windows)]
+unsafe fn find_folder_for_hwnd(fg: HWND) -> Option<String> {
+    let shell: IShellWindows = CoCreateInstance(&ShellWindows, None, CLSCTX_ALL).ok()?;
+    let count = shell.Count().ok()?;
+    // Win11 多选项卡：活动选项卡的内容窗口（ShellTabWindowClass）在子窗口 z-order
+    // 顶层。在 IShellWindows 条目中，用 IShellBrowser::GetWindow() 取到的内容窗口
+    // HWND 与它比对，即可定位当前正在浏览的选项卡（IsWindowVisible 对所有选项卡
+    // 都成立，不可用）。
+    let active_tab = find_active_shell_tab(fg);
+    for i in 0..count {
+        // 索引过期的窗口会返回失败，跳过继续即可，不能 `?` 提前结束整个循环。
+        // 0.52 的 Win32 VARIANT 无 From<i32>，手动构造 VT_I4 变体。
+        let mut index = VARIANT::default();
+        {
+            let value = &mut *index.Anonymous.Anonymous;
+            value.vt = VT_I4;
+            value.Anonymous.lVal = i;
+        }
+        let Ok(dispatch) = shell.Item(index) else { continue };
+        let Ok(app) = dispatch.cast::<IWebBrowserApp>() else { continue };
+        // 只考虑前台顶层窗口对应的条目；同一窗口的多个选项卡条目共享顶层句柄。
+        let Ok(hwnd) = app.HWND() else { continue };
+        if HWND(hwnd.0) != fg {
+            continue;
+        }
+        // 有选项卡时，必须匹配活动选项卡的内容窗口；否则退化为任意条目（旧版无选项卡）。
+        if let Some(active) = active_tab {
+            let Ok(svc) = app.cast::<IServiceProvider>() else { continue };
+            let Ok(browser) = svc.QueryService::<IShellBrowser>(&IShellBrowser::IID) else {
+                continue;
+            };
+            let Ok(this_tab) = browser.GetWindow() else { continue };
+            if this_tab != active {
+                continue;
+            }
+        }
+        if let Ok(url) = app.LocationURL() {
+            return url_to_path(&url.to_string());
+        }
+    }
+    None
+}
+
+/// 枚举前台窗口的子窗口（z-order 自上而下），返回第一个类名为 `ShellTabWindowClass`
+/// 的窗口句柄，即 Win11 资源管理器活动选项卡的内容窗口；无选项卡时返回 `None`。
+#[cfg(windows)]
+unsafe fn find_active_shell_tab(fg: HWND) -> Option<HWND> {
+    const CLASS: &str = "ShellTabWindowClass";
+    let mut hwnd = GetWindow(fg, GW_CHILD);
+    while hwnd.0 != 0 {
+        let mut buf = [0u16; 64];
+        let len = GetClassNameW(hwnd, &mut buf);
+        if len > 0 {
+            let name = String::from_utf16_lossy(&buf[..len as usize]);
+            if name == CLASS {
+                return Some(hwnd);
+            }
+        }
+        hwnd = GetWindow(hwnd, GW_HWNDNEXT);
+    }
+    None
+}
+
+/// 把 `file:///C:/xxx`（可能带百分号编码）转成本地路径，仅接受目录。
+#[cfg(windows)]
+fn url_to_path(url: &str) -> Option<String> {
+    if !url.starts_with("file:") {
+        return None;
+    }
+    let parsed = url::Url::parse(url).ok()?;
+    let path = parsed.to_file_path().ok()?;
+    let path = Path::new(&path);
+    if path.is_dir() {
+        Some(path.to_string_lossy().to_string())
+    } else {
+        None
+    }
+}
+
+/// 非 Windows 平台占位：保持模块可编译。
+#[cfg(not(windows))]
+pub fn detect_explorer_folder() -> Option<String> {
+    None
+}

src-tauri/src/quickpanel/file_index.rs

@@ -6,6 +6,7 @@
 
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::UNIX_EPOCH;
 
 use rusqlite::{params, Connection};
@@ -13,8 +14,10 @@ use serde::Serialize;
 use tauri::{AppHandle, Manager};
 use walkdir::WalkDir;
 
+use specta::Type;
+
 /// 单个文件记录（返回给前端）
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct FileRecord {
     pub path: String,
@@ -25,7 +28,7 @@ pub struct FileRecord {
 }
 
 /// 索引状态（返回给前端）
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct IndexStats {
     pub total: i64,
@@ -61,7 +64,7 @@ pub fn init(app: &AppHandle) {
     let conn = match Connection::open(&path) {
         Ok(c) => c,
         Err(e) => {
-            eprintln!("[quickpanel] 文件索引 DB 初始化失败: {}", e);
+            crate::logger::log_error("quickpanel", &format!("文件索引 DB 初始化失败: {}", e));
             return;
         }
     };
@@ -84,11 +87,22 @@ pub fn init(app: &AppHandle) {
         );",
     );
 
-    let mut guard = index_slot().lock().unwrap();
+    let mut guard = index_slot().lock().unwrap_or_else(|e| e.into_inner());
     *guard = Some(Inner {
         conn: Mutex::new(conn),
     });
-    eprintln!("[quickpanel] 文件索引 DB 已就绪: {}", path.display());
+    crate::logger::log_info("quickpanel", &format!("文件索引 DB 已就绪: {}", path.display()));
+}
+
+/// 懒加载：首次访问文件索引时自动初始化（若尚未初始化）。
+/// 避免应用启动时即打开 SQLite 连接，降低启动 IO 开销。
+pub fn ensure_initialized(app: &AppHandle) {
+    let guard = index_slot().lock().unwrap_or_else(|e| e.into_inner());
+    if guard.is_some() {
+        return;
+    }
+    drop(guard);
+    init(app);
 }
 
 /// 判断索引是否已初始化
@@ -96,7 +110,7 @@ fn with_conn<F, R>(f: F) -> Option<R>
 where
     F: FnOnce(&Connection) -> R,
 {
-    let guard = index_slot().lock().unwrap();
+    let guard = index_slot().lock().unwrap_or_else(|e| e.into_inner());
     if let Some(inner) = guard.as_ref() {
         if let Ok(conn) = inner.conn.lock() {
             return Some(f(&conn));
@@ -105,10 +119,37 @@ where
     None
 }
 
+/// 构建锁：防止手动构建与闲时自动构建并发执行（全量重建含 DELETE+INSERT，
+/// 两个构建交错会互相清空对方刚写入的数据，导致索引残缺）。
+static BUILDING: AtomicBool = AtomicBool::new(false);
+
+/// 尝试开始构建；已在构建中则返回 false。
+pub fn try_begin_build() -> bool {
+    BUILDING
+        .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+        .is_ok()
+}
+
+/// 构建结束（成功/失败）后调用，释放构建锁。
+pub fn end_build() {
+    BUILDING.store(false, Ordering::SeqCst);
+}
+
 /// 遍历指定目录列表建立索引（全量重建）。
 /// 返回索引条目数。在 spawn_blocking 中调用。
 /// 重建完成后自动启动 notify 监听器做增量更新。
+/// 若已有构建正在进行（手动/自动并发），直接返回 Ok(0)，由进行中的构建负责更新索引。
 pub fn build_index(dirs: &[String]) -> Result<i64, String> {
+    if !try_begin_build() {
+        crate::logger::log_info("quickpanel", "索引构建已在进行中，跳过本次请求");
+        return Ok(0);
+    }
+    let result = build_index_inner(dirs);
+    end_build();
+    result
+}
+
+fn build_index_inner(dirs: &[String]) -> Result<i64, String> {
     // 清空旧数据
     let cleared = with_conn(|conn| {
         conn.execute("DELETE FROM files", []).ok()
@@ -140,7 +181,7 @@ pub fn build_index(dirs: &[String]) -> Result<i64, String> {
     // 启动/刷新 notify 监听器
     start_watcher(dirs);
 
-    eprintln!("[quickpanel] 文件索引完成，共 {} 条", count);
+    crate::logger::log_info("quickpanel", &format!("文件索引完成，共 {} 条", count));
     Ok(count)
 }
 
@@ -203,10 +244,13 @@ fn upsert_path(p: &Path) -> bool {
 fn remove_path(p: &Path) {
     let path_str = p.to_string_lossy().to_string();
     let _ = with_conn(|conn| {
-        // 删除该路径及其子项（目录被删除时，子文件也失效）
+        // 删除该路径本身及其直接子项（目录被删除时，子文件也失效）。
+        // 用"路径 + 分隔符"的前缀匹配（而非裸前缀），避免误删 dir2/directory 等兄弟目录。
+        let backslash_prefix = format!("{}\\{}", path_str, "%");
+        let slash_prefix = format!("{}/{}", path_str, "%");
         conn.execute(
-            "DELETE FROM files WHERE path = ?1 OR path LIKE ?2",
-            params![path_str, format!("{}%", path_str)],
+            "DELETE FROM files WHERE path = ?1 OR path LIKE ?2 OR path LIKE ?3",
+            params![path_str, backslash_prefix, slash_prefix],
         )
     });
 }
@@ -306,7 +350,7 @@ pub fn start_watcher(dirs: &[String]) {
     ) {
         Ok(w) => w,
         Err(e) => {
-            eprintln!("[quickpanel] notify watcher 创建失败: {}", e);
+            crate::logger::log_error("quickpanel", &format!("notify watcher 创建失败: {}", e));
             return;
         }
     };
@@ -318,26 +362,61 @@ pub fn start_watcher(dirs: &[String]) {
             continue;
         }
         if let Err(e) = watcher.watch(path, RecursiveMode::Recursive) {
-            eprintln!("[quickpanel] watch {} 失败: {}", dir, e);
+            crate::logger::log_error("quickpanel", &format!("watch {} 失败: {}", dir, e));
         }
     }
 
     // 替换旧 watcher（drop 时自动 unwatch）
-    let mut guard = watcher_slot().lock().unwrap();
+    let mut guard = watcher_slot().lock().unwrap_or_else(|e| e.into_inner());
     *guard = Some(watcher);
-    eprintln!("[quickpanel] notify 监听已启动，监听 {} 个目录", dirs.len());
+    crate::logger::log_info("quickpanel", &format!("notify 监听已启动，监听 {} 个目录", dirs.len()));
 }
 
-/// 处理文件系统事件：创建/修改 → upsert，删除 → remove，重命名 → remove + upsert
+/// 处理文件系统事件：
+/// - 创建/数据或元数据修改 → upsert
+/// - 重命名：旧路径(From) → remove，新路径(To) → upsert
+/// - 删除 → remove
 fn handle_fs_event(event: &notify::Event) {
+    use notify::event::{ModifyKind, RenameMode};
+
     match event.kind {
-        EventKind::Create(_) | EventKind::Modify(_) => {
+        // 创建、数据/元数据修改、类型未知 → upsert
+        EventKind::Create(_)
+        | EventKind::Modify(ModifyKind::Data(_))
+        | EventKind::Modify(ModifyKind::Metadata(_))
+        | EventKind::Modify(ModifyKind::Other)
+        | EventKind::Modify(ModifyKind::Any) => {
             for path in &event.paths {
                 if path.exists() {
                     upsert_path(path);
                 }
             }
         }
+        // 重命名旧路径 → 删除旧记录（含目录子项，避免索引残留失效路径）
+        EventKind::Modify(ModifyKind::Name(RenameMode::From)) => {
+            for path in &event.paths {
+                remove_path(path);
+            }
+        }
+        // 重命名新路径 → 写入新记录
+        EventKind::Modify(ModifyKind::Name(RenameMode::To)) => {
+            for path in &event.paths {
+                if path.exists() {
+                    upsert_path(path);
+                }
+            }
+        }
+        // 重命名模式未知：存在则写入，不存在则删除（幂等兜底）
+        EventKind::Modify(ModifyKind::Name(RenameMode::Any | RenameMode::Both)) => {
+            for path in &event.paths {
+                if path.exists() {
+                    upsert_path(path);
+                } else {
+                    remove_path(path);
+                }
+            }
+        }
+        // 删除 → remove（含子项）
         EventKind::Remove(_) => {
             for path in &event.paths {
                 remove_path(path);
@@ -348,9 +427,3 @@ fn handle_fs_event(event: &notify::Event) {
         }
     }
 }
-
-/// 停止 notify 监听器
-pub fn stop_watcher() {
-    let mut guard = watcher_slot().lock().unwrap();
-    *guard = None;
-}

src-tauri/src/quickpanel/icon_extractor.rs

@@ -10,7 +10,7 @@
 //! - 返回 base64 data URL 而非文件路径，避免独立弹窗窗口的 asset 协议配置问题
 //! - 磁盘缓存避免重复 Windows API 调用（昂贵），内存缓存避免重复磁盘读取 + 编码
 
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 use std::path::PathBuf;
 use std::sync::Mutex;
 
@@ -18,26 +18,32 @@ use base64::Engine as _;
 use tauri::{AppHandle, Manager};
 
 // ===== 内存缓存 =====
-static MEM_CACHE: Mutex<Option<HashMap<String, String>>> = Mutex::new(None);
+/// (path → data URL) + FIFO 淘汰队列（队头最旧，超限时先淘汰）
+static MEM_CACHE: Mutex<Option<(HashMap<String, String>, VecDeque<String>)>> = Mutex::new(None);
 const MEM_CACHE_MAX: usize = 512;
 
 fn mem_get(path: &str) -> Option<String> {
     let cache = MEM_CACHE.lock().ok()?;
-    cache.as_ref()?.get(path).cloned()
+    cache.as_ref()?.0.get(path).cloned()
 }
 
 fn mem_put(path: String, url: String) {
     if let Ok(mut guard) = MEM_CACHE.lock() {
-        let map = guard.get_or_insert_with(HashMap::new);
+        let slot = guard.get_or_insert_with(|| (HashMap::new(), VecDeque::new()));
+        let (map, order) = &mut *slot;
+        if map.contains_key(&path) {
+            // 已存在：仅更新值，不重复入队
+            map.insert(path, url);
+            return;
+        }
         if map.len() >= MEM_CACHE_MAX {
-            // 简单清理：丢弃一半（最早插入的，HashMap 无序，近似随机）
-            let keep = map.len() / 2;
-            let keys: Vec<String> = map.keys().cloned().collect();
-            for k in keys.iter().skip(keep) {
-                map.remove(k);
+            // FIFO 淘汰最旧条目（O(1)），避免无序淘汰把刚插入的常用图标清掉
+            if let Some(oldest) = order.pop_front() {
+                map.remove(&oldest);
             }
         }
-        map.insert(path, url);
+        map.insert(path.clone(), url);
+        order.push_back(path);
     }
 }
 

src-tauri/src/quickpanel/mod.rs

@@ -4,21 +4,27 @@
 //! Phase 2：fuzzy + 拼音引擎，command/calc/web/system Provider
 //! Phase 3：文件索引（walkdir + rusqlite）、应用扫描、剪贴板历史复用
 
+pub mod actions;
 pub mod app_scanner;
 pub mod commands;
+pub mod explorer;
 pub mod file_index;
 pub mod icon_extractor;
 pub mod popup;
 pub mod special_locations;
 
+pub use actions::{
+    quickpanel_apply_rename, quickpanel_batch_extract, quickpanel_list_archives,
+    quickpanel_list_dir, quickpanel_preview_rename,
+};
 pub use commands::{
     quickpanel_build_file_index, quickpanel_clear_app_icon_cache, quickpanel_delete_file,
-    quickpanel_file_index_stats, quickpanel_get_app_icon, quickpanel_get_settings,
-    quickpanel_get_special_locations, quickpanel_hide_popup, quickpanel_init_file_index,
-    quickpanel_lock_screen, quickpanel_open_file, quickpanel_open_special,
-    quickpanel_register_shortcut, quickpanel_reveal_in_explorer, quickpanel_run_custom_command,
-    quickpanel_run_system_command, quickpanel_save_settings, quickpanel_scan_apps,
-    quickpanel_search_files, quickpanel_show_popup, quickpanel_show_window,
-    quickpanel_unregister_shortcut,
+    quickpanel_delete_files, quickpanel_file_index_stats, quickpanel_focus_main_window,
+    quickpanel_get_app_icon, quickpanel_get_settings, quickpanel_get_special_locations,
+    quickpanel_hide_popup, quickpanel_init_file_index, quickpanel_lock_screen,
+    quickpanel_open_file, quickpanel_open_special, quickpanel_register_shortcut,
+    quickpanel_reveal_in_explorer, quickpanel_run_custom_command, quickpanel_run_system_command,
+    quickpanel_save_settings, quickpanel_scan_apps, quickpanel_search_files, quickpanel_show_popup,
+    quickpanel_show_window, quickpanel_unregister_shortcut,
 };
-pub use popup::{ensure_window, load_settings, register_shortcut};
+pub use popup::{ensure_window, load_settings};

src-tauri/src/quickpanel/popup.rs

@@ -13,13 +13,17 @@
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::path::PathBuf;
+use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
 use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder};
 use tauri::window::{Effect, EffectsBuilder};
-use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
 
-use crate::clipboard::popup::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};
+use crate::win32_util::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};
+
+use super::explorer;
+
+use specta::Type;
 
 /// 弹窗窗口标签
 pub const POPUP_LABEL: &str = "quick-panel";
@@ -28,15 +32,76 @@ pub const POPUP_LABEL: &str = "quick-panel";
 const WIN_W: f64 = 600.0;
 const WIN_H: f64 = 420.0;
 
-/// 当前注册的快捷键（用于注销旧快捷键）
-static CURRENT_SHORTCUT: Mutex<Option<String>> = Mutex::new(None);
+/// `quickpanel-show` 事件负载：携带快捷键按下时检测到的 Explorer 当前目录，
+/// 前端据此渲染"当前目录"文件操作分组。
+#[derive(Clone, Serialize)]
+pub struct QuickPanelShowPayload {
+    pub dir: Option<String>,
+}
+
+/// 检测前台 Explorer 目录并连同 show 事件一起下发。
+/// 必须在快捷键回调内调用：此时前台窗口仍是 Explorer，面板尚未抢焦点。
+fn emit_show(app: &AppHandle) {
+    let dir = explorer::detect_explorer_folder();
+    crate::logger::log_info("quickpanel", &format!("show_popup: explorer_dir={:?}", dir));
+    let _ = app.emit(
+        crate::constants::events::QUICKPANEL_SHOW,
+        QuickPanelShowPayload { dir },
+    );
+}
 
 /// 标志：show_popup 兜底创建路径设为 true，前端 onMounted 回调 show_window 时据此判断是否显示。
 /// 预创建路径不设置，避免应用启动时弹窗自动弹出。
 static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
 
+/// 兜底创建路径下 show_popup 计算出的待显示位置（物理坐标），供 show_window 应用，
+/// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。
+static PENDING_POS: Mutex<Option<(f64, f64)>> = Mutex::new(None);
+
+/// 失焦隐藏的宽限期：show 后窗口激活期间焦点可能短暂弹跳（透明 + focus:false 的
+/// WebView2 窗口在透明激活时尤其容易出现），导致 Focused(false) 紧跟在 show 之后
+/// 触发并把刚显示的窗口立即隐藏。距上次 show 不足该时长的失焦事件直接忽略。
+const SHOW_GRACE: Duration = Duration::from_millis(500);
+
+/// 最近一次 show 的时间，用于失焦宽限期判断。
+static LAST_SHOWN: Mutex<Option<Instant>> = Mutex::new(None);
+
+/// 标记"已发起显示"，并记录时间供失焦宽限期使用。
+fn mark_shown() {
+    if let Ok(mut t) = LAST_SHOWN.lock() {
+        *t = Some(Instant::now());
+    }
+}
+
+/// 判断距上次 show 是否仍在宽限期内（是则忽略失焦自动隐藏）。
+fn within_show_grace() -> bool {
+    LAST_SHOWN
+        .lock()
+        .ok()
+        .and_then(|t| *t)
+        .map(|t| t.elapsed() < SHOW_GRACE)
+        .unwrap_or(false)
+}
+
+/// 显示窗口并确保其到达前台。
+/// set_focus 受 Windows 前台锁定限制，可能静默失败；此时用 win32_util::force_foreground
+/// （模拟 Alt 释放重置前台锁定 + SetForegroundWindow + BringWindowToTop）兜底。
+fn show_and_focus(win: &tauri::WebviewWindow) {
+    if let Err(e) = win.show() {
+        crate::logger::log_error("quickpanel", &format!("show popup failed: {}", e));
+    }
+    mark_shown();
+    let focused = win.set_focus();
+    if focused.is_err() {
+        // set_focus 被前台锁定拒绝时，退回到强制置前（与主窗口焦点命令同法）
+        if let Ok(hwnd) = win.hwnd() {
+            crate::win32_util::force_foreground(hwnd.0 as isize);
+        }
+    }
+}
+
 /// 自定义命令
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct CustomCommand {
     pub id: String,
@@ -47,7 +112,7 @@ pub struct CustomCommand {
 }
 
 /// 快速面板设置
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct QuickPanelSettings {
     /// 全局快捷键（如 "Alt+Space"），空字符串表示不注册。
@@ -131,56 +196,6 @@ pub fn save_settings(app: &AppHandle, settings: &QuickPanelSettings) -> Result<(
     std::fs::write(&path, json).map_err(|e| format!("写入设置文件失败: {}", e))
 }
 
-/// 解析快捷键字符串为 Shortcut（格式如 "Alt+Space"、"Ctrl+Shift+P"）
-/// 失败返回 None。
-pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
-    s.trim().parse::<Shortcut>().ok()
-}
-
-/// 注册全局快捷键。重复调用会先注销旧快捷键。
-/// 传入空字符串则仅注销不注册。
-pub fn register_shortcut(app: &AppHandle, shortcut_str: &str) -> Result<(), String> {
-    // 先注销旧快捷键
-    unregister_shortcut(app);
-
-    if shortcut_str.trim().is_empty() {
-        return Ok(());
-    }
-
-    let shortcut = parse_shortcut(shortcut_str)
-        .ok_or_else(|| format!("无效的快捷键: {}", shortcut_str))?;
-
-    let app_handle = app.clone();
-    app.global_shortcut()
-        .on_shortcut(shortcut, move |_app, _shortcut, event| {
-            // 仅在按下时触发（松开不触发）
-            if event.state == ShortcutState::Pressed {
-                show_popup(&app_handle);
-            }
-        })
-        .map_err(|e| format!("注册快捷键失败: {}", e))?;
-
-    if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
-        *cur = Some(shortcut_str.to_string());
-    }
-    eprintln!("[quickpanel] 已注册快捷键: {}", shortcut_str);
-    Ok(())
-}
-
-/// 注销当前快捷键
-pub fn unregister_shortcut(app: &AppHandle) {
-    if let Ok(cur) = CURRENT_SHORTCUT.lock() {
-        if let Some(ref s) = *cur {
-            if let Some(shortcut) = parse_shortcut(s) {
-                let _ = app.global_shortcut().unregister(shortcut);
-            }
-        }
-    }
-    if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
-        *cur = None;
-    }
-}
-
 /// 创建弹窗窗口（隐藏状态）并注册失焦监听。
 /// 位置默认在屏幕外，show_popup 时会重新定位到鼠标所在显示器中央。
 /// 预创建后首次按快捷键走"窗口已存在"分支直接 show，避免首次创建的时序问题。
@@ -206,22 +221,26 @@ fn create_popup_window(app: &AppHandle) {
     {
         Ok(w) => w,
         Err(e) => {
-            eprintln!("[quickpanel] 创建弹窗失败: {}", e);
+            crate::logger::log_error("quickpanel", &format!("创建弹窗失败: {}", e));
             return;
         }
     };
 
     // 监听窗口失焦：自动隐藏
+    // 距上次 show 不足宽限期（激活中焦点弹跳）的失焦事件忽略，避免弹窗刚显示就被隐藏
     let app_handle = app.clone();
     let win_handle = win.clone();
     win.on_window_event(move |event| {
         if let tauri::WindowEvent::Focused(false) = event {
+            if within_show_grace() {
+                return;
+            }
             let _ = win_handle.hide();
-            let _ = app_handle.emit("quickpanel-hide", ());
+            let _ = app_handle.emit(crate::constants::events::QUICKPANEL_HIDE, ());
         }
     });
 
-    eprintln!("[quickpanel] 弹窗窗口已预创建（隐藏状态）");
+    crate::logger::log_info("quickpanel", "弹窗窗口已预创建（隐藏状态）");
 }
 
 /// 应用启动时预创建弹窗窗口（隐藏）。
@@ -237,6 +256,7 @@ pub fn ensure_window(app: &AppHandle) {
 /// popup_position = "cursor" 时在鼠标位置附近显示，否则在鼠标所在显示器中央显示。
 /// 窗口不存在则创建（隐藏状态，等前端挂载后调用 show_window 显示）。
 pub fn show_popup(app: &AppHandle) {
+    crate::logger::log_info("quickpanel", "show_popup triggered");
     let settings = load_settings(app);
     let cursor_mode = settings.popup_position == "cursor";
 
@@ -250,56 +270,80 @@ pub fn show_popup(app: &AppHandle) {
     let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx, my)
         .unwrap_or((0, 0, 1920, 1040));
 
-    // 获取光标所在显示器的 DPI，将物理坐标转为逻辑坐标（DIP）
+    // 光标所在显示器的 DPI：窗口尺寸需按物理像素换算
     let dpi = get_dpi_for_point(mx, my).unwrap_or(96);
     let scale = dpi as f64 / 96.0;
+    let win_w_px = WIN_W * scale;
+    let win_h_px = WIN_H * scale;
 
-    let wa_left_l = wa_left as f64 / scale;
-    let wa_top_l = wa_top as f64 / scale;
-    let wa_right_l = wa_right as f64 / scale;
-    let wa_bottom_l = wa_bottom as f64 / scale;
-
+    // 直接以物理坐标计算（光标 + 工作区均为物理像素，避免混合 DPI 下换算偏移）
     let (x, y) = if cursor_mode {
         // 鼠标位置模式：以鼠标为基准偏移，clamp 到工作区内
-        let mx_l = mx as f64 / scale;
-        let my_l = my as f64 / scale;
-        let x = (mx_l + 12.0).min(wa_right_l - WIN_W).max(wa_left_l);
-        let y = (my_l + 12.0).min(wa_bottom_l - WIN_H).max(wa_top_l);
+        let x = (mx as f64 + 12.0 * scale).min(wa_right as f64 - win_w_px).max(wa_left as f64);
+        let y = (my as f64 + 12.0 * scale).min(wa_bottom as f64 - win_h_px).max(wa_top as f64);
         (x, y)
     } else {
         // 中央模式：窗口居中于鼠标所在显示器工作区
-        let wa_w = wa_right_l - wa_left_l;
-        let wa_h = wa_bottom_l - wa_top_l;
-        (wa_left_l + (wa_w - WIN_W) / 2.0, wa_top_l + (wa_h - WIN_H) / 2.0)
+        let wa_w = (wa_right - wa_left) as f64;
+        let wa_h = (wa_bottom - wa_top) as f64;
+        (
+            wa_left as f64 + (wa_w - win_w_px) / 2.0,
+            wa_top as f64 + (wa_h - win_h_px) / 2.0,
+        )
     };
 
     // 窗口已存在：移动 + 显示 + 请求焦点
     if let Some(win) = app.get_webview_window(POPUP_LABEL) {
-        let _ = win.set_position(tauri::Position::Logical(tauri::LogicalPosition { x, y }));
-        let _ = win.show();
-        let _ = win.set_focus();
-        // 通知前端刷新数据
-        let _ = app.emit("quickpanel-show", ());
+        // 必须先于窗口显示/聚焦检测 Explorer 目录：show/set_focus 会立即抢走前台焦点，
+        // 之后调用 GetForegroundWindow 拿到的就是面板自身了。
+        emit_show(app);
+        let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
+            x: x as i32,
+            y: y as i32,
+        }));
+        show_and_focus(&win);
         return;
     }
 
     // 兜底：窗口被销毁时重新创建（隐藏），等前端 onMounted 回调 show_window
     POPUP_PENDING_SHOW.store(true, Ordering::SeqCst);
+    if let Ok(mut pos) = PENDING_POS.lock() {
+        *pos = Some((x, y));
+    }
     create_popup_window(app);
 }
 
 /// 显示已创建的弹窗窗口（由前端 onMounted 后调用）。
-/// 预创建路径下前端 onMounted 也会调用此函数，但 POPUP_PENDING_SHOW 为 false 时直接跳过，
-/// 避免应用启动时弹窗自动弹出。仅 show_popup 兜底创建路径才真正显示。
+///
+/// 两个路径：
+/// 1. 预创建路径（POPUP_PENDING_SHOW = false）：show_popup 已调用 show_and_focus 显示窗口，
+///    但若 Vue 尚未挂载，quickpanel-show 事件可能丢失。检查窗口是否可见，若可见则重新发送事件。
+/// 2. 兜底创建路径（POPUP_PENDING_SHOW = true）：窗口尚未显示，位置为 PENDING_POS，
+///    先定位再发事件最后显示+聚焦。
 pub fn show_window(app: &AppHandle) {
     if !POPUP_PENDING_SHOW.swap(false, Ordering::SeqCst) {
+        // 预创建路径：窗口已由 show_popup 显示，但事件可能因前端未挂载而丢失。
+        // 窗口可见时重新发送事件，让刚注册的监听器处理（清空输入、聚焦、刷新等）。
+        if let Some(win) = app.get_webview_window(POPUP_LABEL) {
+            if win.is_visible().unwrap_or(false) {
+                emit_show(app);
+            }
+        }
         return;
     }
+    // 兜底创建路径：show_popup 兜底重建，窗口尚未显示
     if let Some(win) = app.get_webview_window(POPUP_LABEL) {
-        let _ = win.show();
-        let _ = win.set_focus();
-        // 通知前端刷新数据
-        let _ = app.emit("quickpanel-show", ());
+        // 应用 show_popup 计算的兜底位置（物理坐标），避免停留在屏幕外
+        let pos = PENDING_POS.lock().ok().and_then(|p| *p);
+        if let Some((x, y)) = pos {
+            let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
+                x: x as i32,
+                y: y as i32,
+            }));
+        }
+        // 同样先检测 Explorer 目录再显示，避免面板抢焦点导致检测失败。
+        emit_show(app);
+        show_and_focus(&win);
     }
 }
 

src-tauri/src/quickpanel/special_locations.rs

@@ -9,8 +9,10 @@
 use std::path::PathBuf;
 use serde::Serialize;
 
+use specta::Type;
+
 /// 快捷位置条目
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct SpecialLocation {
     pub id: String,

src-tauri/src/screenshot/capture.rs

@@ -3,7 +3,8 @@
 //! 实现：
 //! - 全屏（虚拟屏）捕获：BitBlt 从屏幕 DC 拷贝到兼容位图，GetDIBits 取像素
 //! - 窗口捕获：PrintWindow(PW_RENDERFULLCONTENT) 捕获 DWM 内容（覆盖硬件加速窗口）
-//! - 窗口拾取：EnumWindows 按 Z 序命中测试（排除本进程窗口，避免命中覆盖层自身）
+//! - 窗口拾取：pick_windows 枚举 Z 序窗口列表（排除本进程，避免命中覆盖层自身），
+//!   前端缓存列表后本地命中测试
 //! - 顶层窗口枚举：EnumWindows
 //! - 像素 → PNG / CF_DIB 转换
 //!
@@ -276,18 +277,16 @@ pub fn capture_window(hwnd: isize) -> Result<CapturedImage, String> {
     }
 }
 
-/// 获取指定屏幕坐标下的顶层窗口（窗口拾取）
+/// 枚举可拾取的顶层窗口（Z 序顶→底）
 ///
-/// 入参 x/y 为物理屏幕坐标（前端需按显示器 scaleFactor 从逻辑坐标换算）。
-///
-/// 不能直接用 WindowFromPoint：覆盖层是 alwaysOnTop 全屏窗口，会命中覆盖层自身。
-/// 改为 EnumWindows 按 Z 序（顶→底）枚举顶层窗口做命中测试，并排除本进程
-/// （覆盖层/主窗口/编辑器）的窗口，从而取到覆盖层下面的目标窗口。
-pub fn window_from_point(x: i32, y: i32) -> Option<WindowInfo> {
+/// 与逐点拾取同语义：排除本进程窗口（覆盖层/主窗口/编辑器）、不可见窗口、工具窗口。
+/// 前端在截图开始时缓存该列表，鼠标移动时在 JS 侧做命中测试（rect 包含点，取 Z 序
+/// 最顶的第一个命中），消除逐帧 window_from_point 的 IPC 往返；且列表与冻结底图
+/// 同一时刻生成，命中结果与画面严格一致。
+pub fn pick_windows() -> Vec<WindowInfo> {
     struct PickContext {
         my_pid: u32,
-        pt: POINT,
-        found: Option<WindowInfo>,
+        out: Vec<WindowInfo>,
     }
 
     extern "system" fn enum_proc(hwnd: HWND, lparam: isize) -> i32 {
@@ -311,30 +310,24 @@ pub fn window_from_point(x: i32, y: i32) -> Option<WindowInfo> {
             if GetWindowRect(hwnd, &mut rect) == 0 {
                 return 1;
             }
-            // 命中测试（物理坐标），Z 序最顶层的第一个命中即为目标
-            let pt = ctx.pt;
-            if pt.x >= rect.left && pt.x < rect.right && pt.y >= rect.top && pt.y < rect.bottom {
-                ctx.found = Some(WindowInfo {
-                    hwnd,
-                    title: get_window_title(hwnd),
-                    rect: ScreenRect::from(rect),
-                    visual_rect: extended_frame_bounds(hwnd),
-                });
-                return 0; // 停止枚举
-            }
+            ctx.out.push(WindowInfo {
+                hwnd,
+                title: get_window_title(hwnd),
+                rect: ScreenRect::from(rect),
+                visual_rect: extended_frame_bounds(hwnd),
+            });
         }
         1
     }
 
     let mut ctx = PickContext {
         my_pid: std::process::id(),
-        pt: POINT { x, y },
-        found: None,
+        out: Vec::new(),
     };
     unsafe {
         EnumWindows(Some(enum_proc), &mut ctx as *mut _ as isize);
     }
-    ctx.found
+    ctx.out
 }
 
 /// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口）

src-tauri/src/screenshot/commands.rs

@@ -1,12 +1,13 @@
 //! Tauri 命令：截图模块
 //!
 //! 命令清单：
-//! - screenshot_capture_fullscreen：捕获虚拟屏并存入静态（不做 PNG 编码）
+//! - screenshot_capture_fullscreen：捕获虚拟屏并存入静态（不做 PNG 编码），返回捕获时刻光标坐标
 //! - screenshot_get_fullscreen_bmp：取出全屏捕获的 BMP 原始字节（raw IPC，覆盖层显示用，不移除）
 //! - screenshot_fullscreen_png：全屏捕获编码 PNG base64 并清除（全屏截图进编辑器用）
 //! - screenshot_clear_fullscreen：清除静态全屏捕获（覆盖层关闭时）
 //! - screenshot_crop_stored：按物理像素裁剪已存储的全屏捕获
-//! - screenshot_window_from_point：拾取指定屏幕坐标下的顶层窗口
+//! - screenshot_pick_list：枚举可拾取顶层窗口（Z 序，前端缓存后本地命中测试）
+//! - screenshot_show_overlay：一次 IPC 完成覆盖层 show + focus（关键路径减少往返）
 //! - screenshot_enum_windows：枚举可见顶层窗口
 //! - screenshot_capture_window：按 hwnd 捕获指定窗口
 //! - screenshot_set_editor_image / screenshot_get_editor_image：编辑器图片传递
@@ -14,11 +15,12 @@
 //! - screenshot_save_png：写入文件
 //! - screenshot_disable_transitions：禁用窗口显示/隐藏过渡动画（消除覆盖层缩放动画）
 
-use super::{CaptureData, WindowInfo};
-use tauri::Manager;
+use super::{CaptureData, CaptureStart, WindowInfo};
+use tauri::{Emitter, Manager};
 
 /// 禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_disable_transitions(
     app: tauri::AppHandle,
     label: String,
@@ -48,29 +50,58 @@ pub async fn screenshot_disable_transitions(
 
 /// 注册（或切换）截图全局快捷键。传入空字符串则禁用快捷键。
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_register_shortcut(
     app: tauri::AppHandle,
     shortcut: String,
 ) -> Result<(), String> {
-    super::shortcut::register_shortcut(&app, &shortcut)
+    crate::shortcut::register_shortcut(&app, "截图", &shortcut, |a| {
+        let _ = a.emit(crate::constants::events::SCREENSHOT_SHORTCUT, ());
+    })
 }
 
 /// 注销截图全局快捷键
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_unregister_shortcut(app: tauri::AppHandle) -> Result<(), String> {
-    super::shortcut::unregister_shortcut(&app);
+    crate::shortcut::unregister_shortcut(&app, "截图");
     Ok(())
 }
 
-/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码
+/// 注册（或切换）贴图全局快捷键。传入空字符串则禁用快捷键。
+/// 按下时 emit 'screenshot-pin-shortcut'，由前端切换贴图窗口显示/隐藏。
 #[tauri::command]
-pub async fn screenshot_capture_fullscreen() -> Result<(), String> {
+#[specta::specta]
+pub async fn screenshot_register_pin_shortcut(
+    app: tauri::AppHandle,
+    shortcut: String,
+) -> Result<(), String> {
+    crate::shortcut::register_shortcut(&app, "贴图", &shortcut, |a| {
+        let _ = a.emit(crate::constants::events::SCREENSHOT_PIN_SHORTCUT, ());
+    })
+}
+
+/// 注销贴图全局快捷键
+#[tauri::command]
+#[specta::specta]
+pub async fn screenshot_unregister_pin_shortcut(app: tauri::AppHandle) -> Result<(), String> {
+    crate::shortcut::unregister_shortcut(&app, "贴图");
+    Ok(())
+}
+
+/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码。
+/// 同时返回捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返）。
+#[tauri::command]
+#[specta::specta]
+pub async fn screenshot_capture_fullscreen() -> Result<CaptureStart, String> {
     #[cfg(windows)]
     {
         // 屏幕捕获涉及 GDI 调用，放线程池避免阻塞 async 调度
         tauri::async_runtime::spawn_blocking(|| {
             let img = super::capture::capture_virtual_screen()?;
-            super::capture::store_fullscreen(img)
+            super::capture::store_fullscreen(img)?;
+            let (cursor_x, cursor_y) = super::capture::cursor_pos().unwrap_or((0, 0));
+            Ok(CaptureStart { cursor_x, cursor_y })
         })
         .await
         .map_err(|e| format!("捕获任务失败: {}", e))?
@@ -101,6 +132,7 @@ pub async fn screenshot_get_fullscreen_bmp() -> Result<tauri::ipc::Response, Str
 
 /// 全屏捕获编码为 PNG base64 并清除（全屏截图直接进编辑器）
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_fullscreen_png() -> Result<CaptureData, String> {
     #[cfg(windows)]
     {
@@ -116,6 +148,7 @@ pub async fn screenshot_fullscreen_png() -> Result<CaptureData, String> {
 
 /// 清除静态全屏捕获（覆盖层关闭/取消时释放内存）
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_clear_fullscreen() -> Result<(), String> {
     #[cfg(windows)]
     {
@@ -130,6 +163,7 @@ pub async fn screenshot_clear_fullscreen() -> Result<(), String> {
 
 /// 按物理像素坐标裁剪已存储的全屏捕获
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_crop_stored(
     x: i32,
     y: i32,
@@ -153,6 +187,7 @@ pub async fn screenshot_crop_stored(
 
 /// 裁剪已存储的全屏捕获并直接写入剪贴板（一次 IPC 完成"裁剪+复制"）
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_crop_copy_stored(
     x: i32,
     y: i32,
@@ -174,29 +209,41 @@ pub async fn screenshot_crop_copy_stored(
     }
 }
 
-/// 拾取指定物理屏幕坐标下的顶层窗口
+/// 枚举可拾取的顶层窗口（Z 序顶→底，排除本进程/不可见/工具窗口）。
+/// 前端在截图开始时缓存列表，鼠标移动时在 JS 侧本地命中测试，消除逐帧 IPC 往返。
 #[tauri::command]
-pub async fn screenshot_window_from_point(
-    x: i32,
-    y: i32,
-) -> Result<Option<WindowInfo>, String> {
+#[specta::specta]
+pub async fn screenshot_pick_list() -> Result<Vec<WindowInfo>, String> {
     #[cfg(windows)]
     {
-        tauri::async_runtime::spawn_blocking(move || {
-            Ok(super::capture::window_from_point(x, y))
-        })
-        .await
-        .map_err(|e| format!("查询失败: {}", e))?
+        tauri::async_runtime::spawn_blocking(super::capture::pick_windows)
+            .await
+            .map_err(|e| format!("枚举失败: {}", e))
     }
     #[cfg(not(windows))]
     {
-        let _ = (x, y);
-        Ok(None)
+        Ok(vec![])
     }
 }
 
-/// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口）
+/// 一次 IPC 完成指定窗口的显示与聚焦（截图覆盖层显示关键路径，减少串行往返）
 #[tauri::command]
+#[specta::specta]
+pub async fn screenshot_show_overlay(
+    app: tauri::AppHandle,
+    label: String,
+) -> Result<(), String> {
+    let win = app
+        .get_webview_window(&label)
+        .ok_or_else(|| format!("窗口不存在: {}", label))?;
+    win.show().map_err(|e| format!("显示窗口失败: {}", e))?;
+    win.set_focus().map_err(|e| format!("聚焦窗口失败: {}", e))?;
+    Ok(())
+}
+
+/// 获取当前鼠标物理屏幕坐标（贴图窗口拖动跟随等场景使用）
+#[tauri::command]
+#[specta::specta]
 pub async fn screenshot_cursor_pos() -> Result<(i32, i32), String> {
     #[cfg(windows)]
     {
@@ -212,6 +259,7 @@ pub async fn screenshot_cursor_pos() -> Result<(i32, i32), String> {
 
 /// 枚举所有可见顶层窗口
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_enum_windows() -> Result<Vec<WindowInfo>, String> {
     #[cfg(windows)]
     {
@@ -227,6 +275,7 @@ pub async fn screenshot_enum_windows() -> Result<Vec<WindowInfo>, String> {
 
 /// 按 hwnd 捕获指定窗口
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, String> {
     #[cfg(windows)]
     {
@@ -250,6 +299,7 @@ pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, Strin
 
 /// 存入编辑器图片（base64 PNG）
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_set_editor_image(png_base64: String) -> Result<(), String> {
     super::set_editor_image(png_base64);
     Ok(())
@@ -257,12 +307,14 @@ pub async fn screenshot_set_editor_image(png_base64: String) -> Result<(), Strin
 
 /// 取出编辑器图片（编辑器窗口加载时调用，取出即清除）
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_get_editor_image() -> Result<Option<String>, String> {
     Ok(super::take_editor_image())
 }
 
 /// 将 PNG base64 写入系统剪贴板（转 CF_DIB）
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
     #[cfg(windows)]
     {
@@ -283,6 +335,7 @@ pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
 ///
 /// 省去前端 toDataURL(PNG 编码+base64) → Rust base64 解码 → PNG 解码 三次往返。
 /// body 格式：前 8 字节 = width(i32 LE) + height(i32 LE)，之后为 raw RGBA 像素。
+/// 注：参数为 tauri::ipc::Request（原始 body），specta 无法生成，豁免标注。
 #[tauri::command]
 pub async fn screenshot_compose_copy(
     request: tauri::ipc::Request<'_>,
@@ -314,6 +367,7 @@ pub async fn screenshot_compose_copy(
 
 /// 将 PNG base64 写入文件
 #[tauri::command]
+#[specta::specta]
 pub async fn screenshot_save_png(png_base64: String, path: String) -> Result<(), String> {
     tauri::async_runtime::spawn_blocking(move || {
         #[cfg(windows)]
@@ -329,3 +383,96 @@ pub async fn screenshot_save_png(png_base64: String, path: String) -> Result<(),
     .await
     .map_err(|e| format!("保存任务失败: {}", e))?
 }
+
+// ===== 截图历史缓存：完整 PNG 落盘到应用数据目录（持久化，随历史保留数量清理），内存只保留缩略图 =====
+
+/// 历史根目录（app_data_dir/screenshot/history）
+fn history_cache_dir(app: &tauri::AppHandle) -> Result<std::path::PathBuf, String> {
+    let dir = app
+        .path()
+        .app_data_dir()
+        .map_err(|e| format!("获取应用数据目录失败: {}", e))?
+        .join("screenshot")
+        .join("history");
+    std::fs::create_dir_all(&dir).map_err(|e| format!("创建历史目录失败: {}", e))?;
+    Ok(dir)
+}
+
+/// 校验 path 属于历史缓存目录（防止路径穿越/任意文件读写）
+fn ensure_in_history_dir(app: &tauri::AppHandle, path: &str) -> Result<std::path::PathBuf, String> {
+    let dir = history_cache_dir(app)?;
+    let p = std::path::PathBuf::from(path);
+    if !p.starts_with(&dir) {
+        return Err("非法路径：不在截图历史缓存目录内".into());
+    }
+    Ok(p)
+}
+
+/// 将完整 PNG 写入历史缓存目录，返回文件路径
+#[tauri::command]
+#[specta::specta]
+pub async fn screenshot_save_cache(
+    app: tauri::AppHandle,
+    png_base64: String,
+) -> Result<String, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let dir = history_cache_dir(&app)?;
+        // 时间戳微秒命名（避免引入额外依赖；并发截图的同微秒碰撞可忽略）
+        let ts = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_micros())
+            .unwrap_or(0);
+        let path = dir.join(format!("{}.png", ts));
+        super::capture::save_png_to_file(&png_base64, &path.to_string_lossy())?;
+        Ok(path.to_string_lossy().into_owned())
+    })
+    .await
+    .map_err(|e| format!("缓存任务失败: {}", e))?
+}
+
+/// 从历史缓存目录读取 PNG 并返回 base64（点击历史项复制/保存时一次性加载，不常驻内存）
+#[tauri::command]
+#[specta::specta]
+pub async fn screenshot_load_cache(
+    app: tauri::AppHandle,
+    path: String,
+) -> Result<String, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let p = ensure_in_history_dir(&app, &path)?;
+        let bytes = std::fs::read(&p).map_err(|e| format!("读取缓存失败: {}", e))?;
+        use base64::Engine as _;
+        Ok(base64::engine::general_purpose::STANDARD.encode(bytes))
+    })
+    .await
+    .map_err(|e| format!("读取缓存任务失败: {}", e))?
+}
+
+/// 读取历史缓存 PNG 原始字节（raw IPC → 前端 ArrayBuffer，贴图窗口显示用：
+/// 跳过 base64 编码，IPC 传输与前端内存占用均省 ~33%；同 get_fullscreen_bmp 豁免 specta）
+#[tauri::command]
+pub async fn screenshot_load_cache_raw(
+    app: tauri::AppHandle,
+    path: String,
+) -> Result<tauri::ipc::Response, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let p = ensure_in_history_dir(&app, &path)?;
+        let bytes = std::fs::read(&p).map_err(|e| format!("读取缓存失败: {}", e))?;
+        Ok(tauri::ipc::Response::new(bytes))
+    })
+    .await
+    .map_err(|e| format!("读取缓存任务失败: {}", e))?
+}
+
+/// 删除历史缓存文件（历史项移除/清空时调用，静默忽略不存在文件）
+#[tauri::command]
+#[specta::specta]
+pub async fn screenshot_delete_cache(app: tauri::AppHandle, path: String) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        if let Ok(p) = ensure_in_history_dir(&app, &path) {
+            let _ = std::fs::remove_file(p);
+        }
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("删除缓存任务失败: {}", e))?
+}

src-tauri/src/screenshot/mod.rs

@@ -5,13 +5,14 @@
 
 use std::sync::Mutex;
 
+use specta::Type;
+
 #[cfg(windows)]
 pub mod capture;
 pub mod commands;
-pub mod shortcut;
 
 /// 前端可见的捕获数据
-#[derive(serde::Serialize)]
+#[derive(serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct CaptureData {
     pub png_base64: String,
@@ -19,8 +20,16 @@ pub struct CaptureData {
     pub height: i32,
 }
 
+/// 截图启动信息：捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返）
+#[derive(serde::Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CaptureStart {
+    pub cursor_x: i32,
+    pub cursor_y: i32,
+}
+
 /// 窗口信息（窗口拾取 / 枚举）
-#[derive(serde::Serialize)]
+#[derive(serde::Serialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct WindowInfo {
     pub hwnd: isize,
@@ -30,7 +39,7 @@ pub struct WindowInfo {
     pub visual_rect: Option<ScreenRect>,
 }
 
-#[derive(serde::Serialize, Clone, Copy)]
+#[derive(serde::Serialize, Clone, Copy, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct ScreenRect {
     pub x: i32,

src-tauri/src/screenshot/shortcut.rs

@@ -1,60 +0,0 @@
-//! 截图全局快捷键：可自定义注册/注销（默认 Ctrl+Alt+A）。
-//!
-//! 与剪贴板快捷弹窗（clipboard::popup）的实现一致：
-//! 用 `on_shortcut` 为每个快捷键绑定独立处理器，切换时先注销旧的再注册新的。
-//! 按下时 emit `screenshot-shortcut` 事件，前端 store 监听后触发 startCapture。
-
-use std::sync::Mutex;
-use tauri::{AppHandle, Emitter};
-use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
-
-/// 当前已注册的快捷键字符串（用于切换时注销旧快捷键）
-static CURRENT_SHORTCUT: Mutex<Option<String>> = Mutex::new(None);
-
-/// 解析快捷键字符串为 Shortcut（格式如 "Ctrl+Alt+A"、"Shift+PrintScreen"）
-pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
-    s.trim().parse::<Shortcut>().ok()
-}
-
-/// 注册全局快捷键。重复调用会先注销旧快捷键。
-/// 传入空字符串则仅注销不注册（禁用快捷键）。
-pub fn register_shortcut(app: &AppHandle, shortcut_str: &str) -> Result<(), String> {
-    unregister_shortcut(app);
-
-    if shortcut_str.trim().is_empty() {
-        return Ok(());
-    }
-
-    let shortcut = parse_shortcut(shortcut_str)
-        .ok_or_else(|| format!("无效的快捷键: {}", shortcut_str))?;
-
-    let app_handle = app.clone();
-    app.global_shortcut()
-        .on_shortcut(shortcut, move |_app, _shortcut, event| {
-            // 仅在按下时触发（松开不触发）
-            if event.state == ShortcutState::Pressed {
-                let _ = app_handle.emit("screenshot-shortcut", ());
-            }
-        })
-        .map_err(|e| format!("注册快捷键失败: {}", e))?;
-
-    if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
-        *cur = Some(shortcut_str.to_string());
-    }
-    eprintln!("[screenshot] 已注册快捷键: {}", shortcut_str);
-    Ok(())
-}
-
-/// 注销当前快捷键
-pub fn unregister_shortcut(app: &AppHandle) {
-    if let Ok(cur) = CURRENT_SHORTCUT.lock() {
-        if let Some(ref s) = *cur {
-            if let Some(shortcut) = parse_shortcut(s) {
-                let _ = app.global_shortcut().unregister(shortcut);
-            }
-        }
-    }
-    if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
-        *cur = None;
-    }
-}

src-tauri/src/setup.rs

@@ -0,0 +1,141 @@
+//! 应用启动初始化 —— 从 lib.rs 的 setup 闭包拆出，按子系统分组。
+//!
+//! 各子系统职责边界：
+//! - 日志：LogManager（全局日志）
+//! - 代理：MihomoManager + 自动启动
+//! - 监控：MonitorKernel + NetworkMonitor + 自动启动
+//! - 下载：DownloadEngine + 扩展 HTTP API 服务
+//! - 剪贴板：ClipboardManager + 快捷键 + 预创建弹窗
+//! - 快速面板：快捷键 + 预创建弹窗 + 文件索引
+//! - 托盘：自定义菜单窗口
+//! - 进程：监控线程
+
+use std::sync::Arc;
+use tauri::{App, Manager, Wry};
+
+use crate::download_engine::{DownloadEngine, ExtensionServer};
+use crate::logger::LogManager;
+use crate::mihomo_manager::MihomoManager;
+use crate::monitor_kernel::{MonitorKernel, check_and_relaunch_if_needed};
+use crate::network_monitor::NetworkMonitor;
+use crate::process_manager::{ProcessManager, start_monitoring_thread};
+
+/// 应用启动初始化入口（setup 闭包调用）。
+/// 初始化顺序即依赖顺序：日志 → 数据目录 → 各管理器 → 托盘 → 进程监控 → 自动启动。
+pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
+    // ===== 日志系统：{app_data_dir}/logs/ =====
+    let log_dir = app
+        .path()
+        .app_data_dir()
+        .unwrap_or_else(|_| std::path::PathBuf::from("."))
+        .join("logs");
+    let log_manager = LogManager::new(log_dir);
+    // 注册为 Tauri State（供 log_* 命令），同时安装进程级全局日志器（供后端模块 log_line 使用）
+    crate::logger::install_global(log_manager.clone());
+    app.manage(log_manager);
+    // ===== 数据目录：{app_data_dir}/ =====
+    let app_data_dir = app
+        .path()
+        .app_data_dir()
+        .unwrap_or_else(|_| std::path::PathBuf::from("."));
+
+    // 永久提权检查：如果标志已设置且当前非管理员，以管理员权限重启自身并退出
+    // 必须在所有模块初始化之前执行（此时无资源需要清理）
+    if check_and_relaunch_if_needed(&app_data_dir) {
+        std::process::exit(0);
+    }
+
+    // ===== 代理模块：MihomoManager =====
+    let mihomo = MihomoManager::new(app_data_dir.clone());
+    app.manage(mihomo);
+
+    // ===== 监控模块：MonitorKernel（硬件）+ NetworkMonitor（网速） =====
+    let monitor = MonitorKernel::new(app_data_dir.clone());
+    app.manage(monitor);
+
+    // 网速采样不依赖提权，应用启动即开始
+    let network_monitor = Arc::new(NetworkMonitor::new());
+    app.manage(network_monitor.clone());
+    network_monitor.start(app.handle().clone());
+
+    // ===== 下载模块：DownloadEngine + 扩展 HTTP API 服务 =====
+    let engine = DownloadEngine::new(app_data_dir.join("downloader"), app.handle().clone());
+    let settings = engine.get_settings();
+    app.manage(engine.clone());
+
+    let server_engine = engine.clone();
+    let server_port = settings.extension_port;
+    let server_secret = settings.extension_secret.clone();
+    let server_app = app.handle().clone();
+    tauri::async_runtime::spawn(async move {
+        ExtensionServer::start(server_engine, server_port, server_secret, server_app).await;
+    });
+
+    // ===== 剪贴板模块：监听 + 快捷键 + 预创建弹窗 =====
+    let clipboard = crate::clipboard::ClipboardManager::new(app_data_dir.clone());
+    // 应用启动时若已启用则自动开始监听
+    if clipboard.get_settings().enabled {
+        clipboard.start(&app.handle());
+    }
+    // 应用启动时注册快捷弹窗全局快捷键（共享工具模块）
+    let shortcut = clipboard.get_settings().shortcut.clone();
+    if !shortcut.trim().is_empty() {
+        let app_handle = app.handle().clone();
+        if let Err(e) = crate::shortcut::register_shortcut(&app_handle, "剪贴板", &shortcut, |a| {
+            crate::clipboard::popup::show_popup(a)
+        }) {
+            crate::logger::log_error("clipboard", &format!("快捷键注册失败: {}", e));
+        }
+        // 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
+        crate::clipboard::popup::ensure_popup_window(&app_handle);
+        // 同时预创建独立预览窗口（隐藏），弹窗悬停条目时直接显示
+        crate::clipboard::popup::ensure_preview_window(&app_handle);
+    }
+    app.manage(clipboard);
+
+    // ===== 快速面板：快捷键 + 预创建弹窗 =====
+    // defaultEnabled:true 假设启用；用户在设置页禁用模块时由前端 onDisable 钩子注销快捷键。
+    // 文件索引 DB 连接改为懒加载（首次搜索/构建时由 commands 中的 ensure_initialized 触发），
+    // 避免应用启动时即打开 SQLite 连接，降低启动 IO 开销。
+    let qp_settings = crate::quickpanel::load_settings(&app.handle());
+    if !qp_settings.shortcut.trim().is_empty() {
+        let app_handle = app.handle().clone();
+        if let Err(e) = crate::shortcut::register_shortcut(
+            &app_handle,
+            "快速面板",
+            &qp_settings.shortcut,
+            |a| crate::quickpanel::popup::show_popup(a),
+        ) {
+            crate::logger::log_error("quickpanel", &format!("快捷键注册失败: {}", e));
+        }
+        // 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
+        crate::quickpanel::ensure_window(&app_handle);
+    }
+
+    // ===== 托盘菜单 =====
+    crate::tray_menu::create_tray_menu(app.handle())?;
+
+    // ===== 进程监控线程 =====
+    start_monitoring_thread(app.handle().clone());
+
+    // ===== 代理：自动切换节点后台调度（独立于模块激活状态） =====
+    crate::mihomo_manager::start_auto_switch_loop(app.handle().clone());
+
+    // ===== 自动启动（随应用启动，不依赖模块启用） =====
+    // mihomo：用户在设置中开启"自动启动"时随应用启动
+    if let Some(mihomo) = app.try_state::<MihomoManager>() {
+        if let Some(pm) = app.try_state::<ProcessManager>() {
+            mihomo.auto_start_on_launch(app.handle(), &pm);
+        }
+    }
+
+    // monitor Kernel：用户在设置中开启"自动启动"时随应用启动
+    if let Some(monitor) = app.try_state::<MonitorKernel>() {
+        monitor.auto_start_on_launch(app.handle());
+    }
+
+    // 截图快捷键由前端 screenshotStore 启动时调用 screenshot_register_shortcut 注册
+    // （支持自定义，默认 Ctrl+Alt+A），此处不再硬编码注册
+
+    Ok(())
+}

src-tauri/src/shortcut.rs

@@ -0,0 +1,87 @@
+//! 全局快捷键共享工具：剪贴板 / 快速面板 / 截图三处复用的注册逻辑。
+//!
+//! 提供：
+//! - 原子化注册：先注销本模块旧快捷键，冲突检测通过后再注册新的，
+//!   注册失败返回错误（快捷键被系统或其他应用占用时前端可提示用户）。
+//! - 应用内冲突检测：同一组合键不允许被两个模块同时占用，
+//!   避免后注册的 `on_shortcut` 静默覆盖先注册的处理器。
+
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock};
+use tauri::AppHandle;
+use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
+
+/// 快捷键占用表：模块名（中文，用于错误提示）→ 快捷键字符串
+static REGISTRY: OnceLock<Mutex<HashMap<String, String>>> = OnceLock::new();
+
+fn registry() -> &'static Mutex<HashMap<String, String>> {
+    REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// 解析快捷键字符串为 Shortcut（格式如 "Alt+V"、"Ctrl+Shift+V"）
+/// 失败返回 None。
+pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
+    s.trim().parse::<Shortcut>().ok()
+}
+
+/// 原子化注册全局快捷键。
+///
+/// - 先注销 `module` 已注册的旧快捷键（空字符串则仅注销，用于禁用）。
+/// - 注册前做应用内冲突检测：同一组合键被其他模块占用时返回错误。
+/// - 注册成功后登记占用表；失败则返回错误且不登记（此时本模块快捷键为未注册状态）。
+pub fn register_shortcut<F>(
+    app: &AppHandle,
+    module: &str,
+    shortcut_str: &str,
+    handler: F,
+) -> Result<(), String>
+where
+    F: Fn(&AppHandle) + Send + Sync + 'static,
+{
+    // 1. 注销本模块旧快捷键（释放占用条目）
+    unregister_shortcut(app, module);
+
+    let key = shortcut_str.trim().to_string();
+    if key.is_empty() {
+        return Ok(());
+    }
+
+    // 2. 应用内冲突检测
+    if let Ok(reg) = registry().lock() {
+        if let Some(owner) = reg.values().find(|v| **v == key) {
+            return Err(format!("快捷键 {} 已被「{}」模块占用，请更换", key, owner));
+        }
+    }
+
+    let shortcut = parse_shortcut(&key).ok_or_else(|| format!("无效的快捷键: {}", key))?;
+
+    let app_handle = app.clone();
+    app.global_shortcut()
+        .on_shortcut(shortcut, move |_a, _s, event| {
+            // 仅在按下时触发（松开不触发）
+            if event.state == ShortcutState::Pressed {
+                handler(&app_handle);
+            }
+        })
+        .map_err(|e| format!("注册快捷键 {} 失败: {}", key, e))?;
+
+    // 3. 登记占用
+    if let Ok(mut reg) = registry().lock() {
+        reg.insert(module.to_string(), key.clone());
+    }
+    crate::logger::log_info(module, &format!("已注册快捷键: {}", shortcut_str));
+    Ok(())
+}
+
+/// 注销 `module` 的全局快捷键并释放占用条目
+pub fn unregister_shortcut(app: &AppHandle, module: &str) {
+    let old = registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .remove(module);
+    if let Some(s) = old {
+        if let Some(shortcut) = parse_shortcut(&s) {
+            let _ = app.global_shortcut().unregister(shortcut);
+        }
+    }
+}

src-tauri/src/snap_fix.rs

@@ -63,7 +63,7 @@ unsafe extern "system" fn fix_subclass_proc(
 #[tauri::command]
 pub async fn fix_snap_background(app: AppHandle) -> Result<(), String> {
     let main_window = app
-        .get_webview_window("main")
+        .get_webview_window(crate::constants::windows::MAIN)
         .ok_or("main window not found")?;
 
     let hwnd_isize: isize = {

src-tauri/src/tray_menu.rs

@@ -20,14 +20,12 @@ use tauri::{
 /// 记录窗口最后显示时间，用于失焦防抖（避免显示瞬间因焦点未稳定而被立即隐藏）
 static LAST_SHOW_TIME: Mutex<Option<Instant>> = Mutex::new(None);
 
-/// 保存最近一次右键时计算出的定位参数（逻辑坐标），供 `tray_menu_ready` 使用
-/// (x, tray_top_l, wa_top_l, wa_bottom_l, scale)
+/// 保存最近一次右键时计算出的定位参数（物理坐标），供 `tray_menu_ready` 使用
+/// (x, cursor_y, screen_top, screen_bottom, scale)
 static LAST_MENU_LAYOUT: Mutex<Option<(f64, f64, f64, f64, f64)>> = Mutex::new(None);
 
-use crate::clipboard::popup::{get_work_area, get_work_area_at_point, get_dpi_for_point};
-use crate::clipboard::ClipboardManager;
-use crate::download_engine::DownloadEngine;
-use crate::mihomo_manager::MihomoManager;
+use crate::win32_util::{get_work_area, get_monitor_bounds_at_point, get_dpi_for_point};
+use crate::mihomo_manager::{MihomoManager, is_pseudo_node};
 use crate::monitor_kernel::MonitorKernel;
 use crate::process_manager::{ProcessManager, ProcessStatus};
 
@@ -48,43 +46,13 @@ pub struct ProxyNodeInfo {
 #[serde(rename_all = "camelCase")]
 pub struct TrayMenuState {
     pub proxy_running: bool,
+    pub system_proxy: bool,
     pub monitor_running: bool,
     pub proxy_group: Option<String>,
     pub proxy_nodes: Vec<ProxyNodeInfo>,
     pub proxy_current: Option<String>,
 }
 
-// ===== 伪节点过滤（与前端 ProxyModule 保持一致） =====
-
-const PSEUDO_KEYWORDS: &[&str] = &[
-    "DIRECT",
-    "REJECT",
-    "PASS",
-    "COMPATIBLE",
-    "流量",
-    "套餐",
-    "到期",
-    "续费",
-    "官网",
-    "网站",
-    "刷新",
-    "更新",
-    "⭐",
-    "★",
-    "☆",
-    "✕",
-    "✖",
-    "×",
-];
-
-fn is_pseudo_node(name: &str) -> bool {
-    let upper = name.trim().to_uppercase();
-    if upper == "DIRECT" || upper == "REJECT" || upper == "PASS" || upper == "GLOBAL" {
-        return true;
-    }
-    PSEUDO_KEYWORDS.iter().any(|kw| name.contains(kw))
-}
-
 // ===== 状态查询 =====
 
 fn is_proxy_running(app: &AppHandle) -> bool {
@@ -180,9 +148,29 @@ async fn fetch_proxy_nodes(app: &AppHandle) -> Option<(String, Vec<(String, Opti
 
 // ===== 获取菜单状态 =====
 
-pub async fn get_tray_menu_state(app: &AppHandle) -> TrayMenuState {
+/// 基础状态（不含代理节点）。托盘菜单显示不应受 mihomo API 慢/卡死影响，
+/// 因此先秒发基础状态让菜单立即出现，代理节点随后异步补充。
+fn get_base_tray_state(app: &AppHandle) -> TrayMenuState {
     let proxy_running = is_proxy_running(app);
     let monitor_running = is_monitor_running(app);
+    // 读取 Windows 注册表中的真实系统代理状态（不依赖 settings.json 缓存）
+    let system_proxy = crate::mihomo_manager::get_system_proxy_windows();
+    TrayMenuState {
+        proxy_running,
+        system_proxy,
+        monitor_running,
+        proxy_group: None,
+        proxy_nodes: vec![],
+        proxy_current: None,
+    }
+}
+
+/// 完整状态（含代理节点）。可能因调用 mihomo /proxies 而耗时（最长 10s）。
+async fn get_full_tray_state(app: &AppHandle) -> TrayMenuState {
+    let proxy_running = is_proxy_running(app);
+    let monitor_running = is_monitor_running(app);
+    // 读取 Windows 注册表中的真实系统代理状态（不依赖 settings.json 缓存）
+    let system_proxy = crate::mihomo_manager::get_system_proxy_windows();
 
     let (proxy_group, proxy_nodes, proxy_current) = if proxy_running {
         match fetch_proxy_nodes(app).await {
@@ -205,6 +193,7 @@ pub async fn get_tray_menu_state(app: &AppHandle) -> TrayMenuState {
 
     TrayMenuState {
         proxy_running,
+        system_proxy,
         monitor_running,
         proxy_group,
         proxy_nodes,
@@ -212,6 +201,10 @@ pub async fn get_tray_menu_state(app: &AppHandle) -> TrayMenuState {
     }
 }
 
+pub async fn get_tray_menu_state(app: &AppHandle) -> TrayMenuState {
+    get_full_tray_state(app).await
+}
+
 // ===== 显示/隐藏托盘菜单窗口 =====
 
 /// 托盘菜单窗口尺寸（逻辑像素）
@@ -252,7 +245,7 @@ pub fn precreate_tray_menu_window(app: &AppHandle) {
     {
         Ok(w) => w,
         Err(e) => {
-            eprintln!("[tray-menu] 预创建菜单窗口失败: {}", e);
+            crate::logger::log_error("tray", &format!("预创建菜单窗口失败: {}", e));
             return;
         }
     };
@@ -262,7 +255,7 @@ pub fn precreate_tray_menu_window(app: &AppHandle) {
     win.on_window_event(move |event| {
         if let tauri::WindowEvent::Focused(false) = event {
             let should_hide = {
-                let t = LAST_SHOW_TIME.lock().unwrap();
+                let t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
                 match *t {
                     Some(time) => time.elapsed() > Duration::from_millis(300),
                     None => true,
@@ -274,44 +267,39 @@ pub fn precreate_tray_menu_window(app: &AppHandle) {
         }
     });
 
-    eprintln!("[tray-menu] 菜单窗口已预创建（隐藏渲染）");
+    crate::logger::log_info("tray", "菜单窗口已预创建（隐藏渲染）");
 }
 
 /// 右键托盘时调用：计算定位参数、发送状态给前端，但不立即显示窗口。
-/// 窗口等待前端测量内容高度后调用 `tray_menu_ready` 才显示，确保底部精确对齐托盘图标。
+/// 窗口等待前端测量内容高度后调用 `tray_menu_ready` 才显示，确保底部对齐鼠标点击位置。
 ///
-/// `cursor_pos`: 事件报告的鼠标物理坐标；`tray_rect`: 托盘图标区域（物理像素）。
-pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64), tray_rect: (f64, f64, f64, f64)) {
+/// `cursor_pos`: 事件报告的鼠标物理坐标。
+pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64)) {
     let (mx, my) = (cursor_pos.0, cursor_pos.1);
-    let tray_top = tray_rect.1;
 
-    // 获取光标所在显示器的工作区（物理像素）
-    let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx as i32, my as i32)
-        .unwrap_or((0, 0, 1920, 1040));
+    // 获取光标所在显示器的完整边界（含任务栏，物理像素）。
+    // 托盘图标位于任务栏上，菜单需在鼠标位置弹出，因此用屏幕边界而非工作区做 clamp，
+    // 否则会被工作区底部（任务栏顶部）截断，导致菜单整体被推到任务栏上方。
+    let (scr_left, scr_top, scr_right, scr_bottom) = get_monitor_bounds_at_point(mx as i32, my as i32)
+        .unwrap_or((0, 0, 1920, 1080));
 
-    // 获取光标所在显示器的 DPI，将物理坐标转为逻辑坐标（DIP）
+    // 光标所在显示器的 DPI：菜单宽度按物理像素换算
     let dpi = get_dpi_for_point(mx as i32, my as i32).unwrap_or(96);
     let scale = dpi as f64 / 96.0;
+    let menu_w_px = MENU_W * scale;
 
-    let mx_l = mx / scale;
-    let tray_top_l = tray_top / scale;
-    let wa_left_l = wa_left as f64 / scale;
-    let wa_right_l = wa_right as f64 / scale;
-    let wa_top_l = wa_top as f64 / scale;
-    let wa_bottom_l = wa_bottom as f64 / scale;
+    // 水平：菜单左边缘对齐鼠标 X（向右延伸），超出屏幕右边界则左移（物理坐标）
+    let x = mx.max(scr_left as f64).min(scr_right as f64 - menu_w_px);
 
-    // 水平：菜单左边缘对齐鼠标 X（向右延伸），超出右边界则左移
-    let x = mx_l.max(wa_left_l).min(wa_right_l - MENU_W);
-
-    // 保存布局参数，供 tray_menu_ready 使用
+    // 保存布局参数（全部物理坐标 + scale，供 tray_menu_ready 换算前端上报的逻辑高度）
     {
-        let mut layout = LAST_MENU_LAYOUT.lock().unwrap();
-        *layout = Some((x, tray_top_l, wa_top_l, wa_bottom_l, scale));
+        let mut layout = LAST_MENU_LAYOUT.lock().unwrap_or_else(|e| e.into_inner());
+        *layout = Some((x, my, scr_top as f64, scr_bottom as f64, scale));
     }
 
     // 记录显示时间，用于失焦防抖
     {
-        let mut t = LAST_SHOW_TIME.lock().unwrap();
+        let mut t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
         *t = Some(Instant::now());
     }
 
@@ -320,11 +308,26 @@ pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64), tray_rect: (f64,
         precreate_tray_menu_window(app);
     }
 
-    // 发送状态给前端（前端测量内容高度后调用 tray_menu_ready 显示窗口）
+    // 1) 立即发送基础状态（不含代理节点，纯本地查询），菜单秒开——
+    //    前端测量内容高度后调用 tray_menu_ready 显示窗口。
+    let base = get_base_tray_state(app);
+    let _ = app.emit(crate::constants::events::TRAY_MENU_SHOW, base);
+
+    // 2) 异步拉取完整状态（含 mihomo /proxies 节点），到达后经 TRAY_MENU_STATE_UPDATED
+    //    补充给前端（前端在窗口可见时重新测量调整尺寸）。
+    //    mihomo API 慢/挂起时不再阻塞菜单显示；超时 5s 放弃（保持基础状态）。
     let app_clone = app.clone();
     tauri::async_runtime::spawn(async move {
-        let state = get_tray_menu_state(&app_clone).await;
-        let _ = app_clone.emit("tray-menu-show", state);
+        let state = match tokio::time::timeout(
+            Duration::from_millis(5000),
+            get_full_tray_state(&app_clone),
+        )
+        .await
+        {
+            Ok(s) => s,
+            Err(_) => return,
+        };
+        let _ = app_clone.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state);
     });
 }
 
@@ -338,7 +341,23 @@ pub fn hide_tray_menu(app: &AppHandle) {
 /// 刷新菜单状态并发送给前端
 async fn refresh_and_emit_state(app: &AppHandle) {
     let state = get_tray_menu_state(app).await;
-    let _ = app.emit("tray-menu-state-updated", state);
+    let _ = app.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state);
+}
+
+/// 显示主窗口并强制置为前台。
+/// Tauri 的 set_focus 在 Windows 上受前台锁定限制，主窗口被其他应用遮挡时无法到前台；
+/// 改用原生 SetForegroundWindow + BringWindowToTop（模拟 Alt 键重置前台锁定）。
+pub fn focus_main_window(app: &AppHandle) {
+    if let Some(window) = app.get_webview_window(crate::constants::windows::MAIN) {
+        let _ = window.show();
+        let _ = window.unminimize();
+        match window.hwnd() {
+            Ok(hwnd) => crate::win32_util::force_foreground(hwnd.0 as isize),
+            Err(_) => {
+                window.set_focus().ok();
+            }
+        }
+    }
 }
 
 // ===== Tauri 命令 =====
@@ -353,13 +372,13 @@ pub async fn tray_menu_action(
     match action.as_str() {
         "proxy_enable" => {
             if let Err(e) = enable_proxy(&app).await {
-                eprintln!("[tray] 开启代理失败: {}", e);
+                crate::logger::log_error("tray", &format!("开启代理失败: {}", e));
                 send_notification(&app, "代理启动失败", &e);
             }
         }
         "proxy_disable" => {
             if let Err(e) = disable_proxy(&app).await {
-                eprintln!("[tray] 关闭代理失败: {}", e);
+                crate::logger::log_error("tray", &format!("关闭代理失败: {}", e));
                 send_notification(&app, "代理关闭失败", &e);
             }
         }
@@ -377,29 +396,38 @@ pub async fn tray_menu_action(
                 }
             }
         }
+        "system_proxy_toggle" => {
+            // 根据注册表当前真实状态切换（不依赖 settings.json 缓存，避免与主界面不同步）
+            let mihomo = app.state::<MihomoManager>();
+            if crate::mihomo_manager::get_system_proxy_windows() {
+                if let Err(e) = mihomo.disable_system_proxy() {
+                    crate::logger::log_error("tray", &format!("关闭系统代理失败: {}", e));
+                    send_notification(&app, "系统代理关闭失败", &e);
+                }
+            } else {
+                if let Err(e) = mihomo.enable_system_proxy() {
+                    crate::logger::log_error("tray", &format!("开启系统代理失败: {}", e));
+                    send_notification(&app, "系统代理开启失败", &e);
+                }
+            }
+        }
         "osd_toggle" => {
-            let _ = app.emit("tray:toggle-osd", ());
+            let _ = app.emit(crate::constants::events::TRAY_TOGGLE_OSD, ());
         }
         "kernel_restart" => {
             if let Err(e) = restart_kernel(&app).await {
-                eprintln!("[tray] 重启 Kernel 失败: {}", e);
+                crate::logger::log_error("tray", &format!("重启 Kernel 失败: {}", e));
                 send_notification(&app, "Kernel 重启失败", &e);
             }
         }
         "download_new" => {
-            if let Some(window) = app.get_webview_window("main") {
-                window.show().ok();
-                window.set_focus().ok();
-            }
-            let _ = app.emit("tray:new-download", ());
+            focus_main_window(&app);
+            let _ = app.emit(crate::constants::events::TRAY_NEW_DOWNLOAD, ());
             hide_tray_menu(&app);
         }
         "settings" => {
-            if let Some(window) = app.get_webview_window("main") {
-                window.show().ok();
-                window.set_focus().ok();
-            }
-            let _ = app.emit("tray:open-settings", ());
+            focus_main_window(&app);
+            let _ = app.emit(crate::constants::events::TRAY_OPEN_SETTINGS, ());
             hide_tray_menu(&app);
         }
         "quit" => {
@@ -409,9 +437,20 @@ pub async fn tray_menu_action(
         _ => {}
     }
 
-    // 刷新状态并发送给前端（quit 除外，quit 后进程已退出）
-    if action != "quit" {
-        refresh_and_emit_state(&app).await;
+    // 按动作类型选择性刷新，避免无关动作（OSD 开关/跳转设置）也全量请求 mihomo API：
+    // - 代理相关动作：全量刷新（节点列表/延迟可能已变化）
+    // - Kernel/OSD：仅刷新本地基础状态（monitor 运行状态）
+    // - 跳转/退出：不刷新（quit 后进程已退出）
+    match action.as_str() {
+        "proxy_enable" | "proxy_disable" | "proxy_refresh" | "proxy_select_node"
+        | "system_proxy_toggle" => {
+            refresh_and_emit_state(&app).await;
+        }
+        "kernel_restart" | "osd_toggle" => {
+            let state = get_base_tray_state(&app);
+            let _ = app.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state);
+        }
+        _ => {}
     }
 
     Ok(())
@@ -431,25 +470,38 @@ pub async fn tray_menu_ready(content_height: f64, app: AppHandle) -> Result<(),
     let win = app.get_webview_window(TRAY_MENU_LABEL)
         .ok_or("tray-menu window not found")?;
 
-    let (x, tray_top_l, wa_top_l, wa_bottom_l, _scale) = {
-        let layout = LAST_MENU_LAYOUT.lock().unwrap();
-        layout.unwrap_or((0.0, 1040.0, 0.0, 1040.0, 1.0))
+    let (x, cursor_y, scr_top, scr_bottom, scale) = {
+        let layout = LAST_MENU_LAYOUT.lock().unwrap_or_else(|e| e.into_inner());
+        layout.unwrap_or((0.0, 1040.0, 0.0, 1080.0, 1.0))
     };
 
-    // 将内容高度限制在合理范围内
+    // 将内容高度限制在合理范围内（前端上报为逻辑像素）
     let h = content_height.max(100.0).min(520.0);
 
-    // 调整窗口尺寸
-    let _ = win.set_size(tauri::Size::Logical(tauri::LogicalSize {
-        width: MENU_W,
-        height: h,
+    // 调整窗口尺寸（物理像素，与物理坐标定位保持一致，避免混合 DPI 换算偏移）
+    let win_w_px = MENU_W * scale;
+    let win_h_px = h * scale;
+    let _ = win.set_size(tauri::Size::Physical(tauri::PhysicalSize {
+        width: win_w_px as u32,
+        height: win_h_px as u32,
     }));
 
-    // 垂直：菜单下边缘紧贴托盘图标顶部（向上弹出）
-    let y = (tray_top_l - h).max(wa_top_l).min(wa_bottom_l - h);
+    // 垂直：菜单底部对齐鼠标点击位置（向上弹出，物理坐标）。
+    // 用屏幕边界而非工作区 clamp，使菜单贴近/覆盖任务栏上的鼠标位置，
+    // 而不是被工作区底部（任务栏顶部）截断后整体出现在任务栏上方。
+    let y = (cursor_y - win_h_px).max(scr_top).min(scr_bottom - win_h_px);
 
-    let pos = tauri::Position::Logical(tauri::LogicalPosition { x, y });
+    let pos = tauri::Position::Physical(tauri::PhysicalPosition {
+        x: x as i32,
+        y: y as i32,
+    });
     let _ = win.set_position(pos);
+    // 以实际显示时刻重置失焦防抖起点：右键到此处可能间隔较久（前端测量 + 基础状态），
+    // 若沿用右键时刻，WebView2 显示瞬间的焦点抖动会被误判为失焦而立即隐藏菜单。
+    {
+        let mut t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
+        *t = Some(Instant::now());
+    }
     let _ = win.show();
     let _ = win.set_focus();
 
@@ -480,33 +532,57 @@ async fn enable_proxy(app: &AppHandle) -> Result<(), String> {
         }
     }
 
-    // 2. 获取节点列表
-    let proxies = mihomo.get_proxies().await?;
-    let (group, nodes, _now) = parse_main_group(&proxies)
-        .ok_or_else(|| "无法解析代理组".to_string())?;
+    // 2. 获取节点并择优：遵循自动切换的目标组与地区筛选（关闭自动切换时退化为主组 + 全量节点）
+    let settings = mihomo.load_settings();
 
-    if !nodes.is_empty() {
-        // 3. 并行测试所有节点延迟
-        let best = test_and_select_best(&mihomo, &group, &nodes).await;
-
-        // 4. 发送通知
-        match &best {
-            Some((name, delay)) => {
-                send_notification(
-                    app,
-                    "代理已开启",
-                    &format!("当前节点: {} ({}ms)", name, delay),
-                );
+    match crate::mihomo_manager::pick_best(&mihomo, &settings).await {
+        Ok(Some((group, name, delay, now))) => {
+            // 与自动切换一样，仅当当前节点不是最优时才切换
+            if name != now {
+                let _ = mihomo.select_proxy(&group, &name).await;
             }
-            None => {
-                send_notification(app, "代理已开启", "所有节点均超时，未自动选择");
+            send_notification(app, "代理已开启", &format!("当前节点: {} ({}ms)", name, delay));
+        }
+        Ok(None) | Err(_) => {
+            // 区分「无可用节点」与「全部超时」两种情况
+            let unavailable = {
+                let proxies = mihomo.get_proxies().await.ok();
+                let group_name: Option<String> = if !settings.auto_switch_group.is_empty() {
+                    Some(settings.auto_switch_group.clone())
+                } else {
+                    proxies
+                        .as_ref()
+                        .and_then(|p| p.get("proxies"))
+                        .and_then(|m| m.as_object())
+                        .and_then(|map| {
+                            let mut names = map.iter().filter(|(_, v)| {
+                                v.get("type").and_then(|t| t.as_str()) == Some("Selector")
+                            });
+                            names.next().map(|(n, _)| n.clone())
+                        })
+                };
+                let empty = group_name.map(|g| {
+                    proxies
+                        .as_ref()
+                        .and_then(|p| p.get("proxies"))
+                        .and_then(|m| m.as_object())
+                        .and_then(|map| map.get(&g))
+                        .and_then(|v| v.get("all"))
+                        .and_then(|v| v.as_array())
+                        .map(|a| a.is_empty())
+                        .unwrap_or(true)
+                }).unwrap_or(true);
+                empty
+            };
+            if unavailable {
+                send_notification(app, "代理已开启", "无可用节点");
+            } else {
+                send_notification(app, "代理已开启", "所有候选节点均超时，未自动选择");
             }
         }
-    } else {
-        send_notification(app, "代理已开启", "无可用节点");
     }
 
-    // 5. 开启系统代理
+    // 3. 开启系统代理
     mihomo.enable_system_proxy()?;
 
     Ok(())
@@ -529,40 +605,6 @@ async fn disable_proxy(app: &AppHandle) -> Result<(), String> {
 
 // ===== 择优选择节点 =====
 
-/// 并行测试所有节点延迟，选择最低延迟节点
-async fn test_and_select_best(
-    mihomo: &MihomoManager,
-    group: &str,
-    nodes: &[String],
-) -> Option<(String, u32)> {
-    use futures_util::future::join_all;
-
-    let futures: Vec<_> = nodes
-        .iter()
-        .map(|name| async move {
-            let delay = mihomo
-                .test_delay(name, "https://www.gstatic.com/generate_204", 5000)
-                .await
-                .ok();
-            (name.clone(), delay)
-        })
-        .collect();
-
-    let results = join_all(futures).await;
-
-    let best = results
-        .into_iter()
-        .filter_map(|(name, delay)| delay.map(|d| (name, d)))
-        .filter(|(_, d)| *d > 0)
-        .min_by_key(|(_, d)| *d);
-
-    if let Some((ref name, _)) = best {
-        let _ = mihomo.select_proxy(group, name).await;
-    }
-
-    best
-}
-
 /// 并行测试所有节点延迟（更新 mihomo 内部 history）
 async fn test_all_delays(app: &AppHandle) {
     let mihomo = app.state::<MihomoManager>();
@@ -605,7 +647,7 @@ async fn select_proxy_node(app: &AppHandle, group: &str, name: &str) {
             send_notification(app, "节点已切换", &format!("{}\n延迟: {}", name, delay_text));
         }
         Err(e) => {
-            eprintln!("[tray] 切换节点失败: {}", e);
+            crate::logger::log_error("tray", &format!("切换节点失败: {}", e));
             send_notification(app, "切换节点失败", &e);
         }
     }
@@ -657,34 +699,12 @@ fn send_notification(app: &AppHandle, title: &str, message: &str) {
         .show();
 }
 
-// ===== 退出清理 =====
+// ===== 退出入口 =====
 
+/// 托盘菜单"退出"调用。
+/// 资源清理统一收敛到 RunEvent::ExitRequested（覆盖所有退出路径），此处仅请求退出，
+/// 避免清理逻辑双份执行（monitor 的 cleanup 涉及子进程/网络，重复执行有竞态风险）。
 pub fn quit_cleanup(app: &AppHandle) {
-    if let Some(mihomo) = app.try_state::<MihomoManager>() {
-        mihomo.cleanup_on_exit();
-    }
-    if let Some(engine) = app.try_state::<DownloadEngine>() {
-        engine.cleanup_on_exit();
-    }
-    // monitor.cleanup_on_exit 是 async，在 tokio worker 线程中直接 block_on 会 panic，
-    // 放到独立 OS 线程执行 block_on，避免嵌套 runtime。
-    if let Some(monitor) = app.try_state::<MonitorKernel>() {
-        let app_clone = app.clone();
-        let monitor_clone = monitor.inner().clone();
-        std::thread::spawn(move || {
-            tauri::async_runtime::block_on(async move {
-                monitor_clone.cleanup_on_exit(&app_clone).await;
-            });
-        })
-        .join()
-        .ok();
-    }
-    if let Some(clip) = app.try_state::<ClipboardManager>() {
-        clip.stop();
-    }
-    if let Some(pm) = app.try_state::<ProcessManager>() {
-        pm.stop_all();
-    }
     app.exit(0);
 }
 
@@ -703,31 +723,17 @@ pub fn create_tray_menu(app: &AppHandle) -> Result<(), tauri::Error> {
                     button: MouseButton::Left,
                     ..
                 } => {
-                    // 左键：显示主窗口
-                    if let Some(window) = app.get_webview_window("main") {
-                        window.show().ok();
-                        window.set_focus().ok();
-                    }
+                    // 左键：显示主窗口（强制置前，绕过前台锁定）
+                    focus_main_window(&app);
                 }
                 TrayIconEvent::Click {
                     button: MouseButton::Right,
                     position,
-                    rect,
                     ..
                 } => {
-                    // 右键：显示自定义菜单窗口（使用事件中的精确坐标）
+                    // 右键：显示自定义菜单窗口（使用事件中的鼠标坐标）
                     let cursor = (position.x, position.y);
-                    // 从 Rect 的 Position/Size 枚举中提取物理像素值
-                    let (rx, ry) = match rect.position {
-                        tauri::Position::Physical(p) => (p.x as f64, p.y as f64),
-                        tauri::Position::Logical(p) => (p.x, p.y),
-                    };
-                    let (_rw, rh) = match rect.size {
-                        tauri::Size::Physical(s) => (s.width as f64, s.height as f64),
-                        tauri::Size::Logical(s) => (s.width, s.height),
-                    };
-                    let tray_r = (rx, ry, _rw, rh);
-                    show_tray_menu(&app, cursor, tray_r);
+                    show_tray_menu(&app, cursor);
                 }
                 _ => {}
             }

src-tauri/src/updater/mod.rs

@@ -0,0 +1,479 @@
+//! 应用自更新模块。
+//! 更新源为自建 Gitea：`https://gitea.atie.fun/LFeng/Thing` 的 release 资产。
+//! - 便携版（无 unins000.exe 且不在 Program Files）：下载新 thing.exe → update.bat 覆盖重启
+//! - 安装版（NSIS）：下载新 setup.exe → 提权静默安装 /S
+//! - ThingHK 内核：下载 thing-hk_{v}.zip → 停止监控内核 → 覆盖 {app_data}/monitor/cores/ThingHK.exe
+//! mihomo 内核更新继续复用代理模块已有的 GitHub 下载机制，不在此模块处理。
+use futures_util::StreamExt;
+use serde::Serialize;
+use specta::Type;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use tauri::{AppHandle, Emitter, Manager};
+
+use crate::constants::events::UPDATE_PROGRESS;
+
+/// 发布仓库（Gitea）
+const GITEA_REPO: &str = "LFeng/Thing";
+const GITEA_BASE: &str = "https://gitea.atie.fun";
+
+/// release 中的一个资产
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateAsset {
+    pub name: String,
+    pub size: u64,
+    pub browser_download_url: String,
+}
+
+/// 检查更新的结果
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateCheckResult {
+    pub current_version: String,
+    pub latest_version: String,
+    pub has_update: bool,
+    /// portable | installed
+    pub install_type: String,
+    pub release_name: String,
+    pub release_body: String,
+    pub assets: Vec<UpdateAsset>,
+}
+
+/// 更新进度事件载荷（与内核安装进度同构，独立事件便于 UI 区分）
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateProgress {
+    pub stage: String,
+    pub percent: u8,
+    #[specta(type = f64)]
+    pub downloaded_bytes: u64,
+    #[specta(type = Option<f64>)]
+    pub total_bytes: Option<u64>,
+    pub message: String,
+}
+
+// ---------- 版本比较 ----------
+
+/// 解析 vX.Y.Z 为数字元组用于比较；解析失败返回 (0,0,0)
+fn parse_version(v: &str) -> (u32, u32, u32) {
+    let s = v.trim().trim_start_matches('v');
+    let mut parts = s.split('.');
+    let major = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
+    let minor = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
+    let patch = parts
+        .next()
+        .map(|p| p.chars().take_while(|c| c.is_ascii_digit()).collect::<String>())
+        .and_then(|p| p.parse().ok())
+        .unwrap_or(0);
+    (major, minor, patch)
+}
+
+fn version_gt(a: &str, b: &str) -> bool {
+    parse_version(a) > parse_version(b)
+}
+
+// ---------- Gitea API ----------
+
+struct LatestRelease {
+    tag_name: String,
+    name: String,
+    body: String,
+    assets: Vec<UpdateAsset>,
+}
+
+async fn fetch_latest_release() -> Result<LatestRelease, String> {
+    let url = format!("{}/api/v1/repos/{}/releases/latest", GITEA_BASE, GITEA_REPO);
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .map_err(|e| format!("创建 HTTP 客户端失败: {}", e))?;
+    let resp = client
+        .get(&url)
+        .header("User-Agent", "thing-app")
+        .send()
+        .await
+        .map_err(|e| format!("请求 Gitea API 失败: {}", e))?;
+    if !resp.status().is_success() {
+        return Err(format!("Gitea API 返回 HTTP {}", resp.status()));
+    }
+    let json: serde_json::Value = resp
+        .json()
+        .await
+        .map_err(|e| format!("解析 Gitea 响应失败: {}", e))?;
+    let mut assets = Vec::new();
+    if let Some(list) = json.get("assets").and_then(|v| v.as_array()) {
+        for a in list {
+            if let (Some(name), Some(url)) = (
+                a.get("name").and_then(|v| v.as_str()),
+                a.get("browser_download_url").and_then(|v| v.as_str()),
+            ) {
+                assets.push(UpdateAsset {
+                    name: name.to_string(),
+                    size: a.get("size").and_then(|v| v.as_u64()).unwrap_or(0),
+                    browser_download_url: url.to_string(),
+                });
+            }
+        }
+    }
+    Ok(LatestRelease {
+        tag_name: json.get("tag_name").and_then(|v| v.as_str()).unwrap_or("").to_string(),
+        name: json.get("name").and_then(|v| v.as_str()).unwrap_or("").to_string(),
+        body: json.get("body").and_then(|v| v.as_str()).unwrap_or("").to_string(),
+        assets,
+    })
+}
+
+// ---------- 下载 / 解压 ----------
+
+/// 下载文件到 dest，期间通过 UPDATE_PROGRESS 事件上报进度
+async fn download_with_progress(app: &AppHandle, url: &str, dest: &Path) -> Result<(), String> {
+    // 注意：reqwest 的 timeout 是"从连接到响应体读完"的总超时。大文件（如
+    // thing.exe 10+MB）在慢速网络下 30s 内读不完会被掐断流导致下载到一半失败
+    // （此前 bug：更新包总在 ~50% 处中断）。这里只限制连接建立 15s，
+    // 总超时放宽到 10 分钟兜底防止永久悬挂。
+    let client = reqwest::Client::builder()
+        .connect_timeout(std::time::Duration::from_secs(15))
+        .timeout(std::time::Duration::from_secs(600))
+        .build()
+        .map_err(|e| format!("创建 HTTP 客户端失败: {}", e))?;
+    let resp = client
+        .get(url)
+        .header("User-Agent", "thing-app")
+        .send()
+        .await
+        .map_err(|e| format!("下载请求失败: {}", e))?;
+    if !resp.status().is_success() {
+        return Err(format!("下载失败: HTTP {}", resp.status()));
+    }
+    let total = resp.content_length();
+    let mut stream = resp.bytes_stream();
+    let mut file = fs::File::create(dest).map_err(|e| format!("创建文件失败: {}", e))?;
+    let mut downloaded: u64 = 0;
+    let mut last_percent: u8 = 0;
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk.map_err(|e| format!("读取下载流失败: {}", e))?;
+        file.write_all(&chunk).map_err(|e| format!("写入文件失败: {}", e))?;
+        downloaded += chunk.len() as u64;
+        let percent = match total {
+            Some(t) if t > 0 => ((downloaded as f64 / t as f64) * 100.0) as u8,
+            _ => 0,
+        };
+        if percent >= last_percent + 1 {
+            last_percent = percent;
+            let _ = app.emit(
+                UPDATE_PROGRESS,
+                UpdateProgress {
+                    stage: "downloading".into(),
+                    percent,
+                    downloaded_bytes: downloaded,
+                    total_bytes: total,
+                    message: format!(
+                        "已下载 {:.2} MB / {:.2} MB",
+                        downloaded as f64 / 1024.0 / 1024.0,
+                        total.unwrap_or(0) as f64 / 1024.0 / 1024.0
+                    ),
+                },
+            );
+        }
+    }
+    file.flush().map_err(|e| format!("flush 失败: {}", e))?;
+    let _ = app.emit(
+        UPDATE_PROGRESS,
+        UpdateProgress {
+            stage: "downloaded".into(),
+            percent: 100,
+            downloaded_bytes: downloaded,
+            total_bytes: total,
+            message: "下载完成".into(),
+        },
+    );
+    Ok(())
+}
+
+/// 用 zip crate 解压（纯 Rust，避免 PowerShell 执行策略问题）
+fn extract_zip(zip_path: &Path, dest: &Path) -> Result<(), String> {
+    let file = fs::File::open(zip_path).map_err(|e| format!("打开 zip 失败: {}", e))?;
+    let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("读取 zip 失败: {}", e))?;
+    for i in 0..archive.len() {
+        let mut entry = archive
+            .by_index(i)
+            .map_err(|e| format!("读取条目失败: {}", e))?;
+        let outpath = match entry.enclosed_name() {
+            Some(p) => dest.join(p),
+            None => continue,
+        };
+        if entry.is_dir() {
+            fs::create_dir_all(&outpath).map_err(|e| e.to_string())?;
+        } else {
+            if let Some(parent) = outpath.parent() {
+                fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+            }
+            let mut outfile = fs::File::create(&outpath).map_err(|e| e.to_string())?;
+            let mut buf = [0u8; 8192];
+            loop {
+                let n = entry.read(&mut buf).map_err(|e| e.to_string())?;
+                if n == 0 {
+                    break;
+                }
+                outfile.write_all(&buf[..n]).map_err(|e| e.to_string())?;
+            }
+        }
+    }
+    Ok(())
+}
+
+// ---------- 安装类型 / ShellExecute ----------
+
+/// 判断当前是便携版还是安装版。
+/// NSIS 安装会在程序目录生成 unins000.exe；MSI 通常安装到 Program Files。
+fn is_installed_version() -> bool {
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(dir) = exe.parent() {
+            if dir.join("unins000.exe").exists() {
+                return true;
+            }
+            let p = dir.to_string_lossy().to_lowercase();
+            if p.contains("program files") {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// 通过 ShellExecuteW 启动程序/文档（绕过 Job Object，脱离主进程生命周期）
+fn shell_execute(verb: &str, file: &Path, params: &str, show: i32) -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        use std::os::windows::ffi::OsStrExt;
+        use windows_sys::Win32::UI::Shell::ShellExecuteW;
+        let file_w: Vec<u16> = file.as_os_str().encode_wide().chain(std::iter::once(0)).collect();
+        let verb_w: Vec<u16> = verb.encode_utf16().chain(std::iter::once(0)).collect();
+        let params_w: Vec<u16> = params.encode_utf16().chain(std::iter::once(0)).collect();
+        let res = unsafe {
+            ShellExecuteW(
+                0 as isize,
+                verb_w.as_ptr(),
+                file_w.as_ptr(),
+                params_w.as_ptr(),
+                std::ptr::null(),
+                show,
+            )
+        };
+        if (res as isize) <= 32 {
+            return Err(format!("ShellExecuteW 失败 (code={})", res));
+        }
+        Ok(())
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = (verb, file, params, show);
+        Err("仅支持 Windows".into())
+    }
+}
+
+/// 便携版：写 update.bat 等待主进程退出 → 覆盖 exe → 重新启动
+fn apply_portable_update(new_exe: &Path) -> Result<(), String> {
+    let cur_exe = std::env::current_exe().map_err(|e| format!("获取当前程序路径失败: {}", e))?;
+    let cur_dir = cur_exe.parent().ok_or("无法确定程序目录".to_string())?;
+    let bat_path = cur_dir.join("update.bat");
+    let script = format!(
+        "@echo off\r\n\
+         :wait\r\n\
+         tasklist /FI \"IMAGENAME eq thing.exe\" 2>nul | findstr /i \"thing.exe\" >nul\r\n\
+         if not errorlevel 1 (\r\n\
+           ping -n 2 127.0.0.1 >nul\r\n\
+           goto wait\r\n\
+         )\r\n\
+         copy /y \"{new}\" \"{cur}\" >nul\r\n\
+         if errorlevel 1 exit /b 1\r\n\
+         start \"\" \"{cur}\"\r\n\
+         del \"{new}\" >nul 2>nul\r\n\
+         del \"%~f0\" >nul 2>nul\r\n",
+        new = new_exe.display(),
+        cur = cur_exe.display()
+    );
+    fs::write(&bat_path, script).map_err(|e| format!("写入更新脚本失败: {}", e))?;
+    // 用 cmd /c 启动 bat 并隐藏窗口；ShellExecute 启动的进程不属于本进程 Job，
+    // 主进程退出后 update.bat 仍能继续执行
+    let windir = std::env::var("WINDIR").unwrap_or_else(|_| "C:\\Windows".into());
+    let cmd_exe = Path::new(&windir).join("System32").join("cmd.exe");
+    shell_execute("open", &cmd_exe, &format!("/c \"{}\"", bat_path.display()), 0)
+}
+
+// ---------- 命令 ----------
+
+/// 获取当前应用版本
+#[tauri::command]
+#[specta::specta]
+pub fn app_version(app: AppHandle) -> String {
+    app.package_info().version.to_string()
+}
+
+/// 检查 Gitea 最新 release，返回版本对比与可用资产
+#[tauri::command]
+#[specta::specta]
+pub async fn update_check(app: AppHandle) -> Result<UpdateCheckResult, String> {
+    let latest = fetch_latest_release().await?;
+    let latest_version = latest.tag_name.trim_start_matches('v').to_string();
+    let current_version = app.package_info().version.to_string();
+    let has_update = version_gt(&latest_version, &current_version);
+    Ok(UpdateCheckResult {
+        current_version,
+        latest_version,
+        has_update,
+        install_type: if is_installed_version() { "installed".into() } else { "portable".into() },
+        release_name: latest.name,
+        release_body: latest.body,
+        assets: latest.assets,
+    })
+}
+
+/// 更新应用本体（安装阶段）。下载由前端下载模块完成，本命令接收已下载的
+/// 安装包路径（便携版 thing_{v}_x64.exe / 安装版 thing_{v}_x64-setup.exe）。
+/// 便携版：copy 到临时目录 → update.bat 覆盖重启；
+/// 安装版：copy 到临时目录 → 提权静默安装 /S。
+/// 调用返回前会触发应用退出。
+#[tauri::command]
+#[specta::specta]
+pub async fn update_install(app: AppHandle, downloaded_path: String) -> Result<(), String> {
+    let src = PathBuf::from(&downloaded_path);
+    if !src.exists() {
+        return Err(format!("下载文件不存在: {}", downloaded_path));
+    }
+    let installed = is_installed_version();
+    // copy 到临时目录：与 update.bat / 安装器解耦，随后即可删除下载目录中的源文件
+    let temp_dir = std::env::temp_dir().join("thing-update");
+    fs::create_dir_all(&temp_dir).map_err(|e| format!("创建临时目录失败: {}", e))?;
+    let file_name = src
+        .file_name()
+        .map(|n| n.to_string_lossy().to_string())
+        .unwrap_or_else(|| "thing_update.exe".into());
+    let dest = temp_dir.join(&file_name);
+    fs::copy(&src, &dest).map_err(|e| format!("复制安装包到临时目录失败: {}", e))?;
+    // 临时副本就绪后清理下载目录中的源文件（失败不影响更新流程）
+    let _ = fs::remove_file(&src);
+
+    let _ = app.emit(
+        UPDATE_PROGRESS,
+        UpdateProgress {
+            stage: "applying".into(),
+            percent: 100,
+            downloaded_bytes: 0,
+            total_bytes: None,
+            message: if installed { "正在启动安装程序...".into() } else { "正在替换程序文件...".into() },
+        },
+    );
+    if installed {
+        // 提权静默安装 /S；UAC 确认期间主进程已退出，安装器可正常覆盖
+        shell_execute("runas", &dest, "/S", 0)?;
+    } else {
+        apply_portable_update(&dest)?;
+    }
+    // 延迟退出，确保 ShellExecute 已拉起子进程
+    app.exit(0);
+    Ok(())
+}
+
+/// 更新 ThingHK 内核：下载 thing-hk_{v}.zip → 停止监控内核 → 覆盖内核文件
+#[tauri::command]
+#[specta::specta]
+pub async fn update_thinghk(app: AppHandle) -> Result<(), String> {
+    let result = update_thinghk_inner(&app).await;
+    if let Err(ref e) = result {
+        // 失败时 emit error 阶段，避免前端进度卡在最后状态无提示
+        let _ = app.emit(
+            UPDATE_PROGRESS,
+            UpdateProgress {
+                stage: "error".into(),
+                percent: 0,
+                downloaded_bytes: 0,
+                total_bytes: None,
+                message: e.clone(),
+            },
+        );
+    }
+    result
+}
+
+async fn update_thinghk_inner(app: &AppHandle) -> Result<(), String> {
+    let latest = fetch_latest_release().await?;
+    let asset = latest
+        .assets
+        .iter()
+        .find(|a| a.name.starts_with("thing-hk_") && a.name.ends_with(".zip"))
+        .ok_or("未在 release 中找到 ThingHK 内核包".to_string())?;
+    // 停止监控内核（含提权模式的 /shutdown 兜底由前端先停模块），避免 exe 被占用
+    if let Some(monitor) = app.try_state::<crate::monitor_kernel::MonitorKernel>() {
+        monitor.stop_subscription(app).await;
+    }
+    if let Some(pm) = app.try_state::<crate::process_manager::ProcessManager>() {
+        let _ = pm.stop("monitor");
+    }
+    // 等待进程退出释放文件句柄
+    tokio::time::sleep(std::time::Duration::from_millis(600)).await;
+    let temp_dir = std::env::temp_dir().join("thing-update");
+    fs::create_dir_all(&temp_dir).map_err(|e| format!("创建临时目录失败: {}", e))?;
+    let zip_path = temp_dir.join(&asset.name);
+    download_with_progress(app, &asset.browser_download_url, &zip_path).await?;
+    let _ = app.emit(
+        UPDATE_PROGRESS,
+        UpdateProgress {
+            stage: "extracting".into(),
+            percent: 95,
+            downloaded_bytes: 0,
+            total_bytes: None,
+            message: "正在解压内核...".into(),
+        },
+    );
+    let extract_dir = temp_dir.join("thinghk_extract");
+    let _ = fs::remove_dir_all(&extract_dir);
+    extract_zip(&zip_path, &extract_dir)?;
+    // 在解压目录中查找 ThingHK.exe
+    let exe_path = find_thinghk_exe(&extract_dir).ok_or("内核包中未找到 ThingHK.exe".to_string())?;
+    let app_data = app
+        .path()
+        .app_data_dir()
+        .map_err(|e| format!("获取数据目录失败: {}", e))?;
+    let cores_dir = app_data.join("monitor").join("cores");
+    fs::create_dir_all(&cores_dir).map_err(|e| format!("创建内核目录失败: {}", e))?;
+    fs::copy(&exe_path, cores_dir.join("ThingHK.exe"))
+        .map_err(|e| format!("覆盖内核文件失败（请确认监控模块已停止）: {}", e))?;
+    // 清理临时文件
+    let _ = fs::remove_file(&zip_path);
+    let _ = fs::remove_dir_all(&extract_dir);
+    let _ = app.emit(
+        UPDATE_PROGRESS,
+        UpdateProgress {
+            stage: "done".into(),
+            percent: 100,
+            downloaded_bytes: 0,
+            total_bytes: None,
+            message: "ThingHK 内核更新完成".into(),
+        },
+    );
+    Ok(())
+}
+
+fn find_thinghk_exe(dir: &Path) -> Option<PathBuf> {
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                if let Some(found) = find_thinghk_exe(&path) {
+                    return Some(found);
+                }
+            } else if path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .map(|s| s.eq_ignore_ascii_case("ThingHK.exe"))
+                .unwrap_or(false)
+            {
+                return Some(path);
+            }
+        }
+    }
+    None
+}

src-tauri/src/win32_util.rs

@@ -0,0 +1,250 @@
+//! Win32 屏幕/光标/DPI 工具 —— 跨模块共享的平台封装。
+//!
+//! 从 `clipboard::popup` 迁出，供剪贴板弹窗、快速面板、托盘菜单等多窗口模块统一引用，
+//! 避免其他模块反向依赖剪贴板模块。
+
+/// 获取鼠标位置（屏幕坐标，物理像素）
+#[cfg(windows)]
+pub fn get_cursor_pos() -> Option<(i32, i32)> {
+    use windows_sys::Win32::Foundation::POINT;
+    use windows_sys::Win32::UI::WindowsAndMessaging::GetCursorPos;
+
+    let mut pt = POINT { x: 0, y: 0 };
+    unsafe {
+        if GetCursorPos(&mut pt) != 0 {
+            Some((pt.x, pt.y))
+        } else {
+            None
+        }
+    }
+}
+
+/// 获取主屏工作区尺寸（排除任务栏，物理像素）
+#[cfg(windows)]
+pub fn get_work_area() -> Option<(f64, f64)> {
+    use windows_sys::Win32::Foundation::RECT;
+    use windows_sys::Win32::UI::WindowsAndMessaging::{
+        SystemParametersInfoW, SPI_GETWORKAREA,
+    };
+
+    let mut rect = RECT { left: 0, top: 0, right: 0, bottom: 0 };
+    unsafe {
+        if SystemParametersInfoW(SPI_GETWORKAREA, 0, &mut rect as *mut _ as *mut _, 0) != 0 {
+            Some(((rect.right - rect.left) as f64, (rect.bottom - rect.top) as f64))
+        } else {
+            None
+        }
+    }
+}
+
+/// 获取指定点所在显示器的工作区（排除任务栏），返回 (left, top, right, bottom) 物理像素。
+/// 使用 MonitorFromPoint 支持多显示器环境。
+#[cfg(windows)]
+pub fn get_work_area_at_point(x: i32, y: i32) -> Option<(i32, i32, i32, i32)> {
+    use windows_sys::Win32::Foundation::POINT;
+    use windows_sys::Win32::Graphics::Gdi::{
+        GetMonitorInfoW, MonitorFromPoint, MONITORINFO, MONITOR_DEFAULTTONEAREST,
+    };
+
+    let pt = POINT { x, y };
+    let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
+    let mut mi: MONITORINFO = unsafe { std::mem::zeroed() };
+    mi.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
+    unsafe {
+        if GetMonitorInfoW(hmon, &mut mi) != 0 {
+            let rc = mi.rcWork;
+            Some((rc.left, rc.top, rc.right, rc.bottom))
+        } else {
+            None
+        }
+    }
+}
+
+/// 获取指定点所在显示器的完整边界（含任务栏），返回 (left, top, right, bottom) 物理像素。
+/// 与 get_work_area_at_point 不同，这里用 rcMonitor 而非 rcWork，
+/// 用于需要在鼠标位置弹出、允许贴近/覆盖任务栏的场景（如托盘菜单）。
+#[cfg(windows)]
+pub fn get_monitor_bounds_at_point(x: i32, y: i32) -> Option<(i32, i32, i32, i32)> {
+    use windows_sys::Win32::Foundation::POINT;
+    use windows_sys::Win32::Graphics::Gdi::{
+        GetMonitorInfoW, MonitorFromPoint, MONITORINFO, MONITOR_DEFAULTTONEAREST,
+    };
+
+    let pt = POINT { x, y };
+    let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
+    let mut mi: MONITORINFO = unsafe { std::mem::zeroed() };
+    mi.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
+    unsafe {
+        if GetMonitorInfoW(hmon, &mut mi) != 0 {
+            let rc = mi.rcMonitor;
+            Some((rc.left, rc.top, rc.right, rc.bottom))
+        } else {
+            None
+        }
+    }
+}
+
+/// 获取指定点所在显示器的有效 DPI。
+/// scale factor = dpi / 96。
+#[cfg(windows)]
+pub fn get_dpi_for_point(x: i32, y: i32) -> Option<u32> {
+    use windows_sys::Win32::Foundation::POINT;
+    use windows_sys::Win32::Graphics::Gdi::{MonitorFromPoint, MONITOR_DEFAULTTONEAREST};
+    use windows_sys::Win32::UI::HiDpi::{GetDpiForMonitor, MDT_EFFECTIVE_DPI};
+
+    let pt = POINT { x, y };
+    let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
+    let mut dpi_x: u32 = 0;
+    let mut dpi_y: u32 = 0;
+    unsafe {
+        if GetDpiForMonitor(hmon, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == 0 {
+            Some(dpi_x)
+        } else {
+            None
+        }
+    }
+}
+
+/// 强制将窗口置为前台（绕过 Windows 前台锁定限制）。
+/// Tauri 的 set_focus 内部调用 SetForegroundWindow，受前台锁定（foreground lock）限制：
+/// 本进程不拥有前台时调用会被系统忽略，导致已打开但被遮挡的窗口无法到前台。
+/// 先模拟 Alt 键释放以重置前台锁定，再 SetForegroundWindow + BringWindowToTop。
+#[cfg(windows)]
+pub fn force_foreground(hwnd: isize) {
+    use windows_sys::Win32::UI::Input::KeyboardAndMouse::{
+        keybd_event, KEYEVENTF_KEYUP, VK_MENU,
+    };
+    use windows_sys::Win32::UI::WindowsAndMessaging::{BringWindowToTop, SetForegroundWindow};
+
+    unsafe {
+        keybd_event(VK_MENU as u8, 0, KEYEVENTF_KEYUP, 0);
+        let _ = SetForegroundWindow(hwnd);
+        let _ = BringWindowToTop(hwnd);
+    }
+}
+
+/// 应用 WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW 扩展样式到指定窗口。
+/// 用于预览窗等不抢焦点的悬浮窗：窗口可接收鼠标交互但不激活、不进 Alt-Tab。
+#[cfg(windows)]
+pub fn apply_no_activate(hwnd: isize) {
+    use windows_sys::Win32::UI::WindowsAndMessaging::{
+        GetWindowLongPtrW, SetWindowLongPtrW, GWL_EXSTYLE, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
+    };
+    unsafe {
+        let ex = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
+        let new_ex = ex | (WS_EX_NOACTIVATE as isize) | (WS_EX_TOOLWINDOW as isize);
+        SetWindowLongPtrW(hwnd, GWL_EXSTYLE, new_ex);
+    }
+}
+
+/// 鼠标左键当前是否按下（GetAsyncKeyState，全局异步状态，无需窗口焦点）。
+/// 供看护线程轮询检测"点击外部"（配合按下沿判定）。
+#[cfg(windows)]
+pub fn is_left_button_down() -> bool {
+    use windows_sys::Win32::UI::Input::KeyboardAndMouse::GetAsyncKeyState;
+
+    const VK_LBUTTON: i32 = 0x01;
+    ((unsafe { GetAsyncKeyState(VK_LBUTTON) } as u32) & 0x8000) != 0
+}
+
+#[cfg(not(windows))]
+pub fn is_left_button_down() -> bool {
+    false
+}
+
+/// 强制窗口应用系统圆角（DWMWCP_ROUND，Win11 约 8px）。
+/// 带 WS_EX_NOACTIVATE 等扩展样式的悬浮窗系统不会自动圆角（呈现直角），
+/// 与常规弹窗外观不一致；通过 DWMWA_WINDOW_CORNER_PREFERENCE 显式指定圆角偏好。
+#[cfg(windows)]
+pub fn apply_rounded_corners(hwnd: isize) {
+    use windows_sys::Win32::Graphics::Dwm::{
+        DwmSetWindowAttribute, DWMWA_WINDOW_CORNER_PREFERENCE, DWMWCP_ROUND,
+    };
+
+    unsafe {
+        let pref: i32 = DWMWCP_ROUND;
+        let _ = DwmSetWindowAttribute(
+            hwnd,
+            DWMWA_WINDOW_CORNER_PREFERENCE as u32,
+            &pref as *const i32 as *const core::ffi::c_void,
+            std::mem::size_of::<i32>() as u32,
+        );
+    }
+}
+
+/// 以不激活方式显示窗口（SW_SHOWNOACTIVATE），避免抢走弹窗等前台窗口的焦点。
+#[cfg(windows)]
+pub fn show_no_activate(hwnd: isize) {
+    use windows_sys::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_SHOWNOACTIVATE};
+    unsafe {
+        ShowWindow(hwnd, SW_SHOWNOACTIVATE);
+    }
+}
+
+/// 隐藏窗口（SW_HIDE）。供以原生方式显示（SW_SHOWNOACTIVATE）的悬浮窗兜底隐藏，
+/// 与 Tauri 的 hide() 并存以确保任何路径下都被可靠隐藏。
+#[cfg(windows)]
+pub fn hide_window(hwnd: isize) {
+    use windows_sys::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_HIDE};
+    unsafe {
+        ShowWindow(hwnd, SW_HIDE);
+    }
+}
+
+/// 系统自上次用户输入（鼠标/键盘）以来的空闲时长（毫秒）。
+/// 用于闲时执行耗时后台任务（如文件索引构建），避免与应用运行/用户操作抢 IO。
+/// GetLastInputInfo 的 dwTime 与 GetTickCount 同为系统启动后毫秒数，用 wrapping 减法防回绕。
+#[cfg(windows)]
+pub fn get_idle_time_ms() -> u64 {
+    use windows_sys::Win32::System::SystemInformation::GetTickCount;
+    use windows_sys::Win32::UI::Input::KeyboardAndMouse::{
+        GetLastInputInfo, LASTINPUTINFO,
+    };
+    use std::mem::size_of;
+
+    let mut lii = LASTINPUTINFO {
+        cbSize: size_of::<LASTINPUTINFO>() as u32,
+        dwTime: 0,
+    };
+    unsafe {
+        if GetLastInputInfo(&mut lii) != 0 {
+            return GetTickCount().wrapping_sub(lii.dwTime) as u64;
+        }
+    }
+    0
+}
+
+// ===== 非 Windows 平台空实现 =====
+
+#[cfg(not(windows))]
+pub fn get_cursor_pos() -> Option<(i32, i32)> { None }
+
+#[cfg(not(windows))]
+pub fn get_work_area() -> Option<(f64, f64)> { None }
+
+#[cfg(not(windows))]
+pub fn get_work_area_at_point(_x: i32, _y: i32) -> Option<(i32, i32, i32, i32)> { None }
+
+#[cfg(not(windows))]
+pub fn get_dpi_for_point(_x: i32, _y: i32) -> Option<u32> { None }
+
+#[cfg(not(windows))]
+pub fn get_monitor_bounds_at_point(_x: i32, _y: i32) -> Option<(i32, i32, i32, i32)> { None }
+
+#[cfg(not(windows))]
+pub fn force_foreground(_hwnd: isize) {}
+
+#[cfg(not(windows))]
+pub fn apply_no_activate(_hwnd: isize) {}
+
+#[cfg(not(windows))]
+pub fn apply_rounded_corners(_hwnd: isize) {}
+
+#[cfg(not(windows))]
+pub fn show_no_activate(_hwnd: isize) {}
+
+#[cfg(not(windows))]
+pub fn hide_window(_hwnd: isize) {}
+
+#[cfg(not(windows))]
+pub fn get_idle_time_ms() -> u64 { 0 }

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "thing",
-  "version": "0.1.0",
+  "version": "26.8.2",
   "identifier": "thing.lfeng.me",
   "build": {
     "beforeDevCommand": "bun run dev",
@@ -12,19 +12,19 @@
   "app": {
     "windows": [
       {
-        "title": "thing",
+        "title": "Thing",
         "width": 1000,
         "height": 700,
         "decorations": false,
         "transparent": true,
         "visible": false,
         "windowEffects": {
-          "effects": ["acrylic", "mica"]
+          "effects": ["mica", "acrylic"]
         }
       }
     ],
     "security": {
-      "csp": null
+      "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: asset: http://asset.localhost; font-src 'self' data:; connect-src ipc: http://ipc.localhost; media-src 'self' data: blob:"
     }
   },
   "bundle": {
@@ -37,6 +37,11 @@
       "icons/icon.icns",
       "icons/icon.ico"
     ],
-    "resources": ["binaries/*", "resources/thing-extension/**/*"]
+    "resources": ["binaries/*", "resources/thing-extension/**/*"],
+    "windows": {
+      "nsis": {
+        "compression": "lzma"
+      }
+    }
   }
 }

src/App.vue

@@ -1,7 +1,6 @@
 <script setup lang="ts">
 import { ref, onMounted, onUnmounted, shallowRef, computed, watch, type Component } from 'vue'
 import { listen, type UnlistenFn } from '@tauri-apps/api/event'
-import { invoke } from '@tauri-apps/api/core'
 import { getCurrentWindow } from '@tauri-apps/api/window'
 import TitleBar from '@/components/layout/TitleBar.vue'
 import Sidebar from '@/components/layout/Sidebar.vue'
@@ -9,13 +8,21 @@ import ModuleContainer from '@/components/layout/ModuleContainer.vue'
 import { Toaster } from '@/components/ui/sonner'
 import { useAppStore } from '@/stores/appStore'
 import { useScreenshotStore } from '@/stores/screenshotStore'
+import { useQuickPanelStore } from '@/stores/quickpanelStore'
+import { useMonitorStore } from '@/stores/monitorStore'
+import { useProcessStore } from '@/stores/processStore'
 import { TooltipProvider } from '@/components/ui/tooltip'
 import { moduleRegistry } from '@/modules/registry'
 import type { ModuleMeta } from '@/types/module'
-import { pendingNewDownload, pendingOpenSettings } from '@/lib/trayEvents'
+import { pendingNewDownload, pendingShowDownloadTasks } from '@/lib/trayEvents'
+import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
+import { commands } from '@/lib/bindings'
 
 const appStore = useAppStore()
 const screenshotStore = useScreenshotStore()
+const quickpanelStore = useQuickPanelStore()
+const monitorStore = useMonitorStore()
+const processStore = useProcessStore()
 
 /** 侧边栏 / 标题栏需要的模块信息（id + name + icon） */
 interface NavModule {
@@ -32,18 +39,13 @@ const toNavModule = (meta: ModuleMeta): NavModule => ({
 })
 
 /** 上次激活的模块 ID（localStorage 持久化） */
-const LAST_MODULE_KEY = 'thing_last_module'
+const LAST_MODULE_KEY = STORAGE_KEYS.lastModule
 const activeModule = ref('')
 
 const activeComponent = shallowRef<Component | null>(null)
 
-/** 预加载的监控模块组件（用于隐藏预渲染，确保 OSD 在启动时创建） */
-const monitorComponent = shallowRef<Component | null>(null)
-
-/** 监控模块是否已启用 */
-const monitorEnabled = computed(() =>
-  appStore.modules.find(m => m.id === 'monitor')?.enabled ?? false
-)
+/** 模块组件加载中（异步 import 未完成）标志，避免切换期间仍显示上一个模块内容 */
+const moduleLoading = ref(false)
 
 /** 当前可显示的模块（内置模块 + 已启用的用户模块），按用户排序显示 */
 const availableModules = computed<NavModule[]>(() => {
@@ -65,9 +67,19 @@ const availableModules = computed<NavModule[]>(() => {
   })
 })
 
+/** 模块加载请求序号：快速切换模块时丢弃过期加载结果，避免旧组件覆盖新组件 */
+let moduleLoadSeq = 0
 const loadModule = async (moduleId: string) => {
+  const seq = ++moduleLoadSeq
+  // 立即清空旧组件并进入加载态，避免异步 import 期间仍渲染上一个模块内容
+  // （否则 ModuleContainer 以 :key="activeModule" 重挂载旧组件，用户误以为切换失败）
+  activeComponent.value = null
+  moduleLoading.value = true
   const component = await moduleRegistry.loadComponent(moduleId)
+  // 过期请求（期间用户又切换了模块）直接丢弃，不覆盖 activeComponent 也不触发钩子
+  if (seq !== moduleLoadSeq) return
   activeComponent.value = component
+  moduleLoading.value = false
 
   // 调用模块的 onActivate 生命周期钩子
   const config = moduleRegistry.getConfig(moduleId)
@@ -75,6 +87,9 @@ const loadModule = async (moduleId: string) => {
 }
 
 const handleModuleChange = (moduleId: string) => {
+  // 同模块不重新加载（保留组件状态）；搜索/托盘跳转到当前模块时仅触发 tab 导航
+  if (activeModule.value === moduleId) return
+
   // 调用上一个模块的 onDeactivate 钩子
   const prevConfig = moduleRegistry.getConfig(activeModule.value)
   prevConfig?.lifecycle?.onDeactivate?.()
@@ -84,10 +99,9 @@ const handleModuleChange = (moduleId: string) => {
   loadModule(moduleId)
 }
 
+// 搜索跳转与普通切换同路径：补齐 onDeactivate 钩子，避免旧模块资源泄漏
 const handleSearch = (moduleId: string) => {
-  activeModule.value = moduleId
-  localStorage.setItem(LAST_MODULE_KEY, moduleId)
-  loadModule(moduleId)
+  handleModuleChange(moduleId)
 }
 
 const getFallbackModule = () => {
@@ -98,57 +112,19 @@ const getFallbackModule = () => {
   return fallback?.id || 'settings'
 }
 
-watch(() => appStore.enabledModules.length, () => {
+// 按 id 列表监听（而非 length）：同时禁用一个 + 启用另一个时 length 不变，会漏检回退
+watch(() => appStore.enabledModules.map(m => m.id).join(','), () => {
   // 启动期间 activeModule 尚未确定，跳过
   if (!activeModule.value) return
   const enabledIds = appStore.enabledModules.map(m => m.id)
   if (activeModule.value !== 'settings' && !enabledIds.includes(activeModule.value)) {
     const fallback = getFallbackModule()
-    activeModule.value = fallback
-    loadModule(fallback)
+    handleModuleChange(fallback)
   }
   // 模块启用/禁用变化时重新同步快速面板命令缓存
-  syncQuickPanelCommands()
+  quickpanelStore.syncCommands()
 })
 
-/** 同步快速面板命令缓存到 localStorage（供独立窗口读取） */
-function syncQuickPanelCommands() {
-  const enabledIds = appStore.enabledModules.map(m => m.id)
-  const all = moduleRegistry.getAllSearchItems()
-  const commands: Array<{
-    moduleId: string
-    moduleName: string
-    title: string
-    description?: string
-    keywords: string[]
-  }> = []
-  for (const { moduleId, items } of all) {
-    const config = moduleRegistry.getConfig(moduleId)
-    // 内置模块或已启用模块的搜索项才收录
-    if (!config?.builtin && !enabledIds.includes(moduleId)) continue
-    for (const item of items) {
-      commands.push({
-        moduleId,
-        moduleName: config?.name ?? moduleId,
-        title: item.title,
-        description: item.description,
-        keywords: item.keywords,
-      })
-    }
-  }
-  localStorage.setItem('thing_quickpanel_commands', JSON.stringify(commands))
-}
-
-/** 同步快速面板设置到 localStorage（供独立窗口的 web provider 读取搜索引擎） */
-async function syncQuickPanelSettings() {
-  try {
-    const s = await invoke<{ shortcut: string; popupPosition: string; searchEngine: string; indexDirs: string[]; customCommands: unknown[] }>('quickpanel_get_settings')
-    localStorage.setItem('thing_quickpanel_settings', JSON.stringify(s))
-  } catch (e) {
-    console.error('[quickpanel] 同步设置失败:', e)
-  }
-}
-
 /** 计算启动时应打开的默认模块：优先上次记忆，其次排序第一个 */
 const resolveDefaultModule = (): string => {
   const enabledIds = appStore.enabledModules.map(m => m.id)
@@ -171,39 +147,48 @@ const resolveDefaultModule = (): string => {
 onMounted(async () => {
   await appStore.init().catch(e => console.error('App init error:', e))
 
-  // 预加载监控模块组件，用于隐藏预渲染
-  // 这样即使启动时默认模块不是监控，MonitorModule 的 onMounted 也会执行
-  // 从而在应用启动时自动创建 OSD 窗口（如果 OSD 配置已开启）
-  if (monitorEnabled.value) {
-    monitorComponent.value = await moduleRegistry.loadComponent('monitor')
-  }
+  // 初始化监控 store：订阅后端 monitor-data / monitor-network 等事件，
+  // 使 OSD 窗口在应用启动后即可接收数据流，不依赖用户手动打开监控模块。
+  // init() 幂等：MonitorModule 挂载时再次调用不会重复订阅。
+  monitorStore.init()
+  // 显式初始化 OSD
+  // 使 OSD 窗口在应用启动时创建（若配置已开启），且不依赖监控模块挂载/卸载
+  monitorStore.initOsd()
 
   const defaultModule = resolveDefaultModule()
   activeModule.value = defaultModule
   loadModule(defaultModule)
 
   // 快速面板：同步命令缓存与设置到 localStorage，供独立窗口读取
-  syncQuickPanelCommands()
-  syncQuickPanelSettings()
+  quickpanelStore.syncCommands()
+  quickpanelStore.syncSettings()
+  // 初始化文件索引 DB 并恢复增量监听（上次构建过索引时自动恢复，不重建）
+  commands.quickpanelInitFileIndex().catch(e => console.error('文件索引初始化失败:', e))
   // 监听快速面板执行命令事件：显示主窗口 + 切换模块
   trayUnlisteners.push(
     await listen<{ moduleId: string }>('quickpanel-execute-command', async (e) => {
-      const win = getCurrentWindow()
+      // Rust 端强制置前（绕过 Windows 前台锁定，主窗口被遮挡时也能到前台）
       try {
-        await win.show()
-        await win.unminimize()
-        await win.setFocus()
+        await commands.quickpanelFocusMainWindow()
       } catch {
-        /* 忽略窗口操作失败 */
+        // 回退：前端 show + setFocus
+        const win = getCurrentWindow()
+        try {
+          await win.show()
+          await win.unminimize()
+          await win.setFocus()
+        } catch {
+          /* 忽略窗口操作失败 */
+        }
       }
       handleSearch(e.payload.moduleId)
     })
   )
 
   // 监听托盘菜单事件
-  // tray:toggle-osd 由 MonitorModule 直接监听（预渲染实例始终挂载）
+  // tray:toggle-osd 由 monitorStore.initOsd() 注册的监听处理（与监控模块生命周期解耦）
   trayUnlisteners.push(
-    await listen('tray:new-download', () => {
+    await listen(EVENTS.trayNewDownload, () => {
       // 设置标志位，DownloaderModule 挂载后消费
       pendingNewDownload.value = true
       // 切换到下载模块（如果未启用则切换到设置）
@@ -213,9 +198,18 @@ onMounted(async () => {
       }
     })
   )
+  // 浏览器扩展新增下载：直接切到下载模块的任务列表页（主窗口已由 Rust 端置前）
   trayUnlisteners.push(
-    await listen('tray:open-settings', () => {
-      pendingOpenSettings.value = true
+    await listen(EVENTS.downloadExtensionAdded, () => {
+      const enabledIds = appStore.enabledModules.map(m => m.id)
+      if (enabledIds.includes('downloader') || moduleRegistry.getConfig('downloader')?.builtin) {
+        pendingShowDownloadTasks.value = true
+        handleModuleChange('downloader')
+      }
+    })
+  )
+  trayUnlisteners.push(
+    await listen(EVENTS.trayOpenSettings, () => {
       handleModuleChange('settings')
     })
   )
@@ -228,6 +222,10 @@ const trayUnlisteners: UnlistenFn[] = []
 onUnmounted(() => {
   trayUnlisteners.forEach(fn => fn())
   screenshotStore.destroyExportListener()
+  // 释放 OSD 事件监听与配置 watcher
+  monitorStore.disposeOsd()
+  // 释放进程状态事件监听
+  processStore.destroyListener()
 })
 </script>
 
@@ -241,14 +239,9 @@ onUnmounted(() => {
           :active-module="activeModule"
           @change="handleModuleChange"
         />
-        <ModuleContainer :active-component="activeComponent" :active-module="activeModule" />
+        <ModuleContainer :active-component="activeComponent" :active-module="activeModule" :loading="moduleLoading" />
       </div>
     </div>
     <Toaster position="bottom-right" rich-colors close-button :style="{ zIndex: 99999 }" />
-    <!-- 预渲染监控模块（隐藏）：确保 OSD 窗口在应用启动时创建，不依赖用户切换到监控模块。
-         当 activeModule === 'monitor' 时不渲染（由 ModuleContainer 正常渲染），避免重复实例 -->
-    <div v-if="monitorComponent && monitorEnabled && activeModule !== 'monitor'" style="display:none">
-      <component :is="monitorComponent" />
-    </div>
   </TooltipProvider>
 </template>

src/components/layout/ModuleContainer.vue

@@ -1,15 +1,32 @@
 <script setup lang="ts">
 import type { Component } from 'vue'
+import { ref, watch } from 'vue'
 import { ScrollArea } from '@/components/ui/scroll-area'
+import { Skeleton } from '@/components/ui/skeleton'
 
-defineProps<{
+const props = defineProps<{
   activeComponent: Component | null
   activeModule: string
+  loading: boolean
 }>()
+
+const containerRef = ref<HTMLElement | null>(null)
+
+// 切换模块时重置主滚动区位置，避免新模块沿用上一个模块的滚动距离
+watch(
+  () => props.activeModule,
+  () => {
+    const viewport = containerRef.value?.querySelector<HTMLElement>(
+      '[data-slot="scroll-area-viewport"]'
+    )
+    if (viewport) viewport.scrollTop = 0
+  }
+)
 </script>
 
 <template>
   <main
+    ref="containerRef"
     class="flex-1"
     :style="{ backgroundColor: 'var(--effect-bg)', backdropFilter: 'var(--effect-blur)' }"
   >
@@ -22,6 +39,30 @@ defineProps<{
         >
           <component :is="activeComponent" />
         </div>
+        <div
+          v-else-if="loading"
+          key="loading"
+          class="h-full w-full p-6"
+        >
+          <!-- 模块加载骨架：撑起画面，避免空白闪屏 -->
+          <div class="h-full max-w-5xl mx-auto space-y-5">
+            <div class="flex items-center gap-3">
+              <Skeleton class="h-8 w-40" />
+              <Skeleton class="h-6 w-24 ml-auto" />
+            </div>
+            <div class="grid gap-4 md:grid-cols-2">
+              <div v-for="n in 4" :key="n" class="rounded-lg border p-5 space-y-4">
+                <div class="flex items-center justify-between">
+                  <Skeleton class="h-5 w-32" />
+                  <Skeleton class="h-5 w-16" />
+                </div>
+                <Skeleton class="h-4 w-full" />
+                <Skeleton class="h-4 w-5/6" />
+                <Skeleton class="h-4 w-2/3" />
+              </div>
+            </div>
+          </div>
+        </div>
         <div
           v-else
           key="empty"

src/components/layout/Sidebar.vue

@@ -31,14 +31,14 @@ const displayModules = computed(() => {
             <Button
               :variant="activeModule === module.id ? 'default' : 'ghost'"
               size="icon"
-              class="h-10 w-10 rounded-lg transition-[background-color,color,box-shadow] duration-300"
+              class="size-10 rounded-lg transition-[background-color,color,box-shadow] duration-300"
               :class="{
                 'bg-primary text-primary-foreground shadow-md': activeModule === module.id,
                 'hover:bg-secondary/50': activeModule !== module.id
               }"
-              @click="emit('change', module.id)"
+              @click="activeModule !== module.id && emit('change', module.id)"
             >
-              <component :is="getModuleIcon(module.icon)" class="h-5 w-5" />
+              <component :is="getModuleIcon(module.icon)" class="size-4" />
             </Button>
           </TooltipTrigger>
           <TooltipContent side="right" class="w-fit">
@@ -55,14 +55,14 @@ const displayModules = computed(() => {
         <Button
           :variant="activeModule === 'settings' ? 'default' : 'ghost'"
           size="icon"
-          class="h-10 w-10 rounded-lg transition-[background-color,color,box-shadow] duration-300"
+          class="size-10 rounded-lg transition-[background-color,color,box-shadow] duration-300"
           :class="{
             'bg-primary text-primary-foreground shadow-md': activeModule === 'settings',
             'hover:bg-secondary/50': activeModule !== 'settings'
           }"
-          @click="emit('change', 'settings')"
+          @click="activeModule !== 'settings' && emit('change', 'settings')"
         >
-          <Settings class="h-5 w-5" />
+          <Settings class="size-4" />
         </Button>
       </TooltipTrigger>
       <TooltipContent side="right" class="w-fit">

src/components/layout/TitleBar.vue

@@ -1,11 +1,13 @@
 <script setup lang="ts">
-import { ref, computed, onMounted, onUnmounted, nextTick } from 'vue'
+import { ref, computed, onMounted, onUnmounted, nextTick, watch } from 'vue'
 import { Search, Settings, ChevronRight, ArrowUp, Check, Loader2 } from '@lucide/vue'
 import { Input } from '@/components/ui/input'
 import { invoke } from '@tauri-apps/api/core'
 import { getCurrentWindow } from '@tauri-apps/api/window'
 import { useSearchStore, type SearchItem } from '@/stores/searchStore'
 import { useModuleTabsStore } from '@/stores/moduleTabsStore'
+// 复用快速面板匹配引擎（支持拼音/子序列模糊匹配）
+import { getTextForms, bestScore } from '@/modules/quickpanel/engine'
 
 const tabsStore = useModuleTabsStore()
 
@@ -23,10 +25,12 @@ const searchStore = useSearchStore()
 
 const filteredModules = computed(() => {
   if (!searchQuery.value.trim()) return []
-  const query = searchQuery.value.toLowerCase()
-  return props.modules.filter(m => 
-    m.name.toLowerCase().includes(query) || m.id.toLowerCase().includes(query)
-  )
+  const query = searchQuery.value.trim()
+  return props.modules
+    .map(m => ({ m, score: Math.max(bestScore(query, getTextForms(m.name)), bestScore(query, getTextForms(m.id))) }))
+    .filter(e => e.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map(e => e.m)
 })
 
 const searchResults = computed(() => {
@@ -38,6 +42,11 @@ const hasSearchContent = computed(() => {
   return searchQuery.value.trim().length > 0
 })
 
+/** 模块 id → 名称 查找表（用于搜索结果中标注所属模块） */
+const moduleNameById = computed(() => {
+  return new Map(props.modules.map(m => [m.id, m.name]))
+})
+
 const handleSearchSelect = (moduleId: string) => {
   emit('search', moduleId)
   searchQuery.value = ''
@@ -46,6 +55,10 @@ const handleSearchSelect = (moduleId: string) => {
 
 const handleSettingSelect = (item: SearchItem) => {
   emit('search', item.moduleId)
+  // 记录待跳转 tab：模块挂载后由 useModuleTabs 自动切换（模块已挂载时同样生效）
+  if (item.tab) {
+    tabsStore.setPendingTab(item.moduleId, item.tab)
+  }
   if (item.action) {
     item.action()
   }
@@ -53,6 +66,65 @@ const handleSettingSelect = (item: SearchItem) => {
   isSearchFocused.value = false
 }
 
+// ===== 搜索下拉键盘导航（↑↓ 移动 / Enter 选择 / ESC 清空） =====
+
+/** 下拉扁平结果（模块在前、设置项在后），用于统一索引 */
+const flatResults = computed(() => [
+  ...filteredModules.value.map(m => ({ kind: 'module' as const, id: m.id })),
+  ...searchResults.value.map(s => ({ kind: 'setting' as const, id: s.id }))
+])
+
+/** 当前高亮索引（-1 无高亮） */
+const highlightIndex = ref(-1)
+
+const isDropdownOpen = computed(() => isSearchFocused.value && hasSearchContent.value)
+
+// 查询变化时重置高亮到第一项
+watch(searchQuery, () => {
+  highlightIndex.value = flatResults.value.length > 0 ? 0 : -1
+})
+
+const selectIndex = (index: number) => {
+  const entry = flatResults.value[index]
+  if (!entry) return
+  if (entry.kind === 'module') {
+    handleSearchSelect(entry.id)
+  } else {
+    const item = searchResults.value.find(s => s.id === entry.id)
+    if (item) handleSettingSelect(item)
+  }
+}
+
+const handleSearchKeydown = (e: KeyboardEvent) => {
+  if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+    if (!isDropdownOpen.value || flatResults.value.length === 0) return
+    e.preventDefault()
+    const delta = e.key === 'ArrowDown' ? 1 : -1
+    const len = flatResults.value.length
+    highlightIndex.value = (highlightIndex.value + delta + len) % len
+    // 高亮项滚动到下拉可视区（容器 overflow-y-auto）
+    nextTick(() => {
+      document
+        .querySelector(`[data-search-idx="${highlightIndex.value}"]`)
+        ?.scrollIntoView({ block: 'nearest' })
+    })
+  } else if (e.key === 'Enter') {
+    if (isDropdownOpen.value && highlightIndex.value >= 0) {
+      e.preventDefault()
+      selectIndex(highlightIndex.value)
+    }
+  } else if (e.key === 'Escape') {
+    e.preventDefault()
+    if (searchQuery.value) {
+      // 第一阶段：清空查询（下拉随内容消失）
+      searchQuery.value = ''
+    } else {
+      // 第二阶段：失焦收起
+      ;(e.target as HTMLElement).blur()
+    }
+  }
+}
+
 let tauriWindow: ReturnType<typeof getCurrentWindow> | null = null
 try {
   tauriWindow = getCurrentWindow()
@@ -68,6 +140,7 @@ const minimize = async () => {
 // 窗口最大化状态：切换最大化/还原图标
 const isMaximized = ref(false)
 let unlistenMaximize: (() => void) | null = null
+let unlistenFocus: (() => void) | null = null
 
 const maximize = async () => {
   await tauriWindow?.toggleMaximize()
@@ -118,7 +191,8 @@ const close = async () => {
 }
 
 if (tauriWindow) {
-  tauriWindow.onFocusChanged(({ payload: focused }) => {
+  // 保存 unlisten，onUnmounted 时释放（onFocusChanged 返回 Promise<UnlistenFn>）
+  void tauriWindow.onFocusChanged(({ payload: focused }) => {
     if (focused) {
       hoverSuppressed.value = true
       if (document.activeElement instanceof HTMLElement) {
@@ -131,6 +205,8 @@ if (tauriWindow) {
     } else {
       hoverSuppressed.value = true
     }
+  }).then(fn => {
+    unlistenFocus = fn
   })
 }
 
@@ -179,12 +255,23 @@ const initScrollListener = () => {
   }
 }
 
+// resize 节流定时器：拖拽调整大小时 onResized 高频触发，避免每次都发 isMaximized IPC
+let resizeDebounce: ReturnType<typeof setTimeout> | null = null
+
 onMounted(async () => {
   if (tauriWindow) {
     try {
       isMaximized.value = await tauriWindow.isMaximized()
-      unlistenMaximize = await tauriWindow.onResized(async () => {
-        isMaximized.value = await tauriWindow!.isMaximized()
+      unlistenMaximize = await tauriWindow.onResized(() => {
+        if (resizeDebounce) return
+        resizeDebounce = setTimeout(async () => {
+          resizeDebounce = null
+          try {
+            isMaximized.value = await tauriWindow!.isMaximized()
+          } catch {
+            /* 窗口已销毁等异常忽略 */
+          }
+        }, 150)
       })
     } catch {
       // 非 Tauri 环境忽略
@@ -201,7 +288,9 @@ onMounted(async () => {
 onUnmounted(() => {
   window.removeEventListener('mousemove', handleFirstMouseMove)
   if (restoreHoverTimer) clearTimeout(restoreHoverTimer)
+  if (resizeDebounce) clearTimeout(resizeDebounce)
   if (unlistenMaximize) unlistenMaximize()
+  if (unlistenFocus) unlistenFocus()
   if (scrollViewport) scrollViewport.removeEventListener('scroll', handleMainScroll)
   if (rafId !== null) cancelAnimationFrame(rafId)
 })
@@ -250,8 +339,7 @@ const handleBlur = () => {
         <Transition name="floating-tabs">
           <button
             v-if="showScrollTop"
-            class="flex items-center justify-center h-6 w-6 rounded-md text-muted-foreground hover:text-foreground hover:bg-secondary/60 transition-colors"
-            title="回到顶部"
+            class="flex items-center justify-center size-6 rounded-md text-muted-foreground hover:text-foreground hover:bg-secondary/60 transition-colors"
             @click="scrollToTop"
             @mousedown.stop
           >
@@ -267,7 +355,6 @@ const handleBlur = () => {
           v-if="tabsStore.saveVisible"
           class="flex items-center gap-1.5 h-7 px-3 mr-1 text-xs font-medium rounded-md bg-primary text-primary-foreground hover:bg-primary/90 disabled:opacity-60 disabled:pointer-events-none transition-colors pointer-events-auto"
           :disabled="tabsStore.saving"
-          title="保存当前模块设置"
           @click="tabsStore.runSave"
           @mousedown.stop
         >
@@ -278,7 +365,7 @@ const handleBlur = () => {
       </Transition>
       <div class="relative max-w-xs mr-3 pointer-events-auto">
         <Search 
-          class="absolute left-2.5 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" 
+          class="absolute left-2.5 top-1/2 -translate-y-1/2 size-4 text-muted-foreground" 
         />
         <Input
           v-model="searchQuery"
@@ -286,9 +373,10 @@ const handleBlur = () => {
           class="h-7 pl-8 text-sm bg-secondary/50 border-0 focus-visible:ring-1"
           @focus="isSearchFocused = true"
           @blur="handleBlur"
+          @keydown="handleSearchKeydown"
         />
         <div
-          v-if="isSearchFocused && hasSearchContent"
+          v-if="isDropdownOpen"
           class="absolute top-full left-0 right-0 mt-1 bg-popover border border-border rounded-md shadow-lg z-50 overflow-hidden max-h-64 overflow-y-auto"
         >
           <template v-if="filteredModules.length > 0">
@@ -296,10 +384,13 @@ const handleBlur = () => {
               模块
             </div>
             <button
-              v-for="module in filteredModules"
+              v-for="(module, mi) in filteredModules"
               :key="module.id"
               class="w-full px-3 py-2 text-left text-sm hover:bg-accent transition-colors flex items-center gap-2"
+              :class="highlightIndex === mi ? 'bg-accent' : ''"
+              :data-search-idx="mi"
               @click="handleSearchSelect(module.id)"
+              @mouseenter="highlightIndex = mi"
             >
               <span>{{ module.name }}</span>
             </button>
@@ -311,19 +402,27 @@ const handleBlur = () => {
               设置项
             </div>
             <button
-              v-for="item in searchResults"
+              v-for="(item, si) in searchResults"
               :key="item.id"
               class="w-full px-3 py-2 text-left text-sm hover:bg-accent transition-colors flex items-center gap-2"
+              :class="highlightIndex === filteredModules.length + si ? 'bg-accent' : ''"
+              :data-search-idx="filteredModules.length + si"
               @click="handleSettingSelect(item)"
+              @mouseenter="highlightIndex = filteredModules.length + si"
             >
-              <Settings class="h-4 w-4 text-muted-foreground" />
+              <Settings class="size-4 text-muted-foreground shrink-0" />
               <div class="flex-1 min-w-0">
-                <span class="truncate">{{ item.title }}</span>
+                <div class="flex items-center gap-1.5">
+                  <span class="truncate">{{ item.title }}</span>
+                  <span class="shrink-0 text-[10px] text-muted-foreground/70 px-1 py-px rounded bg-muted">
+                    {{ moduleNameById.get(item.moduleId) || item.moduleId }}
+                  </span>
+                </div>
                 <span v-if="item.description" class="block text-xs text-muted-foreground truncate">
                   {{ item.description }}
                 </span>
               </div>
-              <ChevronRight class="h-4 w-4 text-muted-foreground" />
+              <ChevronRight class="size-4 text-muted-foreground shrink-0" />
             </button>
           </template>
           
@@ -338,7 +437,7 @@ const handleBlur = () => {
     
     <div class="flex items-center pointer-events-auto" :class="{ 'hover-suppressed': hoverSuppressed }">
       <button
-        class="h-10 w-10 flex items-center justify-center hover:bg-foreground/5 transition-colors rounded-sm"
+        class="size-10 flex items-center justify-center hover:bg-foreground/5 transition-colors rounded-sm"
         @click="minimize"
         @mousedown.stop
       >
@@ -349,7 +448,7 @@ const handleBlur = () => {
       </button>
       <button
         id="titlebar-maximize"
-        class="h-10 w-10 flex items-center justify-center transition-colors rounded-sm titlebar-maximize-btn"
+        class="size-10 flex items-center justify-center transition-colors rounded-sm titlebar-maximize-btn"
         @click="maximize"
         @mousedown.stop
       >
@@ -366,7 +465,7 @@ const handleBlur = () => {
         </svg>
       </button>
       <button
-        class="h-10 w-10 flex items-center justify-center hover:bg-red-500 hover:text-white text-foreground transition-colors rounded-sm"
+        class="size-10 flex items-center justify-center hover:bg-red-500 hover:text-white text-foreground transition-colors rounded-sm"
         @click="close"
         @mousedown.stop
       >

src/components/ui/empty/Empty.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import { cn } from "@/lib/utils"
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"]
+}>()
+</script>
+
+<template>
+  <div
+    data-slot="empty"
+    :class="cn(
+      'flex min-w-0 flex-1 flex-col items-center justify-center gap-6 text-balance rounded-lg border-dashed p-6 text-center md:p-12',
+      props.class,
+    )"
+  >
+    <slot />
+  </div>
+</template>

src/components/ui/empty/EmptyContent.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import { cn } from "@/lib/utils"
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"]
+}>()
+</script>
+
+<template>
+  <div
+    data-slot="empty-content"
+    :class="cn(
+      'flex w-full min-w-0 max-w-sm flex-col items-center gap-4 text-balance text-sm',
+      props.class,
+    )"
+  >
+    <slot />
+  </div>
+</template>

src/components/ui/empty/EmptyDescription.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import { cn } from "@/lib/utils"
+
+defineProps<{
+  class?: HTMLAttributes["class"]
+}>()
+</script>
+
+<template>
+  <p
+    data-slot="empty-description"
+    :class="cn(
+      'text-muted-foreground [&>a:hover]:text-primary text-sm/relaxed [&>a]:underline [&>a]:underline-offset-4',
+      $attrs.class ?? '',
+    )"
+  >
+    <slot />
+  </p>
+</template>

src/components/ui/empty/EmptyHeader.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import { cn } from "@/lib/utils"
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"]
+}>()
+</script>
+
+<template>
+  <div
+    data-slot="empty-header"
+    :class="cn(
+      'flex max-w-sm flex-col items-center gap-2 text-center',
+      props.class,
+    )"
+  >
+    <slot />
+  </div>
+</template>

src/components/ui/empty/EmptyMedia.vue

@@ -0,0 +1,21 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import type { EmptyMediaVariants } from "."
+import { cn } from "@/lib/utils"
+import { emptyMediaVariants } from "."
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"]
+  variant?: EmptyMediaVariants["variant"]
+}>()
+</script>
+
+<template>
+  <div
+    data-slot="empty-icon"
+    :data-variant="variant"
+    :class="cn(emptyMediaVariants({ variant }), props.class)"
+  >
+    <slot />
+  </div>
+</template>

src/components/ui/empty/EmptyTitle.vue

@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import { cn } from "@/lib/utils"
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"]
+}>()
+</script>
+
+<template>
+  <div
+    data-slot="empty-title"
+    :class="cn('text-lg font-medium tracking-tight', props.class)"
+  >
+    <slot />
+  </div>
+</template>

src/components/ui/empty/index.ts

@@ -0,0 +1,26 @@
+import type { VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+
+export { default as Empty } from "./Empty.vue"
+export { default as EmptyContent } from "./EmptyContent.vue"
+export { default as EmptyDescription } from "./EmptyDescription.vue"
+export { default as EmptyHeader } from "./EmptyHeader.vue"
+export { default as EmptyMedia } from "./EmptyMedia.vue"
+export { default as EmptyTitle } from "./EmptyTitle.vue"
+
+export const emptyMediaVariants = cva(
+  "mb-2 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-transparent",
+        icon: "bg-muted text-foreground flex size-10 shrink-0 items-center justify-center rounded-lg [&_svg:not([class*='size-'])]:size-6",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+)
+
+export type EmptyMediaVariants = VariantProps<typeof emptyMediaVariants>

src/components/ui/skeleton/Skeleton.vue

@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue"
+import { cn } from "@/lib/utils"
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"]
+}>()
+</script>
+
+<template>
+  <div
+    data-slot="skeleton"
+    :class="cn('animate-pulse rounded-md bg-muted', props.class)"
+  />
+</template>

src/components/ui/skeleton/index.ts

@@ -0,0 +1 @@
+export { default as Skeleton } from "./Skeleton.vue"

src/components/ui/switch/Switch.vue

@@ -24,7 +24,7 @@ const forwarded = useForwardPropsEmits(delegatedProps, emits)
     data-slot="switch"
     v-bind="forwarded"
     :class="cn(
-      'peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-3 disabled:cursor-not-allowed disabled:opacity-50',
+      'peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-3 disabled:cursor-not-allowed disabled:opacity-50 cursor-pointer hover:data-[state=checked]:bg-primary/90 hover:data-[state=unchecked]:bg-input/70 active:scale-95',
       props.class,
     )"
   >

src/components/ui/tooltip/TooltipContent.vue

@@ -24,7 +24,7 @@ const forwarded = useForwardPropsEmits(delegatedProps, emits)
     <TooltipContent
       data-slot="tooltip-content"
       v-bind="{ ...forwarded, ...$attrs }"
-      :class="cn('bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit rounded-md px-3 py-1.5 text-xs text-balance', props.class)"
+      :class="cn('bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit max-w-[calc(100vw-2rem)] rounded-md px-3 py-1.5 text-xs', props.class)"
     >
       <slot />
 

src/lib/bindings.ts

@@ -0,0 +1,647 @@
+// This file has been generated by Tauri Specta. Do not edit this file manually.
+
+import { invoke as __TAURI_INVOKE } from "@tauri-apps/api/core";
+
+/** Commands */
+export const commands = {
+	/**  获取当前应用版本 */
+	appVersion: () => __TAURI_INVOKE<string>("app_version"),
+	/**  检查 Gitea 最新 release，返回版本对比与可用资产 */
+	updateCheck: () => __TAURI_INVOKE<UpdateCheckResult>("update_check"),
+	/**
+	 *  更新应用本体（安装阶段）。下载由前端下载模块完成，本命令接收已下载的
+	 *  安装包路径（便携版 thing_{v}_x64.exe / 安装版 thing_{v}_x64-setup.exe）。
+	 *  便携版：copy 到临时目录 → update.bat 覆盖重启；
+	 *  安装版：copy 到临时目录 → 提权静默安装 /S。
+	 *  调用返回前会触发应用退出。
+	 */
+	updateInstall: (downloadedPath: string) => __TAURI_INVOKE<null>("update_install", { downloadedPath }),
+	/**  更新 ThingHK 内核：下载 thing-hk_{v}.zip → 停止监控内核 → 覆盖内核文件 */
+	updateThinghk: () => __TAURI_INVOKE<null>("update_thinghk"),
+	proxyActivateProfile: (id: string) => __TAURI_INVOKE<null>("proxy_activate_profile", { id }),
+	/**  应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。 */
+	proxyApplyKernelUpdate: (zipPath: string) => __TAURI_INVOKE<KernelInfo>("proxy_apply_kernel_update", { zipPath }),
+	/**  取消内核下载/安装（设置取消标志，下载循环轮询后中止） */
+	proxyCancelKernelInstall: () => __TAURI_INVOKE<null>("proxy_cancel_kernel_install"),
+	proxyCheckKernelUpdate: () => __TAURI_INVOKE<KernelUpdateInfo>("proxy_check_kernel_update"),
+	proxyClearSystemProxy: () => __TAURI_INVOKE<null>("proxy_clear_system_proxy"),
+	proxyCloseConnection: (id: string) => __TAURI_INVOKE<null>("proxy_close_connection", { id }),
+	/**
+	 *  前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换。
+	 *  （下载阶段允许 mihomo 运行以便走系统代理，解压替换前必须停止 mihomo，否则 exe 被占用）
+	 */
+	proxyConfirmInstall: () => __TAURI_INVOKE<null>("proxy_confirm_install"),
+	proxyDeleteProfile: (id: string) => __TAURI_INVOKE<null>("proxy_delete_profile", { id }),
+	proxyGetSettings: () => __TAURI_INVOKE<ProxySettings>("proxy_get_settings"),
+	proxyGetSystemProxy: () => __TAURI_INVOKE<boolean>("proxy_get_system_proxy"),
+	proxyImportProfile: (url: string, name: string) => __TAURI_INVOKE<ProfileMeta>("proxy_import_profile", { url, name }),
+	proxyKernelInfo: () => __TAURI_INVOKE<KernelInfo>("proxy_kernel_info"),
+	proxyRestart: () => __TAURI_INVOKE<ProcessInfo>("proxy_restart"),
+	proxySaveSettings: (settings: ProxySettings) => __TAURI_INVOKE<null>("proxy_save_settings", { settings }),
+	proxySelectProxy: (group: string, name: string) => __TAURI_INVOKE<null>("proxy_select_proxy", { group, name }),
+	proxySetSystemProxy: () => __TAURI_INVOKE<null>("proxy_set_system_proxy"),
+	proxyStart: () => __TAURI_INVOKE<ProcessInfo>("proxy_start"),
+	proxyStatus: () => __TAURI_INVOKE<ProxyStatus>("proxy_status"),
+	proxyStop: () => __TAURI_INVOKE<null>("proxy_stop"),
+	proxyTestDelay: (name: string, url: string | null, timeout: number | null) => __TAURI_INVOKE<number>("proxy_test_delay", { name, url, timeout }),
+	proxyUpdateProfile: (id: string) => __TAURI_INVOKE<ProfileMeta>("proxy_update_profile", { id }),
+	/**  读取快速面板设置（快捷键等） */
+	quickpanelGetSettings: () => __TAURI_INVOKE<QuickPanelSettings>("quickpanel_get_settings"),
+	/**
+	 *  保存快速面板设置；快捷键变化时自动重新注册 + 预创建窗口，
+	 *  索引目录变化时闲时自动重建索引。
+	 */
+	quickpanelSaveSettings: (settings: QuickPanelSettings) => __TAURI_INVOKE<null>("quickpanel_save_settings", { settings }),
+	/**  注册（或切换）快速面板全局快捷键 */
+	quickpanelRegisterShortcut: (shortcut: string) => __TAURI_INVOKE<null>("quickpanel_register_shortcut", { shortcut }),
+	/**  注销快速面板全局快捷键 */
+	quickpanelUnregisterShortcut: () => __TAURI_INVOKE<null>("quickpanel_unregister_shortcut"),
+	/**  手动触发显示快速面板（供 UI 按钮调用） */
+	quickpanelShowPopup: () => __TAURI_INVOKE<null>("quickpanel_show_popup"),
+	/**  隐藏快速面板 */
+	quickpanelHidePopup: () => __TAURI_INVOKE<null>("quickpanel_hide_popup"),
+	/**  显示已创建的弹窗窗口（前端 onMounted 后调用） */
+	quickpanelShowWindow: () => __TAURI_INVOKE<null>("quickpanel_show_window"),
+	/**  锁定屏幕（Windows: rundll32 user32.dll,LockWorkStation，CREATE_NO_WINDOW 避免黑窗） */
+	quickpanelLockScreen: () => __TAURI_INVOKE<null>("quickpanel_lock_screen"),
+	/**
+	 *  初始化文件索引数据库（应用启动时调用）。
+	 *  若存在上次构建的索引（last_built_dirs 非空），自动恢复 notify 增量监听，
+	 *  无需重建即可继续自动同步文件变更。
+	 *  若从未构建过（首次运行），闲时自动建立索引，无需用户手动点"构建索引"。
+	 */
+	quickpanelInitFileIndex: () => __TAURI_INVOKE<null>("quickpanel_init_file_index"),
+	/**  构建文件索引（全量重建，阻塞操作建议在 spawn_blocking 调用） */
+	quickpanelBuildFileIndex: () => __TAURI_INVOKE<number>("quickpanel_build_file_index"),
+	/**  搜索文件索引（SQLite 查询移出主线程） */
+	quickpanelSearchFiles: (query: string, limit: number | null) => __TAURI_INVOKE<FileRecord[]>("quickpanel_search_files", { query, limit }),
+	/**  获取索引状态 */
+	quickpanelFileIndexStats: () => __TAURI_INVOKE<IndexStats>("quickpanel_file_index_stats"),
+	/**  扫描已安装应用（遍历开始菜单/桌面/磁盘，移出主线程） */
+	quickpanelScanApps: () => __TAURI_INVOKE<AppRecord[]>("quickpanel_scan_apps"),
+	/**
+	 *  获取应用图标（data URL）。命中内存/磁盘缓存时零 Windows API 调用。
+	 *  前端按需为可见项调用，避免一次性加载全部图标。
+	 *  未命中缓存时 SHGetFileInfoW + 编码 + 落盘为阻塞操作，移出主线程。
+	 */
+	quickpanelGetAppIcon: (path: string) => __TAURI_INVOKE<string | null>("quickpanel_get_app_icon", { path }),
+	/**  清理图标缓存（磁盘 + 内存） */
+	quickpanelClearAppIconCache: () => __TAURI_INVOKE<null>("quickpanel_clear_app_icon_cache"),
+	/**  在资源管理器中显示文件（选中） */
+	quickpanelRevealInExplorer: (path: string) => __TAURI_INVOKE<null>("quickpanel_reveal_in_explorer", { path }),
+	/**
+	 *  用系统默认程序打开文件/文件夹。
+	 *  - 目录：explorer.exe 直接打开（修复索引目录点击后未打开的问题）
+	 *  - 文件：ShellExecuteW open，无关联应用时自动 fallback 到「打开方式」对话框（verb: openas）
+	 */
+	quickpanelOpenFile: (path: string) => __TAURI_INVOKE<null>("quickpanel_open_file", { path }),
+	/**  获取 Windows 常用快捷位置（hosts、回收站、此电脑、用户目录、系统管理工具等） */
+	quickpanelGetSpecialLocations: () => __TAURI_INVOKE<SpecialLocation[]>("quickpanel_get_special_locations"),
+	/**  打开快捷位置（kind: file | shell | cmd） */
+	quickpanelOpenSpecial: (kind: string, target: string, args: string[]) => __TAURI_INVOKE<null>("quickpanel_open_special", { kind, target, args }),
+	/**  删除文件（移到回收站，PowerShell 阻塞等待移出主线程） */
+	quickpanelDeleteFile: (path: string) => __TAURI_INVOKE<null>("quickpanel_delete_file", { path }),
+	/**
+	 *  运行自定义命令（执行可执行文件 + 参数）
+	 *  .lnk 快捷方式不能直接 spawn（os error 193），需通过 cmd /C 启动
+	 */
+	quickpanelRunCustomCommand: (command: string, args: string[]) => __TAURI_INVOKE<null>("quickpanel_run_custom_command", { command, args }),
+	/**
+	 *  运行系统命令（不设置 CREATE_NO_WINDOW，使 cmd/powershell/regedit 等显示自身窗口）
+	 *  适用于内置系统工具：regedit、shutdown、cmd、powershell、taskmgr 等。
+	 */
+	quickpanelRunSystemCommand: (command: string, args: string[]) => __TAURI_INVOKE<null>("quickpanel_run_system_command", { command, args }),
+	/**  列出目录下的压缩包文件（供批量解压面板使用）。 */
+	quickpanelListArchives: (dir: string) => __TAURI_INVOKE<ArchiveInfo[]>("quickpanel_list_archives", { dir }),
+	/**  列出目录下的全部条目（供批量重命名/删除面板使用，不含子目录递归）。 */
+	quickpanelListDir: (dir: string) => __TAURI_INVOKE<FileEntry[]>("quickpanel_list_dir", { dir }),
+	/**
+	 *  批量解压。`files` 为压缩包路径列表，`dest_dir` 为目标目录，
+	 *  `password` 为统一解压密码（可空），`into_subfolder` 是否解压到同名子文件夹。
+	 *  每完成一个文件通过 `quickpanel-extract-progress` 事件推送进度。
+	 */
+	quickpanelBatchExtract: (files: string[], destDir: string, password: string | null, intoSubfolder: boolean) => __TAURI_INVOKE<ExtractResult[]>("quickpanel_batch_extract", { files, destDir, password, intoSubfolder }),
+	/**
+	 *  正则批量重命名预览：对每个文件名应用 `pattern → replacement`，
+	 *  仅返回有匹配的文件，`newName` 为替换结果。
+	 */
+	quickpanelPreviewRename: (files: string[], pattern: string, replacement: string) => __TAURI_INVOKE<RenamePreview[]>("quickpanel_preview_rename", { files, pattern, replacement }),
+	/**  执行重命名。同一目录下若目标已存在则跳过该项。 */
+	quickpanelApplyRename: (items: RenameItem[]) => __TAURI_INVOKE<RenameResult[]>("quickpanel_apply_rename", { items }),
+	/**
+	 *  批量删除文件/目录。`force=false` 时移动至回收站；`force=true` 时先递归清除
+	 *  只读属性再永久删除（可绕过只读/部分占用导致的删除失败，但被其他进程真正
+	 *  锁定的文件仍会失败并返回原因）。
+	 */
+	quickpanelDeleteFiles: (paths: string[], force: boolean) => __TAURI_INVOKE<DeleteResult[]>("quickpanel_delete_files", { paths, force }),
+	/**
+	 *  显示主窗口并强制置为前台。
+	 *  Tauri 的 set_focus 在 Windows 上受前台锁定限制，主窗口被其他应用遮挡时无法到前台；
+	 *  改用原生 SetForegroundWindow + BringWindowToTop（模拟 Alt 键重置前台锁定）。
+	 */
+	quickpanelFocusMainWindow: () => __TAURI_INVOKE<null>("quickpanel_focus_main_window"),
+	clipboardGetHistory: (limit: number | null, offset: number | null, kind: string | null) => __TAURI_INVOKE<HistoryPage>("clipboard_get_history", { limit, offset, kind }),
+	clipboardGetPinned: () => __TAURI_INVOKE<ClipboardItem[]>("clipboard_get_pinned"),
+	clipboardSearch: (query: string, limit: number | null, offset: number | null) => __TAURI_INVOKE<HistoryPage>("clipboard_search", { query, limit, offset }),
+	clipboardGetItem: (id: number) => __TAURI_INVOKE<({
+	/**  文本内容 / 文件列表 JSON */
+	content: string | null,
+	/**  图片 PNG base64（仅 image 类型） */
+	imageBase64: string | null,
+}) & (ClipboardItem) | null>("clipboard_get_item", { id }),
+	/**  获取图片缩略图 PNG base64（弹窗悬停预览用，避免加载全尺寸图片） */
+	clipboardGetThumb: (id: number) => __TAURI_INVOKE<string | null>("clipboard_get_thumb", { id }),
+	clipboardSetPinned: (id: number, pinned: boolean) => __TAURI_INVOKE<boolean>("clipboard_set_pinned", { id, pinned }),
+	clipboardDelete: (id: number) => __TAURI_INVOKE<boolean>("clipboard_delete", { id }),
+	clipboardClear: () => __TAURI_INVOKE<boolean>("clipboard_clear"),
+	clipboardCopyBack: (id: number) => __TAURI_INVOKE<null>("clipboard_copy_back", { id }),
+	clipboardCount: () => __TAURI_INVOKE<number>("clipboard_count"),
+	clipboardGetSettings: () => __TAURI_INVOKE<ClipboardSettings>("clipboard_get_settings"),
+	clipboardSaveSettings: (settings: ClipboardSettings) => __TAURI_INVOKE<null>("clipboard_save_settings", { settings }),
+	clipboardStatus: () => __TAURI_INVOKE<ClipboardStatus>("clipboard_status"),
+	clipboardStart: () => __TAURI_INVOKE<null>("clipboard_start"),
+	clipboardStop: () => __TAURI_INVOKE<null>("clipboard_stop"),
+	/**  注册（或切换）快捷弹窗全局快捷键 */
+	clipboardRegisterShortcut: (shortcut: string) => __TAURI_INVOKE<null>("clipboard_register_shortcut", { shortcut }),
+	/**  注销快捷弹窗全局快捷键 */
+	clipboardUnregisterShortcut: () => __TAURI_INVOKE<null>("clipboard_unregister_shortcut"),
+	/**  手动触发显示快捷弹窗（供 UI 按钮调用） */
+	clipboardShowPopup: () => __TAURI_INVOKE<null>("clipboard_show_popup"),
+	/**  隐藏快捷弹窗 */
+	clipboardHidePopup: () => __TAURI_INVOKE<null>("clipboard_hide_popup"),
+	/**  显示已创建的弹窗窗口（前端 onMounted 后调用） */
+	clipboardShowWindow: () => __TAURI_INVOKE<null>("clipboard_show_window"),
+	/**  隐藏弹窗并模拟 Ctrl+V 粘贴到原窗口 */
+	clipboardPasteToTarget: () => __TAURI_INVOKE<null>("clipboard_paste_to_target"),
+	/**  在弹窗旁显示独立预览窗口（悬停/键盘选中时调用） */
+	clipboardShowPreview: (id: number) => __TAURI_INVOKE<null>("clipboard_show_preview", { id }),
+	/**  隐藏独立预览窗口 */
+	clipboardHidePreview: () => __TAURI_INVOKE<null>("clipboard_hide_preview"),
+	/**
+	 *  按内容自适应调整预览窗大小（逻辑像素）。前端加载内容（文本测高、图片按宽高比）后调用，
+	 *  窗口贴合内容消除留白；后端按弹窗所在屏工作区钳制并重新对齐弹窗。
+	 *  allow_flip：初始落位为 true（优先侧放不下可换侧）；放大/还原为 false（保持原侧）。
+	 */
+	clipboardResizePreview: (width: number | null, height: number | null, allowFlip: boolean) => __TAURI_INVOKE<null>("clipboard_resize_preview", { width, height, allowFlip }),
+	/**
+	 *  显示已就绪的预览窗口。前端完成内容加载与 resize 后调用，窗口以最终尺寸出现，
+	 *  消除"先以上次尺寸（可能是放大态大窗）显示再缩回"的闪烁。
+	 */
+	clipboardRevealPreview: () => __TAURI_INVOKE<null>("clipboard_reveal_preview"),
+	/**
+	 *  预览窗交互锁定：前端预览窗收到 mousedown（放大/缩小、复制、选择文本）时调用。
+	 *  此后弹窗+预览不因失焦/鼠标离开而关闭，仅当点击外部或弹窗重新聚焦时退出锁定。
+	 */
+	clipboardPreviewInteracted: () => __TAURI_INVOKE<null>("clipboard_preview_interacted"),
+	/**  获取所有任务 */
+	downloaderGetTasks: () => __TAURI_INVOKE<DownloadTask[]>("downloader_get_tasks"),
+	/**  检查 URL 重复性并探测文件信息（添加下载前调用） */
+	downloaderCheckUrl: (url: string, dir: string | null, headers: { [key in string]: string } | null) => __TAURI_INVOKE<CheckUrlResult>("downloader_check_url", { url, dir, headers }),
+	/**  添加下载任务 */
+	downloaderAddTask: (url: string, filename: string | null, dir: string | null, headers: { [key in string]: string } | null, autoRename: boolean | null) => __TAURI_INVOKE<string>("downloader_add_task", { url, filename, dir, headers, autoRename }),
+	/**  暂停任务 */
+	downloaderPauseTask: (id: string) => __TAURI_INVOKE<null>("downloader_pause_task", { id }),
+	/**  恢复任务 */
+	downloaderResumeTask: (id: string) => __TAURI_INVOKE<null>("downloader_resume_task", { id }),
+	/**  移除任务 */
+	downloaderRemoveTask: (id: string, deleteFiles: boolean | null) => __TAURI_INVOKE<null>("downloader_remove_task", { id, deleteFiles }),
+	/**  获取设置 */
+	downloaderGetSettings: () => __TAURI_INVOKE<DownloaderSettings>("downloader_get_settings"),
+	/**  保存设置 */
+	downloaderSaveSettings: (settings: DownloaderSettings) => __TAURI_INVOKE<null>("downloader_save_settings", { settings }),
+	/**  用系统资源管理器打开目录 */
+	downloaderOpenDir: (path: string) => __TAURI_INVOKE<null>("downloader_open_dir", { path }),
+	/**  用系统默认浏览器打开 URL */
+	downloaderOpenUrl: (url: string) => __TAURI_INVOKE<null>("downloader_open_url", { url }),
+	/**  禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画 */
+	screenshotDisableTransitions: (label: string) => __TAURI_INVOKE<null>("screenshot_disable_transitions", { label }),
+	/**  一次 IPC 完成指定窗口的显示与聚焦（截图覆盖层显示关键路径，减少串行往返） */
+	screenshotShowOverlay: (label: string) => __TAURI_INVOKE<null>("screenshot_show_overlay", { label }),
+	/**  注册（或切换）截图全局快捷键。传入空字符串则禁用快捷键。 */
+	screenshotRegisterShortcut: (shortcut: string) => __TAURI_INVOKE<null>("screenshot_register_shortcut", { shortcut }),
+	/**  注销截图全局快捷键 */
+	screenshotUnregisterShortcut: () => __TAURI_INVOKE<null>("screenshot_unregister_shortcut"),
+	/**
+	 *  注册（或切换）贴图全局快捷键。传入空字符串则禁用快捷键。
+	 *  按下时 emit 'screenshot-pin-shortcut'，由前端切换贴图窗口显示/隐藏。
+	 */
+	screenshotRegisterPinShortcut: (shortcut: string) => __TAURI_INVOKE<null>("screenshot_register_pin_shortcut", { shortcut }),
+	/**  注销贴图全局快捷键 */
+	screenshotUnregisterPinShortcut: () => __TAURI_INVOKE<null>("screenshot_unregister_pin_shortcut"),
+	/**
+	 *  捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码。
+	 *  同时返回捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返）。
+	 */
+	screenshotCaptureFullscreen: () => __TAURI_INVOKE<CaptureStart>("screenshot_capture_fullscreen"),
+	/**  全屏捕获编码为 PNG base64 并清除（全屏截图直接进编辑器） */
+	screenshotFullscreenPng: () => __TAURI_INVOKE<CaptureData>("screenshot_fullscreen_png"),
+	/**  清除静态全屏捕获（覆盖层关闭/取消时释放内存） */
+	screenshotClearFullscreen: () => __TAURI_INVOKE<null>("screenshot_clear_fullscreen"),
+	/**  按物理像素坐标裁剪已存储的全屏捕获 */
+	screenshotCropStored: (x: number, y: number, w: number, h: number) => __TAURI_INVOKE<CaptureData>("screenshot_crop_stored", { x, y, w, h }),
+	/**  裁剪已存储的全屏捕获并直接写入剪贴板（一次 IPC 完成"裁剪+复制"） */
+	screenshotCropCopyStored: (x: number, y: number, w: number, h: number) => __TAURI_INVOKE<CaptureData>("screenshot_crop_copy_stored", { x, y, w, h }),
+	/**
+	 *  枚举可拾取的顶层窗口（Z 序顶→底，排除本进程/不可见/工具窗口）。
+	 *  前端在截图开始时缓存列表，鼠标移动时在 JS 侧本地命中测试，消除逐帧 IPC 往返。
+	 */
+	screenshotPickList: () => __TAURI_INVOKE<WindowInfo[]>("screenshot_pick_list"),
+	/**  获取当前鼠标物理屏幕坐标（贴图窗口拖动跟随等场景使用） */
+	screenshotCursorPos: () => __TAURI_INVOKE<[number, number]>("screenshot_cursor_pos"),
+	/**  枚举所有可见顶层窗口 */
+	screenshotEnumWindows: () => __TAURI_INVOKE<WindowInfo[]>("screenshot_enum_windows"),
+	/**  按 hwnd 捕获指定窗口 */
+	screenshotCaptureWindow: (hwnd: number) => __TAURI_INVOKE<CaptureData>("screenshot_capture_window", { hwnd }),
+	/**  存入编辑器图片（base64 PNG） */
+	screenshotSetEditorImage: (pngBase64: string) => __TAURI_INVOKE<null>("screenshot_set_editor_image", { pngBase64 }),
+	/**  取出编辑器图片（编辑器窗口加载时调用，取出即清除） */
+	screenshotGetEditorImage: () => __TAURI_INVOKE<string | null>("screenshot_get_editor_image"),
+	/**  将 PNG base64 写入系统剪贴板（转 CF_DIB） */
+	screenshotCopyImage: (pngBase64: string) => __TAURI_INVOKE<null>("screenshot_copy_image", { pngBase64 }),
+	/**  将 PNG base64 写入文件 */
+	screenshotSavePng: (pngBase64: string, path: string) => __TAURI_INVOKE<null>("screenshot_save_png", { pngBase64, path }),
+	/**  将完整 PNG 写入历史缓存目录，返回文件路径 */
+	screenshotSaveCache: (pngBase64: string) => __TAURI_INVOKE<string>("screenshot_save_cache", { pngBase64 }),
+	/**  从历史缓存目录读取 PNG 并返回 base64（点击历史项复制/保存时一次性加载，不常驻内存） */
+	screenshotLoadCache: (path: string) => __TAURI_INVOKE<string>("screenshot_load_cache", { path }),
+	/**  删除历史缓存文件（历史项移除/清空时调用，静默忽略不存在文件） */
+	screenshotDeleteCache: (path: string) => __TAURI_INVOKE<null>("screenshot_delete_cache", { path }),
+};
+
+/* Types */
+export type AppRecord = {
+	name: string,
+	path: string,
+};
+
+export type ArchiveInfo = {
+	name: string,
+	path: string,
+	size: number,
+};
+
+/**  前端可见的捕获数据 */
+export type CaptureData = {
+	pngBase64: string,
+	width: number,
+	height: number,
+};
+
+/**  截图启动信息：捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返） */
+export type CaptureStart = {
+	cursorX: number,
+	cursorY: number,
+};
+
+/**  check_url 命令返回的结果 */
+export type CheckUrlResult = {
+	/**  探测是否成功 */
+	ok: boolean,
+	/**  错误信息（探测失败时） */
+	error: string | null,
+	/**  文件名（探测成功时） */
+	filename: string | null,
+	/**  文件大小（字节） */
+	totalSize: number | null,
+	/**  是否支持断点续传 */
+	supportsResume: boolean,
+	/**  重复类型 */
+	duplicate: DuplicateKind,
+	/**  已存在的任务信息 */
+	existing: ExistingTaskInfo | null,
+};
+
+/**  列表项（不含大字段，用于历史/搜索结果） */
+export type ClipboardItem = {
+	id: number,
+	kind: string,
+	preview: string,
+	size: number,
+	pinned: boolean,
+	pinnedOrder: number | null,
+	createdAt: number,
+};
+
+/**  详情（含文本内容或图片 base64） */
+export type ClipboardItemDetail = {
+	/**  文本内容 / 文件列表 JSON */
+	content: string | null,
+	/**  图片 PNG base64（仅 image 类型） */
+	imageBase64: string | null,
+} & ClipboardItem;
+
+/**  剪贴板设置（持久化到 clipboard/settings.json） */
+export type ClipboardSettings = {
+	/**  监听是否启用 */
+	enabled?: boolean,
+	/**  非固定历史最大条数 */
+	maxItems?: number,
+	/**  图片大小上限（KB），0 表示不限 */
+	maxImageKb?: number,
+	recordText?: boolean,
+	recordImage?: boolean,
+	recordFiles?: boolean,
+	/**  去重（相同内容更新时间而非新增） */
+	dedup?: boolean,
+	/**  快捷弹窗全局快捷键（如 "Alt+V"，空字符串表示禁用） */
+	shortcut?: string,
+};
+
+export type ClipboardStatus = {
+	running: boolean,
+	count: number,
+};
+
+/**  自定义命令 */
+export type CustomCommand = {
+	id: string,
+	title: string,
+	command: string,
+	args?: string[],
+};
+
+/**  批量删除单个条目的结果。 */
+export type DeleteResult = {
+	name: string,
+	path: string,
+	ok: boolean,
+	error: string,
+};
+
+/**  下载任务 */
+export type DownloadTask = {
+	/**  任务 ID（自增 hex 字符串） */
+	id: string,
+	/**  下载地址 */
+	url: string,
+	/**  文件名 */
+	filename: string,
+	/**  保存目录（绝对路径） */
+	dir: string,
+	/**  状态 */
+	status: TaskStatus,
+	/**  文件总大小（字节），0=未知 */
+	totalSize: number,
+	/**  已下载字节 */
+	completedSize: number,
+	/**  当前下载速度 bytes/s */
+	speed: number,
+	/**  服务器是否支持断点续传 */
+	supportsResume: boolean,
+	/**  分段信息 */
+	segments?: Segment[],
+	/**  错误信息 */
+	error?: string | null,
+	/**  创建时间（Unix 时间戳，毫秒） */
+	createdAt: number,
+	/**  自定义请求头（Cookie / Referer 等） */
+	headers?: { [key in string]: string },
+};
+
+/**  下载设置 */
+export type DownloaderSettings = {
+	/**  下载目录 */
+	downloadDir?: string,
+	/**  最大同时下载数 */
+	maxConcurrent?: number,
+	/**  单任务最大连接数（多线程分段数） */
+	maxConnections?: number,
+	/**  断点续传 */
+	continueDownload?: boolean,
+	/**  全局速度限制 KB/s（0=不限） */
+	globalSpeedLimit?: number,
+	/**  扩展 HTTP API 端口 */
+	extensionPort?: number,
+	/**  扩展认证密钥（空=不认证） */
+	extensionSecret?: string,
+	/**  删除任务时是否同时删除已下载的文件 */
+	deleteFilesOnRemove?: boolean,
+	/**  添加下载前检查重复（URL 或文件名重复时询问） */
+	checkDuplicate?: boolean,
+	/**  下载是否使用代理：true=尊重系统代理（mihomo 开启系统代理时经其转发），false=强制直连 */
+	useProxy?: boolean,
+};
+
+/**  重复类型 */
+export type DuplicateKind = 
+/**  无重复 */
+"none" | 
+/**  URL 重复（已有相同链接的任务） */
+"url" | 
+/**  文件名重复（已有同名任务下载到同一目录） */
+"filename" | 
+/**  磁盘文件已存在 */
+"fileExists";
+
+/**  已存在的任务信息（用于前端展示） */
+export type ExistingTaskInfo = {
+	id: string,
+	filename: string,
+	status: TaskStatus,
+};
+
+export type ExtractResult = {
+	name: string,
+	path: string,
+	ok: boolean,
+	error: string,
+};
+
+export type FileEntry = {
+	name: string,
+	path: string,
+	isDir: boolean,
+	size: number,
+};
+
+/**  单个文件记录（返回给前端） */
+export type FileRecord = {
+	path: string,
+	name: string,
+	ext: string,
+	size: number,
+	isDir: boolean,
+};
+
+/**  历史查询结果（含总数，用于分页） */
+export type HistoryPage = {
+	items: ClipboardItem[],
+	total: number,
+};
+
+/**  索引状态（返回给前端） */
+export type IndexStats = {
+	total: number,
+	lastBuiltAt: number,
+	lastBuiltDirs: string[],
+};
+
+export type KernelInfo = {
+	path: string,
+	exists: boolean,
+	version: string | null,
+};
+
+export type KernelUpdateInfo = {
+	currentVersion: string | null,
+	latestVersion: string,
+	downloadUrl: string,
+	hasUpdate: boolean,
+};
+
+/**  进程信息（返回给前端） */
+export type ProcessInfo = {
+	id: string,
+	name: string,
+	status: ProcessStatus,
+	pid: number | null,
+	restartCount: number,
+};
+
+/**  进程状态枚举 */
+export type ProcessStatus = "running" | "stopped" | "crashed" | "starting";
+
+export type ProfileMeta = {
+	id?: string,
+	name?: string,
+	url?: string,
+	addedAt?: string,
+	updatedAt?: string,
+	size?: number | null,
+};
+
+export type ProxySettings = {
+	mixedPort?: number,
+	externalController?: string,
+	secret?: string,
+	mode?: string,
+	logLevel?: string,
+	allowLan?: boolean,
+	systemProxy?: boolean,
+	autoStart?: boolean,
+	autoSystemProxy?: boolean,
+	currentProfile?: string | null,
+	profiles?: ProfileMeta[],
+	autoSwitchEnabled?: boolean,
+	autoSwitchInterval?: number,
+	autoSwitchGroup?: string,
+	autoSwitchRegion?: string,
+	/**
+	 *  内核下载镜像源列表（前缀拼接到 GitHub URL 前）。
+	 *  空字符串 = 直连 GitHub，其余为镜像站前缀（含尾斜杠）。
+	 */
+	kernelMirrors?: string[],
+};
+
+export type ProxyStatus = {
+	running: boolean,
+	pid: number | null,
+	restartCount: number,
+};
+
+/**  快速面板设置 */
+export type QuickPanelSettings = {
+	/**  全局快捷键（如 "Alt+Space"），空字符串表示不注册。 */
+	shortcut?: string,
+	/**  唤起位置：center（鼠标所在显示器中央）| cursor（鼠标位置） */
+	popupPosition?: string,
+	/**  默认搜索引擎：google | bing | baidu */
+	searchEngine?: string,
+	/**  文件索引目录列表（空列表表示使用默认：桌面/文档/下载） */
+	indexDirs?: string[],
+	/**  自定义命令列表 */
+	customCommands?: CustomCommand[],
+};
+
+export type RenameItem = {
+	path: string,
+	oldName: string,
+	newName: string,
+};
+
+export type RenamePreview = {
+	path: string,
+	oldName: string,
+	newName: string,
+	error: string,
+};
+
+export type RenameResult = {
+	oldName: string,
+	newName: string,
+	ok: boolean,
+	error: string,
+};
+
+export type ScreenRect = {
+	x: number,
+	y: number,
+	width: number,
+	height: number,
+};
+
+/**  下载分段（多线程 Range 下载 / 断点续传用） */
+export type Segment = {
+	/**  分段索引 */
+	index: number,
+	/**  起始字节（含） */
+	start: number,
+	/**  结束字节（含） */
+	end: number,
+	/**  已下载字节 */
+	completed: number,
+};
+
+/**  快捷位置条目 */
+export type SpecialLocation = {
+	id: string,
+	title: string,
+	subtitle: string,
+	keywords: string[],
+	/**  file: 真实文件/文件夹路径；shell: explorer 打开的 shell 路径；cmd: 可执行命令 */
+	kind: string,
+	target: string,
+	args: string[],
+};
+
+/**  任务状态 */
+export type TaskStatus = 
+/**  排队等待（并发数已满） */
+"queued" | 
+/**  下载中 */
+"active" | 
+/**  已暂停 */
+"paused" | 
+/**  已完成 */
+"complete" | 
+/**  错误 */
+"error";
+
+/**  release 中的一个资产 */
+export type UpdateAsset = {
+	name: string,
+	size: number,
+	browserDownloadUrl: string,
+};
+
+/**  检查更新的结果 */
+export type UpdateCheckResult = {
+	currentVersion: string,
+	latestVersion: string,
+	hasUpdate: boolean,
+	/**  portable | installed */
+	installType: string,
+	releaseName: string,
+	releaseBody: string,
+	assets: UpdateAsset[],
+};
+
+/**  窗口信息（窗口拾取 / 枚举） */
+export type WindowInfo = {
+	hwnd: number,
+	title: string,
+	rect: ScreenRect,
+	/**  DWM 扩展边框矩形（视觉边界，去掉最大化窗口的隐形缩放边框），命中测试用 rect，高亮用 visual_rect */
+	visualRect: ScreenRect | null,
+};
+

src/lib/calc.test.ts

@@ -0,0 +1,57 @@
+/**
+ * 表达式求值器单测（Node 内置 test runner）。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { evaluateExpression } from './calc.ts'
+
+test('四则运算与优先级', () => {
+  assert.equal(evaluateExpression('1+2*3'), 7)
+  assert.equal(evaluateExpression('2*(3+4)'), 14)
+  assert.equal(evaluateExpression('10-2-3'), 5)
+})
+
+test('除法与取模', () => {
+  assert.equal(evaluateExpression('10/4'), 2.5)
+  assert.equal(evaluateExpression('10%3'), 1)
+})
+
+test('小数与边界写法', () => {
+  assert.equal(evaluateExpression('0.1+0.2'), 0.30000000000000004)
+  assert.equal(evaluateExpression('.5+.5'), 1)
+  assert.equal(evaluateExpression('5.'), 5)
+})
+
+test('一元正负号', () => {
+  assert.equal(evaluateExpression('-5+3'), -2)
+  assert.equal(evaluateExpression('-(2+3)'), -5)
+  assert.equal(evaluateExpression('2*-3'), -6)
+  assert.equal(evaluateExpression('+5'), 5)
+  assert.equal(evaluateExpression('--5'), 5)
+})
+
+test('括号嵌套', () => {
+  assert.equal(evaluateExpression('(1+2)*(3+4)'), 21)
+  assert.equal(evaluateExpression('((1+2))'), 3)
+})
+
+test('空白容忍', () => {
+  assert.equal(evaluateExpression(' 1 + 2 '), 3)
+  assert.equal(evaluateExpression('   '), null)
+})
+
+test('非法输入返回 null', () => {
+  assert.equal(evaluateExpression(''), null)
+  assert.equal(evaluateExpression('abc'), null)
+  assert.equal(evaluateExpression('1/'), null)
+  assert.equal(evaluateExpression('((1+2)'), null)
+  assert.equal(evaluateExpression('1+2)'), null)
+  assert.equal(evaluateExpression('1 2'), null)
+  assert.equal(evaluateExpression('%3'), null)
+  assert.equal(evaluateExpression('1.2.3'), null)
+})
+
+test('非有限结果返回 null（除零）', () => {
+  assert.equal(evaluateExpression('1/0'), null)
+  assert.equal(evaluateExpression('5%0'), null)
+})

src/lib/calc.ts

@@ -0,0 +1,136 @@
+/**
+ * 表达式求值器（CSP 安全，替代 Function/eval）。
+ * 支持：十进制小数、+ - * / %、括号、一元正负号。
+ * 非法输入或结果为非有限值返回 null。
+ *
+ * 语义差异说明：原 Function 实现下 `1++2` / `1--2` 属语法错误；
+ * 此处解析器将连续正负号按一元运算符处理（`1++2` → 3），更宽松且无安全隐患。
+ */
+
+type Token =
+  | { kind: 'num'; value: number }
+  | { kind: 'op'; value: string }
+  | { kind: 'end' }
+
+/** 数字 token：`12.5` / `12.` / `.5` */
+const NUM_RE = /^\d+(\.\d*)?|^\.\d+/
+
+function tokenize(input: string): Token[] | null {
+  const tokens: Token[] = []
+  let i = 0
+  while (i < input.length) {
+    const ch = input[i]
+    if (/\s/.test(ch)) {
+      i++
+      continue
+    }
+    if (/[0-9.]/.test(ch)) {
+      const m = NUM_RE.exec(input.slice(i))
+      if (!m) return null
+      const value = Number(m[0])
+      if (!Number.isFinite(value)) return null
+      tokens.push({ kind: 'num', value })
+      i += m[0].length
+      continue
+    }
+    if ('+-*/%()'.includes(ch)) {
+      tokens.push({ kind: 'op', value: ch })
+      i++
+      continue
+    }
+    return null
+  }
+  tokens.push({ kind: 'end' })
+  return tokens
+}
+
+/** 递归下降解析器：expr → term → factor（支持优先级与括号） */
+class Parser {
+  private pos = 0
+  private tokens: Token[]
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens
+  }
+
+  /** 完整解析：要求消费全部 token 且成功 */
+  parse(): number | null {
+    const v = this.parseExpr()
+    if (v === null) return null
+    if (this.peek().kind !== 'end') return null
+    return v
+  }
+
+  private peek(): Token {
+    return this.tokens[this.pos]
+  }
+
+  private next(): Token {
+    return this.tokens[this.pos++]
+  }
+
+  /** expr := term (('+' | '-') term)* */
+  private parseExpr(): number | null {
+    let left = this.parseTerm()
+    if (left === null) return null
+    while (true) {
+      const tok = this.peek()
+      if (tok.kind !== 'op' || (tok.value !== '+' && tok.value !== '-')) break
+      this.next()
+      const right = this.parseTerm()
+      if (right === null) return null
+      left = tok.value === '+' ? left + right : left - right
+    }
+    return left
+  }
+
+  /** term := factor (('*' | '/' | '%') factor)* */
+  private parseTerm(): number | null {
+    let left = this.parseFactor()
+    if (left === null) return null
+    while (true) {
+      const tok = this.peek()
+      if (tok.kind !== 'op' || (tok.value !== '*' && tok.value !== '/' && tok.value !== '%')) {
+        break
+      }
+      this.next()
+      const right = this.parseFactor()
+      if (right === null) return null
+      left = tok.value === '*' ? left * right : tok.value === '/' ? left / right : left % right
+    }
+    return left
+  }
+
+  /** factor := ('+' | '-') factor | '(' expr ')' | number */
+  private parseFactor(): number | null {
+    const tok = this.peek()
+    if (tok.kind === 'op' && (tok.value === '+' || tok.value === '-')) {
+      this.next()
+      const v = this.parseFactor()
+      if (v === null) return null
+      return tok.value === '-' ? -v : v
+    }
+    if (tok.kind === 'num') {
+      this.next()
+      return tok.value
+    }
+    if (tok.kind === 'op' && tok.value === '(') {
+      this.next()
+      const v = this.parseExpr()
+      if (v === null) return null
+      const close = this.next()
+      if (close.kind !== 'op' || close.value !== ')') return null
+      return v
+    }
+    return null
+  }
+}
+
+/** 求值表达式，非法输入或结果为非有限值返回 null */
+export function evaluateExpression(input: string): number | null {
+  const tokens = tokenize(input)
+  if (!tokens) return null
+  const result = new Parser(tokens).parse()
+  if (result === null || !Number.isFinite(result)) return null
+  return result
+}

src/lib/constants.ts

@@ -0,0 +1,100 @@
+/**
+ * 全局常量集中定义。
+ * 窗口 label / Tauri 事件名 / localStorage 存储键，避免魔法字符串散布各处。
+ * 与 Rust 侧 `src-tauri/src/constants.rs` 保持对应。
+ */
+
+/** 窗口 label（对应 Rust constants::windows 与 capabilities/*.json） */
+export const WINDOWS = {
+  main: 'main',
+  osdOverlay: 'osd-overlay',
+  screenshotOverlay: 'screenshot-overlay',
+  screenshotPin: 'screenshot-pin',
+} as const
+
+/** Tauri 事件名（前端 emit / listen 与 Rust constants::events 对应） */
+export const EVENTS = {
+  // 托盘菜单
+  trayMenuShow: 'tray-menu-show',
+  trayMenuStateUpdated: 'tray-menu-state-updated',
+  trayToggleOsd: 'tray:toggle-osd',
+  trayNewDownload: 'tray:new-download',
+  trayOpenSettings: 'tray:open-settings',
+  // 剪贴板
+  clipboardChanged: 'clipboard-changed',
+  clipboardPopupShow: 'clipboard-popup-show',
+  clipboardPopupHide: 'clipboard-popup-hide',
+  clipboardPreviewShow: 'clipboard-preview-show',
+  clipboardPreviewHide: 'clipboard-preview-hide',
+  // 鼠标进入/离开独立预览窗（弹窗据此决定是否延迟隐藏预览，便于点击复制/放大）
+  clipboardPreviewEnter: 'clipboard-preview-enter',
+  clipboardPreviewLeave: 'clipboard-preview-leave',
+  // 快速面板
+  quickpanelShow: 'quickpanel-show',
+  quickpanelHide: 'quickpanel-hide',
+  quickpanelExecuteCommand: 'quickpanel-execute-command',
+  quickpanelExtractProgress: 'quickpanel-extract-progress',
+  // 文件索引构建完成（闲时自动建立/重建、手动构建）
+  quickpanelIndexUpdated: 'quickpanel-index-updated',
+  // 截图
+  screenshotBegin: 'screenshot-begin',
+  screenshotOverlayReady: 'screenshot-overlay-ready',
+  screenshotShortcut: 'screenshot-shortcut',
+  screenshotPinShortcut: 'screenshot-pin-shortcut',
+  screenshotPinReady: 'screenshot-pin-ready',
+  screenshotPinShow: 'screenshot-pin-show',
+  screenshotExported: 'screenshot-exported',
+  // 内核安装进度
+  kernelInstallProgress: 'kernel-install-progress',
+  // 后端自动切换节点完成（后台执行，刷新节点列表并提示）
+  proxyAutoSwitch: 'proxy-auto-switch',
+  // 应用更新进度
+  updateProgress: 'update-progress',
+  // 监控 OSD
+  osdStateUpdate: 'osd-state-update',
+  /** OSD 数据通道：仅推送显示项 key→value 映射 + 网速（高频，每秒） */
+  osdDataUpdate: 'osd-data-update',
+  /** OSD 窗口挂载后请求主窗口补发配置+数据（防止错过创建时的首推） */
+  osdConfigRequest: 'osd-config-request',
+  osdContentSize: 'osd-content-size',
+  osdSystemUiActive: 'osd-system-ui-active',
+  osdSystemUiInactive: 'osd-system-ui-inactive',
+  osdStartDrag: 'osd-start-drag',
+  osdEndDrag: 'osd-end-drag',
+  monitorReady: 'monitor-ready',
+  monitorLoading: 'monitor-loading',
+  monitorDisconnected: 'monitor-disconnected',
+  monitorError: 'monitor-error',
+  monitorData: 'monitor-data',
+  monitorNetwork: 'monitor-network',
+  // 其他
+  processStatusChanged: 'process-status-changed',
+  downloadAdded: 'download-added',
+  /** 任务被删除（浏览器扩展通过 HTTP API 删除任务时发出，前端据此刷新任务列表） */
+  downloadRemoved: 'download-removed',
+  /** 浏览器扩展通过 HTTP API 新增下载（置前主窗口并跳到下载画面） */
+  downloadExtensionAdded: 'download-extension-added',
+} as const
+
+/** localStorage 存储键 */
+export const STORAGE_KEYS = {
+  appSettings: 'thing_app_settings',
+  lastModule: 'thing_last_module',
+  quickpanelCommands: 'thing_quickpanel_commands',
+  quickpanelSettings: 'thing_quickpanel_settings',
+  quickpanelHistory: 'thing_quickpanel_history',
+  quickpanelHistoryItems: 'thing_quickpanel_history_items',
+  quickpanelPwdHistory: 'thing_quickpanel_pwd_history',
+  quickpanelPwdFavs: 'thing_quickpanel_pwd_favs',
+  quickpanelRenameMatchHistory: 'thing_quickpanel_rename_match_history',
+  quickpanelRenameMatchFavs: 'thing_quickpanel_rename_match_favs',
+  quickpanelRenameReplaceHistory: 'thing_quickpanel_rename_replace_history',
+  quickpanelRenameReplaceFavs: 'thing_quickpanel_rename_replace_favs',
+  quickpanelDeleteFilterHistory: 'thing_quickpanel_delete_filter_history',
+  quickpanelDeleteFilterFavs: 'thing_quickpanel_delete_filter_favs',
+  currencyRates: 'thing_quickpanel_currency_rates',
+  monitorOsdConfig: 'thing_monitor_osd_config',
+  monitorOverviewCards: 'thing_monitor_overview_cards',
+  screenshotHistory: 'thing_screenshot_history',
+  screenshotPinIndex: 'thing_screenshot_pin_index',
+} as const

src/lib/logger.ts

@@ -86,19 +86,19 @@ export async function getLogs(
   level?: LogLevel,
   limit?: number,
 ): Promise<LogEntry[]> {
-  return invoke('get_logs', { module, level, limit })
+  return invoke('log_list', { module, level, limit })
 }
 
 /**
  * 清空所有日志文件。
  */
 export async function clearLogs(): Promise<void> {
-  return invoke('clear_logs')
+  return invoke('log_clear')
 }
 
 /**
  * 获取日志系统信息（目录、文件列表、空间占用）。
  */
 export async function getLogInfo(): Promise<LogInfo> {
-  return invoke('get_log_info')
+  return invoke('log_info_state')
 }

src/lib/trayEvents.ts

@@ -11,5 +11,5 @@ import { ref } from 'vue'
 /** 待打开新建下载对话框（由托盘"新建下载"触发） */
 export const pendingNewDownload = ref(false)
 
-/** 待切换到设置模块（由托盘"常规设置"触发） */
-export const pendingOpenSettings = ref(false)
+/** 待切换到下载任务列表页（由浏览器扩展新增下载触发，不弹对话框直接看任务） */
+export const pendingShowDownloadTasks = ref(false)

src/lib/use-module-tabs.ts

@@ -12,12 +12,15 @@ import { useModuleTabsStore, type ModuleTab } from '@/stores/moduleTabsStore'
  * ```ts
  * // 模块 <script setup> 顶部
  * const activeTab = ref('overview')
- * const tabsListRef = useModuleTabs(activeTab, [
+ * const tabsListRef = useModuleTabs('proxy', activeTab, [
  *   { value: 'overview', label: '概览' },
  *   { value: 'settings', label: '设置' }
  * ])
  * ```
  *
+ * 第一个参数为模块 id：搜索导航跳转时，模块挂载后会自动
+ * 消费 moduleTabsStore 中对应的待跳转 tab（pendingTab）。
+ *
  * ```vue
  * <!-- 模板中给 TabsList 包一层带 ref 的 div -->
  * <div ref="tabsListRef">
@@ -29,7 +32,8 @@ import { useModuleTabsStore, type ModuleTab } from '@/stores/moduleTabsStore'
  * 1. onMounted 时注册标签到 moduleTabsStore，TitleBar 据此渲染浮动切换器
  * 2. 用 IntersectionObserver 监听 TabsList 可见性（rootMargin 裁剪 TitleBar 高度）
  * 3. 双向 watch 同步本地 activeTab 与 store.activeTab
- * 4. onUnmounted 时清理 observer 并注销标签
+ * 4. 消费搜索导航的待跳转 tab（模块尚未挂载的场景）
+ * 5. onUnmounted 时清理 observer 并注销标签
  *
  * ## 约束
  * - TitleBar 高度固定为 40px (h-10)，composable 内部已用 44px 裁剪（含缓冲）
@@ -37,6 +41,7 @@ import { useModuleTabsStore, type ModuleTab } from '@/stores/moduleTabsStore'
  * - 模块卸载时务必让 composable 的 onUnmounted 执行（已自动处理，无需手动调用）
  */
 export function useModuleTabs(
+  moduleId: string,
   activeTab: Ref<string>,
   tabs: ModuleTab[]
 ): Ref<HTMLElement | null> {
@@ -45,6 +50,15 @@ export function useModuleTabs(
 
   let observer: IntersectionObserver | null = null
 
+  /** 应用待跳转 tab（若属于当前模块的 tab 列表） */
+  const applyPendingTab = () => {
+    const pending = tabsStore.consumePendingTab(moduleId)
+    if (pending && tabs.some(t => t.value === pending)) {
+      activeTab.value = pending
+      tabsStore.setActiveTab(pending)
+    }
+  }
+
   const setupObserver = () => {
     const el = tabsListRef.value
     if (!el || observer) return
@@ -75,10 +89,19 @@ export function useModuleTabs(
     }
   })
 
+  // 模块已挂载时（搜索结果选中同一模块），pendingTab 变化 → 直接切换 tab
+  watch(() => tabsStore.pendingTab, (p) => {
+    if (p?.moduleId === moduleId) {
+      applyPendingTab()
+    }
+  })
+
   onMounted(async () => {
     tabsStore.registerTabs(tabs, activeTab.value)
     await nextTick()
     setupObserver()
+    // 搜索导航跳转：模块刚挂载，消费待跳转 tab
+    applyPendingTab()
   })
 
   onUnmounted(() => {

src/main.ts

@@ -1,4 +1,4 @@
-import { createApp } from 'vue'
+import { createApp, type Component } from 'vue'
 import { createPinia } from 'pinia'
 import './style.css'
 import 'vue-sonner/style.css'
@@ -6,6 +6,9 @@ import 'vue-sonner/style.css'
 import { createLogger } from './lib/logger'
 const logger = createLogger('main')
 
+// 禁用 WebView 默认右键菜单（桌面应用体验，主窗口与独立窗口共用）
+document.addEventListener('contextmenu', (e) => e.preventDefault())
+
 // 全局未捕获异常日志
 window.addEventListener('error', (event) => {
   logger.error(`全局JS错误: ${event.message} @ ${event.filename}:${event.lineno}`)
@@ -15,44 +18,33 @@ window.addEventListener('unhandledrejection', (event) => {
   logger.error(`未处理的Promise拒绝: ${event.reason}`)
 })
 
-// ===== OSD 窗口模式检测 =====
+// ===== 独立窗口模式 =====
 // 通过 URL hash 识别独立窗口：#osd-overlay / #clipboard-popup / #quick-panel / #tray-menu / #screenshot-overlay / #screenshot-editor
 // 这些窗口是精简的独立 Vue 应用，不加载主应用的 store 和模块
+// 新增独立窗口只需在此表登记一行（hash → 组件）
+const standaloneWindowApps: Array<[hash: string, label: string, loader: () => Promise<{ default: Component }>]> = [
+  ['#osd-overlay', 'OSD', () => import('./modules/monitor/OsdWindow.vue')],
+  ['#clipboard-popup', '剪贴板弹窗', () => import('./modules/clipboard/ClipboardPopup.vue')],
+  ['#clipboard-preview', '剪贴板预览', () => import('./modules/clipboard/ClipboardPreview.vue')],
+  ['#quick-panel', '快速面板弹窗', () => import('./modules/quickpanel/QuickPanel.vue')],
+  ['#tray-menu', '托盘菜单', () => import('./modules/tray/TrayMenu.vue')],
+  ['#screenshot-overlay', '截图覆盖层', () => import('./modules/screenshot/ScreenshotOverlay.vue')],
+  ['#screenshot-editor', '截图编辑器', () => import('./modules/screenshot/ScreenshotEditor.vue')],
+  ['#screenshot-pin', '贴图窗口', () => import('./modules/screenshot/ScreenshotPin.vue')],
+]
+
 const winHash = window.location.hash
-if (winHash === '#osd-overlay') {
-  logger.info(`OSD 窗口启动: ${winHash}`)
-  void import('./modules/monitor/OsdWindow.vue').then(({ default: OsdWindow }) => {
-    const app = createApp(OsdWindow)
-    app.mount('#app')
-  })
-} else if (winHash === '#clipboard-popup') {
-  logger.info(`剪贴板弹窗窗口启动: ${winHash}`)
-  void import('./modules/clipboard/ClipboardPopup.vue').then(({ default: ClipboardPopup }) => {
-    const app = createApp(ClipboardPopup)
-    app.mount('#app')
-  })
-} else if (winHash === '#quick-panel') {
-  logger.info(`快速面板弹窗窗口启动: ${winHash}`)
-  void import('./modules/quickpanel/QuickPanel.vue').then(({ default: QuickPanel }) => {
-    const app = createApp(QuickPanel)
-    app.mount('#app')
-  })
-} else if (winHash === '#tray-menu') {
-  logger.info(`托盘菜单窗口启动: ${winHash}`)
-  void import('./modules/tray/TrayMenu.vue').then(({ default: TrayMenu }) => {
-    const app = createApp(TrayMenu)
-    app.mount('#app')
-  })
-} else if (winHash.startsWith('#screenshot-overlay')) {
-  logger.info(`截图覆盖层窗口启动: ${winHash}`)
-  void import('./modules/screenshot/ScreenshotOverlay.vue').then(({ default: ScreenshotOverlay }) => {
-    const app = createApp(ScreenshotOverlay)
-    app.mount('#app')
-  })
-} else if (winHash === '#screenshot-editor') {
-  logger.info(`截图编辑器窗口启动: ${winHash}`)
-  void import('./modules/screenshot/ScreenshotEditor.vue').then(({ default: ScreenshotEditor }) => {
-    const app = createApp(ScreenshotEditor)
+
+// #screenshot-overlay 带窗口号参数（多屏），按前缀匹配；其余精确匹配
+const matched = standaloneWindowApps.find(([hash]) =>
+  hash === '#screenshot-overlay' ? winHash.startsWith(hash) : winHash === hash
+)
+
+if (matched) {
+  const [, label, loader] = matched
+  logger.info(`${label}窗口启动: ${winHash}`)
+  void loader().then(({ default: Comp }) => {
+    const app = createApp(Comp)
     app.mount('#app')
   })
 } else {
@@ -90,14 +82,17 @@ if (winHash === '#osd-overlay') {
       useProcessStore().initListener().catch(e => console.error('Process listener init error:', e))
     })
 
-    // 截图模块：加载设置 + 预创建常驻覆盖层窗口 + 监听导出事件（历史/自动保存）+ 注册并监听全局快捷键
+    // 截图模块：加载设置 + 恢复持久化历史 + 预创建常驻覆盖层窗口 + 监听导出事件（历史/自动保存）+ 注册并监听全局快捷键（截图/贴图）
     void import('./stores/screenshotStore').then(({ useScreenshotStore }) => {
       const screenshotStore = useScreenshotStore()
       screenshotStore.loadSettings()
+      screenshotStore.loadHistory()
       screenshotStore.initOverlay().catch(e => console.error('Screenshot overlay init error:', e))
       screenshotStore.initExportListener().catch(e => console.error('Screenshot export listener init error:', e))
       screenshotStore.initShortcutListener().catch(e => console.error('Screenshot shortcut listener init error:', e))
       screenshotStore.initShortcutRegistration().catch(e => console.error('Screenshot shortcut registration init error:', e))
+      screenshotStore.initPinShortcutListener().catch(e => console.error('Screenshot pin shortcut listener init error:', e))
+      screenshotStore.initPinShortcutRegistration().catch(e => console.error('Screenshot pin shortcut registration init error:', e))
     })
   })
 }

src/modules/clipboard/ClipboardModule.vue

@@ -6,7 +6,7 @@ import {
 } from '@lucide/vue'
 import { toast } from 'vue-sonner'
 import { useClipboardStore, type ClipboardItem, type ClipboardKind, type ClipboardItemDetail } from '@/stores/clipboardStore'
-import { useModuleTabs } from '@/lib/useModuleTabs'
+import { useModuleTabs } from '@/lib/use-module-tabs'
 import { useModuleTabsStore } from '@/stores/moduleTabsStore'
 import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs'
 import { ScrollArea } from '@/components/ui/scroll-area'
@@ -26,12 +26,16 @@ import {
 import {
   Pagination, PaginationContent, PaginationItem, PaginationEllipsis,
 } from '@/components/ui/pagination'
+import { Skeleton } from '@/components/ui/skeleton'
+import {
+  Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle,
+} from '@/components/ui/empty'
 
 const store = useClipboardStore()
 
 const activeTab = ref('history')
 const tabsStore = useModuleTabsStore()
-const tabsListRef = useModuleTabs(activeTab, [
+const tabsListRef = useModuleTabs('clipboard', activeTab, [
   { value: 'history', label: '历史' },
   { value: 'pinned', label: '固定' },
   { value: 'settings', label: '设置' },
@@ -72,11 +76,21 @@ const gotoPage = async (p: number) => {
 const detailOpen = ref(false)
 const detailLoading = ref(false)
 const detail = ref<ClipboardItemDetail | null>(null)
+/** 详情加载序号：快速点击多个条目时丢弃过期请求结果，避免旧请求覆盖新详情 */
+let detailSeq = 0
 const openDetail = async (item: ClipboardItem) => {
+  // reka-ui Dialog 打开时会把当前活动元素记为 triggerElement，关闭时对其无 preventScroll 地 focus，
+  // 导致历史列表的 ScrollAreaViewport(tabindex=0) 被聚焦并滚回顶部。打开前 blur，避免记录滚动容器。
+  const active = document.activeElement
+  if (active instanceof HTMLElement) {
+    active.blur()
+  }
   detailOpen.value = true
   detailLoading.value = true
   detail.value = null
+  const seq = ++detailSeq
   const d = await store.getItem(item.id)
+  if (seq !== detailSeq) return // 过期请求丢弃
   detail.value = d
   detailLoading.value = false
 }
@@ -249,14 +263,14 @@ const handleClear = async () => {
   toast.success('已清空历史')
 }
 
-// 显示辅助
-const kindIcon = (k: ClipboardKind) => {
+// 显示辅助（kind 来自 bindings 生成的 string，按字符串比较）
+const kindIcon = (k: string) => {
   if (k === 'text') return FileText
   if (k === 'image') return ImageIcon
   return Files
 }
-const kindLabel = (k: ClipboardKind) => (k === 'text' ? '文本' : k === 'image' ? '图片' : '文件')
-const kindBadgeClass = (k: ClipboardKind) =>
+const kindLabel = (k: string) => (k === 'text' ? '文本' : k === 'image' ? '图片' : '文件')
+const kindBadgeClass = (k: string) =>
   k === 'text'
     ? 'border-blue-500/40 bg-blue-500/10 text-blue-600 dark:text-blue-400'
     : k === 'image'
@@ -282,9 +296,17 @@ const historyList = computed(() => store.history)
 const pinnedList = computed(() => store.pinned)
 
 onMounted(async () => {
-  await store.init()
-  await Promise.all([loadPage(), store.refreshPinned()])
-  form.value = { ...store.settings }
+  // 首次进入：异步加载并显示骨架屏。再次进入时 store 已缓存历史/固定/设置，
+  // 直接即时渲染缓存数据，后台并行静默刷新，避免每次切换都出现骨架屏/空态闪烁。
+  const isFirst = !store.initialized
+  if (isFirst) store.loading = true
+  try {
+    await Promise.all([store.init(), loadPage(), store.refreshPinned()])
+    store.initialized = true
+    form.value = { ...store.settings }
+  } finally {
+    store.loading = false
+  }
 })
 
 onUnmounted(() => {
@@ -308,7 +330,7 @@ onUnmounted(() => {
       <TabsContent value="history" class="flex-1 min-h-0 flex flex-col mt-4 tab-animate">
         <div class="flex items-center gap-2 mb-3 shrink-0">
           <div class="relative flex-1 max-w-sm">
-            <Search class="absolute left-2.5 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+            <Search class="absolute left-2.5 top-1/2 -translate-y-1/2 size-4 text-muted-foreground" />
             <Input v-model="searchQuery" placeholder="搜索历史..." class="pl-8" />
           </div>
           <div class="flex items-center gap-1">
@@ -327,7 +349,7 @@ onUnmounted(() => {
             {{ store.historyTotal }} 条
           </Badge>
           <Button variant="outline" size="sm" @click="clearOpen = true" :disabled="!historyList.length">
-            <Eraser class="h-4 w-4 mr-1" />清空
+            <Eraser class="size-4 mr-1" />清空
           </Button>
         </div>
 
@@ -368,22 +390,42 @@ onUnmounted(() => {
         
         <ScrollArea class="flex-1 min-h-0">
           <div class="space-y-1.5 pr-2">
-          <div
-            v-if="!historyList.length"
-            class="flex flex-col items-center justify-center text-muted-foreground py-12"
-          >
-            <ClipboardList class="h-12 w-12 mb-3 opacity-40" />
-            <p class="text-sm">暂无历史记录，复制内容后将自动收录</p>
+          <!-- 加载骨架：数据异步返回前撑起画面，避免误显示"暂无历史" -->
+          <div v-if="store.loading" class="space-y-1.5">
+            <div
+              v-for="n in 8" :key="n"
+              class="flex items-center gap-3 rounded-lg border p-3"
+            >
+              <Skeleton class="size-4 shrink-0" />
+              <div class="flex-1 space-y-2">
+                <Skeleton class="h-3.5 w-3/4" />
+                <Skeleton class="h-2.5 w-1/4" />
+              </div>
+            </div>
           </div>
+          <Empty
+            v-else-if="!historyList.length"
+            class="py-12"
+          >
+            <EmptyHeader>
+              <EmptyMedia variant="icon">
+                <ClipboardList class="size-6" />
+              </EmptyMedia>
+              <EmptyTitle>暂无历史记录</EmptyTitle>
+            </EmptyHeader>
+            <EmptyContent>
+              <EmptyDescription>复制内容后将自动收录，图片与文件也会被记录</EmptyDescription>
+            </EmptyContent>
+          </Empty>
           <Card
             v-for="item in historyList"
             :key="item.id"
             class="group hover:shadow-md transition-shadow py-0"
           >
             <CardContent class="flex items-center gap-3 px-3 py-2">
-              <component :is="kindIcon(item.kind)" class="h-4 w-4 text-muted-foreground shrink-0" />
+              <component :is="kindIcon(item.kind)" class="size-4 text-muted-foreground shrink-0" />
               <div class="flex-1 min-w-0 cursor-pointer" @click="openDetail(item)">
-                <p class="text-sm break-all line-clamp-1" :title="item.preview">{{ item.preview }}</p>
+                <p class="text-sm break-all line-clamp-1">{{ item.preview }}</p>
                 <div class="flex items-center gap-2 mt-0.5 text-xs text-muted-foreground flex-wrap">
                   <Badge variant="outline" :class="['px-1.5 py-0 text-[10px] border', kindBadgeClass(item.kind)]">{{ kindLabel(item.kind) }}</Badge>
                   <span>{{ formatTime(item.createdAt) }}</span>
@@ -391,13 +433,13 @@ onUnmounted(() => {
                 </div>
               </div>
               <div class="flex items-center gap-0.5 shrink-0 opacity-0 group-hover:opacity-100 transition">
-                <Button variant="ghost" size="icon" class="h-7 w-7" title="复制" @click.stop="handleCopy(item)">
+                <Button variant="ghost" size="icon" class="size-7" title="复制" @click.stop="handleCopy(item)">
                   <Copy class="h-3.5 w-3.5" />
                 </Button>
-                <Button variant="ghost" size="icon" class="h-7 w-7" :title="item.pinned ? '取消固定' : '固定'" @click.stop="handlePin(item)">
+                <Button variant="ghost" size="icon" class="size-7" :title="item.pinned ? '取消固定' : '固定'" @click.stop="handlePin(item)">
                   <component :is="item.pinned ? PinOff : Pin" class="h-3.5 w-3.5" />
                 </Button>
-                <Button variant="ghost" size="icon" class="h-7 w-7 hover:text-destructive" title="删除" @click.stop="handleDelete(item)">
+                <Button variant="ghost" size="icon" class="size-7 hover:text-destructive" title="删除" @click.stop="handleDelete(item)">
                   <Trash2 class="h-3.5 w-3.5" />
                 </Button>
               </div>
@@ -410,19 +452,22 @@ onUnmounted(() => {
       <!-- 固定 -->
       <TabsContent value="pinned" class="flex-1 min-h-0 flex flex-col mt-4 tab-animate">
         <div class="flex-1 min-h-0 overflow-y-auto space-y-1.5 pr-1">
-          <div
-            v-if="!pinnedList.length"
-            class="flex flex-col items-center justify-center h-full text-muted-foreground"
-          >
-            <Pin class="h-12 w-12 mb-3 opacity-40" />
-            <p class="text-sm">暂无固定条目</p>
-            <p class="text-xs mt-1">鼠标悬停历史条目，点击图钉按钮即可固定</p>
-          </div>
+          <Empty v-if="!pinnedList.length" class="h-full py-8">
+            <EmptyHeader>
+              <EmptyMedia variant="icon">
+                <Pin class="size-6" />
+              </EmptyMedia>
+              <EmptyTitle>暂无固定条目</EmptyTitle>
+            </EmptyHeader>
+            <EmptyContent>
+              <EmptyDescription>鼠标悬停历史条目，点击图钉按钮即可固定</EmptyDescription>
+            </EmptyContent>
+          </Empty>
           <Card v-for="item in pinnedList" :key="item.id" class="group hover:shadow-md transition-shadow py-0">
             <CardContent class="flex items-center gap-3 px-3 py-2">
-              <component :is="kindIcon(item.kind)" class="h-4 w-4 text-primary shrink-0" />
+              <component :is="kindIcon(item.kind)" class="size-4 text-primary shrink-0" />
               <div class="flex-1 min-w-0 cursor-pointer" @click="openDetail(item)">
-                <p class="text-sm break-all line-clamp-1" :title="item.preview">{{ item.preview }}</p>
+                <p class="text-sm break-all line-clamp-1">{{ item.preview }}</p>
                 <div class="flex items-center gap-2 mt-0.5 text-xs text-muted-foreground flex-wrap">
                   <Badge variant="outline" :class="['px-1.5 py-0 text-[10px] border', kindBadgeClass(item.kind)]">{{ kindLabel(item.kind) }}</Badge>
                   <span>{{ formatTime(item.createdAt) }}</span>
@@ -430,13 +475,13 @@ onUnmounted(() => {
                 </div>
               </div>
               <div class="flex items-center gap-0.5 shrink-0 opacity-0 group-hover:opacity-100 transition">
-                <Button variant="ghost" size="icon" class="h-7 w-7" title="复制" @click.stop="handleCopy(item)">
+                <Button variant="ghost" size="icon" class="size-7" title="复制" @click.stop="handleCopy(item)">
                   <Copy class="h-3.5 w-3.5" />
                 </Button>
-                <Button variant="ghost" size="icon" class="h-7 w-7" title="取消固定" @click.stop="handlePin(item)">
+                <Button variant="ghost" size="icon" class="size-7" title="取消固定" @click.stop="handlePin(item)">
                   <PinOff class="h-3.5 w-3.5" />
                 </Button>
-                <Button variant="ghost" size="icon" class="h-7 w-7 hover:text-destructive" title="删除" @click.stop="handleDelete(item)">
+                <Button variant="ghost" size="icon" class="size-7 hover:text-destructive" title="删除" @click.stop="handleDelete(item)">
                   <Trash2 class="h-3.5 w-3.5" />
                 </Button>
               </div>
@@ -450,7 +495,7 @@ onUnmounted(() => {
         <div class="max-w-xl space-y-4">
           <div class="flex items-center">
             <h3 class="text-base font-medium flex items-center gap-2">
-              <SettingsIcon class="h-4 w-4" />基本设置
+              <SettingsIcon class="size-4" />基本设置
             </h3>
           </div>
 
@@ -519,7 +564,7 @@ onUnmounted(() => {
               <div class="flex items-center justify-between">
                 <div>
                   <Label class="flex items-center gap-2">
-                    <Keyboard class="h-4 w-4" />快捷弹窗快捷键
+                    <Keyboard class="size-4" />快捷弹窗快捷键
                   </Label>
                   <p class="text-xs text-muted-foreground mt-1">全局快捷键触发鼠标位置历史弹窗，留空禁用</p>
                 </div>
@@ -563,7 +608,7 @@ onUnmounted(() => {
         </DialogHeader>
         <div class="flex-1 min-h-0 overflow-auto">
           <div v-if="detailLoading" class="flex items-center justify-center py-12">
-            <Loader2 class="h-6 w-6 animate-spin text-muted-foreground" />
+            <Loader2 class="size-6 animate-spin text-muted-foreground" />
           </div>
           <template v-else-if="detail">
             <img
@@ -575,7 +620,7 @@ onUnmounted(() => {
             <p v-else-if="detail.kind === 'image'" class="text-sm text-muted-foreground text-center py-8">
               图片预览不可用
             </p>
-            <pre v-else-if="detail.kind === 'text'" class="text-sm whitespace-pre-wrap break-all font-mono bg-muted/50 p-3 rounded">{{ detail.content }}</pre>
+            <pre v-else-if="detail.kind === 'text'" class="text-sm whitespace-pre-wrap break-all font-mono bg-muted/50 p-3 rounded select-text cursor-text">{{ detail.content }}</pre>
             <ul v-else-if="detail.kind === 'files'" class="space-y-1 text-sm">
               <li
                 v-for="(p, i) in (parseFiles(detail.content))"

src/modules/clipboard/ClipboardPopup.vue

@@ -1,34 +1,29 @@
 <script setup lang="ts">
 import { ref, computed, onMounted, onUnmounted, nextTick, watch } from 'vue'
-import { invoke } from '@tauri-apps/api/core'
 import { listen, type UnlistenFn } from '@tauri-apps/api/event'
 import { getCurrentWindow } from '@tauri-apps/api/window'
+import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
 import { Effect, EffectState } from '@tauri-apps/api/window'
+// Rust 端通过 tauri-specta 生成的命令绑定（bindings.ts）
+import { commands } from '@/lib/bindings'
 import {
   ClipboardList, Pin, PinOff, Trash2, Search, Image as ImageIcon,
-  FileText, Files, Loader2,
+  FileText, Files,
 } from '@lucide/vue'
 import { ScrollArea } from '@/components/ui/scroll-area'
 import { Input } from '@/components/ui/input'
+import { Button } from '@/components/ui/button'
+import {
+  Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
+} from '@/components/ui/select'
 import {
   Pagination, PaginationContent, PaginationItem, PaginationEllipsis,
 } from '@/components/ui/pagination'
+import { Skeleton } from '@/components/ui/skeleton'
 
-// ===== 与 Rust 端对应的数据结构（camelCase） =====
-type ClipboardKind = 'text' | 'image' | 'files'
-interface ClipboardItem {
-  id: number
-  kind: ClipboardKind
-  preview: string
-  size: number
-  pinned: boolean
-  pinnedOrder: number | null
-  createdAt: number
-}
-interface HistoryPage {
-  items: ClipboardItem[]
-  total: number
-}
+// ===== 与 Rust 端对应的数据结构（bindings 提供，camelCase） =====
+// kind 为 bindings 生成的 string，前端按字符串比较即可
+import type { ClipboardItem, HistoryPage } from '@/lib/bindings'
 
 // ===== 状态 =====
 const items = ref<ClipboardItem[]>([])
@@ -36,6 +31,8 @@ const total = ref(0)
 const currentPage = ref(1)
 const PAGE_SIZE = 50
 const searchQuery = ref('')
+/** 类型筛选：全部/文本/图片/文件 */
+const kindFilter = ref<'all' | 'text' | 'image' | 'files'>('all')
 const selectedIndex = ref(0)
 const loading = ref(false)
 const searchInputRef = ref<HTMLInputElement | null>(null)
@@ -45,27 +42,58 @@ let searchTimer: ReturnType<typeof setTimeout> | null = null
 const totalPages = computed(() => Math.max(1, Math.ceil(total.value / PAGE_SIZE)))
 
 // ===== 数据加载 =====
+/** 加载请求序号：翻页/搜索快速操作时丢弃过期请求结果，避免旧请求覆盖新结果 */
+let loadSeq = 0
+/** 列表视图：history = 全部历史（后端分页）；pinned = 仅钉住条目（前端筛选+分页） */
+const viewMode = ref<'history' | 'pinned'>('history')
 async function loadData() {
+  const seq = ++loadSeq
   loading.value = true
   try {
-    const q = searchQuery.value.trim()
-    const offset = (currentPage.value - 1) * PAGE_SIZE
-    let res: HistoryPage
-    if (q) {
-      res = await invoke<HistoryPage>('clipboard_search', { query: q, limit: PAGE_SIZE, offset })
+    if (viewMode.value === 'pinned') {
+      // 钉住视图：一次性取回，前端按类型/搜索筛选并分页
+      const all = await commands.clipboardGetPinned()
+      if (seq !== loadSeq) return
+      const q = searchQuery.value.trim().toLowerCase()
+      const kind = kindFilter.value
+      let filtered = all
+      if (kind !== 'all') filtered = filtered.filter(i => i.kind === kind)
+      if (q) filtered = filtered.filter(i => i.preview.toLowerCase().includes(q))
+      total.value = filtered.length
+      const start = (currentPage.value - 1) * PAGE_SIZE
+      items.value = filtered.slice(start, start + PAGE_SIZE)
     } else {
-      res = await invoke<HistoryPage>('clipboard_get_history', { limit: PAGE_SIZE, offset, kind: 'all' })
+      const q = searchQuery.value.trim()
+      const offset = (currentPage.value - 1) * PAGE_SIZE
+      let res: HistoryPage
+      if (q) {
+        res = await commands.clipboardSearch(q, PAGE_SIZE, offset)
+      } else {
+        res = await commands.clipboardGetHistory(PAGE_SIZE, offset, kindFilter.value)
+      }
+      if (seq !== loadSeq) return // 过期请求丢弃
+      items.value = res.items
+      total.value = res.total
     }
-    items.value = res.items
-    total.value = res.total
     selectedIndex.value = 0
   } catch (e) {
+    if (seq !== loadSeq) return
     console.error('[clipboard-popup] 加载失败:', e)
   } finally {
-    loading.value = false
+    // 仅最新请求可结束 loading，避免旧请求提前清除新请求的加载态
+    if (seq === loadSeq) loading.value = false
   }
-  await nextTick()
-  scrollSelectedIntoView()
+  if (seq === loadSeq) {
+    await nextTick()
+    scrollSelectedIntoView()
+  }
+}
+
+/** 切换历史/钉住视图 */
+async function toggleViewMode() {
+  viewMode.value = viewMode.value === 'history' ? 'pinned' : 'history'
+  currentPage.value = 1
+  await loadData()
 }
 
 async function gotoPage(p: number) {
@@ -73,8 +101,8 @@ async function gotoPage(p: number) {
   await loadData()
 }
 
-// 防抖搜索
-watch(searchQuery, () => {
+// 防抖搜索/筛选
+watch([searchQuery, kindFilter], () => {
   currentPage.value = 1
   if (searchTimer) clearTimeout(searchTimer)
   searchTimer = setTimeout(loadData, 200)
@@ -84,9 +112,9 @@ watch(searchQuery, () => {
 /// 选中条目 → 写回剪贴板 → 隐藏窗口 → 模拟 Ctrl+V 粘贴到原窗口
 async function selectAndPaste(item: ClipboardItem) {
   try {
-    await invoke('clipboard_copy_back', { id: item.id })
+    await commands.clipboardCopyBack(item.id)
     // paste_to_target 会先隐藏窗口，再延迟模拟 Ctrl+V
-    await invoke('clipboard_paste_to_target')
+    await commands.clipboardPasteToTarget()
   } catch (e) {
     console.error('[clipboard-popup] 粘贴失败:', e)
     // 失败时至少隐藏窗口
@@ -97,7 +125,7 @@ async function selectAndPaste(item: ClipboardItem) {
 async function togglePin(item: ClipboardItem, ev: Event) {
   ev.stopPropagation()
   try {
-    await invoke('clipboard_set_pinned', { id: item.id, pinned: !item.pinned })
+    await commands.clipboardSetPinned(item.id, !item.pinned)
     await loadData()
   } catch (e) {
     console.error('[clipboard-popup] 固定失败:', e)
@@ -107,8 +135,15 @@ async function togglePin(item: ClipboardItem, ev: Event) {
 async function deleteItem(item: ClipboardItem, ev: Event) {
   ev.stopPropagation()
   try {
-    await invoke('clipboard_delete', { id: item.id })
+    await commands.clipboardDelete(item.id)
+    // 本地先移除保持即时反馈，再整页刷新（total/分页数与后端保持一致；
+    // 钉住视图下数据源也需重建）
     items.value = items.value.filter((i) => i.id !== item.id)
+    // 当前页删空且不在第一页：回退一页，避免停留在空页
+    if (items.value.length === 0 && currentPage.value > 1) {
+      currentPage.value -= 1
+    }
+    await loadData()
   } catch (e) {
     console.error('[clipboard-popup] 删除失败:', e)
   }
@@ -116,25 +151,115 @@ async function deleteItem(item: ClipboardItem, ev: Event) {
 
 async function hideWindow() {
   try {
-    await invoke('clipboard_hide_popup')
+    await commands.clipboardHidePopup()
   } catch {
     /* 忽略 */
   }
 }
 
+// ===== 独立预览窗口 =====
+async function showPreview(item: ClipboardItem) {
+  try {
+    await commands.clipboardShowPreview(item.id)
+  } catch {
+    /* 忽略 */
+  }
+}
+
+async function hidePreview() {
+  try {
+    await commands.clipboardHidePreview()
+  } catch {
+    /* 忽略 */
+  }
+}
+
+/** 存储条目预览文本元素，用于检测是否被截断（仅截断的文本才显示预览） */
+const previewEls = new Map<number, HTMLElement>()
+function setPreviewEl(id: number, el: unknown) {
+  if (el instanceof HTMLElement) previewEls.set(id, el)
+  else previewEls.delete(id)
+}
+
+/** line-clamp-1 截断检测：内容高度超过单行即视为截断 */
+function isTextTruncated(id: number): boolean {
+  const el = previewEls.get(id)
+  if (!el) return true // 无法测量时保守显示
+  return el.scrollHeight > el.clientHeight
+}
+
+/** 当前条目是否需要预览：图片始终预览；文本仅被截断时预览 */
+function needsPreview(item: ClipboardItem): boolean {
+  if (item.kind === 'image') return true
+  if (item.kind === 'text') return isTextTruncated(item.id)
+  return false
+}
+
+let hoverTimer: ReturnType<typeof setTimeout> | null = null
+/** 鼠标是否位于独立预览窗内：为 true 时离开条目不隐藏预览，便于点击复制/放大 */
+const mouseInPreview = ref(false)
+
+/** 键盘选中：立即显示/隐藏预览（不等待悬停延迟） */
+function showSelectedPreview() {
+  cancelHoverTimer()
+  mouseInPreview.value = false
+  const item = items.value[selectedIndex.value]
+  if (item && needsPreview(item)) {
+    void showPreview(item)
+  } else {
+    void hidePreview()
+  }
+}
+
+function onItemHover(idx: number, item: ClipboardItem) {
+  selectedIndex.value = idx
+  // 先取消之前的定时器
+  cancelHoverTimer()
+  mouseInPreview.value = false
+  // 不需要预览的条目：立即隐藏预览（避免前一条目的预览残留）
+  if (!needsPreview(item)) {
+    void hidePreview()
+    return
+  }
+  // 100ms 后显示（快速响应悬停意图，同时避免鼠标快速划过时频繁开关）
+  hoverTimer = setTimeout(() => {
+    void showPreview(item)
+  }, 100)
+}
+
+function onItemLeave() {
+  // 延迟隐藏：避免鼠标在条目间快速移动时预览闪烁。
+  // 若鼠标已移入预览窗（点击复制/放大），由 preview-enter 事件取消该定时器。
+  cancelHoverTimer()
+  if (mouseInPreview.value) return
+  hoverTimer = setTimeout(() => {
+    void hidePreview()
+  }, 250)
+}
+
+function cancelHoverTimer() {
+  if (hoverTimer) {
+    clearTimeout(hoverTimer)
+    hoverTimer = null
+  }
+}
+
 // ===== 键盘导航 =====
+// 类型筛选 Select 的展开状态：展开时 ↑↓/Enter/Esc 由 Select 自行处理，
+// 不触发列表导航/粘贴/关闭弹窗
+const selectOpen = ref(false)
+
 function onKeydown(e: KeyboardEvent) {
+  if (selectOpen.value) return
   if (e.key === 'ArrowDown') {
     e.preventDefault()
     selectedIndex.value = Math.min(selectedIndex.value + 1, items.value.length - 1)
-    cancelHoverTimer()
-    previewVisible.value = false
+    showSelectedPreview()
     scrollSelectedIntoView()
   } else if (e.key === 'ArrowUp') {
     e.preventDefault()
     selectedIndex.value = Math.max(selectedIndex.value - 1, 0)
-    cancelHoverTimer()
-    previewVisible.value = false
+    showSelectedPreview()
     scrollSelectedIntoView()
   } else if (e.key === 'Enter') {
     e.preventDefault()
@@ -142,6 +267,8 @@ function onKeydown(e: KeyboardEvent) {
     if (item) selectAndPaste(item)
   } else if (e.key === 'Escape') {
     e.preventDefault()
+    cancelHoverTimer()
+    void hidePreview()
     hideWindow()
   }
 }
@@ -153,14 +280,14 @@ function scrollSelectedIntoView() {
   })
 }
 
-// ===== 显示辅助 =====
-const kindIcon = (k: ClipboardKind) => {
+// ===== 显示辅助（kind 为 bindings 生成的 string，按字符串比较） =====
+const kindIcon = (k: string) => {
   if (k === 'text') return FileText
   if (k === 'image') return ImageIcon
   return Files
 }
-const kindLabel = (k: ClipboardKind) => (k === 'text' ? '文本' : k === 'image' ? '图片' : '文件')
-const kindBadgeClass = (k: ClipboardKind) =>
+const kindLabel = (k: string) => (k === 'text' ? '文本' : k === 'image' ? '图片' : '文件')
+const kindBadgeClass = (k: string) =>
   k === 'text'
     ? 'badge-text'
     : k === 'image'
@@ -177,67 +304,11 @@ const formatTime = (ms: number) => {
 
 const hasItems = computed(() => items.value.length > 0)
 
-// ===== 图片悬停预览（悬停 100ms 后显示缩略图） =====
-const previewSrc = ref('')
-const previewVisible = ref(false)
-let hoverTimer: ReturnType<typeof setTimeout> | null = null
-// 缓存已加载的图片 id → dataUrl，避免重复请求
-const imageCache = new Map<number, string>()
-
-/** 根据 base64 前缀判断 MIME 类型 */
-function buildImageDataUrl(b64: string): string {
-  const mime = b64.startsWith('/9j/') ? 'image/jpeg' : 'image/png'
-  return `data:${mime};base64,${b64}`
-}
-
-async function onItemHover(idx: number, item: ClipboardItem) {
-  selectedIndex.value = idx
-  // 仅图片类型触发预览
-  if (item.kind !== 'image') {
-    cancelHoverTimer()
-    previewVisible.value = false
-    return
-  }
-  // 先取消之前的定时器和预览
-  cancelHoverTimer()
-  // 100ms 后加载并显示（快速响应悬停意图）
-  hoverTimer = setTimeout(async () => {
-    try {
-      let src = imageCache.get(item.id)
-      if (!src) {
-        const detail = await invoke<{ imageBase64: string | null } | null>('clipboard_get_item', { id: item.id })
-        if (detail?.imageBase64) {
-          src = buildImageDataUrl(detail.imageBase64)
-          imageCache.set(item.id, src)
-        }
-      }
-      if (src) {
-        previewSrc.value = src
-        previewVisible.value = true
-      }
-    } catch {
-      /* 忽略加载失败 */
-    }
-  }, 100)
-}
-
-function cancelHoverTimer() {
-  if (hoverTimer) {
-    clearTimeout(hoverTimer)
-    hoverTimer = null
-  }
-}
-
-function onItemLeave() {
-  cancelHoverTimer()
-  previewVisible.value = false
-}
-
 // ===== 主题应用（与主应用同步） =====
 /** 从 localStorage 读取主应用的主题设置 */
 function readMainTheme(): { theme: string; effect: string } {
   try {
-    const raw = localStorage.getItem('thing_app_settings')
+    const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
     if (raw) {
       const s = JSON.parse(raw)
       return {
@@ -330,20 +401,42 @@ onMounted(async () => {
   unlistenFns.push(() => mq.removeEventListener('change', onThemeChange))
 
   // 监听弹窗显示事件：每次显示时重新同步主题 + 刷新数据
-  unlistenFns.push(await listen('clipboard-popup-show', async () => {
+  unlistenFns.push(await listen(EVENTS.clipboardPopupShow, async () => {
     // 主应用可能切换了主题，每次显示前重新应用
     await applyTheme()
     searchQuery.value = ''
     currentPage.value = 1
-    // 重置预览状态，清空缓存避免历史图片占用内存
+    // 隐藏独立预览窗口（弹窗重新显示时清除上次预览）
     cancelHoverTimer()
-    previewVisible.value = false
-    imageCache.clear()
+    mouseInPreview.value = false
+    void hidePreview()
     await loadData()
     await nextTick()
     searchInputRef.value?.focus()
   }))
 
+  // 监听弹窗隐藏事件：取消悬停定时器并隐藏预览，避免弹窗隐藏后残留定时器重新弹出预览窗
+  unlistenFns.push(await listen(EVENTS.clipboardPopupHide, () => {
+    cancelHoverTimer()
+    mouseInPreview.value = false
+    void hidePreview()
+  }))
+
+  // 鼠标进入预览窗：取消条目离开触发的隐藏定时器，允许在预览窗内停留并点击复制/放大
+  unlistenFns.push(await listen(EVENTS.clipboardPreviewEnter, () => {
+    mouseInPreview.value = true
+    cancelHoverTimer()
+  }))
+
+  // 鼠标离开预览窗：恢复可隐藏状态并延迟隐藏；鼠标移回条目时由 onItemHover 重新显示
+  unlistenFns.push(await listen(EVENTS.clipboardPreviewLeave, () => {
+    mouseInPreview.value = false
+    cancelHoverTimer()
+    hoverTimer = setTimeout(() => {
+      void hidePreview()
+    }, 250)
+  }))
+
   // 加载初始数据
   await loadData()
   await nextTick()
@@ -351,7 +444,7 @@ onMounted(async () => {
 
   // 主题和数据都就绪后，调用 Rust 端显示窗口
   try {
-    await invoke('clipboard_show_window')
+    await commands.clipboardShowWindow()
   } catch {
     /* 忽略 */
   }
@@ -365,10 +458,10 @@ onUnmounted(() => {
 
 <template>
   <div class="popup-root flex flex-col h-screen w-screen" @keydown="onKeydown">
-    <!-- 搜索栏（与剪切板主页统一样式） -->
+    <!-- 搜索栏（与剪切板主页统一样式）+ 类型筛选 -->
     <div class="flex items-center gap-2 px-3 py-2 border-b border-border shrink-0">
-      <div class="relative flex-1 max-w-sm">
-        <Search class="absolute left-2.5 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+      <div class="relative flex-1 min-w-0">
+        <Search class="absolute left-2.5 top-1/2 -translate-y-1/2 size-4 text-muted-foreground" />
         <Input
           ref="searchInputRef"
           v-model="searchQuery"
@@ -377,24 +470,38 @@ onUnmounted(() => {
           spellcheck="false"
         />
       </div>
-      <span class="text-xs text-muted-foreground whitespace-nowrap">{{ total }} 条</span>
+      <Select v-model="kindFilter" :open="selectOpen" @update:open="selectOpen = $event">
+        <SelectTrigger size="sm" class="w-[76px] shrink-0 text-xs" title="按类型筛选">
+          <SelectValue />
+        </SelectTrigger>
+        <!-- 内容宽度与 trigger 等宽：覆盖默认 min-w-[8rem]（128px），紧凑弹窗内不显过宽 -->
+        <SelectContent class="w-(--reka-select-trigger-width) min-w-0">
+          <SelectItem value="all">全部</SelectItem>
+          <SelectItem value="text">文本</SelectItem>
+          <SelectItem value="image">图片</SelectItem>
+          <SelectItem value="files">文件</SelectItem>
+        </SelectContent>
+      </Select>
     </div>
 
-    <!-- 图片悬停预览浮层 -->
-    <Transition name="popup-preview">
-      <div v-if="previewVisible && previewSrc" class="popup-preview">
-        <img :src="previewSrc" alt="预览" />
-      </div>
-    </Transition>
-
     <!-- 列表 -->
     <ScrollArea class="popup-list flex-1 min-h-0">
       <div class="space-y-1.5 p-2">
-        <div v-if="loading && !hasItems" class="flex flex-col items-center justify-center py-12 text-muted-foreground">
-          <Loader2 class="h-6 w-6 animate-spin" />
+        <div v-if="loading && !hasItems" class="space-y-1.5">
+          <div
+            v-for="n in 8"
+            :key="n"
+            class="flex items-start gap-3 rounded-lg border px-3 py-2"
+          >
+            <Skeleton class="size-4 shrink-0 mt-0.5" />
+            <div class="flex-1 space-y-1.5">
+              <Skeleton class="h-3.5 w-3/4" />
+              <Skeleton class="h-2.5 w-1/4" />
+            </div>
+          </div>
         </div>
         <div v-else-if="!hasItems" class="flex flex-col items-center justify-center py-12 text-muted-foreground">
-          <ClipboardList class="h-10 w-10 mb-2 opacity-40" />
+          <ClipboardList class="size-10 mb-2 opacity-40" />
           <p class="text-sm">
             {{ searchQuery ? '无匹配结果' : '暂无历史记录' }}
           </p>
@@ -408,19 +515,22 @@ onUnmounted(() => {
           @mouseenter="onItemHover(idx, item)"
           @mouseleave="onItemLeave"
         >
-          <component :is="kindIcon(item.kind)" class="h-4 w-4 text-muted-foreground shrink-0 mt-0.5" />
+          <component :is="kindIcon(item.kind)" class="size-4 text-muted-foreground shrink-0 mt-0.5" />
           <div class="flex-1 min-w-0">
-            <p class="text-sm break-all line-clamp-1" :title="item.preview">{{ item.preview }}</p>
+            <p
+              class="text-sm break-all line-clamp-1"
+              :ref="el => setPreviewEl(item.id, el)"
+            >{{ item.preview }}</p>
             <div class="flex items-center gap-2 mt-0.5 text-xs text-muted-foreground flex-wrap">
               <span class="popup-item-kind px-1.5 py-0 text-[10px] border rounded-sm" :class="kindBadgeClass(item.kind)">{{ kindLabel(item.kind) }}</span>
               <span>{{ formatTime(item.createdAt) }}</span>
             </div>
           </div>
           <div class="popup-item-actions shrink-0">
-            <button class="popup-action-btn h-7 w-7" title="固定" @click="togglePin(item, $event)">
+            <button class="popup-action-btn size-7" :title="item.pinned ? '取消固定' : '固定'" @click="togglePin(item, $event)">
               <component :is="item.pinned ? PinOff : Pin" class="h-3.5 w-3.5" />
             </button>
-            <button class="popup-action-btn h-7 w-7 hover:text-destructive" title="删除" @click="deleteItem(item, $event)">
+            <button class="popup-action-btn size-7 hover:text-destructive" title="删除" @click="deleteItem(item, $event)">
               <Trash2 class="h-3.5 w-3.5" />
             </button>
           </div>
@@ -428,38 +538,56 @@ onUnmounted(() => {
       </div>
     </ScrollArea>
 
-    <!-- 分页（与剪切板历史统一样式） -->
-    <div v-if="totalPages > 1" class="flex items-center justify-center gap-1 px-2 py-1 border-t border-border">
-      <Pagination
-        v-slot="{ page }"
-        :page="currentPage"
-        :total="total"
-        :items-per-page="PAGE_SIZE"
-        :sibling-count="1"
-        show-edges
-        @update:page="gotoPage"
-      >
-        <PaginationContent v-slot="{ items: pageItems }" class="gap-1">
-          <template v-for="(item, index) in pageItems" :key="index">
-            <PaginationItem
-              v-if="item.type === 'page'"
-              :value="item.value"
-              :is-active="item.value === page"
-              size="icon"
-              class="size-7 text-xs"
-            >
-              {{ item.value }}
-            </PaginationItem>
-            <PaginationEllipsis v-else class="size-7" />
-          </template>
-        </PaginationContent>
-      </Pagination>
+    <!-- 底部：总数 + 分页 + 视图切换（grid 两侧 1fr 等宽，分页严格居中） -->
+    <div class="grid grid-cols-[1fr_auto_1fr] items-center gap-2 px-3 py-1 border-t border-border shrink-0">
+      <span class="text-xs text-muted-foreground whitespace-nowrap justify-self-start">{{ total }} 条</span>
+      <div v-if="totalPages > 1" class="justify-self-center">
+        <Pagination
+          v-slot="{ page }"
+          :page="currentPage"
+          :total="total"
+          :items-per-page="PAGE_SIZE"
+          :sibling-count="1"
+          show-edges
+          @update:page="gotoPage"
+        >
+          <PaginationContent v-slot="{ items: pageItems }" class="gap-1">
+            <template v-for="(item, index) in pageItems" :key="index">
+              <PaginationItem
+                v-if="item.type === 'page'"
+                :value="item.value"
+                :is-active="item.value === page"
+                size="icon"
+                class="size-7 text-xs"
+              >
+                {{ item.value }}
+              </PaginationItem>
+              <PaginationEllipsis v-else class="size-7" />
+            </template>
+          </PaginationContent>
+        </Pagination>
+      </div>
+      <!-- col-start-3：无分页时中间轨道宽为 0，若不固定列位置按钮会被自动放置
+           到第 2 轨道（视觉居中），显式固定第 3 轨道保证始终贴右 -->
+      <div class="justify-self-end col-start-3">
+        <Button
+          :variant="viewMode === 'pinned' ? 'default' : 'outline'"
+          size="sm"
+          class="h-7 px-2 text-xs gap-1"
+          :title="viewMode === 'pinned' ? '当前：仅钉住条目，点击查看全部历史' : '当前：全部历史，点击仅查看钉住条目'"
+          @click="toggleViewMode"
+        >
+          <!-- 图标与文字同义（Pin=钉住视图 / ClipboardList=历史视图），高亮表示当前视图 -->
+          <component :is="viewMode === 'pinned' ? Pin : ClipboardList" class="size-3.5" />
+          {{ viewMode === 'pinned' ? '钉住' : '历史' }}
+        </Button>
+      </div>
     </div>
 
     <!-- 底部提示 -->
     <div class="popup-footer shrink-0">
       <span><kbd>↑</kbd><kbd>↓</kbd> 导航</span>
-      <span><kbd>Enter</kbd> 粘贴</span>
+      <span><kbd>Enter</kbd>/<kbd>左键</kbd> 粘贴</span>
       <span><kbd>Esc</kbd> 关闭</span>
     </div>
   </div>
@@ -579,39 +707,6 @@ onUnmounted(() => {
   color: var(--muted-foreground);
 }
 
-/* 图片悬停预览浮层：固定在弹窗右上角，不遮挡列表操作 */
-.popup-preview {
-  position: absolute;
-  top: 50px;
-  right: 10px;
-  z-index: 100;
-  max-width: 180px;
-  max-height: 180px;
-  border-radius: 6px;
-  overflow: hidden;
-  border: 1px solid var(--border);
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.25);
-  background: var(--popover, var(--background));
-  pointer-events: none;
-}
-
-.popup-preview img {
-  display: block;
-  max-width: 100%;
-  max-height: 180px;
-  object-fit: contain;
-}
-
-/* 预览浮层淡入淡出 */
-.popup-preview-enter-active,
-.popup-preview-leave-active {
-  transition: opacity 0.15s ease;
-}
-.popup-preview-enter-from,
-.popup-preview-leave-to {
-  opacity: 0;
-}
-
 .popup-footer kbd {
   background: var(--muted);
   color: var(--foreground);

src/modules/clipboard/ClipboardPreview.vue

@@ -0,0 +1,369 @@
+<script setup lang="ts">
+import { ref, onMounted, onUnmounted } from 'vue'
+import { listen, emit, type UnlistenFn } from '@tauri-apps/api/event'
+import { getCurrentWindow, Effect, EffectState } from '@tauri-apps/api/window'
+import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
+import { commands } from '@/lib/bindings'
+import { ZoomIn, ZoomOut, FileText, Image as ImageIcon } from '@lucide/vue'
+import { ScrollArea } from '@/components/ui/scroll-area'
+
+// ===== 状态 =====
+const kind = ref<'text' | 'image' | ''>('')
+const textContent = ref('')
+const thumbSrc = ref('')
+const fullSrc = ref('')
+const enlarged = ref(false)
+const loading = ref(false)
+let unlistenFns: UnlistenFn[] = []
+// 加载序号：连续悬停快速切换时丢弃过期请求结果
+let loadSeq = 0
+
+/** 根据 base64 前缀判断 MIME 类型 */
+function buildImageDataUrl(b64: string): string {
+  const mime = b64.startsWith('/9j/') ? 'image/jpeg' : 'image/png'
+  return `data:${mime};base64,${b64}`
+}
+
+// ===== 窗口尺寸自适应（贴合内容消除留白） =====
+// 布局常量（逻辑像素，与模板样式对应）
+const PAD = 12            // 内容区 p-3
+const HEADER_H = 30       // 头部栏高度（py-1.5*2 + 行高 + 边框）
+const TEXT_W = 360        // 文本预览窗口宽
+const THUMB_MAX_W = 440   // 缩略态图片最大显示宽
+const THUMB_MAX_H = 340   // 缩略态图片最大显示高
+const DEF_W = 340         // 默认/兜底窗口宽（非文本图片、加载失败）
+const DEF_H = 300         // 默认/兜底窗口高
+
+/** 离屏测量文本在指定内容宽下的自然高度（样式与模板 pre 一致，保证测量准确） */
+function measureTextHeight(text: string, width: number): number {
+  const el = document.createElement('pre')
+  el.className = 'text-xs whitespace-pre-wrap break-all font-mono leading-relaxed'
+  el.style.cssText = `position:fixed;left:-9999px;top:0;width:${width}px;margin:0;visibility:hidden`
+  el.textContent = text
+  document.body.appendChild(el)
+  const h = el.getBoundingClientRect().height
+  el.remove()
+  return h
+}
+
+/** 读取图片原始尺寸 */
+function loadImageSize(src: string): Promise<{ w: number; h: number }> {
+  return new Promise((resolve) => {
+    const img = new Image()
+    img.onload = () => resolve({ w: img.naturalWidth || 0, h: img.naturalHeight || 0 })
+    img.onerror = () => resolve({ w: 0, h: 0 })
+    img.src = src
+  })
+}
+
+/** 按当前内容自适应窗口尺寸：文本测高、图片按宽高比（放大态用原图尺寸），
+ *  后端按工作区钳制并重新对齐弹窗；完成后 reveal 显示（窗口出现即最终尺寸，
+ *  无"先大后小"闪烁）。seq 用于丢弃快速切换时的过期请求。
+ *  allowFlip：初始落位为 true（放不下可换侧）；放大/还原为 false（保持原侧）。 */
+async function fitWindow(seq: number, allowFlip: boolean) {
+  let w = DEF_W
+  let h = DEF_H
+  if (kind.value === 'text') {
+    const th = measureTextHeight(textContent.value, TEXT_W - PAD * 2)
+    w = TEXT_W
+    h = HEADER_H + PAD * 2 + th
+  } else if (kind.value === 'image') {
+    const src = enlarged.value ? fullSrc.value : thumbSrc.value
+    if (src) {
+      const { w: iw, h: ih } = await loadImageSize(src)
+      if (seq !== loadSeq) return
+      if (iw && ih) {
+        let dw = iw
+        let dh = ih
+        if (!enlarged.value) {
+          // 缩略态：等比缩放进显示区（不放大超过图片自身尺寸）
+          const scale = Math.min(THUMB_MAX_W / iw, THUMB_MAX_H / ih, 1)
+          dw = Math.round(iw * scale)
+          dh = Math.round(ih * scale)
+        }
+        w = dw + PAD * 2
+        h = dh + HEADER_H + PAD * 2
+      }
+    }
+  }
+  if (seq !== loadSeq) return
+  try {
+    // 先 resize（窗口仍隐藏）完成定位，再 reveal 以最终尺寸显示
+    await commands.clipboardResizePreview(w, h, allowFlip)
+    await commands.clipboardRevealPreview()
+  } catch {
+    /* 忽略 */
+  }
+}
+
+/** 根据条目 id 加载预览内容（文本取全文，图片先取缩略图） */
+async function loadItem(id: number) {
+  const seq = ++loadSeq
+  loading.value = true
+  enlarged.value = false
+  kind.value = ''
+  textContent.value = ''
+  thumbSrc.value = ''
+  fullSrc.value = ''
+  try {
+    const detail = await commands.clipboardGetItem(id)
+    if (seq !== loadSeq) return
+    if (detail?.kind === 'text') {
+      kind.value = 'text'
+      textContent.value = detail.content ?? ''
+    } else if (detail?.kind === 'image') {
+      kind.value = 'image'
+      if (detail.imageBase64) fullSrc.value = buildImageDataUrl(detail.imageBase64)
+      const thumb = await commands.clipboardGetThumb(id).catch(() => null)
+      if (seq !== loadSeq) return
+      thumbSrc.value = thumb ? buildImageDataUrl(thumb) : fullSrc.value
+    }
+  } catch {
+    /* 加载失败保持空态 */
+  } finally {
+    if (seq === loadSeq) {
+      loading.value = false
+      // 初始落位：允许换侧（优先侧放不下时切到另一侧）
+      void fitWindow(seq, true)
+    }
+  }
+}
+
+/** 图片点击：缩略图 ↔ 原图放大切换（窗口随内容自适应：放大态按原图尺寸） */
+function toggleEnlarge() {
+  if (kind.value !== 'image' || !fullSrc.value) return
+  enlarged.value = !enlarged.value
+  // 尺寸变化不换侧：窗口跳侧会使鼠标落在窗外误触发隐藏；保持原侧靠工作区 clamp
+  void fitWindow(loadSeq, false)
+}
+
+// ===== 鼠标进入/离开联动 =====
+// 弹窗的 onItemLeave 会在鼠标离开条目后延迟隐藏预览；鼠标移入预览窗时通知弹窗
+// 取消隐藏定时器，保证停留在预览窗内可点击"复制/放大"，移出后再隐藏。
+// mousedown 也重新上报进入状态：兜底防止 WebView2 偶发的 mouseleave 触发隐藏定时器，
+// 保证"点击预览文本/放大按钮"不会因此关闭预览。
+// 交互锁定：一旦点击过预览窗（放大/缩小、复制、选择文本），通知后端进入锁定模式
+// ——弹窗+预览不再因失焦/鼠标离开而关闭，仅点击外部或弹窗重新聚焦时退出；
+// 此时鼠标离开预览窗也不上报 leave（预览保持显示，由看护线程管理生命周期）。
+const interacted = ref(false)
+
+function onRootEnter() {
+  void emit(EVENTS.clipboardPreviewEnter)
+}
+
+function onRootMouseDown() {
+  onRootEnter()
+  interacted.value = true
+  void commands.clipboardPreviewInteracted().catch(() => {})
+}
+
+function onRootLeave() {
+  // 交互锁定模式：不上报离开，预览保持显示（点击外部才随弹窗一起关闭）
+  if (interacted.value) return
+  void emit(EVENTS.clipboardPreviewLeave)
+}
+
+/** Ctrl+C：有选区交给浏览器默认复制；无选区则复制整段文本，支持预览窗内自由复制 */
+function onKeydown(e: KeyboardEvent) {
+  if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'c') {
+    if (window.getSelection()?.toString().trim()) return
+    if (textContent.value) {
+      e.preventDefault()
+      navigator.clipboard?.writeText(textContent.value).catch(() => {})
+    }
+  }
+}
+
+// ===== 主题应用（与弹窗保持一致） =====
+function readMainTheme(): { theme: string; effect: string } {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
+    if (raw) {
+      const s = JSON.parse(raw)
+      return { theme: s.theme ?? 'system', effect: s.effect ?? 'mica' }
+    }
+  } catch {
+    /* 忽略 */
+  }
+  return { theme: 'system', effect: 'mica' }
+}
+
+function resolveIsDark(theme: string): boolean {
+  if (theme === 'dark') return true
+  if (theme === 'light') return false
+  return window.matchMedia('(prefers-color-scheme: dark)').matches
+}
+
+async function applyTheme() {
+  const root = document.documentElement
+  const { theme, effect } = readMainTheme()
+  try {
+    const tauriWin = getCurrentWindow()
+    if (theme === 'system') await tauriWin.setTheme(null)
+    else await tauriWin.setTheme(theme as 'dark' | 'light')
+  } catch {
+    /* 非 Tauri 环境忽略 */
+  }
+  const isDark = resolveIsDark(theme)
+  root.classList.remove('dark', 'effect-mica', 'effect-acrylic', 'effect-normal')
+  root.classList.add(`effect-${effect}`)
+  if (isDark) root.classList.add('dark')
+  try {
+    const tauriWin = getCurrentWindow()
+    await tauriWin.clearEffects()
+    if (effect === 'mica') {
+      await tauriWin.setEffects({
+        effects: [Effect.Mica],
+        // 预览窗为 NoActivate 悬浮窗，永远不会进入激活态；
+        // FollowsWindowActiveState 会渲染成非激活的淡化效果，与弹窗不一致。
+        // 强制 Active 态渲染，保证与弹窗视觉统一。
+        state: EffectState.Active,
+        color: isDark ? [30, 41, 59, 0] : [248, 250, 252, 0],
+      })
+      await tauriWin.setBackgroundColor('#00000000')
+      root.style.setProperty('--popup-bg', 'transparent')
+    } else if (effect === 'acrylic') {
+      await tauriWin.setEffects({
+        effects: [Effect.Acrylic],
+        state: EffectState.Active,
+        color: isDark ? [30, 41, 59, 0] : [248, 250, 252, 0],
+      })
+      await tauriWin.setBackgroundColor('#00000000')
+      root.style.setProperty('--popup-bg', 'transparent')
+    } else {
+      await tauriWin.setBackgroundColor(isDark ? '#0f172a' : '#ffffff')
+      root.style.setProperty('--popup-bg', isDark ? '#0f172a' : '#ffffff')
+    }
+  } catch {
+    /* 非 Tauri 环境忽略 */
+  }
+}
+
+onMounted(async () => {
+  await applyTheme()
+  const mq = window.matchMedia('(prefers-color-scheme: dark)')
+  const onThemeChange = () => applyTheme()
+  mq.addEventListener('change', onThemeChange)
+  unlistenFns.push(() => mq.removeEventListener('change', onThemeChange))
+
+  // 弹窗悬停/选中条目 → 先同步主题（主应用可能切换了主题），再加载内容
+  unlistenFns.push(await listen<number>(EVENTS.clipboardPreviewShow, async (e) => {
+    await applyTheme()
+    void loadItem(e.payload)
+  }))
+
+  // 隐藏/离开 → 清空内容；预览实际隐藏时复位交互锁定（下次悬停恢复常规模式）
+  unlistenFns.push(await listen(EVENTS.clipboardPreviewHide, () => {
+    loadSeq++ // 丢弃在途请求
+    kind.value = ''
+    textContent.value = ''
+    thumbSrc.value = ''
+    fullSrc.value = ''
+    enlarged.value = false
+    loading.value = false
+    interacted.value = false
+  }))
+})
+
+onUnmounted(() => {
+  unlistenFns.forEach((fn) => fn())
+})
+</script>
+
+<template>
+  <div
+    class="preview-root h-screen w-screen outline-none"
+    tabindex="0"
+    @mouseenter="onRootEnter"
+    @mousedown="onRootMouseDown"
+    @mouseleave="onRootLeave"
+    @keydown="onKeydown"
+  >
+    <!-- 加载中 -->
+    <div v-if="loading" class="h-full flex items-center justify-center text-xs text-muted-foreground">
+      加载中…
+    </div>
+
+    <!-- 文本预览 -->
+    <div v-else-if="kind === 'text'" class="h-full flex flex-col">
+      <div class="flex items-center px-3 py-1.5 border-b border-border shrink-0">
+        <span class="text-xs text-muted-foreground flex items-center gap-1.5">
+          <FileText class="size-3.5" />文本预览/自由复制
+        </span>
+      </div>
+      <ScrollArea class="flex-1 min-h-0">
+        <pre class="text-xs whitespace-pre-wrap break-all font-mono select-text cursor-text leading-relaxed p-3">{{ textContent }}</pre>
+      </ScrollArea>
+    </div>
+
+    <!-- 图片预览 -->
+    <div v-else-if="kind === 'image'" class="h-full flex flex-col">
+      <div class="flex items-center justify-between px-3 py-1.5 border-b border-border shrink-0">
+        <span class="text-xs text-muted-foreground flex items-center gap-1.5">
+          <ImageIcon class="size-3.5" />图片预览
+        </span>
+        <button v-if="fullSrc" class="preview-btn" :title="enlarged ? '还原' : '点击查看原图'" @click="toggleEnlarge">
+          <component :is="enlarged ? ZoomOut : ZoomIn" class="h-3.5 w-3.5" />{{ enlarged ? '还原' : '放大' }}
+        </button>
+      </div>
+      <!-- 放大态：ScrollArea 滚动查看原图；缩略态：内容居中不滚动 -->
+      <ScrollArea v-if="enlarged" class="flex-1 min-h-0">
+        <div class="p-3">
+          <img
+            :src="fullSrc"
+            alt="剪贴板图片预览"
+            class="rounded block cursor-default"
+            @click="toggleEnlarge"
+          />
+        </div>
+      </ScrollArea>
+      <div v-else class="flex-1 min-h-0 p-3 preview-img-thumb">
+        <img
+          :src="thumbSrc"
+          alt="剪贴板图片预览"
+          class="rounded block max-w-full max-h-full mx-auto cursor-zoom-in"
+          @click="toggleEnlarge"
+        />
+      </div>
+    </div>
+
+    <!-- 空态 -->
+    <div v-else class="h-full flex items-center justify-center text-xs text-muted-foreground">
+      将鼠标悬停条目查看预览
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.preview-root {
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Microsoft YaHei', 'PingFang SC', sans-serif;
+  background: var(--popup-bg, transparent);
+  color: var(--foreground);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.preview-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: 5px;
+  border: 1px solid var(--border);
+  background: var(--muted);
+  color: var(--foreground);
+  cursor: pointer;
+  transition: background-color 0.1s;
+}
+.preview-btn:hover {
+  background: var(--accent);
+}
+
+/* 缩略图态：内容居中，图片不放大 */
+.preview-img-thumb {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+</style>

src/modules/clipboard/index.ts

@@ -5,7 +5,44 @@ const searchItems: SearchIndexItem[] = [
   {
     title: '剪贴板历史',
     description: '查看和管理剪贴板记录',
-    keywords: ['剪贴板', '复制', '粘贴', 'clipboard', 'copy', 'paste']
+    keywords: ['剪贴板', '复制', '粘贴', 'clipboard', 'copy', 'paste'],
+    tab: 'history'
+  },
+  {
+    title: '固定记录',
+    description: '查看固定的剪贴板条目',
+    keywords: ['固定', '收藏', 'pin', '置顶'],
+    tab: 'pinned'
+  },
+  {
+    title: '剪贴板设置',
+    description: '历史数量、图片收录与快捷弹窗快捷键',
+    keywords: ['设置', 'setting', '选项', '配置'],
+    tab: 'settings'
+  },
+  {
+    title: '快捷弹窗快捷键',
+    description: '配置全局快捷键唤起剪贴板弹窗',
+    keywords: ['快捷键', '热键', 'shortcut', 'hotkey', '弹窗', 'popup'],
+    tab: 'settings'
+  },
+  {
+    title: '最大历史条数',
+    description: '设置剪贴板历史记录数量上限',
+    keywords: ['历史', '数量', '上限', '条数', 'max', 'limit'],
+    tab: 'settings'
+  },
+  {
+    title: '图片大小上限',
+    description: '设置收录图片的大小上限 (KB)',
+    keywords: ['图片', '大小', '上限', 'image', 'kb', '体积'],
+    tab: 'settings'
+  },
+  {
+    title: '记录图片',
+    description: '是否收录复制/截图的图片',
+    keywords: ['图片', '截图', '收录', 'image', 'capture'],
+    tab: 'settings'
   }
 ]
 

src/modules/downloader/index.ts

@@ -5,22 +5,44 @@ const searchItems: SearchIndexItem[] = [
   {
     title: '下载任务',
     description: '查看与管理下载任务',
-    keywords: ['下载', 'download', '任务', 'task']
+    keywords: ['下载', 'download', '任务', 'task'],
+    tab: 'tasks'
   },
   {
     title: '添加下载',
     description: '添加 HTTP/HTTPS 直链下载',
-    keywords: ['添加', '链接', 'url', 'add', '新建']
+    keywords: ['添加', '链接', 'url', 'add', '新建'],
+    tab: 'tasks'
   },
   {
     title: '下载设置',
     description: '配置下载目录、并发数与速度限制',
-    keywords: ['设置', 'setting', '速度', '目录', '并发']
+    keywords: ['设置', 'setting', '速度', '目录', '并发'],
+    tab: 'settings'
+  },
+  {
+    title: '下载目录',
+    description: '设置任务默认保存目录',
+    keywords: ['目录', '保存', '路径', 'dir', 'folder', '下载位置'],
+    tab: 'settings'
+  },
+  {
+    title: '并发下载数',
+    description: '设置同时下载的任务数量上限',
+    keywords: ['并发', '数量', 'concurrent', '线程'],
+    tab: 'settings'
+  },
+  {
+    title: '速度限制',
+    description: '设置全局下载/上传限速',
+    keywords: ['限速', '速度', '速率', 'rate', 'limit', '带宽'],
+    tab: 'settings'
   },
   {
     title: '浏览器扩展',
     description: '安装 Thing Extension 接管浏览器下载',
-    keywords: ['扩展', 'extension', '浏览器', 'chrome', 'edge']
+    keywords: ['扩展', 'extension', '浏览器', 'chrome', 'edge'],
+    tab: 'extension'
   }
 ]