终端模块初版

.gitignore

@@ -7,8 +7,14 @@ yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
 
-# 发布暂存目录
+.trae
+.workbuddy
+.npm-cache
+.bun-tmp
+.uploads
+temp/
 release_stage/
+musicdl_outputs/
 
 node_modules
 dist

MODULE_DEV_GUIDE.md

@@ -1,618 +0,0 @@
-# 模块开发指南
-
-本文档详细说明 Thing 应用的模块系统架构，帮助开发者快速理解并创建新模块。
-
-## 架构概述
-
-Thing 采用**统一模块注册机制**，每个模块通过 `index.ts` 自描述其全部配置（名称、图标、组件、搜索项、进程配置、生命周期钩子等），由中央注册表 `moduleRegistry` 统一管理。
-
-```
-┌─────────────────────────────────────────────────────┐
-│                    main.ts                          │
-│         import './modules' (触发注册)                │
-└──────────────────────┬──────────────────────────────┘
-                       ▼
-┌─────────────────────────────────────────────────────┐
-│              src/modules/index.ts                    │
-│        聚合入口：导入所有模块配置并注册               │
-└──────────────────────┬──────────────────────────────┘
-                       ▼
-┌─────────────────────────────────────────────────────┐
-│           src/modules/registry.ts                    │
-│     ModuleRegistry 单例：注册 / 查询 / 组件懒加载     │
-└──────┬───────────────┬───────────────┬──────────────┘
-       │               │               │
-       ▼               ▼               ▼
-  App.vue         Sidebar.vue     GeneralSettings
-  (组件加载)       (侧边栏导航)     (模块开关管理)
-```
-
-## 核心文件说明
-
-| 文件 | 职责 |
-|------|------|
-| `src/types/module.ts` | 模块配置类型定义 |
-| `src/modules/registry.ts` | 注册表单例：注册、查询、组件懒加载缓存 |
-| `src/modules/index.ts` | 聚合入口：导入并注册所有模块 |
-| `src/modules/icons.ts` | 模块图标映射表 |
-| `src/modules/<name>/index.ts` | 各模块的配置声明 |
-| `src/modules/<name>/*.vue` | 模块前端组件 |
-
-## 模块配置类型
-
-```typescript
-// src/types/module.ts
-
-interface ModuleConfig {
-  /** 模块唯一标识（如 'proxy'、'clipboard'） */
-  id: string
-  /** 显示名称 */
-  name: string
-  /** 图标标识（对应 icons.ts 中的 key） */
-  icon: string
-  /** 模块描述（显示在设置界面的模块管理中） */
-  description: string
-  /** 模块分类 */
-  category: 'network' | 'tool' | 'system' | 'media'
-  /** 默认是否启用（默认 true） */
-  defaultEnabled?: boolean
-  /** 是否为内置模块（不可禁用，如设置模块） */
-  builtin?: boolean
-  /** 懒加载组件的 loader 函数（推荐） */
-  loader?: () => Promise<{ default: Component }>
-  /** 直接组件引用（内置模块可用，无需懒加载） */
-  component?: Component
-  /** 全局搜索项 */
-  searchItems?: SearchIndexItem[]
-  /** 进程配置（需要管理子进程的模块填写） */
-  process?: ModuleProcessConfig
-  /** 生命周期钩子 */
-  lifecycle?: ModuleLifecycle
-  /** 排序权重（数值越小越靠前，默认 100） */
-  order?: number
-}
-```
-
-## 创建新模块
-
-### 第 1 步：创建模块目录
-
-```
-src/modules/my-module/
-├── index.ts              # 模块配置
-└── MyModule.vue          # 前端组件
-```
-
-### 第 2 步：编写模块配置
-
-```typescript
-// src/modules/my-module/index.ts
-import type { ModuleConfig } from '@/types/module'
-
-export const moduleConfig: ModuleConfig = {
-  id: 'my-module',
-  name: '我的模块',
-  icon: 'my-module',           // 需在 icons.ts 中添加映射
-  description: '模块功能描述',
-  category: 'tool',
-  defaultEnabled: true,
-  loader: () => import('./MyModule.vue'),
-  searchItems: [
-    {
-      title: '功能名称',
-      description: '功能描述',
-      keywords: ['关键词1', '关键词2', 'keyword']
-    }
-  ],
-  order: 70
-}
-```
-
-### 第 3 步：注册模块
-
-在 `src/modules/index.ts` 中添加导入：
-
-```typescript
-import { moduleConfig as myModule } from './my-module'
-
-const allModules: ModuleConfig[] = [
-  // ... 已有模块
-  myModule
-]
-
-moduleRegistry.registerAll(allModules)
-```
-
-### 第 4 步：添加图标映射
-
-在 `src/modules/icons.ts` 中添加：
-
-```typescript
-import { Wrench } from '@lucide/vue'  // 选择合适的图标
-
-export const moduleIconMap: Record<string, Component> = {
-  // ... 已有映射
-  'my-module': Wrench
-}
-```
-
-### 第 5 步（可选）：添加 Rust 后端命令
-
-如果模块需要 Rust 后端支持，在 `src-tauri/src/` 中创建命令模块，并在 `lib.rs` 的 `invoke_handler` 中注册。
-
-## 进程管理
-
-需要管理外部子进程的模块（如 mihomo）通过 `ModuleProcessConfig` 声明进程配置。下载器模块使用进程内自建下载引擎，不涉及外部子进程管理。
-
-### 配置示例
-
-```typescript
-// src/modules/proxy/index.ts
-export const moduleConfig: ModuleConfig = {
-  // ...
-  process: {
-    name: 'mihomo',              // 进程标识
-    executable: '',              // 可执行文件路径（运行时确定）
-    args: ['-f', 'config.yaml'], // 启动参数
-    autoStart: false,            // 模块启用时是否自动启动
-    restartOnCrash: true,        // 崩溃后自动重启
-    maxRestarts: 3               // 最大重启次数（0 = 不限制）
-  }
-}
-```
-
-### 前端 API
-
-```typescript
-import { useProcessStore } from '@/stores/processStore'
-
-const processStore = useProcessStore()
-
-// 通过模块 ID 启动进程（自动读取模块配置）
-await processStore.startByModule('proxy')
-
-// 停止进程
-await processStore.stopByModule('proxy')
-
-// 获取进程状态（从缓存读取）
-const status = processStore.getProcessStatus('proxy')
-// status.status: 'running' | 'stopped' | 'crashed' | 'starting'
-
-// 刷新所有进程状态
-await processStore.refreshAll()
-```
-
-### 自动化行为
-
-模块启用/禁用时，`appStore.toggleModule` 会自动处理：
-
-| 操作 | 禁用模块 | 启用模块 |
-|------|----------|----------|
-| 进程 | 停止运行中的进程 | 若 `autoStart` 为 true，启动进程 |
-| 搜索项 | 移除该模块的搜索项 | 恢复该模块的搜索项 |
-| 组件缓存 | 清除组件缓存，释放内存 | 下次访问时重新懒加载 |
-| 生命周期 | 调用 `onDisable` 钩子 | 调用 `onEnable` 钩子 |
-| 侧边栏 | 从侧边栏隐藏 | 在侧边栏显示 |
-| Toast 通知 | 显示"已禁用 {模块名}" | 显示"已启用 {模块名}" |
-
-## 生命周期钩子
-
-```typescript
-interface ModuleLifecycle {
-  /** 模块首次加载时调用 */
-  onInit?: () => void | Promise<void>
-  /** 模块组件挂载时调用（切换到该模块） */
-  onActivate?: () => void | Promise<void>
-  /** 模块组件卸载时调用（切换离开该模块） */
-  onDeactivate?: () => void | Promise<void>
-  /** 模块被禁用时调用 */
-  onDisable?: () => void | Promise<void>
-  /** 模块被启用时调用 */
-  onEnable?: () => void | Promise<void>
-}
-```
-
-使用示例：
-
-```typescript
-export const moduleConfig: ModuleConfig = {
-  // ...
-  lifecycle: {
-    onEnable: async () => {
-      console.log('模块已启用')
-      // 初始化资源、建立连接等
-    },
-    onDisable: async () => {
-      console.log('模块已禁用')
-      // 释放资源、关闭连接等
-    },
-    onActivate: () => {
-      console.log('用户切换到本模块')
-      // 开始实时数据更新等
-    },
-    onDeactivate: () => {
-      console.log('用户离开本模块')
-      // 暂停实时更新以节省资源
-    }
-  }
-}
-```
-
-## 全局搜索
-
-模块通过 `searchItems` 声明可被全局搜索的功能项。用户在标题栏搜索框输入关键词时，匹配的搜索项会显示在结果列表中。
-
-```typescript
-searchItems: [
-  {
-    title: '代理设置',           // 显示标题
-    description: '配置网络代理',  // 显示描述
-    keywords: ['代理', 'proxy', '网络']  // 匹配关键词
-  }
-]
-```
-
-如果搜索项需要执行特定操作（如跳转到子页面、触发命令），在模块组件挂载时通过 `searchStore.registerAction` 注册：
-
-```typescript
-import { useSearchStore } from '@/stores/searchStore'
-
-const searchStore = useSearchStore()
-
-onMounted(() => {
-  // 注册第 0 个搜索项的 action
-  searchStore.registerAction('my-module', 0, () => {
-    // 跳转到特定子页面或执行操作
-    activeTab.value = 'settings'
-  })
-})
-```
-
-## 模块分类
-
-| 分类 | 说明 | 适用场景 |
-|------|------|----------|
-| `network` | 网络相关 | 代理、下载器、网络工具 |
-| `tool` | 实用工具 | 剪贴板、文件搜索、文本处理 |
-| `system` | 系统相关 | 硬件监控、系统设置 |
-| `media` | 媒体相关 | 截图、录屏、图片处理 |
-
-分类目前用于元信息标记，未来可用于设置界面的分组展示。
-
-## 模块禁用机制详解
-
-当用户在设置页面切换模块开关时：
-
-```
-用户点击开关
-    │
-    ▼
-appStore.toggleModule(moduleId, enabled)
-    │
-    ├─ 禁用时：
-    │   ├─ searchStore.unregisterModule(moduleId)   // 移除搜索项
-    │   ├─ processStore.stopByModule(moduleId)       // 停止进程
-    │   ├─ config.lifecycle?.onDisable?.()           // 生命周期钩子
-    │   ├─ moduleRegistry.clearComponentCache(id)    // 清除组件缓存
-    │   ├─ modules[id].enabled = false               // 更新状态
-    │   └─ toast.success('已禁用 {模块名}')           // 通知用户
-    │
-    └─ 启用时：
-        ├─ modules[id].enabled = true                // 更新状态
-        ├─ config.lifecycle?.onEnable?.()            // 生命周期钩子
-        ├─ searchStore.registerItem(...)             // 恢复搜索项
-        ├─ processStore.startByModule(moduleId)      // 启动进程（若 autoStart）
-        └─ toast.success('已启用 {模块名}')            // 通知用户
-```
-
-禁用后的效果：
-- 模块从侧边栏导航中隐藏
-- 模块的搜索项从全局搜索中移除
-- 模块的后台进程被停止
-- 模块的组件缓存被清除，释放内存
-- 如果当前正在查看被禁用的模块，自动切换到第一个可用模块
-
-## 注意事项
-
-1. **模块 ID 必须唯一**：重复注册会被忽略并输出警告
-2. **图标必须映射**：模块配置中的 `icon` 字符串必须在 `icons.ts` 中有对应映射，否则回退到 Settings 图标
-3. **懒加载优先**：使用 `loader` 而非 `component`，避免首屏加载所有模块代码
-4. **避免循环依赖**：模块的 `index.ts` 只导出配置，不导入其他模块的 store
-5. **进程配置的 executable**：通常留空，由模块组件在运行时根据用户设置确定实际路径
-6. **内置模块**：设置 `builtin: true` 的模块不可被用户禁用，开关处于禁用状态
-
-## 跨模块开发经验（代理模块沉淀）
-
-以下要点来自代理模块开发，对后续涉及子进程管理、外部 API 交互、shadcn-vue 组件使用的模块同样适用。
-
-### Tauri 命令与主线程
-
-- **同步命令（`pub fn`）会阻塞主线程**：Tauri 的同步命令在主线程执行，其内部的 `std::thread::sleep`、磁盘 I/O、网络请求会阻塞所有 async 命令的调度。涉及等待/阻塞操作的命令必须声明为 `pub async fn`，并用 `tauri::async_runtime::spawn_blocking(|| { std::thread::sleep(...) }).await` 将阻塞操作放到线程池。
-- **Windows 端口释放有延迟**：`child.kill()` + `child.wait()` 后 TCP 端口不会立即可用，需等待约 800ms 再重新绑定。重启类命令应预留此延迟。
-- **`Mutex` 持锁期间禁止 sleep**：`ProcessManager::check_and_cleanup` 等持锁函数中不要执行长时间 sleep，否则会阻塞所有需要该锁的命令（如状态查询）。应先释放锁再 sleep，或移出临界区。
-- **进程监控线程**：`start_monitoring_thread` 每 3 秒检查一次进程状态，崩溃时自动重启（可配置 `maxRestarts`）。前端通过监听 `process-status-changed` 事件更新 UI。
-
-### 外部 API 交互
-
-- **API 就绪轮询**：子进程 spawn 后 API 不会立即可用（需初始化配置、加载 geo 文件等）。前端应在请求前轮询健康检查接口（如 `/version`），500ms 间隔、10s 超时。
-- **缓存配置避免频繁读盘**：后端 Manager 每次方法调用都从磁盘读 settings 会拖慢批量操作。建议在 Manager 内维护内存缓存，`save_settings` 时同步更新。
-- **并发请求限流**：批量测速等场景不要一次性 `Promise.all` 全部请求，应分批（如每批 20 个），避免压垮子进程。
-
-### shadcn-vue / reka-ui 注意事项
-
-- **Select 禁止空字符串 value**：`<SelectItem value="">` 会触发警告并失效。使用哨兵值（如 `__default__`、`__all__`）替代空字符串，在 `@update:model-value` 回调中转回空值。
-- **Select 双击问题**：reka-ui Select 的 DismissableLayer + closeAutoFocus 会导致连续点击两个 Select 时第一次点击仅关闭上一个、需第二次点击才打开下一个。当前未完美解决，建议同一界面避免放置过多相邻 Select。
-- **Switch 使用 `model-value` / `update:model-value`**：reka-ui v2+ 的 Switch 不再使用 `checked` / `update:checked`。
-- **Sonner toast 不可见**：通常是缺少 `vue-sonner/lib/index.css` 导入，而非 z-index 问题。确保在入口处导入该 CSS。
-- **AlertDialog 替代 confirm()**：原生 `confirm()` 在 Tauri WebView 中样式不一致，使用 shadcn-vue AlertDialog 封装 Promise 化的 `showConfirm()` 函数，支持 destructive 样式。
-
-### 数据一致性与自愈
-
-- **配置文件与磁盘 reconcile**：settings.json 中的列表（如订阅 profiles）可能与磁盘文件不同步（用户手动删除、反序列化失败被 default 覆盖）。每次 `load_settings` 时应扫描磁盘补全缺失条目，并在 `currentProfile` 为 null 时自动指向第一个。
-- **操作顺序防重复**：导入文件后写入 settings 时，若先写文件再 load_settings（含 reconcile 扫盘），reconcile 会扫到新文件添加一次，随后 push 又添加一次。应先 load_settings → 写文件 → push（加去重保护）。
-- **子进程崩溃循环防护**：子进程因依赖文件损坏（如 geo 数据库）崩溃时，`restart_on_crash` 会反复重启。需配置备用下载源（如 jsdelivr 镜像）避免无代理时 GitHub 超时。
-
-### UI 细节
-
-- **瀑布流布局避免卡片等高撑开**：使用 `columns-1 md:columns-2 gap-4 [&>*]:mb-4 [&>*]:break-inside-avoid` 替代 `grid`，让卡片按内容高度自然排列。
-- **模块禁用清理系统状态**：模块 `onDisable` 钩子应清理系统级副作用（如系统代理注册表项），避免模块停用后遗留导致系统异常。
-- **应用退出清理**：在 `lib.rs` 的 `quit_app` 命令和托盘退出事件中都要调用 `cleanup_on_exit` + `stop_all`，确保任何退出路径都清理干净。
-
-## 近期重要变更（影响其他模块开发）
-
-以下是最近几次改动中确立的约定和模式，开发新模块时需遵循。
-
-### 后端：子进程启动必须隐藏控制台窗口
-
-`process_manager.rs` 暴露了公共函数 `setup_creation_flags(cmd: &mut Command)`，Windows 上会设置 `CREATE_NO_WINDOW` 标志。
-
-**所有用 `std::process::Command` 启动外部程序的地方都必须调用它**，否则会弹出黑色控制台窗口（即使程序是后台运行）。包括：
-
-- `ProcessManager::start()` 启动 mihomo 等内核
-- `ProcessManager::check_and_cleanup()` 崩溃重启
-- 任何调用 `mihomo.exe -v` 等查询版本的场景
-
-跨平台：非 Windows 平台该函数为空实现，无需条件编译。
-
-```rust
-use crate::process_manager::setup_creation_flags;
-
-let mut cmd = std::process::Command::new(&path);
-cmd.arg("-v");
-setup_creation_flags(&mut cmd);  // 必须调用
-cmd.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
-```
-
-### 后端：长时间 wait() 不要阻塞主线程
-
-`ProcessManager::stop()` 中 `child.kill()` 是快速的，但 `child.wait()` 可能阻塞几十到几百毫秒。**wait() 已移到后台线程**：
-
-```rust
-thread::spawn(move || {
-    let _ = entry.child.wait();
-});
-```
-
-新模块若有类似的"终止外部进程"逻辑，也应遵循此模式，避免 Tauri 命令阻塞导致前端卡顿。
-
-### 后端：内核/二进制下载用流式 + 事件推送
-
-`mihomo_manager/` 目录（`kernel.rs`）的 `install_kernel` 确立了"下载二进制资源"的标准模式，未来若有其他模块需要下载外部内核时应复用：
-
-- **流式下载**：`reqwest::Response::bytes_stream()` + `futures_util::StreamExt`，避免大文件一次性读入内存
-- **进度事件**：通过 `app.emit("xxx-install-progress", progress)` 推送，事件载荷结构参考 `InstallProgress`
-- **事件节流**：仅在百分比变化 ≥1% 时 emit，避免事件轰炸
-- **zip 解压**：用 `zip` crate（纯 Rust），不要用 PowerShell `Expand-Archive`（有执行策略问题）
-- **文件名匹配**：解压后用 `find_exe_in_dir` 查找 `.exe`（zip 内文件名可能含版本号，不是固定名字），找到后重命名为标准名
-
-### 后端：GitHub API rate limit 规避
-
-`check_kernel_update` 采用 **API 优先 + 重定向回退** 策略：
-
-1. 先调 `api.github.com/.../releases/latest`（能拿完整资产列表，命名变化时更健壮）
-2. 失败（403 rate limit / 网络错误）时回退到访问 `github.com/.../releases/latest`，从 302 重定向的最终 URL 提取版本号，按稳定命名规则构造下载 URL
-
-**新模块若需要查 GitHub 最新版本，应复用此模式**，不要直接调 API（未认证 60次/小时/IP 极易超限）。
-
-### 后端：资产命名规则适配
-
-mihomo v1.19+ 改了 Windows 资产命名，按 CPU 微架构分级：
-
-- 旧：`mihomo-windows-amd64-vX.X.X.zip`（已废弃）
-- 新：`mihomo-windows-amd64-v3-vX.X.X.zip`（v1/v2/v3 对应 CPU level）
-
-`fetch_latest_via_api` 中的匹配优先级：v3 标准 > v3-go124 > v3-go123 > v3 其他 > v2 > v1 > 旧命名。若未来其他内核也有类似分级，参考此优先级策略。
-
-### 前端：Transition 内的 v-if/v-else 必须加 key
-
-**这是 dev 模式的坑**。`<Transition mode="out-in">` 内的 `v-if`/`v-else` 分支如果缺 `:key`，Vue 3.5.x dev 模式下会触发 `__vnode` 写入竞态，导致：
-
-- 控制台报错 `Cannot set properties of null (setting '__vnode')`
-- vnode 树损坏，所有事件派发失效（按钮点击没反应）
-- **build 模式不报错**（生产构建剥除了 `__vnode` instrumentation），容易漏掉
-
-**约定**：`<Transition>` 内所有分支（v-if/v-else-if/v-else）都必须加 `:key`，即使是原生 div 也要加。
-
-```vue
-<Transition name="fade" mode="out-in">
-  <ComponentA v-if="cond" key="a" />
-  <div v-else key="empty">占位</div>
-</Transition>
-```
-
-`ModuleContainer.vue` 和 `ProxyModule.vue` 的 Progress 区块已修复，新模块开发时注意。
-
-### 前端：模块内 Tabs 顶部固定模式
-
-模块根容器用 `h-full overflow-hidden flex flex-col`，Tabs 用 `flex-1 min-h-0 flex flex-col`，TabsList 加 `shrink-0`，TabsContent 加 `flex-1 min-h-0 overflow-y-auto`：
-
-```vue
-<div class="h-full p-6 overflow-hidden flex flex-col">
-  <Tabs v-model="tab" class="flex-1 min-h-0 flex flex-col">
-    <TabsList class="shrink-0">...</TabsList>
-    <TabsContent value="x" class="flex-1 min-h-0 overflow-y-auto">...</TabsContent>
-  </Tabs>
-</div>
-```
-
-这样 TabsList 固定在顶部，只有 TabsContent 滚动。`min-h-0` 是 flex 子元素 overflow 生效的关键，不能省。
-
-### 前端：Tauri 事件监听需在 store 中管理生命周期
-
-`proxyStore.ts` 的 `installKernel` 确立了模式：
-
-- 监听在方法调用时注册，`finally` 块中取消
-- 用模块级变量保存 `UnlistenFn`，避免重复注册
-- 错误事件由后端保证 emit（前端不重复弹 toast，统一由 watch 处理）
-
-```typescript
-let progressUnlisten: UnlistenFn | null = null
-const installKernel = async () => {
-  if (!progressUnlisten) {
-    progressUnlisten = await listen<Progress>('xxx-progress', (e) => {
-      progress.value = e.payload
-    })
-  }
-  try {
-    await invoke('xxx_command')
-  } finally {
-    if (progressUnlisten) {
-      progressUnlisten()
-      progressUnlisten = null
-    }
-  }
-}
-```
-
-### 前端：窗口隐藏前 blur 焦点
-
-TitleBar 的关闭按钮实际是 `hide()` 到托盘。webview 快速隐藏时浏览器 `mouseleave` 可能不触发，导致从托盘恢复后按钮仍显示 hover 高亮。
-
-**修复**：`hide()` 前调用 `document.activeElement.blur()`，并监听 `onFocusChanged` 在窗口重新获得焦点时再 blur 一次。新模块若有类似的"隐藏窗口"操作（如全局快捷键隐藏），同样需要 blur。
-
-### 前端：浮动标签切换器（TabsList 滚动遮挡时在 TitleBar 显示）
-
-模块详情页内容滚动时，顶部 `TabsList` 会被 `TitleBar` 遮挡，导致用户必须滚回顶部才能切换 Tab。已抽取通用 composable `src/lib/use-module-tabs.ts` 自动处理。
-
-**接入方式**（任何使用 Tabs 的模块都可用，代理/下载器模块已接入）：
-
-```ts
-// 模块 <script setup> 顶部
-import { useModuleTabs } from '@/lib/use-module-tabs'
-
-const activeTab = ref('overview')
-const tabsListRef = useModuleTabs(activeTab, [
-  { value: 'overview', label: '概览' },
-  { value: 'settings', label: '设置' }
-])
-```
-
-```vue
-<!-- 模板中给 TabsList 包一层带 ref 的 div -->
-<Tabs v-model="activeTab">
-  <div ref="tabsListRef">
-    <TabsList>...</TabsList>
-  </div>
-  <TabsContent .../>
-</Tabs>
-```
-
-**工作原理**：
-- composable 内部在 `onMounted` 时注册标签到 `moduleTabsStore`，`onUnmounted` 时注销
-- 用 `IntersectionObserver`（`rootMargin: '-44px 0px 0px 0px'` 裁剪 TitleBar 高度）监听 TabsList 可见性
-- 滚动遮挡时 `TitleBar` 中"Thing"标题右侧自动显示浮动切换按钮（带淡入+左滑动画）
-- 双向 watch 同步本地 `activeTab` 与 store，用户点击 TitleBar 浮动按钮也能切换模块内 Tab
-
-**约束**：TitleBar 高度固定 40px（h-10），composable 已用 44px 裁剪（含 4px 缓冲）；store 是单例，一个模块同一时间只能注册一组标签。
-
-### 前端：内核路径用 %APPDATA% 简化显示
-
-内核路径较长（如 `C:\Users\xxx\AppData\Roaming\thing.lfeng.me\proxy\cores\mihomo.exe`），展示时用 `%APPDATA%` 替换前缀，并提供复制完整路径 / 在文件夹中显示两个按钮。代理和下载器模块的内核管理区块已采用此模式。
-
-```ts
-import { appDataDir } from '@tauri-apps/api/path'
-
-const appDataPath = ref('')
-onMounted(async () => {
-  try { appDataPath.value = await appDataDir() } catch {}
-})
-
-const pathDisplay = computed(() => {
-  const p = store.kernel?.path
-  if (!p) return ''
-  if (appDataPath.value && p.toLowerCase().startsWith(appDataPath.value.toLowerCase())) {
-    return '%APPDATA%' + p.slice(appDataPath.value.length)
-  }
-  return p
-})
-```
-
-`<title>` 放完整路径，显示文本用 `pathDisplay`，复制时复制完整路径。
-
-### 前端：任务历史持久化（下载器模块模式）
-
-下载引擎在进程内运行，状态通过 `engine_state.json` 持久化到磁盘。前端 store 的做法：
-
-- `onMounted` 时调用 `store.init()`，一次性加载 status/settings/extensionInfo/tasks
-- 通过 Tauri 事件 `download-progress`、`download-complete`、`download-added` 实时更新任务状态
-- 引擎在 `Storage::new` 时自动创建数据目录，`save` 时兜底重建父目录，避免路径不存在错误
-
-此模式适用于任何"引擎在进程内运行、状态需持久化"的场景。
-
-### 前端：轻量设置 Dialog（替代独立 Tab）
-
-模块设置项较多时，传统做法是单独开一个"设置"Tab。但任务页工具栏需要快速调整少量核心设置（如下载目录、并发数），切到设置 Tab 再切回来体验割裂。
-
-**模式**：在任务工具栏放一个"下载设置"按钮，点击弹出 Dialog，包含核心设置项（与设置页共用 `store.settings`），保存时调用 `handleSaveSettings`（引擎立即应用新配置，无需重启）并自动关闭弹窗。完整设置仍保留在"设置"Tab。
-
-适用场景：需要在任务页快速调整的少量高频设置；若设置项不多，可完全用 Dialog 替代设置 Tab。
-
-### 后端：opener 插件 scope 限制与绕过
-
-`tauri-plugin-opener` 的 `opener:allow-open-path` 权限默认 **无 scope**，IPC `open_path` 命令会拒绝任何路径并报错 `Not allowed to open path`。
-
-**解决方案**：在 Rust 端写一个自定义命令，用 `OpenerExt::opener().open_path()` 直接调用（绕过 IPC scope 检查）：
-
-```rust
-use tauri_plugin_opener::OpenerExt;
-
-#[tauri::command]
-pub fn my_open_dir(app: AppHandle, path: String) -> Result<(), String> {
-    let p = std::path::Path::new(&path);
-    if !p.exists() {
-        return Err(format!("路径不存在: {}", path));
-    }
-    app.opener().open_path(path, None::<&str>).map_err(|e| e.to_string())
-}
-```
-
-在 `lib.rs` 的 `invoke_handler` 中注册，前端通过 `invoke('my_open_dir', { path })` 调用。下载器模块的"打开下载目录"已采用此方案。
-
-### 前端：剩余时间（ETA）可读化
-
-下载卡片直接显示 `(total-completed)/speed` 会得到 `17.217666215634114 B` 这种难懂的字节数。应格式化为时间：
-
-```ts
-const formatEta = (seconds: number): string => {
-  if (!isFinite(seconds) || seconds <= 0) return ''
-  if (seconds < 60) return `剩余 ${Math.ceil(seconds)} 秒`
-  if (seconds < 3600) {
-    const m = Math.floor(seconds / 60)
-    const s = Math.ceil(seconds % 60)
-    return `剩余 ${m} 分 ${s} 秒`
-  }
-  const h = Math.floor(seconds / 3600)
-  const m = Math.ceil((seconds % 3600) / 60)
-  return `剩余 ${h} 小时 ${m} 分`
-}
-```
-
-`getEta(task) = (totalLength - completedLength) / downloadSpeed`，speed≤0 时返回 0（不显示）。
-
-### 前端：状态统计用 Badge 替代纯文本
-
-下载任务工具栏的速度/活跃/等待/已完成数量，以及代理概览页的内核状态/版本，从纯文本改为 `Badge variant="secondary"` 或带颜色的 `Badge`（绿色已安装/红色未安装），视觉更醒目。新模块的状态展示建议统一用 Badge。
-
-### 后端：应用退出清理（单一出口）
-
-退出清理已收敛到 `lib.rs` 的 `RunEvent::ExitRequested` 分支（P0-1/V7）：`quit_app` 命令与托盘退出项都只触发 `app.exit(0)`，清理逻辑（`cleanup_on_exit` + `stop_all`）只在该分支执行一次。新增管理子进程的模块时，在 `ExitRequested` 分支注册自己的 `cleanup_on_exit` 即可，不要在命令或托盘路径重复清理。

README.md

@@ -111,7 +111,7 @@ Thing/
 - [x] 自建进程内下载引擎（多线程 HTTP/HTTPS，无需外部内核）
 - [x] 接管浏览器下载，浏览器扩展（Thing Extension）
 - [x] HTTP 下载支持
-- [ ] BT/磁力链接支持（后续支持）
+- [x] BT/磁力链接支持（后续支持）
 - [x] 下载任务管理（历史）
 - [x] 速度限制
 - [x] 断点续传
@@ -124,8 +124,8 @@ Thing/
 
 ### 第三阶段：优化与完善
 
-- [x] 性能优化（P1/P2：轮询随窗口可见性暂停、批量测速限并发、渲染 memo 化等，见 MODULE_REVIEW.md）
+- [x] 性能优化（见 MODULE_REVIEW.md）
-- [x] 错误处理与日志完善（B5 进程级全局日志器、异常兜底）
+- [x] 错误处理与日志完善（全局日志器、异常兜底）
 - [x] 用户体验优化（混合 DPI 定位、rAF 节流、UI 细节）
 - [x] 自动更新机制
 - [x] 打包发布

TERMINAL_MODULE_PLAN.md

@@ -0,0 +1,841 @@
+# 终端模块规划（Terminal Module Plan）
+
+> 状态：**P0 骨架已落地；P1 进行中**（Rust 侧：cwd 跟踪 / 状态事件 / GBK 编码 / SFTP 后端已完成并编译通过）
+> 定位：Thing 工具集的第 11 个模块，`id = terminal`，`category = 'tool'`
+> 作者：砚　|　日期：2026-09-17
+> 关联文档：`AI_DEV_GUIDE.md`（模块注册机制 / IPC / 进程管理范式）
+>
+> **实施进度与踩坑记录见文末 §9（P0）与 §10（P1）**（含与本规划不一致之处，以 §9 / §10 为准）
+
+---
+
+## 0. 结论先行
+
+三个关键判断，先摆在这里，后文展开论证：
+
+1. **终端模块不应复用 `ProcessManager`**。它是为「单例常驻守护进程（mihomo）」设计的：一个模块 ID 对应一个进程，崩溃即重启。而终端要的是「N 个会话、每个会话生命周期独立、能挂起能重连、能写 stdin」——语义不同，硬套会把这套抽象撑坏。正确做法是**新建独立的 `TerminalManager`**，与 `ClipboardManager` / `MusicManager` / `TranslateManager` 平级，`manage()` 进 Tauri State。
+
+2. **会话进程必须跑在 Rust 侧，不能是前端 shell**。这是 Windows 上的硬约束，且与已有基建同构：`ProcessManager`、`download_engine` 都在 Rust 侧管进程。理由有三——(a) WebView2 无 PTY 访问；(b) 前端持有的子进程会在页面重载时变孤儿；(c) 多标签、后台保活、断线重连都需要一个独立于 UI 生命周期的宿主。
+
+3. **SSH 走「自研客户端 + 真实 PTY」，而不是「拼接 ssh.exe + ConPTY」**。后者实现快但天花板低：无法做 SFTP 复用连接、无法读主机密钥指纹、无法做跳板机链、无法统一错误模型、`ssh.exe` 的输出会与 ConPTY 的 ANSI 处理打架。代价是 Ruffles/ssh2 的移植与 ConPTY 绑定要自己写，收益是整个能力面没有上限。
+
+**总工作量估算**：P0 骨架（本地 Shell + 多会话 + 密钥管理）约 8~12 个工作日；P1（SSH/SFTP 完整能力）约 15~20 个工作日；P2（高级能力）按需。**建议按 P0 先行落地可用版本，再迭代。**
+
+> **收官状态（2026-09-18）**：P0–P2 全部落地（ZMODEM 经评估放弃，见实施记录），
+> 并完成一轮全链路审查（修复键盘输入失效、切标签丢缓冲、连接期关闭竞态等 7 项）。
+> 单测 91/91、`cargo check` 与 `vue-tsc` 零错误。实施记录见 §9-11（精编版）。
+
+---
+
+## 1. 需求解构
+
+用户提出的四条主干，拆成可执行的规格：
+
+| 用户原话 | 解构为 | 落点 |
+|---|---|---|
+| 「主要是 ssh」 | SSH2 客户端、主机密钥校验、认证（密钥/密码/Agent/键盘交互/2FA）、跳板机、端口转发、连接复用 | §4.2 / §5.1 |
+| 「多会话」 | 多标签 + 分屏、会话持久化（切页不断连）、状态栏、会话恢复、会话模板 | §4.3 |
+| 「密钥管理」 | SSH 密钥生成/导入/列举、passphrase 托管、known_hosts 管理、ssh-agent 集成、私钥不进明文 | §4.4 |
+| 「文件快捷管理」 | SFTP 双栏文件管理器、拖拽上传下载、跟随终端 cwd、内联 `rz/sz`、文件编辑器 | §4.5 |
+| 「方便的快捷键」 | 终端键盘映射（复制粘贴/搜索/新建标签/分屏/跳转）、可配置、与全局面板联动 | §4.6 |
+| （我补充） | **本地 Shell**（PowerShell/cmd/WSL/Git-Bash）、**命令补全与历史**、**命令片段库**、**AI 命令助手**、**日志与审计**、**快速面板联动** | §4.1 / §4.7 / §4.8 |
+
+---
+
+## 2. 现状勘察（论证依据）
+
+以下为 2026-09-17 从仓库实际读取的结果，作为设计约束的来源。
+
+### 2.1 已具备的基建
+
+| 能力 | 现有实现 | 终端模块可复用的部分 |
+|---|---|---|
+| 模块注册 | `src/modules/registry.ts` + `src/modules/index.ts` 静态导入 | 直接沿用，新增一行导入 + 图标映射 |
+| 类型绑定 | `tauri-specta` 自动生成 `src/lib/bindings.ts`，debug 构建时导出 | **必须复用**，终端命令量较大，手写 `invoke` 类型不可接受 |
+| 凭据存储 | `src-tauri/src/secrets.rs`：`keyring` + Windows 凭据管理器（DPAPI），服务名固定 `"Thing"` | **直接复用**，见 §4.4 |
+| 全局快捷键 | `src-tauri/src/shortcut.rs`：原子化注册 + 应用内冲突检测 + 占用表 | **直接复用**，见 §4.6 |
+| 托盘 | `src-tauri/src/tray_menu.rs` | 可挂「新建会话」入口（P2） |
+| 日志 | `src-tauri/src/logger.rs`（`log_info` / `log_warn` / `log_error`） | 继承统一日志，日志页可过滤 |
+| 窗口常量 | `src-tauri/src/constants.rs`（`windows` / `events`） | 需新增窗口与事件常量 |
+| 弹窗范式 | `translate-popup` 的 NOACTIVATE 预创建窗口 + `capabilities/translate-popup.json` | 终端「快速会话/命令补全」浮层可参照 |
+
+### 2.2 关键缺口（需要新增依赖）
+
+| 缺口 | 现状 | 方案 |
+|---|---|---|
+| ConPTY 绑定 | 无。`windows-sys` 未开启 `Win32_System_Console` | 开启该 feature；或引入 `portable-pty`（见 §3.1 取舍） |
+| SSH 客户端 | 无 | 引入 `russh`（纯 Rust）或 `ssh2`（libssh2 绑定） |
+| SFTP | 无 | 随 SSH 库一并引入 |
+| 终端渲染 | 无。`node_modules` 中**不存在** `@xterm/*` | 引入 `@xterm/xterm` + `@xterm/addon-fit` + `@xterm/addon-webgl` + `@xterm/addon-search` + `@xterm/addon-web-links` |
+| 前端代码编辑器 | 无 | 按需引入 `codemirror` 或复用纯 `<textarea>`（见 §4.5） |
+| 密码短语输入 | 无安全输入通道 | 用 Tauri 原生窗口 + 一次性输入，不经 IPC 明文回传 |
+
+> **注意**：仓库 `Cargo.toml` 存在**编码损坏**（多处注释已是乱码，如第 64、70、120、121、127 行）。新增依赖时建议顺带修复该文件编码，否则后续 diff 会持续污染。这是一个独立的清理项，不阻塞终端模块。
+
+---
+
+## 3. 技术选型
+
+### 3.1 终端进程层：ConPTY
+
+Windows 10 1809+ 提供 **ConPTY**（`CreatePseudoConsole`），是 Windows Terminal 的底层机制。三条路径：
+
+| 方案 | 优势 | 代价 | 判断 |
+|---|---|---|---|
+| `portable-pty`（wezterm 提取库） | 跨平台、API 干净、久经考验 | 引入一个非 Tauri 生态的大依赖；其 Windows 后端同样走 ConPTY，出问题时要下钻 | 可接受 |
+| **直接绑 `windows-sys` 的 ConPTY** | 零额外依赖、完全可控、与项目已有 `windows-sys` 姿态一致 | 需自行处理 pseudo console handle 生命周期、read/write 线程、resize 时序 | **推荐** |
+| `conpty` 窄封装 crate | 上手快 | 维护活跃度不确定 | 备选 |
+
+**推荐直接绑定 `windows-sys`**，理由：项目已有大量原生 Win32 调用（`win32_util.rs`、`screenshot/wgc_capture.rs`、`translate/capture/uia_capture.rs`），团队对该路径熟悉；且 ConPTY 的坑（下述）无论如何都要踩，多一层封装只增加定位难度。
+
+ConPTY 的三个已知陷阱，必须在设计阶段规避：
+
+1. **`ClosePseudoConsole` 会阻塞**，直到所有引用该 PTY 的句柄关闭。必须在独立线程调用，且先取消挂起的 `ReadFile`。
+2. **`ResizePseudoConsole` 有竞态**：进程刚创建、还没开始读 stdout 时 resize 可能被吞掉。需要在首帧输出后再应用队列中的尺寸。
+3. **进程退出不等于 PTY 关闭**：要等 `ReadFile` 返回 0 或 `ERROR_BROKEN_PIPE`，才算真正结束，否则会漏掉尾部输出。
+
+### 3.2 SSH 层：`russh` vs `ssh2`
+
+| 维度 | `russh`（纯 Rust，基于 `thrussh`） | `ssh2`（libssh2 绑定） |
+|---|---|---|
+| 构建 | 纯 Rust，无 C 依赖，交叉编译友好 | 需 libssh2；Windows 下常走 vendored 编译 |
+| async | 原生 async，与现有 `tokio` 运行时契合 | 同步阻塞，需 `spawn_blocking` 包装 |
+| 算法覆盖 | 新算法跟进快（如 `chacha20-poly1305`、`sntrup761x25519`） | 受 libssh2 版本限制 |
+| 稳定性 | API 演进较快，偶有破坏性变更 | 老牌稳定，几乎不再变化 |
+| 与 `tokio` 集成 | 直接 | 需额外线程池，与 `ProcessManager` 的线程模型并存会增加心智负担 |
+
+**推荐 `russh`**。决定性理由是 **async 契合度**：Cargo.toml 已启用 `tokio` 的 `rt-multi-thread` / `sync` / `net` / `fs`，而终端会话本质是「一个长连接 + 多个并发数据流（shell channel、SFTP channel、port forward）」，用 async 表达最自然；`ssh2` 的同步模型会迫使每个会话占一个 OS 线程，多会话场景下线程数线性增长。
+
+若 `russh` 在实际接入中出现阻塞性问题，回落方案是 `ssh2` + `spawn_blocking`，本规划的结构（`SessionHandle` 抽象）可容纳这次替换。
+
+### 3.3 前端渲染：xterm.js
+
+`@xterm/xterm` 是事实标准（VS Code 终端同源）。必须装的插件：
+
+| 包 | 用途 |
+|---|---|
+| `@xterm/xterm` | 核心 VT 解析与渲染 |
+| `@xterm/addon-fit` | 容器尺寸 → 行列数，配合 ConPTY resize |
+| `@xterm/addon-webgl` | GPU 渲染，大量输出时的性能关键（无它时大 `tail` 会卡） |
+| `@xterm/addon-search` | 终端内搜索 |
+| `@xterm/addon-web-links` | 链接可点击 |
+| `@xterm/addon-unicode11` | 宽字符 / emoji 正确宽度（中文场景重要） |
+| `@xterm/addon-serialize`（P1） | 会话快照序列化，用于恢复 |
+
+### 3.4 数据流架构
+
+```
+┌──────────────────────── WebView (Vue 3) ────────────────────────┐
+│  TerminalModule.vue                                             │
+│   ├── SessionSidebar.vue      会话/标签/分组                     │
+│   ├── TerminalTabs.vue        多标签 + 分屏容器                  │
+│   │    └── TerminalPane.vue   xterm 实例（每个会话一个）          │
+│   ├── SftpPanel.vue           文件管理器（P1）                   │
+│   ├── KeyManagerPanel.vue     密钥管理                           │
+│   └── SnippetsPanel.vue       命令片段库                         │
+│  stores/terminal.ts          Pinia：会话元数据 / 布局 / 设置      │
+└───────────────┬─────────────────────────────────────────────────┘
+                │  invoke（命令，请求-响应）
+                │  listen（事件，流式输出）
+┌───────────────▼──────────────── Rust ───────────────────────────┐
+│  TerminalManager  (Tauri State, manage())                       │
+│   ├── sessions: DashMap<SessionId, Arc<Mutex<Session>>>         │
+│   ├── local: ConPtyBackend       本地 Shell 后端                 │
+│   ├── remote: SshBackend         SSH 后端（russh）               │
+│   │    ├── shell channel   → 终端 I/O                           │
+│   │    ├── sftp subsystem  → 文件管理                            │
+│   │    └── port forward    → 隧道（P2）                          │
+│   └── known_hosts: HostKeyStore  主机密钥校验                    │
+│  secrets.rs             ← 复用：passphrase / 密码 / 代理凭据      │
+│  shortcut.rs            ← 复用：全局快捷键                       │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**关键设计**：`Session` 是一层 trait 抽象，`ConPtyBackend` 与 `SshBackend` 都实现它（`write` / `resize` / `kill` / `subscribe_output`）。这样上层命令层（`terminal_write`、`terminal_resize`）无需区分本地与远程，多会话管理逻辑只需写一遍。
+
+---
+
+## 4. 功能规格
+
+### 4.1 本地 Shell（P0）
+
+- **Shell 探测**：启动时枚举可用 Shell，按顺序探测——
+  - PowerShell 7+（`pwsh.exe`，优先）
+  - Windows PowerShell（`powershell.exe`）
+  - cmd（`cmd.exe`）
+  - Git Bash（`bash.exe`，从 `git --exec-path` 反推）
+  - WSL 发行版（`wsl.exe -l -q` 枚举）
+- **Shell 配置**：每个 Shell 可配可执行路径、启动参数、工作目录、环境变量覆盖、启动时执行命令（如 `cd /d/project && claude`）。
+- **默认工作目录**：记住上次 cwd；新建会话时可选「跟随当前项目目录」。
+- **注意 cwd 同步**：ConPTY 拿不到子进程的真实 cwd（`GetCurrentDirectory` 只反映父进程）。需要**注入 shell hook**（PowerShell 用 `$PROMPT` 包装输出 OSC 7；bash 用 `PS1` 输出 OSC 7）来跟踪 `cwd`。这是 SFTP「跟随终端目录」的前提，P0 就要做进去。
+
+### 4.2 SSH 连接（P0 骨架 / P1 完整）
+
+**连接管理**
+- 主机条目 CRUD：别名、host、port、user、认证方式、私钥、跳板机、分组、备注、标签色。
+- **从 `~/.ssh/config` 导入**（P0 就做——用户已有配置不该被要求重录）。
+- 连接超时、keep-alive 间隔、重试次数可配。
+- 连接状态机：`idle → connecting → auth → established → degraded → closed`，每态可观测。
+
+**认证方式**（P0 覆盖前两项，P1 补齐）
+1. **公钥认证**（P0）：支持 RSA / ECDSA / Ed25519，私钥来自文件或导入的存储。
+2. **密码认证**（P0）：密码存 `secrets.rs`，键名 `terminal-ssh-password-{hostId}`。
+3. **ssh-agent 集成**（P1）：Windows OpenSSH Agent 命名管道 `\\.\pipe\openssh-ssh-agent`。
+4. **键盘交互 / 2FA**（P1）：需要前端弹窗接收一次性输入，走「弹窗 → 回传 → 继续握手」的异步流程，不能阻塞握手线程。
+5. **证书认证**（P2）。
+
+**主机密钥校验（安全基线，P0 必须做）**
+- 首次连接展示指纹，要求用户显式确认（**不允许 TOFU 静默接受**）。
+- 维护 `known_hosts`（放在 `{app_data_dir}/terminal/known_hosts.json`），格式与 OpenSSH 兼容以便导出。
+- 指纹变更时**红色告警 + 阻断连接**，要求用户明确选择「接受新指纹」或「中止」。这是防 MITM 的核心开关，不能省。
+- 支持 SHA256 / MD5 双格式展示（SHA256 为主，MD5 兼容老文档）。
+
+**高级能力（P2）**
+- 跳板机链（ProxyJump，多级）。
+- 端口转发：本地转发 `-L`、远程转发 `-R`、动态转发 `-D`（SOCKS5）。
+- 连接复用（ControlMaster 式）：同主机多会话共享 TCP 连接，第二次开标签秒开。
+
+### 4.3 多会话（P0）
+
+**组织形态**
+- **左侧会话侧栏**：树形结构，支持「收藏 / 按主机分组 / 按项目分组」，支持拖拽排序（复用 `vue-draggable-plus`）。
+- **标签页**：会话标签可关闭、可拖动重排、可重命名、可固定（pin）。
+- **分屏**：水平/垂直切分，最多 2×2（4 格）。**每个格子是独立会话**，而非同一会话的两视图（后者需要 SSH 多 channel，复杂度高收益低）。
+- **会话持久化**：切换到别的模块时**会话不断开**（进程在 Rust 侧活着），回来时重新 attach，用 `@xterm/addon-serialize` 恢复可视区快照。
+
+**会话状态可视化**
+- 侧栏与标签上显示状态点：绿=已连接、黄=连接中、灰=已断开、红=异常。
+- 状态栏展示：会话类型（Local/SSH）、用户@主机、cwd、编码、终端尺寸、连接延迟。
+
+**会话恢复（P2）**
+- 应用重启后，提供「恢复上次会话」——本地会话重建 shell 并 `cd` 到原目录；SSH 会话重连（**不恢复进程态**，这点要在 UI 上说明，避免误解）。
+- 会话模板：把「一组会话 + 布局」存为模板（如「后端开发环境」= 3 个 SSH 会话横向分屏），一键拉起。
+
+### 4.4 密钥管理（P0）
+
+**密钥生命周期**
+- **生成**：Ed25519（推荐默认）/ RSA（2048/3072/4096）/ ECDSA（P-256/P-384/P-521）。可设注释、可设 passphrase。
+- **导入**：支持 OpenSSH 格式、PEM、PKCS#8；支持带 passphrase 的私钥；**支持 PuTTY `.ppk`**（Windows 用户存量多，P1）。
+- **导出**：导出公钥到剪贴板（一键复制 `ssh-ed25519 AAAA... comment`，配合用户自己贴到服务器）。
+- **删除**：二次确认 + 提示「该密钥还关联 N 个主机」。
+
+**存储策略（安全姿态必须与本项目既有约定对齐）**
+
+参照 `secrets.rs` 头部注释里明确批判过的历史问题——「同样是可冒充身份的凭据，不该区别对待」。据此定：
+
+| 数据 | 存放位置 | 理由 |
+|---|---|---|
+| 私钥**文件本身** | `{app_data_dir}/terminal/keys/` 目录，文件权限收紧 | 私钥可能几 KB，塞进凭据管理器（单条上限约 2.5KB）不可靠；且用户需要用其他工具引用该路径 |
+| 私钥 **passphrase** | `secrets.rs` → 系统凭据管理器 | 是「可冒充身份的凭据」，必须 DPAPI 保护，键名 `terminal-key-passphrase-{keyId}` |
+| SSH 密码 | `secrets.rs` | 同上，键名 `terminal-ssh-password-{hostId}` |
+| 代理密码（P2） | `secrets.rs` | 同上 |
+| 主机密钥指纹 / known_hosts | JSON 文件 | 非机密，需要人可读、可导出 |
+| 主机配置 / 会话元数据 / 设置 | `{app_data_dir}/terminal/settings.json` | 非机密；`#[serde(default)]` 容器级默认，保证向后兼容 |
+
+**明文禁令**（写入代码注释与评审清单）：
+- 私钥明文**只允许**存在于内存与 `keys/` 目录，禁止回写 `settings.json`。
+- 私钥 passphrase / SSH 密码禁止进入 localStorage、禁止进入任何日志行。
+- 前端**不存在读取凭据明文的命令**——参照 `translate` 模块的姿态：列表接口只回传 `hasPassphrase: bool` + 掩码串。
+
+**ssh-agent 集成（P1）**
+- 检测 Windows OpenSSH Agent 服务是否运行。
+- 「添加到 agent」/「从 agent 移除」操作。
+- 指明哪些密钥由 agent 托管（UI 上区分展示）。
+
+**known_hosts 管理（P1）**
+- 列表查看所有已知主机，支持搜索、删除单条、批量导入导出。
+- 变更告警历史留档。
+
+### 4.5 文件快捷管理（P1）
+
+**SFTP 双栏文件管理器**
+- 左侧本地、右侧远程（或双远程，支持拖拽跨栏传输）。
+- 列视图：名称 / 大小 / 类型 / 权限 / 修改时间 / 所有者。支持排序、多选、框选。
+- 路径面包屑 + 可直接编辑路径 + 前进后退历史。
+- 权限可视化与编辑（`rwxr-xr-x` ↔ `755` 双向互转）。
+
+**文件操作**
+- 新建目录 / 新建文件 / 重命名 / 删除（二次确认）/ 复制 / 移动。
+- 上传 / 下载：目录递归、进度显示、**并发分片**（多小文件并行，大文件单流）、断点续传、失败重试、队列管理。
+- 拖拽：从 Windows 资源管理器拖入上传；从远程栏拖出到本地栏下载。
+- 编辑远程文件：双击打开内置编辑器，保存时上传（P1 用 `<textarea>`，P2 换 CodeMirror 带语法高亮）。
+
+**与终端的联动（这是本模块区别于普通 SFTP 客户端的核心）**
+- **跟随 cwd**：终端里 `cd` 后，SFTP 面板自动跟随（依赖 §4.1 的 OSC 7 hook）。
+- **`rz` / `sz` 内联传输**：拦截终端里的 `sz <file>`，自动弹出「保存到本地」对话框；拦截 `rz`，弹出「选择本地文件上传」。需要实现 ZMODEM 协议或调用 `lrzsz`（P2，但价值高）。
+- **选中即操作**：终端里双击路径（如 `/var/log/nginx/error.log`）→ 右键菜单「用 SFTP 打开所在目录」。
+
+**本地文件管理（附带）**
+- 「本地 Shell」会话同样挂载文件面板，可当轻量双栏文件管理器用（与快速面板的文件能力形成互补，不重复：快速面板面向「搜索定位」，这里面向「浏览操作」）。
+
+### 4.6 快捷键体系（P0）
+
+分三层，边界清晰：
+
+**第一层：全局快捷键**（走 `shortcut.rs`，与系统级冲突检测）
+
+| 功能 | 默认值 | 说明 |
+|---|---|---|
+| 唤起快速会话菜单 | `Ctrl+Alt+T` | 类「新建终端」语义，弹浮层选主机/Shell |
+| 打开终端模块 | 无（不抢占） | 建议不设，避免与用户既有习惯冲突 |
+
+> 注意：`shortcut.rs` 的应用内冲突检测会拒绝「已被其他模块占用」的组合。截图默认 `Ctrl+Alt+A`、翻译面板默认 `Ctrl+2`。终端默认值需与此避让。
+
+**第二层：终端内快捷键**（xterm `attachCustomKeyEventHandler` 拦截，仅在终端聚焦时生效）
+
+| 功能 | Windows 键位 | 说明 |
+|---|---|---|
+| 复制 | `Ctrl+Shift+C` | Windows Terminal 惯例。**不拦 `Ctrl+C`**（必走 SIGINT） |
+| 粘贴 | `Ctrl+Shift+V` | |
+| 选中即复制 | 可开关 | 习惯问题，默认关 |
+| 新建标签 | `Ctrl+Shift+T` | |
+| 关闭标签 | `Ctrl+Shift+W` | 有活动进程时二次确认 |
+| 下一个/上一个标签 | `Ctrl+Tab` / `Ctrl+Shift+Tab` | |
+| 跳转到第 N 标签 | `Alt+1..9` | |
+| 垂直/水平分屏 | `Ctrl+Shift+D` / `Ctrl+Shift+E` | |
+| 关闭分屏 | `Ctrl+Shift+Q` | |
+| 终端内搜索 | `Ctrl+Shift+F` | 走 `addon-search` |
+| 清屏 | `Ctrl+Shift+K` | 发送 `clear` 或 `cls`（按 shell 判断） |
+| 字体放大/缩小/复位 | `Ctrl+=` / `Ctrl+-` / `Ctrl+0` | |
+| 打开 SFTP 面板 | `Ctrl+Shift+P` | |
+| 命令片段库 | `Ctrl+Shift+S` | |
+| 重命名标签 | `F2` | |
+| 会话切换器（快速跳转） | `Ctrl+Shift+O` | 模糊搜索所有会话 |
+
+**第三层：Shell 内快捷键**（终端原生，不改）
+- `Ctrl+L`、`Ctrl+R`、`Ctrl+A/E/U/K` 等一律透传给 shell，终端不拦截。
+
+**可配置性**
+- 第二层全部可自定义，配置存 `terminal/settings.json`。
+- 冲突检测：同一组合被两个动作占用时高亮提示。
+- 提供「重置为默认」。
+
+### 4.7 命令增强（P1，体现「全能」）
+
+- **命令历史搜索**：跨会话聚合历史（本地 shell 从 PowerShell 历史文件读，SSH 会话抓取输出流），`Ctrl+R` 增强版，模糊搜索 + 频次排序。
+- **命令片段库（Snippets）**：保存常用命令模板，支持 `{{变量}}` 占位符，选择时弹窗填参；支持分类与搜索；支持一键发送到当前会话。
+- **命令补全**（P1）：基于历史 + 片段做行内补全（类似 fish 的灰字建议），在 xterm 上叠加一层浮层实现。
+- **AI 命令助手（P2）**：复用 `translate` 模块已配置的 AI 引擎（`translate/settings.rs` 里的 `TranslateEngineConfig`），把自然语言转成命令。「复用引擎配置而非另配一套」是关键——用户在翻译模块填过的 API Key 不该再填一遍。
+
+### 4.8 与既有模块联动（P1/P2）
+
+| 联动对象 | 联动方式 |
+|---|---|
+| **快速面板** | (a) 快速面板搜索里出现「打开 SSH：prod-web-01」条目；(b) 快速面板输入 `> ssh prod` 直接建会话 |
+| **剪贴板模块** | 终端内复制的内容进入剪贴板历史，可回溯找回；剪贴板历史的「粘贴到目标」支持终端 |
+| **翻译模块** | 终端选中文本 → `Ctrl+Alt+T` 之类触发划词翻译（**注意**：需把终端进程加进 `SelectionSettings.blacklist` 的思考——实际上终端不在黑名单里，因为终端内 `Ctrl+C` 是复制语义由 xterm 处理，不会误触发；但需实测确认） |
+| **代理模块** | SSH 连接可走 mihomo 代理（读 `proxy/settings.json` 的 `mixedPort`，参照 `translate/mod.rs::read_mixed_port` 的写法：**只读文件不依赖 Manager 状态**） |
+| **日志模块** | 连接失败、认证失败、主机密钥变更等关键事件写统一日志 |
+| **下载器** | SFTP 传输是否复用下载器的队列/进度 UI？（**建议不复用**——传输语义与 HTTP 下载差异大，共享 UI 会两边受限） |
+
+### 4.9 其他工程能力（补充项）
+
+- **终端外观**：主题（跟随应用亮/暗 + 内置若干配色）、字体族与字号、行高、光标样式（块/竖线/下划线 + 闪烁）、滚动缓冲区行数（默认 10000）、背景透明度。
+- **编码**：默认 UTF-8；SSH 老服务器可能是 GBK，需支持按会话指定编码（`encoding_rs` crate）。中文环境下这是刚需，不是可选项。
+- **日志与审计（P2）**：可开启「记录会话输入输出到文件」（合规场景），提供脱敏正则。
+- **安全基线**：
+  - 禁止在日志中出现私钥、passphrase、密码。
+  - 会话命令回显中若匹配到疑似密钥（如 `-----BEGIN`），提示用户。
+  - 危险命令（`rm -rf /`、`dd`）不做拦截（越权），但可做**高亮提示**（可选功能）。
+
+---
+
+## 5. 工程实现
+
+### 5.1 Rust 侧目录结构
+
+```
+src-tauri/src/terminal/
+├── mod.rs                  # TerminalManager（Tauri State）+ 设置读写
+├── settings.rs             # 设置数据模型（#[serde(default)] 容器级默认）
+├── commands.rs             # Tauri 命令层（薄：参数整形 / 校验 / 错误归类）
+├── session.rs              # Session trait + SessionRegistry（DashMap）
+├── pty/
+│   ├── mod.rs
+│   └── conpty.rs           # ConPTY 绑定、read/write 线程、resize 时序处理
+├── shell.rs                # 本地 Shell 探测与启动参数组装
+├── ssh/
+│   ├── mod.rs              # SshBackend（实现 Session）
+│   ├── auth.rs             # 认证方式（公钥/密码/agent/键盘交互）
+│   ├── hostkey.rs          # known_hosts 与指纹校验
+│   ├── sftp.rs             # SFTP 客户端与传输队列
+│   ├── forward.rs          # 端口转发（P2）
+│   └── config.rs           # ~/.ssh/config 解析
+├── keys.rs                 # 密钥生成/导入/列举（含 passphrase 走 secrets.rs）
+├── snippets.rs             # 命令片段库
+├── history.rs              # 命令历史（SQLite，参照 translate/history.rs）
+└── encoding.rs             # 编码转换（UTF-8 / GBK 等）
+```
+
+**命令命名**：`terminal_*` 前缀，snake_case。预计 P0 约 30 个、P1 约 45 个命令。
+
+**注册顺序**（严格按此，缺一不可）：
+1. `lib.rs` `mod terminal;` + `use terminal::{...}` 导入命令
+2. `lib.rs` `manage(TerminalManager::new(...))`（`setup.rs` 中构造，与 `TranslateManager` 同法）
+3. `lib.rs` `invoke_handler![...]` 追加命令
+4. `lib.rs` `export_bindings()` 的 `collect_commands![...]` 追加同名命令 —— **漏掉这步前端就没有 `commands.terminalXxx` 类型**
+5. `RunEvent::ExitRequested` 中追加 `terminal.cleanup_on_exit()`（关闭所有会话与 PTY）
+6. `constants.rs` 新增 `windows::TERMINAL_*` 与 `events::TERMINAL_*`
+
+### 5.2 前端目录结构
+
+```
+src/modules/terminal/
+├── index.ts                    # ModuleConfig（含 searchItems / lifecycle / order）
+├── TerminalModule.vue          # 主组件（布局容器）
+├── components/
+│   ├── SessionSidebar.vue      # 会话树（拖拽排序）
+│   ├── TerminalTabs.vue        # 标签 + 分屏管理
+│   ├── TerminalPane.vue        # xterm 实例宿主（单个会话）
+│   ├── TerminalToolbar.vue     # 顶部工具条
+│   ├── TerminalStatusBar.vue   # 底部状态栏
+│   ├── HostEditorDialog.vue    # 主机编辑
+│   ├── KeyManagerPanel.vue     # 密钥管理
+│   ├── SftpPanel.vue           # 文件管理器（P1）
+│   ├── SnippetsPanel.vue       # 命令片段
+│   └── QuickSessionPopup.vue   # 全局快捷键唤起的快速会话浮层
+├── composables/
+│   ├── useXterm.ts             # xterm 实例创建 / 插件装配 / 尺寸同步
+│   ├── useSessionStream.ts     # 事件订阅 → 写入 xterm（含背压处理）
+│   └── useTerminalKeys.ts      # 快捷键拦截与分发
+└── settings/TerminalSettings.vue  # 设置页（挂进 settings 模块）
+```
+
+**store**：`src/stores/terminal.ts` — 会话元数据（不持有 xterm 实例）、布局树、当前激活会话、设置缓存。
+
+**事件常量**（`constants.ts` 对应前端 `src/lib/constants.ts`）：
+
+| 事件名 | 负载 | 触发时机 |
+|---|---|---|
+| `terminal-output` | `{ sessionId, data: Vec<u8>（base64） , seq }` | 会话有输出 |
+| `terminal-exit` | `{ sessionId, code, signal }` | 会话进程/连接结束 |
+| `terminal-state` | `{ sessionId, state }` | 状态机变更 |
+| `terminal-cwd` | `{ sessionId, cwd }` | OSC 7 报告目录变化 |
+| `terminal-sftp-progress` | `{ taskId, transferred, total, speed }` | 传输进度 |
+
+> **背压是重点**：大量输出（如 `cat` 大文件）时，事件频率会压垮 WebView。设计上用**批次聚合**——Rust 侧 8~16ms 窗口聚合一次，前端按 `seq` 校验无丢包；xterm 侧用 `write(data, callback)` 的回调控制写入节奏，配合 `addon-webgl` 提升渲染吞吐。
+
+### 5.3 设置模型（`terminal/settings.json`）
+
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]   // 容器级默认：字段增减向后兼容
+pub struct TerminalSettings {
+    pub version: u32,                     // 结构版本，用于迁移判断（参照 translate 的 heal 模式）
+    pub shells: Vec<ShellProfile>,        // 本地 Shell 配置
+    pub hosts: Vec<SshHost>,              // SSH 主机条目
+    pub layout: LayoutSettings,           // 标签/分屏默认行为
+    pub appearance: AppearanceSettings,   // 主题/字体/光标/缓冲区
+    pub shortcuts: Vec<ShortcutBinding>,  // 可自定义快捷键
+    pub selection: SelectionSettings,     // 终端内选中行为（复制/粘贴策略）
+    pub sftp: SftpSettings,               // 传输并发、覆盖策略、时间戳保留
+    pub history: HistorySettings,         // 命令历史开关与条数
+    pub security: SecuritySettings,       // 主机密钥策略、代理开关、编码默认值
+}
+```
+
+**`version` + `heal()` 模式必须沿用**：参照 `translate/settings.rs::heal` ——老配置缺字段取默认值、失效引用自动回落、版本号推进。这是本项目已确立的向后兼容约定。
+
+### 5.4 权限与窗口
+
+- 主窗口已具备 `core:default` 等权限，终端模块**无需新增 capabilities**（全部通过自定义命令走 IPC）。若做独立的快速会话浮层窗口，则需新增 `capabilities/terminal-quick.json`，参照 `translate-popup.json`（NOACTIVATE + 预创建）。
+- 若后续要做「终端独立窗口」（P2），同样需要独立 capability。
+
+### 5.5 依赖清单
+
+**Rust（`Cargo.toml`）** —— 以下为**实施后的实际形态**（本节的规划值已被 §9/§10 修正，以这里为准）
+
+```toml
+# ===== SSH =====
+russh = "0.63"             # 规划写 0.5；实际落地版本 0.63.3（见 §9.2 偏差表）
+russh-sftp = "3.0"         # 【规划遗漏】russh 不含 SFTP，协议在独立 crate 里
+                           # 版本配套：russh-sftp 3.0.0 依赖 `russh ^0.63.2`，与上面同源。
+                           # 这一点是硬约束——SFTP 通道必须从**已认证的同一个
+                           # Session** 上开，跨 patch 版本的类型不互通。
+
+# ===== 编码 =====
+encoding_rs = "0.8"        # GBK/GB18030/Big5/Shift_JIS/EUC-KR/latin1
+                           # 依赖树里已存在（reqwest → encoding_rs 0.8.35），
+                           # 提升为直接依赖**不新增编译单元**
+
+# ===== 已存在可直接用 =====
+# tokio / serde / serde_json / base64 / sha2 / rand / rusqlite / dirs / keyring / dashmap
+
+# ===== 需开启 feature =====
+windows-sys = { version = "0.52", features = ["Win32_System_Console", "Win32_System_Pipes",
+                                              "Win32_System_Threading", "Win32_Foundation", ...] }
+# 注意：InitializeProcThreadAttributeList / UpdateProcThreadAttribute /
+# DeleteProcThreadAttributeList 虽属 Win32_System_Threading，但 0.52 未随 feature 导出，
+# 用 `unsafe extern "system"` 自行声明（见 conpty.rs 尾部），
+# 避免为三个函数开启一个大 feature 而显著拖长编译时间。
+```
+
+**前端（`package.json`）**
+```
+@xterm/xterm
+@xterm/addon-fit
+@xterm/addon-webgl
+@xterm/addon-search
+@xterm/addon-web-links
+@xterm/addon-unicode11
+@xterm/addon-serialize        # P1
+```
+
+### 5.5.1 依赖数量校验（实施后）
+
+`cargo metadata --no-deps` 结果：**50 个直接依赖，0 重复**。重点确认了两件事：
+
+1. `russh` 只有一份（`russh-sftp` 3.0.0 把 `russh` 列为 dev-dependency，不会重复引入）。
+2. `encoding_rs` 不会引入第二个 `iconv` 类 C 依赖——它是纯 Rust 实现。
+
+### 5.6 模块注册
+
+```typescript
+// src/modules/terminal/index.ts
+export const moduleConfig: ModuleConfig = {
+  id: 'terminal',
+  name: '终端',
+  icon: 'terminal',              // 需在 icons.ts 加映射 → lucide 的 SquareTerminal
+  description: 'SSH 与本地 Shell 多会话终端，含密钥管理与文件传输',
+  category: 'tool',
+  defaultEnabled: true,
+  loader: () => import('./TerminalModule.vue'),
+  searchItems,                   // 见下方搜索项设计
+  order: 18                      // 建议：proxy=10 / music=15 / terminal=18 / clipboard=20 / translate=25
+}
+```
+
+`src/modules/icons.ts` 新增：
+```typescript
+import { SquareTerminal } from '@lucide/vue'
+// moduleIconMap 中追加
+terminal: SquareTerminal
+```
+
+**全局搜索项**（`searchItems`）建议覆盖：终端、本地 Shell、SSH 主机（动态）、密钥管理、known_hosts、命令片段、终端设置、外观、编码、快捷键。
+
+---
+
+## 6. 分期路线图
+
+### P0 — 骨架可跑（目标：本地 Shell + SSH 基本连得上 + 密钥管理）
+
+**Rust**
+- [ ] `TerminalManager` 骨架 + `Session` trait + `SessionRegistry`
+- [ ] ConPTY 绑定（含 resize 时序、阻塞关闭、EOF 处理三个坑）
+- [ ] 本地 Shell 探测（PowerShell 7 / Windows PowerShell / cmd / Git Bash / WSL）
+- [ ] 输出读线程 + 事件聚合（8~16ms 批处理）
+- [ ] OSC 7 cwd hook 注入与解析
+- [ ] `secrets.rs` 复用：密码 / passphrase 存取
+- [ ] 密钥生成（Ed25519 / RSA / ECDSA）、导入、列举、删除
+- [ ] SSH 连接（russh）：公钥认证 + 密码认证
+- [ ] 主机密钥校验 + known_hosts 存储 + 指纹变更阻断
+- [ ] 设置模型 + `heal()` 迁移骨架
+- [ ] `lib.rs` 六处注册（含 `collect_commands!`）+ `cleanup_on_exit`
+- [ ] `constants.rs` 窗口/事件常量
+
+**前端**
+- [ ] 模块注册（`index.ts` / `modules/index.ts` / `icons.ts`）
+- [ ] `useXterm.ts`：实例装配（fit + webgl + unicode11 + search + web-links）
+- [ ] `TerminalPane.vue`：I/O 绑定、尺寸同步、焦点管理
+- [ ] `TerminalTabs.vue`：多标签 + 关闭确认
+- [ ] `SessionSidebar.vue`：会话列表 + 状态点
+- [ ] 主机编辑对话框 + 密码短语输入
+- [ ] `KeyManagerPanel.vue`
+- [ ] 三层快捷键（第二层可配置）
+- [ ] 设置页（外观 / Shell / 快捷键）
+- [ ] `stores/terminal.ts`
+
+**P0 验收标准**：能开 3 个本地 PowerShell 标签 + 2 个 SSH 会话（一个公钥、一个密码），秒级切换不卡顿，切到其他模块再回来会话仍在，`Ctrl+Shift+C/V` 可复制粘贴，关闭应用无残留进程。
+
+### P1 — 完整能力
+
+- [ ] SFTP 双栏文件管理器（浏览 / 上传 / 下载 / 目录递归 / 并发分片 / 断点续传）
+- [ ] 分屏（2×2）
+- [ ] ssh-agent 集成
+- [ ] 键盘交互认证 / 2FA
+- [ ] `~/.ssh/config` 导入
+- [ ] 命令历史聚合 + 增强搜索
+- [ ] 命令片段库
+- [ ] 会话侧栏拖拽分组、收藏
+- [ ] 会话快照序列化与恢复
+- [ ] 全局快捷键「快速会话浮层」
+- [ ] 快速面板联动（搜索项 + `> ssh` 语法）
+- [ ] SFTP 跟随 cwd
+- [ ] 编码支持（GBK）
+- [ ] 终端内搜索、链接点击
+
+### P2 — 高级与生态
+
+- [x] 端口转发（`-L` / `-R`）（2026-09-18 第五轮，见 §11.3；`-D` SOCKS5 留作后续）
+- [x] 跳板机链（ProxyJump）（2026-09-18 第四轮，见 §11.2）
+- [x] 连接复用（2026-09-18 第八轮，见 §11.8）
+- [x] AI 命令助手（复用 translate 引擎配置）（2026-09-18 第七轮，见 §11.7）
+- [x] `rz` / `sz` ZMODEM 内联传输 —— **已放弃**（2026-09-18 评审：SFTP 已覆盖主场景，
+     协议成本 600–800 行且无法单测主流程；详见实施记录 §11.9 评估）
+- [x] 会话模板（一键拉起一组会话 + 布局）（2026-09-18 第六轮，见 §11.6）
+- [x] 终端独立窗口（P1 已交付 detach/attach；「拖出标签成窗」手势留后续）
+- [x] 会话日志与审计（2026-09-18 第五轮，见 §11.4）
+- [x] PuTTY `.ppk` 导入（2026-09-18 第四轮，见 §11.1）
+- [x] 主机分组同步（导入导出配置）（2026-09-18 第六轮，见 §11.5）
+
+---
+
+## 7. 风险清单
+
+| # | 风险 | 影响 | 缓解 |
+|---|---|---|---|
+| 1 | ConPTY resize 竞态导致 TUI 程序（vim/htop）花屏 | 中 | 首帧后延迟应用尺寸；监听 `WINDOW_BUFFER_SIZE_EVENT` 校正；实测 vim/top/less |
+| 2 | `ClosePseudoConsole` 阻塞导致退出卡死 | **高** | 独立线程 + 先取消 `ReadFile`；`cleanup_on_exit` 带超时（参照 `MonitorKernel` 的 3s `recv_timeout` 写法） |
+| 3 | 输出洪流压垮 WebView（`cat` 大文件） | **高** | Rust 侧 8~16ms 批次聚合 + `seq` 校验；xterm `write` 回调节流；`addon-webgl` |
+| 4 | `russh` API 破坏性变更 | 中 | 锁定小版本；`Session` trait 隔离，必要时可换 `ssh2` |
+| 5 | 主机密钥校验被用户习惯性点过（TOFU 疲劳） | **高（安全）** | 首次连接突出展示指纹；变更时红色阻断而非黄色提示；提供「仅本次接受」与「永久接受」区分 |
+| 6 | 多会话内存占用（每个 xterm 实例 + 滚动缓冲） | 中 | 默认缓冲 10000 行；会话数量上限提示；非激活标签暂停渲染 |
+| 7 | 中文宽字符对齐错乱 | 中 | 必装 `addon-unicode11`；实测 `ls -l` 中文文件名的列对齐 |
+| 8 | SSH 老服务器 GBK 编码乱码 | 中 | `encoding_rs` 按会话转码；默认 UTF-8 可选 GBK |
+| 9 | 私钥文件被其他进程读取 | 中（安全） | `keys/` 目录权限收紧；passphrase 存凭据管理器；UI 提示用户优先使用带 passphrase 的密钥 |
+| 10 | `Cargo.toml` 编码损坏影响新增依赖的 diff | 低 | 独立清理项，建议在动工前修复 |
+| 11 | 分屏 × 标签 × 会话的组合复杂度爆炸 | 中 | 分屏上限 2×2；布局用树结构表达并单测 |
+| 12 | 全局快捷键与应用内快捷键语义混淆 | 低 | 明确三层边界，UI 上一处分开展示；不做「全局拦截 Ctrl+C」这类危险映射 |
+
+---
+
+## 8. 待确认决策项
+
+动工前需要拍板的四项，我给出倾向但需要用户确认：
+
+1. **SSH 库**：倾向 `russh`（async 契合）。若用户更看重稳定性与既有经验，可改 `ssh2`。
+2. **ConPTY**：倾向直接绑定 `windows-sys`（与项目现有原生态一致）。若更看重开发速度，可用 `portable-pty`。
+3. **P0 范围**：本规划把「SSH + 密钥管理 + 多会话 + 快捷键」全放进 P0，工作量偏大（8~12 天）。若希望更快见到可用版本，可将 SSH 拆到 P0.5，先交付「本地 Shell + 多会话 + 快捷键」。
+4. **是否需要终端独立窗口**：影响窗口与 capability 设计，早定早省事。
+
+---
+
+## 附录 A：与既有模块的范式对照
+
+| 范式 | 既有实现 | 终端模块对应 |
+|---|---|---|
+| 模块 ID / 分类 | `translate`：`category: 'tool'` | 同 |
+| 设置持久化 | `{app_data_dir}/<module>/settings.json` | `{app_data_dir}/terminal/settings.json` |
+| 设置兼容 | 容器级 `#[serde(default)]` + `heal()` + `version` | 完全沿用 |
+| 凭据存储 | `secrets.rs` + 服务名 `"Thing"` | 完全复用，仅新增键名约定 |
+| 命令层姿态 | `translate/commands.rs`「薄」：整形/校验/归类 | 同 |
+| 类型绑定 | `tauri-specta` → `src/lib/bindings.ts` | 必须复用 |
+| 事件命名 | `kebab-case`：`translate-stream-chunk` | `terminal-output` / `terminal-exit` / ... |
+| 快捷键 | `shortcut.rs` 原子注册 + 冲突检测 | 完全复用 |
+| 退出清理 | `RunEvent::ExitRequested` 逐个 `cleanup_on_exit` | 追加 `TerminalManager` |
+| 历史存储 | `translate/history.rs`（SQLite） | `terminal/history.rs` 同法 |
+| 原生浮层窗口 | `translate-popup`（NOACTIVATE 预创建） | 快速会话浮层参照 |
+
+## 附录 B：命名规范落点
+
+| 类型 | 规范 | 示例 |
+|---|---|---|
+| 前端组件 | PascalCase | `TerminalPane.vue` |
+| 前端文件 | kebab-case | `use-session-stream.ts`（composable 目录内用 camelCase 前缀 `use`） |
+| Pinia store | camelCase 文件 | `src/stores/terminal.ts` |
+| Rust 模块 | snake_case | `terminal/pty/conpty.rs` |
+| Tauri 命令 | `terminal_` + snake_case | `terminal_open_session` |
+| Tauri 事件 | kebab-case | `terminal-output` |
+| 凭据键名 | `terminal-<用途>-<id>` | `terminal-key-passphrase-{keyId}` |
+| 设置字段 | camelCase（serde rename_all） | `maxScrollback` |
+
+---
+
+## 9-11. 实施记录（P0–P2 精编）
+
+> 本节为 2026-09-18 全链路审查时按「精简」要求压缩的版本：保留全部**架构决策、
+> 坑记录与语义备忘**，省略逐轮的过程性叙述与重复的验证表。按阶段分节的原始
+> 详版（P0 §9 / P1 §10 / P2 §11，共 8 轮）记录在 git 历史与当日工作日志中。
+
+### 交付总览
+
+| 阶段 | 交付 | 状态 |
+|---|---|---|
+| P0 | 本地 Shell（ConPTY）、SSH 连接、多标签、密钥管理、快捷键骨架 | ✅ |
+| P1 | SFTP 双栏、分屏 2×2、命令片段库、命令历史（OSC 133）、编码切换、Cargo.toml 修复 | ✅ |
+| P2 | `.ppk` 导入、ProxyJump 跳板链、端口转发 -L/-R、会话日志与审计、主机导入导出、会话模板、AI 命令助手、连接复用 | ✅ |
+| P2 | 终端独立窗口 | ✅（P1 交付 detach/attach） |
+| P2 | ZMODEM | ❌ 已放弃（评估见下） |
+| 审查 | 全链路审查：修复 2 个 P0 级前端缺陷 + 1 个后端竞态 + 4 个中低问题 | ✅ |
+
+### 分阶段决策摘要
+
+**P0（骨架）**
+- ConPTY 直接用 `windows-sys`，`CreatePseudoConsole` 三函数自行声明（避免拖入大 feature）。
+- 会话抽象 `Session` trait：本地/SSH 双后端共用命令层；`ProcessManager` 不适用（N 会话 + 双向流 + 退出不重启）。
+- `SessionId` 用短序号（`s1`…），会出现在窗口 label 与日志。
+- 密码/密钥 passphrase 分离存储：密码进系统凭据管理器（按 id 键名），私钥本体落 `keys/` 目录。
+
+**P1（完整能力）**
+- SFTP：russh 不含 SFTP → 引入 `russh-sftp`；通道挂在会话连接上（非独立连接）。
+- 分屏 = 新建会话 + 并排渲染（tmux 语义），上限 4（WebGL 上下文约束）；CSS Grid 布局。
+- 命令片段：占位符 `${name}` 语法只在 Rust 侧实现一份（前端自己写正则必分叉）；两步执行（填入 vs 执行）。
+- 命令历史：OSC 133 + 1337 提取命令边界；本地用 shell hook 上报 cwd；不做 DROP 重建式迁移。
+- 编码切换：解码在前端（用户可切编码重看历史），读写两侧都从会话状态现取。
+
+**P2（高级与生态，共 8 轮）**
+- `.ppk` 导入：`ssh-key` 的 `ppk` feature（russh 不转发 → 自己声明同版本号 `=0.7.0-rc.11`）；PPK 解析后统一转 OpenSSH 落盘。
+- ProxyJump：russh 无内置 → 逐跳手搭（`direct-tcpip` 通道流 + `connect_stream`）；跳板与直连同权校验。
+- 端口转发 -L/-R：`direct-tcpip` + `copy_bidirectional` / `tcpip_forward` + Handler 白名单回调；规则挂会话不持久化。
+- 会话日志：双后端 `flush_output` 单点挂钩；记原始字节含 ANSI；只记输出不记输入（密码安全）。
+- 主机同步：JSON 备份只含配置不含密码/私钥；导入重编 id（凭据键名冲突）+ 重写跳板链 + 三元组去重。
+- 会话模板：捕获当前可见面板集合；拉起 = 逐条开会话 + addPane；只存 target 引用。
+- AI 助手：复用翻译模块引擎配置（`chat_once` 通用补全出口）；三层解析防御；默认填入不执行。
+- 连接复用：连接池按「用户名|host:port|auth|材料指纹」共享 SSH 连接；引用计数归零才断开。
+
+### 关键架构语义备忘（跨模块契约）
+
+1. **`ssh-key 0.7` 的 `decrypt()`/`encrypt()` 都是 `&self → Result<Self>` 转换语义**——返回值必须接住；
+   丢返回值 = 仍在加密态（坑 31，曾导致加密私钥导入从未成功过）。
+2. **`encrypt()` 会清空内存对象的注释**（重建 public_key），但加密载荷里含注释（decrypt 可读回）；
+   `set_comment` 必须在 encrypt 之后调用。
+3. **`collect_commands!`（导出绑定）与 `generate_handler!`（运行时注册）是两份独立清单**——
+   新增命令必须双清单登记；前端用原生 `invoke` + 手写镜像类型（translate 先例，terminal 跟随）。
+4. **`export_bindings()` 失败是运行时的**：specta 类型注册表全局按名索引，
+   跨模块同名 `Type` 派生类型会让应用启动即 panic（`cargo check` 完全看不见）。
+5. **`tauri-specta` derive 路径无法重命名类型**（`#[specta(rename)]` 只对函数宏生效）——
+   通用词（Settings/HistoryPage/Item…）一律加模块前缀。
+6. **`Write` 契约**：前端 `store.write(string)` 必须 TextEncoder 编码后 base64
+   （后端严格解码）；xterm onData / 粘贴走字符串分支。
+7. **`vue-draggable-plus` 的 `target` 是跨容器专用 prop**，且 `querySelector` 不匹配元素自身——
+   单容器排序禁止传 target。
+8. **连接池槽位是 tokio Mutex**（连接建立期跨 `.await` 持锁，天然串行化同主机并发连接）；
+   sftp/转发的同步访问走 `spawn_blocking + block_on`，锁在 block_on 内获取。
+9. **跳板 Handle 挂池条目**而非首建会话——否则首建会话关闭剪断他人隧道。
+10. **`-R` 入站路由按端口全局匹配**：连接级 Handler 的 session_id 属于首建会话；
+    远程监听端口全局唯一（add 时强制）。
+11. **`chat_once`（translate 根 re-export）是终端 AI 助手的唯一 API 配置源**——
+    终端不持有任何引擎配置副本。
+12. **面板常驻挂载**：`renderPanes` 含全部会话，v-show 切可见性——
+    切标签/分屏绝不销毁 xterm 实例（缓冲与隐藏期输出不丢）。
+
+### 坑记录（35 条精编）
+
+| # | 一句话 | 修复/规避 |
+|---|---|---|
+| 1 | `ssh-key` 双版本分叉（0.6 vs russh 钉的 0.7） | 只用 russh re-export；例外须同版本号声明 |
+| 2 | ssh-key 的 getrandom feature 门控（rand_core 0.10） | 直接依赖 getrandom 0.4 + UnwrapErr(SysRng) |
+| 3 | `#[specta::specta]` 与 `#[tauri::command]` 必须成对 | 漏一个 = 绑定缺失或运行时不可调 |
+| 4 | windows-sys 0.52 的 HANDLE/HPCON 是 isize | 注意类型转换 |
+| 5 | ConPTY 三个时序陷阱（先建管道再建 PTY 等） | 见 pty::conpty 注释 |
+| 6 | `create_pipe()` 已返回 File，不要再转一次 | — |
+| 7 | xterm 无 selectWordAt（自实现选择词语） | 右键菜单自定义 |
+| 8 | PowerShell 写文件产出 UTF-16LE | 让程序自己写或 Python 落盘 |
+| 9 | 密码与配置分离存储（凭据管理器 vs settings.json） | 永不明文落盘 |
+| 10 | 新建主机先向后端要 id（密码按 id 存取） | id 规则单点 |
+| 11 | russh 无 SFTP → 引入 russh-sftp | 通道复用连接 |
+| 12 | SFTP 通道借用 Handle 需 spawn_blocking+block_on | Handle 不可 Clone、不能跨 await 持锁 |
+| 13 | WebGL 上下文上限 4 个（黑屏风险） | maxPanes 封顶 + onContextLoss 回退 |
+| 14 | 分屏容器是标签级的，切标签要重置 | resetPanesTo（见坑 36 修正） |
+| 15 | 本机 Bash 缺 coreutils，管道全部失真 | 验证命令重定向到文件后用 Python 读 |
+| 16 | `npx` 触发 wsl.exe 黑名单拦截 | 直接调 JS 入口 |
+| 17 | PowerShell 重定向产出 UTF-16LE | 同 8 |
+| 18 | `vite build` 重定向+后台 = 假死（非 OOM） | 构建一律前台跑 |
+| 19 | impl 块放错位置 → trait 方法「已实现却报未实现」 | — |
+| 20 | Session trait 未引入时报错指不到成因 | 显式 use |
+| 21 | OSC 133 命令文本与结束标记是两个独立序列 | 必须累积 |
+| 22 | `1337` 与 `133` 共享前缀，判断顺序错了静默失效 | 先判长前缀 |
+| 23 | `${x#"$y"}` 类语法在 Rust 字符串里写不出 | 换等价写法 |
+| 24 | 两份 `scan_control_sequences` 拷贝按后端分支出诡异 bug | 收敛到一处 |
+| 25 | 命令历史遵守 `HISTCONTROL=ignorespace` 惯例 | 前导空格不记录 |
+| 26 | FTS 与 LIKE 双路径查询需一致性测试 | — |
+| 27 | `export_bindings()` 失败是运行时的（编译全绿 ≠ 能启动） | 新增 Type 必须实际跑二进制 |
+| 28 | 两份命令清单不自动同步 | 双清单登记 + 交叉注释 |
+| 29 | 重定向/后台让验证命令本身不可信 | 前台对照实验 |
+| 30 | `vue-draggable-plus` 的 `target` 是跨容器专用（querySelector 不搜自身） | 单容器禁用 target |
+| 31 | `decrypt()/encrypt()` 是转换语义，丢返回值 = 加密私钥导入从未成功 | 接住 Result\<Self\> |
+| 32 | `encrypt()` 清空内存对象注释（载荷里有） | set_comment 在 encrypt 后 |
+| 33 | trait object 不能挂两个非 auto trait（E0225） | 合并 trait + blanket impl |
+| 34 | russh 对 forwarded-tcpip 默认全收 | Handler 白名单覆写 |
+| 35 | 连接复用后 -R 入站按 session_id 路由永不命中 | 全局端口匹配 + 唯一性 |
+| 36 | **[审查轮]** 切标签销毁 xterm 实例、隐藏期输出被丢弃 | renderPanes 常驻全部会话 + v-show |
+| 37 | **[审查轮]** store.write 字符串分支未编码 → 键盘输入完全失效 | TextEncoder 后 base64 |
+
+### 全链路审查（2026-09-18，P2 收官）
+
+探查代理 + 人工复核，确认并修复 7 项（另排除 2 项误报）：
+
+| # | 级别 | 问题 | 修复 |
+|---|---|---|---|
+| 1 | **P0** | `store.write` 字符串分支未 base64 编码——xterm 键盘输入/粘贴全部被后端拒绝，**终端无法打字**（坑 37） | TextEncoder 编码后再 base64 |
+| 2 | **P0** | 切标签卸载其他会话的 TerminalPane：xterm 缓冲丢失、隐藏期输出被丢弃（坑 36） | renderPanes 常驻全部会话 + v-show |
+| 3 | 高 | 连接期间关闭标签的竞态：do_connect 复活会话（Established 覆盖 Closed）、连接写进已拆除的池条目永不断开 | do_connect 三处 closed 检查点，命中则断开新连接并放弃 |
+| 4 | 高 | `closeTab` 分屏组误判：分屏激活时关后台标签会误关分屏组而非目标 | 仅当目标在分屏组内才按组关闭 |
+| 5 | 中 | SFTP 面板在 SSH 会话间切换不关旧通道（泄漏） | `<SftpPanel :key="sessionId">` 强制重建 |
+| 6 | 低 | HistoryPanel 防抖定时器卸载不清理 | onBeforeUnmount clearTimeout |
+| 7 | 低 | Alt+1..9 要求焦点在 `.xterm` 内（侧栏/对话框下失效） | 只在输入控件聚焦时让路 |
+
+已排除的误报：「兜底 watch 只看 sessions.length」（实际有 activeSessionId 有效性校验）等。
+
+**性能结论**：输出管线（8ms 聚合窗口 + base64 + 事件）与渲染（WebGL + 回退）无热点；
+面板常驻化后 xterm 实例数 = 会话数，WebGL 超限已有回退兜底。无需要改动的热路径。
+
+### ZMODEM 评估（已放弃）
+
+完整协议（帧结构 / CRC-16+32 / 转义编码 / 滑动窗口重同步 / 双向状态机）约 600–800 行，
+调试依赖真实 rz/sz 对端，无法用单测覆盖主流程。SFTP 已覆盖绝大多数文件传输场景，
+ZMODEM 剩余价值主要在串口/老旧嵌入式设备。成本收益不成立，正式放弃；
+若未来出现需求，建议独立一轮且优先做 sz 下载方向。
+
+### 验证汇总（收官状态）
+
+| 检查 | 结果 |
+|---|---|
+| `cargo check` | exit 0（警告数与 P0 基线一致） |
+| `cargo test --lib` | **91/91 通过**（keys 17 + commands 9 + assistant 6 + audit 5 + pool 5 + 既有 49） |
+| `vue-tsc --noEmit` | exit 0 |
+| 类型重名扫描 / 池引用计数 / 解析防御 | 单测覆盖 |
+
+### 待用户真机验证清单
+
+1. 终端键盘输入与粘贴（审查轮修复 #1——此前从未被测出）。
+2. 多标签切换不丢缓冲、隐藏期输出不丢（修复 #2）。
+3. 连接复用：同主机双标签秒连、关一个另一个不受影响、全关后连接断开。
+4. ProxyJump 跳板链、端口转发 -L/-R、`.ppk` 导入、会话模板拉起、AI 助手（需翻译引擎配置）。
+
+## 附：P1 新增命令清单（供前端对接与后续维护）
+
+| 命令 | 参数 | 返回 |
+|---|---|---|
+| `terminal_sftp_is_open` | `sessionId` | `bool` |
+| `terminal_sftp_open` | `sessionId` | `ActionOutcome`（幂等） |
+| `terminal_sftp_close` | `sessionId` | `()` |
+| `terminal_sftp_list` | `sessionId`, `path` | `RemoteDir` |
+| `terminal_sftp_parent` | `path` | `string` |
+| `terminal_sftp_read_link` | `sessionId`, `path` | `string` |
+| `terminal_sftp_mkdir` | `sessionId`, `path` | `()` |
+| `terminal_sftp_delete` | `sessionId`, `path`, `isDir` | `ActionOutcome` |
+| `terminal_sftp_rename` | `sessionId`, `from`, `to` | `()` |
+| `terminal_sftp_upload` | `sessionId`, `localPath`, `remotePath` | `ActionOutcome` |
+| `terminal_sftp_download` | `sessionId`, `remotePath`, `localPath` | `ActionOutcome` |
+| `terminal_session_cwd_value` | `sessionId` | `string` |
+| `terminal_open_local_path` | `path` | `()` |
+| `terminal_reveal_local_path` | `path` | `()` |
+| `terminal_list_snippets` | — | `SnippetView[]` |
+| `terminal_save_snippet` | `snippet` | `SnippetView[]` |
+| `terminal_delete_snippet` | `snippetId` | `SnippetView[]` |
+| `terminal_render_snippet` | `snippetId`, `values` | `string` |
+| `terminal_run_snippet` | `sessionId`, `snippetId`, `values`, `submit` | `ActionOutcome` |
+| `terminal_restore_default_snippets` | — | `SnippetView[]` |
+
+**新增事件**：`terminal-transfer-progress`（负载 `TransferProgress`，200ms 节流）。
+
+### 追加：P1 第四 / 第五批（字符编码 + 命令历史）
+
+| 命令 | 参数 | 返回 | 备注 |
+|---|---|---|---|
+| `terminal_set_encoding` | `sessionId`, `encoding` | `string` | 返回**后端 normalize 后的规范名**，前端须以此回写；内部已 emit `TERMINAL_STATE`，前端不要重复刷新 |
+| `terminal_history_query` | `query: HistoryQuery` | `HistoryPage` | `keyword` 短于 3 字符自动走 `LIKE` 回退（trigram 索引对 `ls`/`cd` 无效） |
+| `terminal_history_sources` | — | `HistorySource[]` | 只返回**有历史记录**的来源，不是全部主机列表 |
+| `terminal_history_toggle_favorite` | `id` | `bool` | 返回切换后的状态 |
+| `terminal_history_delete` | `id` | `ActionOutcome` | |
+| `terminal_history_clear` | `keepFavorites: Option<bool>` | `ActionOutcome` | 省略时默认 `true`（保留收藏）；`ActionOutcome` 带删除条数 |
+| `terminal_history_run` | `sessionId`, `command`, `submit: Option<bool>` | `ActionOutcome` | `submit` 省略即 `false`（只填入不执行）；命令内 `\r`/`\n` **折叠为空格** |
+
+**前端配套约定**
+
+- `SessionInfo.encoding` 是唯一编码事实源；状态栏下拉改值走 `terminal_set_encoding`，成功后回写 store 里的 `session.encoding`。
+- 输出侧解码在 `useXterm`（`decoderFor(encoding)` 缓存 `TextDecoder`）；**Rust 侧永不转码**，只发原始字节的 base64。
+- 输入侧重编码在 `SshSession::write`（本地会话不需要 —— Windows 控制台收的是 UTF-8，UTF-16 转换由 ConPTY 负责）。
+- 历史面板 `Ctrl+Shift+H`；单击**填入**、双击 / `Enter` **填入并执行**（默认不执行是刻意的取舍，理由见 §10.12）。

ThingHK/Contracts.cs

@@ -66,6 +66,8 @@ internal sealed class KernelStatus
 {
     public bool Ready { get; set; }
     public bool IsAdmin { get; set; }
+    /// <summary>PawnIO 驱动是否已安装（ring0 传感器读取依赖它或 WinRing0，缺失时温度/频率通常无法读取）</summary>
+    public bool PawnIoInstalled { get; set; }
     public double UptimeMs { get; set; }
     public int GroupCount { get; set; }
     public int SensorCount { get; set; }

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
+        // 首个快照带上冷启动耗时，后续为 0（修复：此前每个快照都携带 ColdStartMs）
-        if (_coldStartMs > 0 && snap.Timestamp > 0)
+        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 在当前权限或机型下检测不到对应硬件，
@@ -243,7 +277,7 @@ internal sealed class HardwareManager : IDisposable
         _ => "",
     };
 
-    private static bool IsRunningAsAdmin()
+    internal static bool IsRunningAsAdmin()
     {
         try
         {
@@ -290,14 +324,14 @@ internal sealed class SnapshotVisitor : IVisitor
 }
 
 /// <summary>
-/// 采样调度器：按快/慢通道分频驱动 HardwareManager.UpdateAll。
+/// 采样调度器：按快/慢通道分频驱动 HardwareManager 的分层 Update。
 /// 使用 Channel 向 SSE 推送层广播快照（解耦：调度器不关心有几个订阅者）。
 ///
 /// 调度策略：
-/// - 快通道 tick：UpdateAll（含慢通道硬件，因 UpdateAll 成本主要在 SMART，已通过慢通道分频减少调用频率）
+/// - 快通道 tick：UpdateFastOnly（仅 CPU/GPU/Memory/Network 等轻量硬件），
-///   实际优化：快通道 tick 只 Update 快通道硬件（UpdateFastOnly），慢通道单独按慢节奏 Update
+///   避免 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);

ThingHK/HttpEndpoints.cs

@@ -44,6 +44,7 @@ internal static class HttpEndpoints
             {
                 Ready = hw?.Ready ?? false,
                 IsAdmin = hw?.IsAdmin ?? false,
+                PawnIoInstalled = PawnIoSupport.IsServiceInstalled(),
                 UptimeMs = kernel.Uptime.Elapsed.TotalMilliseconds,
                 GroupCount = snap?.Groups.Count ?? 0,
                 SensorCount = kernel.Scheduler.Cache.SensorCount,

ThingHK/PawnIoSupport.cs

@@ -0,0 +1,101 @@
+using System.Diagnostics;
+using Microsoft.Win32;
+
+namespace ThingHK;
+
+/// <summary>
+/// PawnIO 驱动支持：检测 + 静默安装。
+///
+/// 背景：LHM 读取 CPU 温度/频率等 ring0 数据依赖内核驱动，回退用的 WinRing0 被
+/// 微软"易受攻击的驱动程序阻止列表"和部分杀软（如火绒）拦截，导致传感器缺失。
+/// PawnIO 是正规签名的替代驱动（不在阻止列表、兼容 HVCI/安全启动），
+/// LHM 0.9.5+ 检测到已安装时优先使用，无需任何代码开关。
+///
+/// 安装器约定：PawnIO_setup.exe 与 ThingHK.exe 同目录
+/// （由 Tauri 侧 prepare_kernel 从资源目录随内核一起复制到 {app_data}/monitor/cores/）。
+///
+/// 静默参数：-install -silent（官方 CLI 参数，见 namazso/PawnIO.Setup）。
+/// 退出码：0=成功；3010=成功但需重启（ERROR_SUCCESS_REBOOT_REQUIRED）。
+///
+/// 策略：仅在内核已提权时安装。两种提权模式（Thing 提权继承 / 仅提权 ThingHK）
+/// 都只有一次 UAC，内核拿到权限后自行静默安装，避免二次弹窗。
+/// serve 模式调用；scan 诊断模式不安装，保持被动。
+/// </summary>
+internal static class PawnIoSupport
+{
+    /// <summary>驱动服务注册表键：存在即认为已安装</summary>
+    private const string ServiceKeyName = @"SYSTEM\CurrentControlSet\Services\PawnIO";
+
+    private const string SetupFileName = "PawnIO_setup.exe";
+
+    /// <summary>3010 = ERROR_SUCCESS_REBOOT_REQUIRED（安装成功但需重启生效）</summary>
+    private const int ExitCodeRebootRequired = 3010;
+
+    /// <summary>驱动安装通常数秒内完成，留足余量防止卡死启动流程</summary>
+    private const int InstallTimeoutMs = 90_000;
+
+    /// <summary>检测 PawnIO 驱动服务是否已注册</summary>
+    public static bool IsServiceInstalled()
+    {
+        try
+        {
+            using var key = Registry.LocalMachine.OpenSubKey(ServiceKeyName);
+            return key != null;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 确保 PawnIO 就绪：已安装直接返回；未安装且当前已提权时静默安装。
+    /// 返回描述性结果（写入 stderr 日志 + /status 诊断）。
+    /// </summary>
+    public static string EnsureInstalled()
+    {
+        if (IsServiceInstalled())
+            return "already-installed";
+
+        if (!HardwareManager.IsRunningAsAdmin())
+            return "skipped: not elevated (温度/频率等传感器需要提权运行)";
+
+        string setupPath = Path.Combine(AppContext.BaseDirectory, SetupFileName);
+        if (!File.Exists(setupPath))
+            return $"skipped: {SetupFileName} 未找到（应随内核一起部署，见 prepare_kernel）";
+
+        try
+        {
+            using var process = Process.Start(new ProcessStartInfo
+            {
+                FileName = setupPath,
+                Arguments = "-install -silent",
+                UseShellExecute = false,
+                CreateNoWindow = true,
+            });
+            if (process == null)
+                return "failed: Process.Start 返回 null";
+
+            if (!process.WaitForExit(InstallTimeoutMs))
+            {
+                try { process.Kill(); } catch { /* 超时后进程可能已自行退出 */ }
+                return "failed: 安装超时";
+            }
+
+            int code = process.ExitCode;
+            if (code == ExitCodeRebootRequired)
+                return "installed: 需重启后生效";
+
+            if (code != 0)
+                return $"failed: 安装器退出码 {code}";
+
+            return IsServiceInstalled()
+                ? "installed"
+                : "failed: 安装器返回 0 但服务未注册";
+        }
+        catch (Exception ex)
+        {
+            return $"failed: {ex.Message}";
+        }
+    }
+}

ThingHK/Program.cs

@@ -87,6 +87,11 @@ internal static class Program
 
         Console.Error.WriteLine($"[ThingHK] serve 模式: port={port} config={configPath ?? "(默认)"} fast={fastMs}ms slow={slowMs}ms");
 
+        // PawnIO：ring0 传感器读取的首选驱动（未安装且已提权时静默安装，
+        // 避开 WinRing0 被系统阻止列表/杀软拦截导致的温度/频率缺失）
+        string pawnIoResult = PawnIoSupport.EnsureInstalled();
+        Console.Error.WriteLine($"[ThingHK] PawnIO: {pawnIoResult}");
+
         using var kernel = new KernelHost();
         await kernel.StartAsync(configPath, fastMs, slowMs);
 

ThingHK/ThingHK.csproj

@@ -25,7 +25,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.7-pre716" />
+    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.7-pre729" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
   </ItemGroup>
 

bun.lock

@@ -16,6 +16,7 @@
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "pinia": "^3.0.4",
+        "pinyin-pro": "^3.28.2",
         "reka-ui": "^2.10.1",
         "tailwind-merge": "^3.6.0",
         "tailwindcss": "^4.3.2",
@@ -381,6 +382,8 @@
 
     "pinia": ["pinia@3.0.4", "https://registry.npmmirror.com/pinia/-/pinia-3.0.4.tgz", { "dependencies": { "@vue/devtools-api": "^7.7.7" }, "peerDependencies": { "typescript": ">=4.5.0", "vue": "^3.5.11" }, "optionalPeers": ["typescript"] }, "sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw=="],
 
+    "pinyin-pro": ["pinyin-pro@3.29.4", "https://registry.npmmirror.com/pinyin-pro/-/pinyin-pro-3.29.4.tgz", {}, "sha512-SPXpDT2cHEy+d26V1RXYMlVzXN42hotFAak1fzyWPi4o2dKXb61UqD4pzxDJHwk6gbv8vQ6EfErd+hYX0Qhzug=="],
+
     "postcss": ["postcss@8.5.19", "https://registry.npmmirror.com/postcss/-/postcss-8.5.19.tgz", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-Mz8SaolMd8nB+G13WkORcxQKHZ/NE4xXevtkJHVuG+guo9/wYKlIMTKAqGdEmYOXR2ijPjTYNHssizdaVSUNdQ=="],
 
     "reka-ui": ["reka-ui@2.10.1", "https://registry.npmmirror.com/reka-ui/-/reka-ui-2.10.1.tgz", { "dependencies": { "@floating-ui/dom": "^1.6.13", "@floating-ui/vue": "^1.1.6", "@internationalized/date": "^3.5.0", "@internationalized/number": "^3.5.0", "@tanstack/vue-virtual": "^3.12.0", "@vueuse/core": "^14.1.0", "@vueuse/shared": "^14.1.0", "aria-hidden": "^1.2.4", "defu": "^6.1.5", "ohash": "^2.0.11" }, "peerDependencies": { "vue": ">= 3.4.0" } }, "sha512-drcOQ4rQtDYAcGCsyQBqQg8QQ+H3B+zDaMJU0h8KPEPMa7g9BHu3zcOi4OB39XJSWizceFoNO0Z9tctSGLOXqg=="],

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "thing",
-  "version": "0.1.0",
+  "version": "26.9.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "thing",
-      "version": "0.1.0",
+      "version": "26.9.3",
       "dependencies": {
         "@lucide/vue": "^1.28.0",
         "@tailwindcss/vite": "^4.3.2",
@@ -16,6 +16,13 @@
         "@tauri-apps/plugin-global-shortcut": "^2",
         "@tauri-apps/plugin-opener": "^2",
         "@vueuse/core": "^14.4.0",
+        "@xterm/addon-fit": "^0.11.0",
+        "@xterm/addon-search": "^0.16.0",
+        "@xterm/addon-serialize": "^0.14.0",
+        "@xterm/addon-unicode11": "^0.9.0",
+        "@xterm/addon-web-links": "^0.12.0",
+        "@xterm/addon-webgl": "^0.19.0",
+        "@xterm/xterm": "^6.0.0",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "pinia": "^3.0.4",
@@ -1719,6 +1726,51 @@
         "vue": "^3.5.0"
       }
     },
+    "node_modules/@xterm/addon-fit": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/addon-fit/-/addon-fit-0.11.0.tgz",
+      "integrity": "sha512-jYcgT6xtVYhnhgxh3QgYDnnNMYTcf8ElbxxFzX0IZo+vabQqSPAjC3c1wJrKB5E19VwQei89QCiZZP86DCPF7g==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/addon-search": {
+      "version": "0.16.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/addon-search/-/addon-search-0.16.0.tgz",
+      "integrity": "sha512-9OeuBFu0/uZJPu+9AHKY6g/w0Czyb/Ut0A5t79I4ULoU4IfU5BEpPFVGQxP4zTTMdfZEYkVIRYbHBX1xWwjeSA==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/addon-serialize": {
+      "version": "0.14.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/addon-serialize/-/addon-serialize-0.14.0.tgz",
+      "integrity": "sha512-uteyTU1EkrQa2Ux6P/uFl2fzmXI46jy5uoQMKEOM0fKTyiW7cSn0WrFenHm5vO5uEXX/GpwW/FgILvv3r0WbkA==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/addon-unicode11": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/addon-unicode11/-/addon-unicode11-0.9.0.tgz",
+      "integrity": "sha512-FxDnYcyuXhNl+XSqGZL/t0U9eiNb/q3EWT5rYkQT/zuig8Gz/VagnQANKHdDWFM2lTMk9ly0EFQxxxtZUoRetw==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/addon-web-links": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/addon-web-links/-/addon-web-links-0.12.0.tgz",
+      "integrity": "sha512-4Smom3RPyVp7ZMYOYDoC/9eGJJJqYhnPLGGqJ6wOBfB8VxPViJNSKdgRYb8NpaM6YSelEKbA2SStD7lGyqaobw==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/addon-webgl": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/addon-webgl/-/addon-webgl-0.19.0.tgz",
+      "integrity": "sha512-b3fMOsyLVuCeNJWxolACEUED0vm7qC0cy4wRvf3oURSzDTYVQiGPhTnhWZwIHdvC48Y+oLhvYXnY4XDXPoJo6A==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/xterm": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmmirror.com/@xterm/xterm/-/xterm-6.0.0.tgz",
+      "integrity": "sha512-TQwDdQGtwwDt+2cgKDLn0IRaSxYu1tSUjgKarSDkUM0ZNiSRXFpjxEsvc/Zgc5kq5omJ+V0a8/kIM2WD3sMOYg==",
+      "license": "MIT",
+      "workspaces": [
+        "addons/*"
+      ]
+    },
     "node_modules/alien-signals": {
       "version": "1.0.13",
       "dev": true,

package.json

@@ -1,11 +1,13 @@
 {
   "name": "thing",
   "private": true,
-  "version": "26.8.1",
+  "version": "26.9.3",
   "type": "module",
   "scripts": {
     "dev": "vite",
-    "build": "vue-tsc --noEmit && vite build",
+    "build": "vue-tsc --noEmit && node --max-old-space-size=8192 node_modules/vite/bin/vite.js build",
+    "build:vite": "node --max-old-space-size=8192 node_modules/vite/bin/vite.js build",
+    "typecheck": "vue-tsc --noEmit",
     "preview": "vite preview",
     "test": "node --test src/modules/quickpanel/engine.test.ts src/lib/calc.test.ts",
     "tauri": "tauri"
@@ -19,6 +21,13 @@
     "@tauri-apps/plugin-global-shortcut": "^2",
     "@tauri-apps/plugin-opener": "^2",
     "@vueuse/core": "^14.4.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-search": "^0.16.0",
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/addon-unicode11": "^0.9.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/xterm": "^6.0.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "pinia": "^3.0.4",

scripts/release.ps1

@@ -54,17 +54,18 @@ $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
+# UTF-8 安全读写：`Get-Content` 默认按系统 ANSI(如 GBK) 解码，会把本就含中文/乱码的文件二次编码损坏（曾导致
-$t = $t -replace '("version"\s*:\s*")[^"]*(")', "`${1}$Version`${2}"
+# Cargo.toml 的 keyring 依赖行被弄丢）。这里统一用显式 UTF-8 无 BOM 读写，保证逐字节稳定往返。
-[System.IO.File]::WriteAllText($tauriConf, $t, (New-Object System.Text.UTF8Encoding($false)))
+function Set-Utf8Version([string]$Path, [string]$Pattern, [string]$NewVersion) {
+  $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
+  $content = [System.IO.File]::ReadAllText($Path, $utf8NoBom)
+  $content = $content -replace $Pattern, "`${1}$NewVersion`${2}"
+  [System.IO.File]::WriteAllText($Path, $content, $utf8NoBom)
+}
 
-$c = Get-Content $cargoToml -Raw
+Set-Utf8Version -Path $tauriConf -Pattern '("version"\s*:\s*")[^"]*(")' -NewVersion $Version
-$c = $c -replace '(?m)^(version\s*=\s*")[^"]*(")', "`${1}$Version`${2}"
+Set-Utf8Version -Path $cargoToml -Pattern '(?m)^(version\s*=\s*")[^"]*(")' -NewVersion $Version
-[System.IO.File]::WriteAllText($cargoToml, $c, (New-Object System.Text.UTF8Encoding($false)))
+Set-Utf8Version -Path $pkgJson   -Pattern '("version"\s*:\s*")[^"]*(")' -NewVersion $Version
-
-$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. 构建 ----------

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "thing"
-version = "26.8.1"
+version = "26.9.3"
 description = "A Tauri App"
 authors = ["you"]
 edition = "2021"
@@ -24,6 +24,9 @@ tauri-plugin-dialog = "2"
 tauri-plugin-snap-layout = "1"
 tauri-plugin-global-shortcut = "2"
 tauri-plugin-notification = "2"
+# 翻译引擎抽象：TranslateEngine 需要 Box<dyn> 动态分派（多源在运行期决定），
+# 原生 async fn in trait 在 dyn 场景下不可用
+async-trait = "0.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 regex = "1"
@@ -32,31 +35,95 @@ specta = { version = "=2.0.0-rc.25", features = ["derive", "function", "serde_js
 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"] }
+reqwest = { version = "0.12", features = ["json", "stream", "multipart"] }
 futures-util = "0.3"
 tokio = { version = "1", features = ["io-util", "time", "rt-multi-thread", "macros", "sync", "fs", "net"] }
 axum = "0.7"
 url = "2"
 zip = "2"
 dirs = "5"
+# ===== 终端模块 =====
+# 字符编码转换：老服务器（CentOS 6/7 默认 LANG=zh_CN.GBK）输出 GBK 字节，
+# 直接按 UTF-8 解码会得到乱码。encoding_rs 是 Firefox 的实现抽出，比 iconv 绑定
+# 干净（纯 Rust、无 C 依赖），且本项目依赖树里已存在（reqwest → encoding_rs 0.8.35），
+# 提升为直接依赖不会新增编译单元。
+encoding_rs = "0.8"
+# SSH 客户端：纯 Rust + 原生 async，与项目 tokio 运行时契合。
+# 选 russh 而非 ssh2（libssh2 绑定）的理由见 terminal/ssh/mod.rs 模块注释。
+# 注意：实施时核实该 crate 已到 0.63.x（规划文档中的 0.5 已过时）。
+russh = "0.63"
+# SSH 密钥的生成/解析/加密统一走 `russh::keys::ssh_key` re-export。
+#
+# **不要**声明与 russh 钉住版本不同的 `ssh-key`——若声明 0.6 会引入第二个不兼容
+# 版本，两边的 PrivateKey/PublicKey 无法互转（这是 P0 踩过的坑）。
+#
+# 唯一的例外是下面这一行：必须声明**完全相同**的版本号 `=0.7.0-rc.11`。
+# 原因是 russh 的 `[features]` **没有向 ssh-key 转发 `ppk`**
+# （只有 dsa / rsa / serde 三个转发项），而 P2 要支持 PuTTY `.ppk` 导入，
+# 只能由我们自己打开 `ssh-key/ppk`。
+#
+# Cargo 会把「russh 的 `=0.7.0-rc.11`」与「这里的 `=0.7.0-rc.11`」**合并为同一个
+# 依赖节点**（版本要求完全相同，不存在二选一），因此不会产生分叉。
+# 已用 `cargo tree -i ssh-key` 复核：图中只有 `ssh-key v0.7.0-rc.11` 一个节点。
+#
+# 注意：改这里之后必须重跑 `cargo tree -i ssh-key` 确认仍只有一个节点。
+ssh-key = { version = "=0.7.0-rc.11", default-features = false, features = ["ppk", "encryption", "alloc"] }
+
+# 系统随机源：ssh-key 0.7 的 `getrandom` feature 默认**未启用**（russh 没开，
+# 我们上面的 ssh-key 声明也没开），故 `ssh_key::getrandom::SysRng` 不可见。
+# 这里直接依赖 getrandom 0.4 ——它与 ssh-key 共用同一份 `rand_core 0.10`，
+# `UnwrapErr(SysRng)` 能直接满足 ssh-key 的 `CryptoRng`/`TryCryptoRng` 约束
+# （见 terminal/keys.rs 的 sys_rng）。
+getrandom = "0.4"
+# SFTP 客户端。**russh 本身不含 SFTP**——只是一个 SSH 传输层，SFTP 协议
+# （OPEN/READ/WRITE/READDIR 等报文）由独立的 russh-sftp 实现。
+# 版本配套：russh-sftp 3.0.0 的依赖是 `russh ^0.63.2`，与上面的 0.63 同源，
+# 共用同一份 russh 实例类型 —— 这一点关键：SFTP 通道必须从**已认证的同一个
+# Session** 上开（`request_subsystem(true, "sftp")`），跨版本是做不到的。
+# 另注：3.0.0 把 `russh` 列为 dev-dependency，故不会重复引入第二个 russh。
+russh-sftp = "3.0"
+# ConPTY 之外还需要窗口/进程相关 API；Win32_System_Console 为 CreatePseudoConsole 所在 feature
+# 终端会话并发注册表：读多写少（每次输出批次都查表），分片锁避免各会话 I/O 互相等待
+dashmap = "6"
+# 音频标签解析（本地曲库元数据：标题/歌手/专辑/时长/内嵌封面）
+lofty = "0.22"
 sysinfo = "0.32"
 rusqlite = { version = "0.32", features = ["bundled"] }
 base64 = "0.22"
+sha2 = "0.10"
+md-5 = "0.10"
+hmac = "0.12"
+aes = "0.8"
+cbc = "0.1"
+rsa = { version = "0.9", features = ["pem"] }
+rand = "0.8"
+tokio-tungstenite = "0.24"
 image = { version = "0.25", default-features = false, features = ["png"] }
 walkdir = "2"
 notify = { version = "6", features = [] }
+librqbit = "9"
+bytes = "1"
+windows-capture = "2.0.1"
+# HDR 截图说明：windows-capture 的 Windows Graphics Capture 后端在 HDR 显示器上
+# 可能输出 scRGB / rgba16F 或 HDR10(PQ) 格式的帧，与项目其余截图路径
+# （GDI BitBlt，sRGB 8bit）色彩空间不一致。capture 层统一转成 sRGB 8bit
+# 后再交给编码器，否则 HDR 屏上截出的图会整体偏灰 / 过曝。
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.52"
+# WebDAV 凭据加密存储（Windows 凭据管理器，DPAPI 保护）
+keyring = { version = "3", features = ["windows-native"] }
 raw-window-handle = "0.6"
 windows-sys = { version = "0.52", features = [
     "Win32_Networking_WinInet",
     "Win32_Foundation",
+    "Win32_Globalization",
     "Win32_Security",
     "Win32_System_Threading",
     "Win32_System_Ole",
     "Win32_System_Memory",
     "Win32_System_DataExchange",
+    "Win32_System_SystemInformation",
     "Win32_UI_WindowsAndMessaging",
     "Win32_UI_Shell",
     "Win32_UI_HiDpi",
@@ -65,8 +132,18 @@ windows-sys = { version = "0.52", features = [
     "Win32_Graphics_Dwm",
     "Win32_Storage_Xps",
     "Win32_Storage_FileSystem",
+    "Win32_Devices_Display",
+    # 终端模块：ConPTY（CreatePseudoConsole / ResizePseudoConsole / ClosePseudoConsole）
+    "Win32_System_Console",
+    # 终端模块：CreatePipe（ConPTY 的输入/输出管道）
+    "Win32_System_Pipes",
+    # 终端模块：ReadFile / CancelIoEx / GetOverlappedResult（ConPTY 输出读取）
+    # 注意：0.52 起 ReadFile 定义在 Storage_FileSystem 但被 Win32_System_IO 特性门控，
+    # 两个特性必须同时开启，否则导入会解析失败。
+    "Win32_System_IO",
 ] }
-# Explorer 前台目录检测（IShellWindows COM）：仅引入用到的 feature，控制编译体积
+# Explorer ShellWindows COM：用于枚举已打开的资源管理器窗口并取当前路径
+# （快速面板「用资源管理器打开」联动）。依赖 Win32_System_Com 特性。
 windows = { version = "0.52", features = [
     "Win32_Foundation",
     "Win32_System_Com",
@@ -74,8 +151,46 @@ windows = { version = "0.52", features = [
     "Win32_System_Variant",
     "Win32_UI_Shell",
     "Win32_UI_WindowsAndMessaging",
+    # 翻译模块：Windows.Media.Ocr 本地识别（WinRT）
+    # Foundation_Collections：OcrResult.Lines / OcrEngine.AvailableRecognizerLanguages 返回 IVectorView
+    # Security_Cryptography：用 CryptographicBuffer 从内存字节构造 IBuffer（不落盘）
+    "Foundation",
+    "Foundation_Collections",
+    "Globalization",
+    "Graphics_Imaging",
+    "Media_Ocr",
+    "Security_Cryptography",
+    # 划词取词的智能路径：UIA 直读焦点元素选区（IUIAutomation / ITextProvider）
+    "Win32_UI_Accessibility",
+    "Storage_Streams",
+    # HDR 探测：DXGI 的 advanced color 查询用于判断显示器是否处于 HDR / WCG 状态，
+    # 并读取其色域与传递函数（G2084/PQ 表示 HDR10）。截图前据此决定是否做色调映射。
+    # 对应 feature：Win32_Graphics_Dxgi / Win32_Graphics_Dxgi_Common。
+    "Win32_Graphics_Dxgi_Common",
+    "Win32_Graphics_Gdi",
 ] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-autostart = "2"
 
+# ===== 编译配置 =====
+# dev profile：日常 `tauri dev` 的取舍。
+# - incremental = true：增量编译，改一行代码只需重编受影响的 crate
+# - debug = "line-tables-only"：只保留行号表，去掉完整 DWARF，交付期
+#   target/ 目录因此从数 GB 降到数百 MB，而 panic 回溯仍能定位到源码行。
+# 注意：这里没开 opt-level。依赖 crate（尤其 tauri/wry/windows-sys）
+# 在 opt-level=0 下开销明显；若 dev 下界面卡顿，可只给依赖提优化。
+
+[profile.dev]
+incremental = true
+debug = "line-tables-only"
+
+# release profile：交付构建。
+# - strip = true：剥离符号信息，显著缩小产物体积
+# - lto = true：全程序链接时优化，跨 crate 内联，通常带来 10~20% 性能提升，
+#   代价是链接时间从秒级升到分钟级。只在 release 构建付出这个代价。
+# 未开 codegen-units=1：会再压榨约 5% 性能，但编译时间翻倍，不值得。
+[profile.release]
+strip = true
+lto = true
+

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/download-window.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "download-window",
+  "description": "Capability for the per-download one-time window",
+  "windows": ["download-window-*"],
+  "permissions": [
+    "core:default",
+    "core:window:allow-hide",
+    "core:window:allow-show",
+    "core:window:allow-set-focus",
+    "core:window:allow-minimize",
+    "core:window:allow-unminimize",
+    "core:window:allow-set-title",
+    "core:window:allow-set-size",
+    "core:window:allow-start-dragging",
+    "core:window:allow-set-always-on-top",
+    "core:window:allow-set-skip-taskbar",
+    "core:window:allow-set-theme",
+    "core:window:allow-set-effects",
+    "core:window:allow-set-background-color",
+    "core:window:allow-close",
+    "core:event:allow-emit",
+    "core:event:allow-listen",
+    "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, editor and pin windows",
+  "description": "Capability for screenshot overlay, editor, pin and scroll-control windows",
-  "windows": ["screenshot-overlay*", "screenshot-editor-*", "screenshot-pin"],
+  "windows": ["screenshot-overlay*", "screenshot-editor*", "screenshot-pin", "screenshot-scroll-*"],
   "permissions": [
     "core:default",
     "core:window:allow-hide",
@@ -18,6 +18,7 @@
     "core:window:allow-close",
     "core:event:allow-emit",
     "core:event:allow-listen",
+    "core:webview:allow-create-webview-window",
     "dialog:default",
     "snap-layout:default"
   ]

src-tauri/capabilities/terminal-window.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "terminal-window",
+  "description": "Capability for detached terminal windows (one session per window, label = terminal-window-<sessionId>)",
+  "windows": ["terminal-window-*"],
+  "permissions": [
+    "core:default",
+    "core:window:allow-close",
+    "core:window:allow-minimize",
+    "core:window:allow-maximize",
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-set-focus",
+    "core:window:allow-start-dragging",
+    "core:window:allow-set-theme",
+    "core:window:allow-set-background-color",
+    "core:event:allow-listen",
+    "core:event:allow-emit",
+    "opener:default",
+    "opener:allow-open-path",
+    "opener:allow-reveal-item-in-dir",
+    "snap-layout:default"
+  ]
+}

src-tauri/capabilities/translate-popup.json

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

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

@@ -358,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
@@ -373,27 +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)
+    const start = item.startTime ? new Date(item.startTime).getTime() : 0
-    await chrome.downloads.erase({ id: downloadItem.id })
+    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 {
-    await addDownload(url, filename, downloadItem.referrer, '')
+    const tasks = await apiRequest('/api/downloads')
-  } catch (e) {
+    return tasks.some(t => {
-    // 添加失败：回退到浏览器自带下载，不弹通知
+      const s = t.status
-    try { await chrome.downloads.download({ url }) } catch { /* ignore */ }
+      if (s === 'complete' || s === 'error') return false
+      return t.url === url
+    })
+  } catch {
+    return false
   }
 }
 
-// ===== 右键菜单 =====
+async function handleDownloadCreated(downloadItem) {
-chrome.runtime.onInstalled.addListener(() => {
+  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 {
+    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(async (details) => {
+  // 记录首次安装时间：用于区分"安装前的历史下载"（被浏览器恢复的旧下载）与"安装后的新下载"
+  if (details.reason === 'install') {
+    await chrome.storage.local.set({ installTime: Date.now() })
+  }
   chrome.contextMenus.create({
     id: 'thing-download-link',
     title: '使用 Thing 下载此链接',

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",

src-tauri/src/clipboard/commands.rs

@@ -7,7 +7,7 @@ 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, Type)]
@@ -95,6 +95,21 @@ pub async fn clipboard_get_item(
         .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(
@@ -162,25 +177,44 @@ pub async fn clipboard_save_settings(
     app: AppHandle,
     manager: State<'_, ClipboardManager>,
 ) -> Result<(), String> {
-    let prev_enabled = manager.get_settings().enabled;
+    let prev = manager.get_settings();
-    let prev_shortcut = manager.get_settings().shortcut.clone();
+    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 {
+    // 快捷键改为空字符串（禁用）：注销旧快捷键
-        crate::shortcut::register_shortcut(&app, "剪贴板", &settings.shortcut, |a| {
+    if settings.shortcut.trim().is_empty() && settings.shortcut != prev_shortcut {
-            super::popup::show_popup(a)
+        crate::shortcut::unregister_shortcut(&app, "剪贴板");
-        })?;
-        // 新快捷键非空时确保弹窗窗口已预创建
-        if !settings.shortcut.trim().is_empty() {
-            super::popup::ensure_popup_window(&app);
-        }
     }
+
     Ok(())
 }
 
@@ -262,3 +296,52 @@ 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

@@ -12,6 +12,8 @@ use specta::Type;
 use super::monitor::start_monitor;
 use super::reader::{write_dib, write_files, write_text};
 use super::storage::Storage;
+use super::suppress::SuppressState;
+use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber;
 
 /// 剪贴板设置（持久化到 clipboard/settings.json）
 #[derive(Clone, Serialize, Deserialize, Type)]
@@ -55,7 +57,9 @@ impl Default for ClipboardSettings {
 pub struct ClipboardManager {
     storage: Arc<Storage>,
     settings: Arc<Mutex<ClipboardSettings>>,
-    suppress: Arc<AtomicBool>,
+    /// 写入抑制状态。由本模块持有（谁启动监听谁负责），但**对其他模块开放**：
+    /// 划词取词会连续改三次剪贴板，同样需要屏蔽，见 `super::suppress`。
+    suppress: Arc<SuppressState>,
     monitor_stop: Arc<AtomicBool>,
     monitor_handle: Mutex<Option<JoinHandle<()>>>,
     settings_path: PathBuf,
@@ -73,7 +77,7 @@ impl ClipboardManager {
         };
         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(SuppressState::new());
         let monitor_stop = Arc::new(AtomicBool::new(true));
         Self {
             storage,
@@ -139,13 +143,12 @@ impl ClipboardManager {
         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),
@@ -163,10 +166,12 @@ impl ClipboardManager {
             _ => false,
         };
         if ok {
+            // 绑定到写入完成后的剪贴板序列号：仅跳过本次写入产生的记录，
+            // 用户后续复制（序列号不同）不会被误吞。
+            let seq = unsafe { GetClipboardSequenceNumber() };
+            self.suppress.mark_seq(seq);
             Ok(())
         } else {
-            // 写入失败也清除 suppress，避免误吞下次复制
-            self.suppress.store(false, Ordering::SeqCst);
             Err("写回剪贴板失败".into())
         }
     }
@@ -174,6 +179,20 @@ impl ClipboardManager {
     pub fn storage(&self) -> &Arc<Storage> {
         &self.storage
     }
+
+    /// 写入抑制状态（供划词取词等会改剪贴板的其他模块共享）
+    pub fn suppress(&self) -> Arc<SuppressState> {
+        self.suppress.clone()
+    }
+
+    /// 把**当前**剪贴板序列号登记为「应跳过」。
+    ///
+    /// 给其他模块写完剪贴板后调用：它们自己拿不到「写入后」的序列号，
+    /// 但知道「刚刚写完」这件事。把 win32 调用留在这个模块里，
+    /// 别处就不必重复引入 DataExchange。
+    pub fn suppress_current_sequence(&self) {
+        self.suppress.mark_seq(unsafe { GetClipboardSequenceNumber() });
+    }
 }
 
 impl Drop for ClipboardManager {

src-tauri/src/clipboard/mod.rs

@@ -6,12 +6,16 @@ pub mod monitor;
 pub mod popup;
 pub mod reader;
 pub mod storage;
+pub mod suppress;
 
 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_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_get_thumb,
-    clipboard_paste_to_target, clipboard_register_shortcut, clipboard_save_settings, clipboard_search,
+    clipboard_hide_popup, clipboard_hide_preview, clipboard_paste_to_target,
-    clipboard_set_pinned, clipboard_show_popup, clipboard_show_window, clipboard_start,
+    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};
@@ -12,21 +12,24 @@ use tauri::{AppHandle, Emitter};
 
 use super::reader::{read_clipboard, ClipData};
 use super::storage::{NewItem, Storage};
+use super::suppress::SuppressState;
 use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber;
 
 /// 启动监听线程，返回 JoinHandle。
+/// `suppress` 记录本应用写入剪贴板产生的序列号、以及取词等流程的屏蔽窗口，
+/// 用于跳过自身写入产生的记录。
 pub fn start_monitor(
     storage: Arc<Storage>,
     app: AppHandle,
     settings: Arc<Mutex<super::manager::ClipboardSettings>>,
-    suppress: Arc<AtomicBool>,
+    suppress: Arc<SuppressState>,
     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,9 +43,9 @@ pub fn start_monitor(
         if seq == last {
             continue;
         }
-        // 序列号变化，处理一次
+        // 序列号变化，但可能来自本应用：精确记账（copy_back）或屏蔽窗口内（取词流程）。
-        if suppress.swap(false, Ordering::SeqCst) {
+        // 判定放在读剪贴板之前，避免为一次注定要丢弃的变化做无谓的读取与解码。
-            // 由本应用 copy_back 触发，跳过记录
+        if suppress.should_skip(seq) {
             continue;
         }
         let (rec_text, rec_image, rec_files, max_items, max_image_kb, dedup) = {
@@ -99,6 +102,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 +114,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 +137,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,12 +10,27 @@
 
 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};
 
 /// 弹窗窗口标签
 pub const POPUP_LABEL: &str = "clipboard-popup";
 
+/// 预览窗口标签（悬停/键盘选中条目时在弹窗旁显示内容）
+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);
@@ -24,6 +39,50 @@ static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
 /// 避免窗口重建后仍停留在屏幕外 (-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);
+}
+
+/// 判断距上次 show 是否仍在宽限期内（是则忽略失焦自动隐藏）。
+fn within_show_grace() -> bool {
+    LAST_SHOWN
+        .lock()
+        .ok()
+        .and_then(|t| *t)
+        .map(|t| t.elapsed() < SHOW_GRACE)
+        .unwrap_or(false)
+}
+
 /// 创建弹窗窗口（隐藏状态）并注册失焦监听。
 /// 位置默认在屏幕外，show_popup 时会重新定位。
 /// 预创建后首次按快捷键走"窗口已存在"分支直接 show，避免首次创建的时序问题。
@@ -54,13 +113,41 @@ fn create_popup_window(app: &AppHandle) {
         }
     };
 
-    // 监听窗口失焦：自动隐藏
+    // 监听窗口失焦：自动隐藏（同时隐藏预览窗）
     let app_handle = app.clone();
     let win_handle = win.clone();
     win.on_window_event(move |event| {
-        if let tauri::WindowEvent::Focused(false) = event {
+        match event {
-            let _ = win_handle.hide();
+            tauri::WindowEvent::Focused(false) => {
-            let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ());
+                // 失焦宽限期：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);
+            }
+            _ => {}
         }
     });
 
@@ -112,6 +199,7 @@ pub fn show_popup(app: &AppHandle) {
             y: y as i32,
         }));
         let _ = win.show();
+        mark_shown();
         let _ = win.set_focus();
         // 通知前端刷新数据
         let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
@@ -143,17 +231,27 @@ pub fn show_window(app: &AppHandle) {
             }));
         }
         let _ = win.show();
+        mark_shown();
         let _ = win.set_focus();
         // 通知前端刷新数据
         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 粘贴到之前聚焦的窗口。
@@ -207,6 +305,434 @@ fn simulate_paste() {
     // 非 Windows 平台暂不支持自动粘贴
 }
 
+// ===== 独立预览窗口 =====
+
+/// 创建预览窗口（隐藏状态），应用 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;
+        }
+    };
+
+    // 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),
+    };
+
+    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);
+        }
+    }
+
+    // 通知前端加载条目内容（前端完成后自行 resize + reveal）
+    let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_SHOW, id);
+}
+
+/// 显示已就绪的预览窗口（前端完成内容加载与 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();
+    }
+}
+
+/// 按内容自适应调整预览窗大小（逻辑像素），位置沿用当前所在侧并重新对齐弹窗。
+/// 前端加载/切换内容（文本测高、图片按宽高比）后调用，窗口贴合内容消除留白。
+/// 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 }));
+}
+
+/// 交互锁定模式入口：前端预览窗收到 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,6 +2,7 @@
 //!
 //! 表结构见 `init_db`。所有方法线程安全（内部 Mutex 包裹 Connection）。
 
+use base64::Engine as _;
 use rusqlite::{params, Connection, OptionalExtension};
 use specta::Type;
 use std::fs;
@@ -38,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,
@@ -88,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。
@@ -120,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)
+                (kind, content, blob, thumb, preview, size, hash, pinned, pinned_order, created_at)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, 0, NULL, ?7)",
+             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,
@@ -249,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()?;

src-tauri/src/clipboard/suppress.rs

@@ -0,0 +1,142 @@
+//! 剪贴板写入抑制。
+//!
+//! 存在的理由：剪贴板监听线程会把**任何**序列号变化录进历史。而应用自身也会写剪贴板
+//! （copy_back 写回、划词取词时模拟 Ctrl+C 与随后的还原），这些都不该出现在用户的
+//! 历史里。抑制状态因此必须能被**多个模块**访问，而不是某个模块的私有字段。
+//!
+//! 两种机制并存，因为要解决的问题不同：
+//!
+//! - **精确抑制（seq）**：只跳过「本应用刚写入的那一次变化」。写入者是我们自己时，
+//!   写入后的序列号可以立刻读到，于是能精确记账一次；用户随后的复制是另一个序列号，
+//!   不会被误吞。`copy_back` 用这条。
+//!
+//! - **时间窗抑制（burst）**：屏蔽一个区间内的**所有**变化。划词取词要连续动三次剪贴板
+//!   （Ctrl+C 覆盖 → 我们读走 → 还原原文），而监听线程是 250ms 轮询：按序列号逐个记账
+//!   存在竞态——监听恰好落在我们两次操作之间时，选区文本就被录进历史了。
+//!   因此取词期间必须整体屏蔽，读完并还原之后再解除。
+//!
+//! burst 用**计数**而非布尔：取词流程内部可能再触发一次写入，用布尔会在内层先结束时
+//! 提前解除屏蔽。配对由 [`SuppressState::burst`] 返回的 RAII 守卫保证，提前 return 也安全。
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Mutex;
+
+#[derive(Default)]
+pub struct SuppressState {
+    /// 待跳过的序列号（消费一次即清空）
+    seq: Mutex<Option<u32>>,
+    /// 屏蔽窗口嵌套计数
+    burst: AtomicUsize,
+}
+
+/// 屏蔽窗口守卫：析构时自动解除，保证与 `begin` 严格配对。
+pub struct BurstGuard<'a>(&'a SuppressState);
+
+impl Drop for BurstGuard<'_> {
+    fn drop(&mut self) {
+        self.0.end_burst();
+    }
+}
+
+impl SuppressState {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// 记账：跳过 `seq` 这一次变化（消费一次）。
+    /// 只记一个序列号即可——本应用的写入是串行的，不会同时积压多次。
+    pub fn mark_seq(&self, seq: u32) {
+        if let Ok(mut guard) = self.seq.lock() {
+            *guard = Some(seq);
+        }
+    }
+
+    /// 开始屏蔽窗口。返回的守卫析构时自动结束，**不要**手动配对 end。
+    pub fn burst(&self) -> BurstGuard<'_> {
+        self.burst.fetch_add(1, Ordering::SeqCst);
+        BurstGuard(self)
+    }
+
+    fn end_burst(&self) {
+        // saturating：异常路径下的多余 end 不应让计数下溢，否则会永久屏蔽
+        let _ = self
+            .burst
+            .fetch_update(Ordering::SeqCst, Ordering::SeqCst, |v| {
+                Some(v.saturating_sub(1))
+            });
+    }
+
+    /// 当前是否处于屏蔽窗口内（供调用方在取词前做提示，不参与判定）
+    pub fn in_burst(&self) -> bool {
+        self.burst.load(Ordering::SeqCst) > 0
+    }
+
+    /// 监听线程询问：这次变化是否应当跳过。
+    /// 命中序列号时**消费**该记账（下次同序列号不再跳过），避免误吞用户后续的复制。
+    pub fn should_skip(&self, seq: u32) -> bool {
+        if self.in_burst() {
+            return true;
+        }
+        let mut guard = match self.seq.lock() {
+            Ok(g) => g,
+            Err(e) => e.into_inner(),
+        };
+        if *guard == Some(seq) {
+            *guard = None;
+            true
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn seq_suppression_is_consumed_once() {
+        let s = SuppressState::new();
+        s.mark_seq(7);
+        assert!(s.should_skip(7), "记账的那次应被跳过");
+        assert!(!s.should_skip(7), "同序列号不应被反复跳过");
+        assert!(!s.should_skip(8), "其他序列号不受影响");
+    }
+
+    #[test]
+    fn burst_suppresses_everything_until_dropped() {
+        let s = SuppressState::new();
+        {
+            let _guard = s.burst();
+            assert!(s.should_skip(1));
+            assert!(s.should_skip(2));
+            assert!(s.in_burst());
+        }
+        assert!(!s.in_burst());
+        assert!(!s.should_skip(3));
+    }
+
+    #[test]
+    fn burst_is_reentrant() {
+        let s = SuppressState::new();
+        let outer = s.burst();
+        {
+            let _inner = s.burst();
+        }
+        // 内层结束不应提前解除外层
+        assert!(s.in_burst());
+        assert!(s.should_skip(9));
+        drop(outer);
+        assert!(!s.in_burst());
+    }
+
+    #[test]
+    fn extra_end_does_not_underflow() {
+        let s = SuppressState::new();
+        s.end_burst();
+        s.end_burst();
+        // 下溢会让计数变成极大值从而永久屏蔽，这里确保不会
+        assert!(!s.in_burst());
+        assert!(!s.should_skip(4));
+    }
+}

src-tauri/src/constants.rs

@@ -12,6 +12,13 @@ pub mod windows {
     pub const SCREENSHOT_OVERLAY: &str = "screenshot-overlay";
     #[allow(dead_code)]
     pub const SCREENSHOT_PIN: &str = "screenshot-pin";
+    #[allow(dead_code)]
+    pub const SCREENSHOT_SCROLL: &str = "screenshot-scroll";
+    /// 取词翻译悬浮窗（由 translate 模块预创建，非激活显示）
+    pub const TRANSLATE_POPUP: &str = "translate-popup";
+    /// 终端独立窗口前缀，实际 label = `${TERMINAL_WINDOW}-<sessionId>`
+    /// 每个终端窗口承载一个会话，脱离主窗口独立存在。
+    pub const TERMINAL_WINDOW: &str = "terminal-window";
 }
 
 /// Tauri 事件名（与前端 constants::EVENTS 对应）
@@ -26,10 +33,14 @@ pub mod events {
     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";
@@ -40,18 +51,60 @@ pub mod events {
     // 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_GAME_ACTIVE: &str = "osd-game-active";
+    pub const OSD_GAME_INACTIVE: &str = "osd-game-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";
+    /// 滚动截图会话：实时进度 { width, height, auto }
+    pub const SCROLL_PROGRESS: &str = "screenshot-scroll-progress";
+    /// 滚动截图会话：完成并导出
+    pub const SCROLL_COMPLETE: &str = "screenshot-scroll-complete";
+    /// 滚动截图会话：已取消（无负载）
+    pub const SCROLL_CANCELLED: &str = "screenshot-scroll-cancelled";
     // 内核安装进度
     pub const KERNEL_INSTALL_PROGRESS: &str = "kernel-install-progress";
+    // 翻译：取词悬浮窗显示（负载见 translate::popup::PopupPayload）/ 隐藏（无负载）
+    pub const TRANSLATE_POPUP_SHOW: &str = "translate-popup-show";
+    pub const TRANSLATE_POPUP_HIDE: &str = "translate-popup-hide";
+    // 翻译：流式输出（负载见 translate::engines::StreamEvent；失败经 start 的 Promise reject，
+    // 已发出 requestId 之后的失败额外走 error 事件兜底）
+    pub const TRANSLATE_STREAM_CHUNK: &str = "translate-stream-chunk";
+    pub const TRANSLATE_STREAM_DONE: &str = "translate-stream-done";
+    pub const TRANSLATE_STREAM_ERROR: &str = "translate-stream-error";
+    // 音乐模块：Python 便携运行时安装进度
+    pub const MUSIC_RUNTIME_INSTALL_PROGRESS: &str = "music-runtime-install-progress";
+    // 终端模块：会话输出批次（负载见 terminal::events::OutputPayload）
+    // 按 8~16ms 窗口聚合，前端用 seq 校验连续性
+    pub const TERMINAL_OUTPUT: &str = "terminal-output";
+    // 终端模块：会话结束（负载见 terminal::events::ExitPayload）
+    pub const TERMINAL_EXIT: &str = "terminal-exit";
+    // 终端模块：会话状态变更（负载为 SessionInfo，前端据此刷新侧栏与标签）
+    pub const TERMINAL_STATE: &str = "terminal-state";
+    // 终端模块：工作目录变化（OSC 7 hook 上报；SFTP 跟随目录依赖此事件）
+    pub const TERMINAL_CWD: &str = "terminal-cwd";
+    // 终端模块：SSH 主机密钥需用户确认（阻塞式交互，握手暂停等待回传）
+    pub const TERMINAL_HOST_KEY_PROMPT: &str = "terminal-host-key-prompt";
+    // 终端模块：请求前端对「关闭仍在运行的会话」二次确认
+    // （P2 起用：P0 的关闭确认在前端 store 内完成，事件通道先占位）
+    #[allow(dead_code)]
+    pub const TERMINAL_CONFIRM_CLOSE: &str = "terminal-confirm-close";
+    // 终端模块：SFTP 传输进度（负载见 terminal::ssh::sftp::TransferProgress）
+    // 节流后发送（约 200ms 一次），前端据此画进度条
+    pub const TERMINAL_TRANSFER_PROGRESS: &str = "terminal-transfer-progress";
+    // 音乐模块：下载任务事件（桥接事件行 → 前端，负载见 bridge.py _emit_event）
+    pub const MUSIC_DOWNLOAD_EVENT: &str = "music-download-event";
+    // 后端自动切换节点完成（前端据以刷新节点列表并提示）
+    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 新增下载（前端需置前主窗口并跳到下载画面）
+    /// 任务被删除（浏览器扩展通过 HTTP API 删除任务时发出，前端据此刷新任务列表）
+    pub const DOWNLOAD_REMOVED: &str = "download-removed";
+    /// 浏览器扩展通过 HTTP API 新增下载（负载 { id }，前端据以为该任务创建专属下载窗口）
     pub const DOWNLOAD_EXTENSION_ADDED: &str = "download-extension-added";
 }

src-tauri/src/download_engine/commands.rs

@@ -1,10 +1,11 @@
 use std::collections::HashMap;
 
-use tauri::{AppHandle, State};
+use tauri::{AppHandle, Manager, State};
 use tauri_plugin_opener::OpenerExt;
 
 use super::engine::{CheckUrlResult, DownloadEngine};
 use super::task::{DownloadTask, DownloaderSettings};
+use super::torrent::TorrentInfo;
 
 /// 获取所有任务
 #[tauri::command]
@@ -13,6 +14,20 @@ pub fn downloader_get_tasks(engine: State<'_, DownloadEngine>) -> Vec<DownloadTa
     engine.get_tasks()
 }
 
+/// 解析磁力链 / .torrent 文件，返回种子信息（名称 / infohash / 文件列表），供前端做文件勾选
+#[tauri::command]
+#[specta::specta]
+pub async fn downloader_inspect(engine: State<'_, DownloadEngine>, input: String) -> Result<TorrentInfo, String> {
+    engine.inspect(&input).await
+}
+
+/// 磁力任务：元数据解析成功后，用户勾选文件并确认开始下载
+#[tauri::command]
+#[specta::specta]
+pub async fn downloader_select_bt_files(engine: State<'_, DownloadEngine>, id: String, only_files: Vec<u32>) -> Result<(), String> {
+    engine.select_bt_files(&id, only_files).await
+}
+
 /// 检查 URL 重复性并探测文件信息（添加下载前调用）
 #[tauri::command]
 #[specta::specta]
@@ -57,8 +72,9 @@ pub async fn downloader_add_task(
     dir: Option<String>,
     headers: Option<HashMap<String, String>>,
     auto_rename: Option<bool>,
+    only_files: Option<Vec<u32>>,
 ) -> Result<String, String> {
-    engine.add_task(url, filename, dir, headers.unwrap_or_default(), auto_rename.unwrap_or(false)).await
+    engine.add_task(url, filename, dir, headers.unwrap_or_default(), auto_rename.unwrap_or(false), only_files).await
 }
 
 /// 暂停任务
@@ -75,6 +91,20 @@ pub fn downloader_resume_task(engine: State<'_, DownloadEngine>, id: String) ->
     engine.resume_task(&id)
 }
 
+/// 取消任务（置为已取消，清空进度并删除下载文件，但保留记录）
+#[tauri::command]
+#[specta::specta]
+pub fn downloader_cancel_task(engine: State<'_, DownloadEngine>, id: String) -> Result<(), String> {
+    engine.cancel_task(&id)
+}
+
+/// 重新下载已取消/出错的任务
+#[tauri::command]
+#[specta::specta]
+pub async fn downloader_redownload(engine: State<'_, DownloadEngine>, id: String) -> Result<(), String> {
+    engine.redownload(&id).await
+}
+
 /// 移除任务
 #[tauri::command]
 #[specta::specta]
@@ -141,3 +171,24 @@ pub fn downloader_open_url(app: AppHandle, url: String) -> Result<(), String> {
         .open_url(url, None::<&str>)
         .map_err(|e| format!("打开链接失败: {}", e))
 }
+
+/// 将指定 label 的下载窗口显示并强制置为前台。
+/// Tauri 的 set_focus 在 Windows 上受前台锁定限制（尤其下载窗口由后台进程创建、
+/// 或创建到非主显示器时更明显），改用原生 SetForegroundWindow + BringWindowToTop
+/// （模拟 Alt 键重置前台锁定），保证开始/完成下载时窗口能正确定位到前台。
+#[tauri::command]
+#[specta::specta]
+pub fn downloader_focus_window(app: AppHandle, label: String) -> Result<(), String> {
+    let Some(window) = app.get_webview_window(&label) else {
+        return Ok(()); // 窗口已关闭则忽略
+    };
+    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(())
+}

src-tauri/src/download_engine/http_dl.rs

@@ -1,11 +1,12 @@
 use futures_util::StreamExt;
+use reqwest::Proxy;
 use reqwest::Client;
 use std::collections::HashMap;
 use std::fs::OpenOptions;
 use std::io::SeekFrom;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use tokio::io::{AsyncSeekExt, AsyncWriteExt};
 use tokio::task::JoinSet;
 
@@ -21,27 +22,110 @@ const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3
 /// HTTP/HTTPS 下载器
 #[derive(Clone)]
 pub struct HttpDownloader {
-    client: Client,
+    /// 直连客户端：强制禁用代理（no_proxy），用于降级重试与控制端探测
+    direct_client: Client,
+    /// mihomo 显式代理客户端缓存（与代理地址一一对应）：走 http://127.0.0.1:{mixed_port}。
+    /// 地址未配置（mihomo 未运行）时为 no_proxy 直连。Arc 共享同一状态，任意 clone 统一生效。
+    mihomo: Arc<Mutex<(Option<String>, Client)>>,
 }
 
 impl HttpDownloader {
     pub fn new() -> Self {
-        let client = Client::builder()
+        let direct_client = Client::builder()
+            // 强制直连：即使系统代理已开启，下载也不经过系统代理
+            .no_proxy()
             .build()
             .unwrap_or_else(|_| Client::new());
-        Self { client }
+        Self {
+            direct_client: direct_client.clone(),
+            mihomo: Arc::new(Mutex::new((None, direct_client))),
+        }
+    }
+
+    /// 配置 mihomo 显式代理客户端。
+    /// - `Some("http://127.0.0.1:{port}")`：走本地 mihomo 的 mixed 端口；
+    /// - `None`：回退直连（不走系统代理）。
+    /// 地址未变化时复用缓存，不重复重建，避免丢失连接复用。
+    pub fn configure_mihomo_proxy(&self, proxy_url: Option<String>) {
+        let mut guard = self.mihomo.lock().unwrap_or_else(|e| e.into_inner());
+        if guard.0 == proxy_url {
+            return;
+        }
+        let client = match &proxy_url {
+            Some(url) => {
+                let mut cb = Client::builder();
+                if let Ok(p) = Proxy::all(url.clone()) {
+                    cb = cb.proxy(p);
+                }
+                cb.build().unwrap_or_else(|_| Client::new())
+            }
+            None => Client::builder()
+                .no_proxy()
+                .build()
+                .unwrap_or_else(|_| Client::new()),
+        };
+        *guard = (proxy_url, client);
+    }
+
+    /// 探测 mihomo 外部控制端是否在线（用于判断代理模块是否真正运行）。
+    /// 走直连客户端，避免探测本身依赖代理。
+    pub async fn probe_controller(&self, controller: &str) -> bool {
+        let url = format!("http://{}/version", controller);
+        match tokio::time::timeout(
+            std::time::Duration::from_secs(3),
+            self.direct_client.get(&url).send(),
+        )
+        .await
+        {
+            Ok(Ok(r)) => r.status().is_success(),
+            _ => false,
+        }
+    }
+
+    /// 根据 use_proxy 选择客户端（克隆句柄，Client 内部共享连接池）
+    fn client(&self, use_proxy: bool) -> Client {
+        if use_proxy {
+            self.mihomo
+                .lock()
+                .unwrap_or_else(|e| e.into_inner())
+                .1
+                .clone()
+        } else {
+            self.direct_client.clone()
+        }
     }
 
     /// 探测下载资源信息（大小、是否支持 Range、文件名）
-    /// 优先用 GET + Range: bytes=0-0（返回 206 + Content-Range），回退到 HEAD
+    /// 优先用 GET + Range: bytes=0-0（返回 206 + Content-Range），回退到 HEAD。
+    /// 代理降级：use_proxy=true 时先走系统代理，失败则回退 no_proxy 直连重试一次
     pub async fn probe(
         &self,
         url: &str,
         headers: &HashMap<String, String>,
+        use_proxy: bool,
+    ) -> Result<ProbeResult, String> {
+        let first = self.client(use_proxy);
+        match self.probe_with_client(&first, url, headers).await {
+            Ok(r) => return Ok(r),
+            Err(e) if use_proxy => {
+                let direct = self.client(false);
+                self.probe_with_client(&direct, url, headers)
+                    .await
+                    .map_err(|e2| format!("代理探测失败（{}），直连重试也失败（{}）", e, e2))
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    /// 用指定 client 执行探测（GET Range → 回退 HEAD），供代理降级复用
+    async fn probe_with_client(
+        &self,
+        client: &Client,
+        url: &str,
+        headers: &HashMap<String, String>,
     ) -> Result<ProbeResult, String> {
         // 先尝试 Range 请求（能同时判断 Accept-Ranges 和获取大小）
-        let mut req = self
+        let mut req = client
-            .client
             .get(url)
             .header("Range", "bytes=0-0")
             .header("User-Agent", "Thing-Download-Engine/1.0");
@@ -97,7 +181,7 @@ 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);
                 }
@@ -132,6 +216,7 @@ impl HttpDownloader {
     /// - `cancel`: 取消标志
     /// - `progress`: 每个分段的已下载字节（AtomicU64，与 segments 一一对应）
     /// - `limiter`: 全局限速器
+    /// - `use_proxy`: 是否使用系统代理（false=强制直连）
     pub async fn download(
         &self,
         url: &str,
@@ -141,6 +226,37 @@ impl HttpDownloader {
         cancel: Arc<AtomicBool>,
         progress: &[Arc<AtomicU64>],
         limiter: Arc<RateLimiter>,
+        use_proxy: bool,
+    ) -> Result<(), String> {
+        // 代理降级：仅当 use_proxy=true 才有"走代理→失败回退直连"的意义。
+        // use_proxy=false 直接用直连客户端，无需回退。
+        // 注意：用户主动暂停/取消（返回"已取消"）必须原样透传，不能触发代理回退，
+        // 否则会把"已取消"包装成"代理失败"，导致引擎将其误判为错误而非暂停。
+        let first = self.client(use_proxy);
+        match self.download_with_client(&first, url, headers, segments, file_path, cancel.clone(), progress, &limiter).await {
+            Ok(()) => return Ok(()),
+            Err(e) if use_proxy && e != "已取消" => {
+                // 回退直连重试（不继承 use_proxy，保证用 no_proxy 客户端）
+                let direct = self.client(false);
+                self.download_with_client(&direct, url, headers, segments, file_path, cancel, progress, &limiter)
+                    .await
+                    .map_err(|e2| format!("代理下载失败（{}），直连重试也失败（{}）", e, e2))
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    /// 用指定 client 执行下载（支持单线程与多线程分段），供代理降级复用
+    async fn download_with_client(
+        &self,
+        client: &Client,
+        url: &str,
+        headers: &HashMap<String, String>,
+        segments: &[Segment],
+        file_path: &Path,
+        cancel: Arc<AtomicBool>,
+        progress: &[Arc<AtomicU64>],
+        limiter: &Arc<RateLimiter>,
     ) -> Result<(), String> {
         let total_size = segments.iter().map(|s| s.len()).sum();
 
@@ -167,7 +283,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.clone(), client)
                 .await?;
             return Ok(());
         }
@@ -187,7 +303,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(
@@ -241,9 +357,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,
@@ -366,6 +483,15 @@ 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(_) => {

src-tauri/src/download_engine/mod.rs

@@ -5,10 +5,11 @@ pub mod rate_limit;
 pub mod server;
 pub mod storage;
 pub mod task;
+pub mod torrent;
 
 pub use commands::{
-    downloader_add_task, downloader_check_url, downloader_get_extension_info, downloader_get_settings, downloader_get_tasks,
+    downloader_add_task, downloader_cancel_task, downloader_check_url, downloader_focus_window, downloader_get_extension_info, downloader_get_settings, downloader_get_tasks, downloader_inspect, downloader_select_bt_files,
-    downloader_open_dir, downloader_open_url, downloader_pause_task, downloader_remove_task,
+    downloader_open_dir, downloader_open_url, downloader_pause_task, downloader_redownload, downloader_remove_task,
     downloader_resume_task, downloader_save_settings, downloader_status,
 };
 pub use engine::DownloadEngine;

src-tauri/src/download_engine/server.rs

@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 use std::net::SocketAddr;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 use axum::{
     extract::{Path, State},
@@ -9,14 +11,25 @@ use axum::{
     Router,
 };
 use serde::{Deserialize, Serialize};
-use tauri::{AppHandle, Emitter, Manager};
+use tauri::{AppHandle, Emitter};
 
 use super::engine::DownloadEngine;
-use super::task::DownloadTask;
+use super::task::{DownloadTask, TaskStatus};
 
 /// 扩展 HTTP API 服务器
 pub struct ExtensionServer;
 
+/// 最近处理过的下载 URL（短窗口去重）：记录对应任务 id 与创建时刻，
+/// 用于拦截"探测期间并发 POST"与"任务已结束但扩展重试"造成的重复创建
+#[derive(Clone)]
+struct RecentEntry {
+    id: String,
+    at: Instant,
+}
+
+/// 同 URL 去重窗口：窗口内重复 POST 复用既有任务 id
+const DEDUP_WINDOW: Duration = Duration::from_secs(30);
+
 #[derive(Serialize)]
 struct HealthResponse {
     ok: bool,
@@ -57,6 +70,7 @@ impl ExtensionServer {
                 engine,
                 secret,
                 app_handle,
+                recent: Arc::new(Mutex::new(HashMap::new())),
             });
 
         let listener = match tokio::net::TcpListener::bind(&addr).await {
@@ -80,6 +94,8 @@ struct AppState {
     engine: DownloadEngine,
     secret: String,
     app_handle: AppHandle,
+    /// 最近创建的 URL→任务 id（短窗口去重）
+    recent: Arc<Mutex<HashMap<String, RecentEntry>>>,
 }
 
 /// 鉴权检查：如果配置了 secret，校验 Bearer token
@@ -114,13 +130,46 @@ async fn create_download(
         return Err((StatusCode::UNAUTHORIZED, Json(ErrorResponse { error: "未授权".into() })));
     }
 
-    match state.engine.add_task(req.url, req.filename, req.dir, req.headers, true).await {
+    // 1. 检查短窗口缓存：同 URL 30s 内已有创建记录，直接返回（拦截浏览器/扩展重试和并发 POST）
+    {
+        let mut recent = state.recent.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some(entry) = recent.get(&req.url) {
+            if entry.at.elapsed() < DEDUP_WINDOW {
+                // 30 秒内重复请求 → 返回已创建任务 id，不重复新建
+                return Ok(Json(CreateDownloadResponse { id: entry.id.clone() }));
+            } else {
+                // 窗口过期 → 删除旧记录继续检查引擎层去重
+                recent.remove(&req.url);
+            }
+        }
+    }
+
+    // 2. 引擎层去重：同 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
+    }) {
+        // 添加到短窗口缓存以便拦截重试
+        let mut recent = state.recent.lock().unwrap_or_else(|e| e.into_inner());
+        recent.insert(req.url.clone(), RecentEntry { id: existing.id.clone(), at: Instant::now() });
+        return Ok(Json(CreateDownloadResponse { id: existing.id }));
+    }
+
+    // add_task 会 move 掉 req 的字段，先取出 url 供去重缓存使用
+    let task_url = req.url.clone();
+    match state.engine.add_task(req.url, req.filename, req.dir, req.headers, true, None).await {
         Ok(id) => {
-            // 浏览器扩展发起下载：置前主窗口并通知前端跳到下载画面（替代原桌面通知）
+            // 记录到短窗口缓存：拦截后续同一 URL 的重复转发/重试
-            crate::tray_menu::focus_main_window(&state.app_handle);
+            let url = task_url.clone();
-            let _ = state
+            let mut recent = state.recent.lock().unwrap_or_else(|e| e.into_inner());
-                .app_handle
+            recent.insert(url, RecentEntry { id: id.clone(), at: Instant::now() });
-                .emit(crate::constants::events::DOWNLOAD_EXTENSION_ADDED, ());
+            drop(recent);
+            // 浏览器扩展发起下载：不再置前主窗口，改为带 task id 通知前端，
+            // 由前端为该任务创建一个专属的一次性下载窗口（不打断主界面）
+            let _ = state.app_handle.emit(
+                crate::constants::events::DOWNLOAD_EXTENSION_ADDED,
+                serde_json::json!({ "id": id }),
+            );
             Ok(Json(CreateDownloadResponse { id }))
         }
         Err(e) => Err((StatusCode::BAD_REQUEST, Json(ErrorResponse { error: e }))),
@@ -146,7 +195,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/task.rs

@@ -2,6 +2,17 @@ use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::collections::HashMap;
 
+/// 任务下载协议类型
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Type, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum TaskProtocol {
+    /// HTTP/HTTPS 直链
+    #[default]
+    Http,
+    /// BitTorrent（磁力链 / .torrent 文件）
+    BitTorrent,
+}
+
 /// 任务状态
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Type)]
 #[serde(rename_all = "lowercase")]
@@ -16,6 +27,8 @@ pub enum TaskStatus {
     Complete,
     /// 错误
     Error,
+    /// 已取消（用户取消：进度与文件已清除，仅保留记录，只能再次下载）
+    Cancelled,
 }
 
 /// 下载分段（多线程 Range 下载 / 断点续传用）
@@ -37,24 +50,57 @@ 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()
     }
 }
 
+/// BT 种子内文件条目（多文件任务用；阶段1下载全部文件，但保留列表供 UI 展示）
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct BtFileInfo {
+    /// 文件在种子内的索引
+    pub index: u32,
+    /// 相对种子根目录的路径（如 "sub/file.mkv"）
+    pub path: String,
+    /// 文件大小（字节）
+    pub size: u64,
+}
+
 /// 下载任务
 #[derive(Debug, Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct DownloadTask {
     /// 任务 ID（自增 hex 字符串）
     pub id: String,
-    /// 下载地址
+    /// 下载地址（HTTP URL 或磁力链接）
     pub url: String,
-    /// 文件名
+    /// 文件名（HTTP：目标文件名；BT：种子名称）
     pub filename: String,
     /// 保存目录（绝对路径）
     pub dir: String,
+    /// 协议类型
+    #[serde(default)]
+    pub protocol: TaskProtocol,
+    /// BT 种子 infohash（协议=BitTorrent 时存在）
+    #[serde(default)]
+    pub info_hash: Option<String>,
+    /// BT 种子内文件列表（协议=BitTorrent 时存在）
+    #[serde(default)]
+    pub bt_files: Vec<BtFileInfo>,
+    /// BT 元数据是否已解析就绪（异步添加时：后台解析完成前为 false，调度器跳过）
+    #[serde(default)]
+    pub bt_metadata_ready: bool,
     /// 状态
     pub status: TaskStatus,
     /// 文件总大小（字节），0=未知
@@ -129,6 +175,21 @@ pub struct DownloaderSettings {
     /// 添加下载前检查重复（URL 或文件名重复时询问）
     #[serde(default = "default_true")]
     pub check_duplicate: bool,
+    /// 下载是否使用代理：true=尊重系统代理（mihomo 开启系统代理时经其转发），false=强制直连
+    #[serde(default = "default_true")]
+    pub use_proxy: bool,
+    /// BitTorrent 上传限速 KB/s（0=不限）
+    #[serde(default)]
+    pub bt_upload_limit_kb: u64,
+    /// BitTorrent 下载完成后是否继续做种上传（false=下载完即停止上传）
+    #[serde(default)]
+    pub bt_seed_after_download: bool,
+    /// BitTorrent 监听端口（0=自动选择）
+    #[serde(default)]
+    pub bt_listen_port: u16,
+    /// BitTorrent 使用代理下载：开启后自动使用代理模块（mihomo）的 SOCKS5 端口；代理不可用时降级直连
+    #[serde(default)]
+    pub bt_use_proxy: bool,
 }
 
 fn default_max_concurrent() -> u32 {
@@ -167,6 +228,11 @@ impl Default for DownloaderSettings {
             extension_secret: String::new(),
             delete_files_on_remove: false,
             check_duplicate: true,
+            use_proxy: true,
+            bt_upload_limit_kb: 0,
+            bt_seed_after_download: false,
+            bt_listen_port: 0,
+            bt_use_proxy: false,
         }
     }
 }

src-tauri/src/download_engine/torrent.rs

@@ -0,0 +1,477 @@
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex, RwLock};
+
+// 会话字段专用 tokio 异步互斥（与 std 互斥区分开）：
+// 创建 Session 是 async 操作，必须持锁跨 await，否则"双重检查"在 await 期间失效，
+// 并发首次添加 BT 任务可能各建一个全局会话，产生孤儿会话与跨会话无效句柄。
+use tokio::sync::Mutex as AsyncMutex;
+
+use librqbit::api::TorrentIdOrHash;
+use librqbit::{AddTorrent, AddTorrentOptions, AddTorrentResponse, ManagedTorrent, Session};
+
+use super::task::BtFileInfo;
+
+/// 磁力元数据解析超时（秒）：依赖 DHT/tracker 拉取，过短易误报，过长体验差
+pub(crate) const INSPECT_TIMEOUT_SECS: u64 = 60;
+
+/// 每日 tracker 同步源（XIU2/TrackersListCollection，官方新域名 cf.trackerslist.com）。
+/// 注意：GitHub 仓库 raw 路径（raw.githubusercontent.com/...trackers_best.txt）已随项目
+/// 迁移失效（404），不要再用 GitHub 代理镜像。以下为官方 Cloudflare 分发地址，
+/// 国内直连通常可达，按顺序尝试、首个成功即用。
+const TRACKER_SYNC_SOURCES: &[&str] = &[
+    "https://cf.trackerslist.com/best.txt",
+    "https://trackerslist.com/best.txt",
+    "https://cf.trackerslist.com/all.txt",
+];
+/// 动态 tracker 持久化文件与同步元数据
+const TRACKERS_FILE: &str = "bt_trackers.txt";
+const TRACKERS_META_FILE: &str = "bt_trackers_meta.json";
+
+/// 常用公共 tracker：磁力链接本身可能只带很少 tracker，追加这些可提升解析成功率。
+/// 混合 UDP/HTTP(S)/WebSocket，覆盖 UDP 被屏蔽但 HTTP 可用的网络环境。
+pub const PUBLIC_TRACKERS: &[&str] = &[
+    // UDP
+    "udp://tracker.opentrackr.org:1337/announce",
+    "udp://open.tracker.cl:1337/announce",
+    "udp://tracker.openbittorrent.com:6969/announce",
+    "udp://tracker.torrent.eu.org:451/announce",
+    "udp://open.stealth.si:80/announce",
+    "udp://exodus.desync.com:6969/announce",
+    "udp://tracker.tiny-vps.com:6969/announce",
+    "udp://open.demonii.com:1337/announce",
+    "udp://tracker.moeking.me:6969/announce",
+    "udp://ipv4.tracker.harry.lu:80/announce",
+    "udp://explodie.org:6969/announce",
+    "udp://tracker.birkenfeld.ru:7496/announce",
+    "udp://tracker.pomf.se:80/announce",
+    "udp://tracker.tamersunion.org:6969/announce",
+    "udp://retracker.lanta-net.ru:2710/announce",
+    // HTTP(S)
+    "http://tracker.opentrackr.org:1337/announce",
+    "http://tracker.openbittorrent.com:80/announce",
+    "http://tracker1.itzmx.com:8080/announce",
+    "http://tracker4.itzmx.com:2710/announce",
+    "https://tracker.gbitt.info:443/announce",
+    "https://tracker.nanoha.org:443/announce",
+    "http://tracker.bt4g.com:2095/announce",
+    "http://tracker.gbitt.info:80/announce",
+];
+
+/// 种子信息（inspect 解析结果，供命令返回给前端做文件勾选）
+#[derive(Debug, Clone, serde::Serialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct TorrentInfo {
+    /// 种子名称
+    pub name: String,
+    /// infohash（hex 小写字符串）
+    pub info_hash: String,
+    /// 种子内全部文件总大小（字节）
+    pub total_size: u64,
+    /// 种子内文件列表
+    pub files: Vec<BtFileInfo>,
+}
+
+/// BitTorrent 下载器：封装 librqbit 全局会话（多任务共享 DHT / 监听端口 / tracker 缓存）。
+/// 会话懒创建：只有真正添加 BT 任务时才初始化，避免引擎启动即拉起 BT 内核。
+#[derive(Clone)]
+pub struct TorrentDownloader {
+    /// 全局会话（懒创建；tokio 异步互斥保证并发首次添加只创建一个会话）
+    session: Arc<AsyncMutex<Option<Arc<Session>>>>,
+    /// 会话默认输出目录（每个任务用 AddTorrentOptions.output_folder 覆盖）
+    base_dir: PathBuf,
+    /// 上传限速 bytes/s（0=不限），per-torrent 应用
+    upload_limit_bps: Arc<std::sync::atomic::AtomicU64>,
+    /// 监听端口（0=自动）
+    listen_port: Arc<std::sync::atomic::AtomicU16>,
+    /// SOCKS5 代理地址（None=直连；来自代理模块，不可用时降级直连）
+    proxy_addr: Arc<Mutex<Option<String>>>,
+    /// 动态公共 tracker（每日从外部列表同步，叠加到内置列表）
+    dynamic_trackers: Arc<RwLock<Vec<String>>>,
+}
+
+impl TorrentDownloader {
+    pub fn new(base_dir: PathBuf) -> Self {
+        Self {
+            session: Arc::new(AsyncMutex::new(None)),
+            base_dir,
+            upload_limit_bps: Arc::new(std::sync::atomic::AtomicU64::new(0)),
+            listen_port: Arc::new(std::sync::atomic::AtomicU16::new(0)),
+            proxy_addr: Arc::new(Mutex::new(None)),
+            dynamic_trackers: Arc::new(RwLock::new(Vec::new())),
+        }
+    }
+
+    /// 更新 BT 专属设置（上传限速 KB/s、监听端口、SOCKS5 代理地址）— 会话创建时生效
+    pub fn set_settings(&self, upload_limit_kb: u64, listen_port: u16, proxy_addr: Option<String>) {
+        self.upload_limit_bps
+            .store(upload_limit_kb.saturating_mul(1024), std::sync::atomic::Ordering::SeqCst);
+        self.listen_port
+            .store(listen_port, std::sync::atomic::Ordering::SeqCst);
+        *self.proxy_addr.lock().unwrap_or_else(|e| e.into_inner()) = proxy_addr;
+    }
+
+    /// 设置动态 tracker（合并去重）
+    pub fn add_dynamic_trackers(&self, list: Vec<String>) {
+        if list.is_empty() {
+            return;
+        }
+        let mut g = self.dynamic_trackers.write().unwrap_or_else(|e| e.into_inner());
+        for t in list {
+            let t = t.trim().to_string();
+            if !t.is_empty() && !g.contains(&t) {
+                g.push(t);
+            }
+        }
+    }
+
+    /// 当前动态 tracker 数量
+    pub fn dynamic_count(&self) -> usize {
+        self.dynamic_trackers.read().unwrap_or_else(|e| e.into_inner()).len()
+    }
+
+    /// 合并内置 + 动态 tracker（去重），供 inspect / add_async 共用
+    fn build_trackers(&self) -> Vec<String> {
+        let dyn_trackers = self.dynamic_trackers.read().unwrap_or_else(|e| e.into_inner()).clone();
+        let mut trackers: Vec<String> = PUBLIC_TRACKERS.iter().map(|s| s.to_string()).collect();
+        for t in dyn_trackers {
+            if !trackers.contains(&t) {
+                trackers.push(t);
+            }
+        }
+        trackers
+    }
+
+    /// 每日同步动态 tracker：读取本地缓存 → 判断今天是否已同步 → 未同步则拉取更新。
+    /// 失败静默降级：保留上次成功的列表。
+    pub async fn sync_dynamic_trackers(&self, data_dir: &Path) {
+        fn parse_list(text: &str) -> Vec<String> {
+            text.lines()
+                .map(|l| l.trim())
+                .filter(|l| l.starts_with("http://") || l.starts_with("https://") || l.starts_with("udp://") || l.starts_with("ws://") || l.starts_with("wss://"))
+                .map(|l| l.to_string())
+                .collect()
+        }
+        let trackers_path = data_dir.join(TRACKERS_FILE);
+        let meta_path = data_dir.join(TRACKERS_META_FILE);
+        let today = chrono::Local::now().format("%Y-%m-%d").to_string();
+
+        // 1. 先加载上次成功保存的列表到内存（覆盖"重启后内存被清空"）
+        if let Ok(s) = std::fs::read_to_string(&trackers_path) {
+            self.add_dynamic_trackers(parse_list(&s));
+        }
+
+        // 2. 今天已同步过则不再下载
+        if let Ok(meta) = std::fs::read_to_string(&meta_path) {
+            if let Ok(v) = serde_json::from_str::<serde_json::Value>(&meta) {
+                if v.get("date").and_then(|d| d.as_str()) == Some(&today) {
+                    return;
+                }
+            }
+        }
+
+        // 3. 依次尝试各镜像源（记录每个源的失败原因，便于判断是 DNS 还是连接超时）
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(10))
+            .build()
+            .ok();
+        for url in TRACKER_SYNC_SOURCES {
+            let Some(c) = &client else { break };
+            match c.get(*url).send().await {
+                Err(e) => {
+                    crate::logger::log_line("download", crate::logger::LogLevel::Debug, &format!("动态 tracker 源不可达 {}: {}", url, e));
+                    continue;
+                }
+                Ok(resp) => {
+                    let text = match resp.text().await {
+                        Ok(t) => t,
+                        Err(e) => {
+                            crate::logger::log_line("download", crate::logger::LogLevel::Debug, &format!("动态 tracker 源读取失败 {}: {}", url, e));
+                            continue;
+                        }
+                    };
+                    let list = parse_list(&text);
+                    if list.is_empty() {
+                        crate::logger::log_line("download", crate::logger::LogLevel::Debug, &format!("动态 tracker 源返回空列表 {}", url));
+                        continue;
+                    }
+                    // 保存列表与同步元数据
+                    let _ = std::fs::write(&trackers_path, format!("{}\n", list.join("\n")));
+                    let _ = std::fs::write(&meta_path, serde_json::json!({ "date": today }).to_string());
+                    self.add_dynamic_trackers(list);
+                    crate::logger::log_info("download", &format!("已同步动态 tracker（共 {} 条）", self.dynamic_count()));
+                    return;
+                }
+            }
+        }
+        crate::logger::log_warn("download", "动态 tracker 全部同步源不可达，使用上次成功列表或内置列表（不影响磁力解析，公共 tracker 仍会生效）");
+    }
+
+    /// 会话级公共 tracker（HashSet<Url>，供 SessionOptions.trackers 使用）。
+    /// 注意：librqbit 对磁力链接只采用 magnet URL 自带的 tr= 参数，完全忽略
+    /// AddTorrentOptions.trackers（见 librqbit session.rs 的 magnet 分支），导致
+    /// 纯磁力（无自带 tr）解析元数据时 "trackers list is empty"。而会话级
+    /// SessionOptions.trackers 会在 make_peer_rx 中合并进每个种子（含磁力），
+    /// 因此必须放到这里才能让磁力链接真正带上公共 tracker。
+    fn session_trackers(&self) -> std::collections::HashSet<url::Url> {
+        self.build_trackers()
+            .into_iter()
+            .filter_map(|t| url::Url::parse(&t).ok())
+            .collect()
+    }
+
+    /// 获取或创建全局会话。
+    /// 持 tokio 互斥锁覆盖整个构造过程：并发调用在此串行化，
+    /// 先进入者创建并写入，后续者锁内二次检查直接复用（避免多会话竞态）。
+    /// 开启代理时先尝试用代理初始化；失败则降级为直连（记录下来供 add 重试判断）。
+    async fn get_session(&self) -> Result<Arc<Session>, String> {
+        let mut guard = self.session.lock().await;
+        if let Some(s) = guard.as_ref() {
+            return Ok(s.clone());
+        }
+        let _ = std::fs::create_dir_all(&self.base_dir);
+        let port = self.listen_port.load(std::sync::atomic::Ordering::SeqCst);
+        let proxy = self.proxy_addr.lock().unwrap_or_else(|e| e.into_inner()).clone();
+        let connect_opt = proxy.as_ref().map(|p| librqbit::ConnectionOptions { proxy_url: Some(p.clone()), ..Default::default() });
+        let had_proxy = connect_opt.is_some();
+
+        // 构造带代理（若启用）+ 监听端口 + 会话级公共 tracker 的会话选项
+        let mut opts = lib_session_options();
+        opts.trackers = self.session_trackers();
+        if connect_opt.is_some() {
+            opts.connect = connect_opt;
+        }
+        if port > 0 {
+            if let Ok(addr) = format!("0.0.0.0:{}", port).parse::<std::net::SocketAddr>() {
+                opts.listen = Some(librqbit::ListenerOptions {
+                    listen_addr: addr,
+                    ..Default::default()
+                });
+            } else {
+                crate::logger::log_error("download", &format!("BT 监听端口 {} 无效，使用自动端口", port));
+            }
+        }
+        // 尝试创建会话：先按配置（可能带代理），失败且有代理则降级直连重试
+        let s = match Session::new_with_opts(self.base_dir.clone(), opts).await {
+            Ok(s) => s,
+            Err(e) => {
+                if had_proxy {
+                    crate::logger::log_error("download", &format!("BT 代理会话初始化失败（{}），降级为直连", e));
+                    let mut m = lib_session_options();
+                    m.trackers = self.session_trackers();
+                    if port > 0 {
+                        if let Ok(addr) = format!("0.0.0.0:{}", port).parse::<std::net::SocketAddr>() {
+                            m.listen = Some(librqbit::ListenerOptions { listen_addr: addr, ..Default::default() });
+                        }
+                    }
+                    Session::new_with_opts(self.base_dir.clone(), m).await.map_err(|e2| format!("初始化 BitTorrent 会话失败: {}", e2))?
+                } else {
+                    return Err(format!("初始化 BitTorrent 会话失败: {}", e));
+                }
+            }
+        };
+        *guard = Some(s.clone());
+        Ok(s)
+    }
+
+    /// 解析磁力链 / 本地 .torrent 文件，返回种子信息（不开始下载）。
+    /// list_only 模式：仅获取元数据，不加入会话，因此不影响后续真正添加。
+    /// 磁力元数据依赖 DHT/tracker 拉取，无超时会永久等待，故加超时。
+    pub async fn inspect(&self, input: &str) -> Result<TorrentInfo, String> {
+        let session = self.get_session().await?;
+        let trackers = self.build_trackers();
+        // 磁力：需从网络拉取元数据，可能较慢（取决于种子热度与网络连通性）；
+        // 本地 .torrent / http(s) .torrent URL：元数据在文件内，from_cli_argument 会读取/下载并解析
+        let add = AddTorrent::from_cli_argument(input).map_err(|e| format!("无效的种子输入: {}", e))?;
+        let add_fut = session.add_torrent(
+            add,
+            Some(AddTorrentOptions {
+                list_only: true,
+                trackers: Some(trackers),
+                ..Default::default()
+            }),
+        );
+        let resp = tokio::time::timeout(std::time::Duration::from_secs(INSPECT_TIMEOUT_SECS), add_fut)
+            .await
+            .map_err(|_| "解析磁力元数据超时：未能从 DHT/Tracker 获取种子信息，请确认种子有做种源或网络可直连 BT".to_string())?
+            .map_err(|e| format!("解析种子失败: {}", e))?;
+
+        let AddTorrentResponse::ListOnly(lo) = resp else {
+            return Err("该链接未返回有效的种子元数据".to_string());
+        };
+
+        let info = lo.info.info();
+        let name = info
+            .name
+            .as_ref()
+            .map(|b| String::from_utf8_lossy(b.as_ref()).into_owned())
+            .or_else(|| lo.info.name().map(|c| c.to_string()))
+            .unwrap_or_else(|| "未命名种子".to_string());
+
+        let mut files = Vec::new();
+        let mut total_size = 0u64;
+        if let Some(fs) = &info.files {
+            for (i, f) in fs.iter().enumerate() {
+                let path = f
+                    .path
+                    .iter()
+                    .map(|p| String::from_utf8_lossy(p.as_ref()).into_owned())
+                    .collect::<Vec<_>>()
+                    .join("/");
+                files.push(BtFileInfo {
+                    index: i as u32,
+                    path,
+                    size: f.length,
+                });
+                total_size += f.length;
+            }
+        } else if let Some(len) = info.length {
+            // 单文件种子
+            files.push(BtFileInfo {
+                index: 0,
+                path: name.clone(),
+                size: len,
+            });
+            total_size = len;
+        }
+
+        Ok(TorrentInfo {
+            name,
+            info_hash: hex_encode(&lo.info_hash.0),
+            total_size,
+            files,
+        })
+    }
+
+    /// 异步添加种子：立即返回句柄（不等待元数据），由调用方后台解析。
+    /// 附加公共 tracker 提升磁力元数据解析成功率；上传限速 per-torrent 应用。
+    pub async fn add_async(
+        &self,
+        input: &str,
+        output_dir: &str,
+    ) -> Result<(usize, Arc<ManagedTorrent>), String> {
+        let session = self.get_session().await?;
+        std::fs::create_dir_all(output_dir).map_err(|e| format!("创建下载目录失败: {}", e))?;
+        let up = self.upload_limit_bps.load(std::sync::atomic::Ordering::SeqCst);
+        let upload_bps = std::num::NonZeroU32::new(up.min(u32::MAX as u64) as u32);
+        let trackers = self.build_trackers();
+        let opts = AddTorrentOptions {
+            paused: true,
+            output_folder: Some(output_dir.to_string()),
+            overwrite: true,
+            trackers: Some(trackers),
+            ratelimits: librqbit::limits::LimitsConfig {
+                upload_bps,
+                download_bps: None,
+            },
+            ..Default::default()
+        };
+        let add = AddTorrent::from_cli_argument(input).map_err(|e| format!("无效的种子输入: {}", e))?;
+        let resp = session
+            .add_torrent(add, Some(opts))
+            .await
+            .map_err(|e| format!("添加种子失败: {}", e))?;
+        match resp {
+            AddTorrentResponse::Added(id, handle) => Ok((id, handle)),
+            AddTorrentResponse::AlreadyManaged(id, handle) => Ok((id, handle)),
+            _ => Err("种子已存在或元数据无效".to_string()),
+        }
+    }
+
+    /// 等待种子元数据初始化就绪（磁力需要从网络拉取，带超时）
+    pub async fn wait_initialized(&self, handle: &Arc<ManagedTorrent>) -> Result<(), String> {
+        tokio::time::timeout(
+            std::time::Duration::from_secs(INSPECT_TIMEOUT_SECS),
+            handle.wait_until_initialized(),
+        )
+        .await
+        .map_err(|_| "解析磁力元数据超时：未能从 DHT/Tracker 获取种子信息，请确认种子有做种源或网络可直连 BT".to_string())?
+        .map_err(|e| format!("获取种子元数据失败: {}", e))
+    }
+
+    /// 设置要下载的种子文件子集（用户文件勾选；传全部索引则全选）
+    pub async fn set_only_files(&self, handle: &Arc<ManagedTorrent>, files: &[u32]) -> Result<(), String> {
+        let session = self.get_session().await?;
+        let set: std::collections::HashSet<usize> = files.iter().map(|&i| i as usize).collect();
+        session
+            .update_only_files(handle, &set)
+            .await
+            .map_err(|e| format!("设置下载文件失败: {}", e))
+    }
+
+    /// 读取句柄当前进度：返回 (已下载字节, 总字节, 每文件已下载字节)
+    /// `file_progress` 与种子文件一一对应，供前端详情页展示单文件进度。
+    pub fn progress_full(handle: &Arc<ManagedTorrent>) -> (u64, u64, Vec<u64>) {
+        let s = handle.stats();
+        (s.progress_bytes, s.total_bytes, s.file_progress.clone())
+    }
+
+    /// 暂停种子（下载中的连接会停止，已下载片段保留，可继续）
+    pub async fn pause(&self, handle: &Arc<ManagedTorrent>) -> Result<(), String> {
+        let session = self.get_session().await?;
+        session
+            .pause(handle)
+            .await
+            .map_err(|e| format!("暂停种子失败: {}", e))
+    }
+
+    /// 继续种子（幂等）：恢复已暂停的种子。
+    /// 若种子本已处于 Live（例如 select_bt_files 的 set_only_files 内部已恢复过、
+    /// 或暂停期间被其他逻辑恢复），直接视为成功，避免 librqbit 报 "torrent is already live"
+    /// 而导致 pause→resume 链路被误判为失败。
+    pub async fn unpause(&self, handle: &Arc<ManagedTorrent>) -> Result<(), String> {
+        let session = self.get_session().await?;
+        match handle.stats().state {
+            librqbit::TorrentStatsState::Live => Ok(()),
+            librqbit::TorrentStatsState::Error => Err("种子处于错误状态，无法继续".to_string()),
+            librqbit::TorrentStatsState::Paused
+            | librqbit::TorrentStatsState::Initializing { .. } => session
+                .unpause(handle)
+                .await
+                .map_err(|e| format!("继续种子失败: {}", e)),
+        }
+    }
+
+    /// 删除种子（info_hash 为 hex 字符串；delete_files 是否同时删除已下载文件）
+    pub async fn delete(&self, info_hash: &str, delete_files: bool) -> Result<(), String> {
+        let session = self.get_session().await?;
+        let id = TorrentIdOrHash::parse(info_hash)
+            .map_err(|_| format!("无效的 infohash: {}", info_hash))?;
+        session
+            .delete(id, delete_files)
+            .await
+            .map_err(|e| format!("删除种子失败: {}", e))
+    }
+
+    /// 读取句柄当前下载进度 (已下载字节, 总字节)
+    pub fn progress(handle: &Arc<ManagedTorrent>) -> (u64, u64) {
+        let s = handle.stats();
+        (s.progress_bytes, s.total_bytes)
+    }
+
+    /// 停止全局会话（应用退出时调用）
+    pub async fn stop(&self) {
+        let session = {
+            let mut guard = self.session.lock().await;
+            guard.take()
+        };
+        if let Some(s) = session {
+            let _ = s.stop().await;
+        }
+    }
+}
+
+/// 字节数组转小写十六进制字符串（librqbit 的 Id 未实现 Display）
+pub(crate) fn hex_encode(bytes: &[u8]) -> String {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for &b in bytes {
+        out.push(HEX[(b >> 4) as usize] as char);
+        out.push(HEX[(b & 0x0f) as usize] as char);
+    }
+    out
+}
+
+/// 默认会话选项（后续如需新增 DHT/缓存等可在此统一配置）
+fn lib_session_options() -> librqbit::SessionOptions {
+    librqbit::SessionOptions::default()
+}

src-tauri/src/lib.rs

@@ -6,44 +6,63 @@ mod download_engine;
 mod logger;
 mod mihomo_manager;
 mod monitor_kernel;
+mod music;
 mod network_monitor;
 mod osd_window;
 mod process_manager;
 mod quickpanel;
 mod screenshot;
+mod secrets;
 mod setup;
 mod shortcut;
 mod snap_fix;
+mod terminal;
+mod translate;
 mod tray_menu;
 mod updater;
 mod win32_util;
 
 use download_engine::{
     DownloadEngine,
-    downloader_add_task, downloader_check_url, downloader_get_extension_info, downloader_get_settings, downloader_get_tasks,
+    downloader_add_task, downloader_cancel_task, downloader_check_url, downloader_focus_window, downloader_get_extension_info, downloader_get_settings, downloader_get_tasks, downloader_inspect, downloader_select_bt_files,
-    downloader_open_dir, downloader_open_url, downloader_pause_task, downloader_remove_task,
+    downloader_open_dir, downloader_open_url, downloader_pause_task, downloader_redownload, downloader_remove_task,
     downloader_resume_task, downloader_save_settings, downloader_status,
 };
 use logger::{
     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_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
-    proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_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_install_kernel, proxy_kernel_info, proxy_patch_configs, proxy_restart, proxy_save_settings,
+    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_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop, proxy_traffic,
-    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_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_repair_pawnio, monitor_set_auto_start, monitor_set_elevate_on_launch,
-    monitor_start, monitor_start_elevated, monitor_status, monitor_stop, MonitorKernel,
+    monitor_set_hardware_config, monitor_start, monitor_start_elevated, monitor_status, monitor_stop,
+    MonitorKernel,
+};
+use music::{
+    feiniu_activate_connection, feiniu_cache_clear, feiniu_cache_fetch, feiniu_cache_status,
+    feiniu_delete_connection, feiniu_delete_local, feiniu_fnconnect_resolve, feiniu_get_config,
+    feiniu_list_connections, feiniu_list_audio_files, feiniu_list_tracks, feiniu_login,
+    feiniu_logout, feiniu_lyric,
+    feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection,
+    music_cancel_runtime_install, music_download, music_download_cancel, music_env_status,
+    music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping,
+    music_resolve, music_save_settings, music_search, music_secret_get, music_secret_set,
+    music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret,
+    webdav_save_secret, webdav_test,
+    webdav_upload, MusicManager,
 };
 use network_monitor::network_status;
 use osd_window::{
-    osd_apply_overlay_style, osd_begin_drag, osd_set_click_through, osd_set_topmost,
+    osd_apply_overlay_style, osd_begin_drag, osd_set_bounds, osd_set_click_through,
-    osd_start_drag_watch, osd_start_topmost_watch, osd_stop_watch,
+    osd_set_topmost, osd_start_drag_watch, osd_start_game_watch, osd_start_topmost_watch,
+    osd_stop_watch,
 };
 use process_manager::{
     process_all_status, process_start, process_status,
@@ -51,20 +70,26 @@ use process_manager::{
 };
 use screenshot::commands::{
     screenshot_capture_fullscreen, screenshot_capture_window, screenshot_clear_fullscreen,
-    screenshot_compose_copy, screenshot_copy_image, screenshot_crop_copy_stored,
+    screenshot_compose_copy, screenshot_compose_png, screenshot_copy_image,
-    screenshot_crop_stored, screenshot_cursor_pos, screenshot_delete_cache,
+    screenshot_crop_copy_stored, screenshot_crop_stored, screenshot_cursor_pos,
-    screenshot_disable_transitions, screenshot_enum_windows, screenshot_fullscreen_png,
+    screenshot_delete_cache, screenshot_disable_transitions, screenshot_enum_windows,
-    screenshot_get_editor_image, screenshot_get_fullscreen_bmp, screenshot_load_cache,
+    screenshot_fullscreen_png, screenshot_get_fullscreen_bmp, screenshot_load_cache,
-    screenshot_register_pin_shortcut, screenshot_register_shortcut, screenshot_save_cache,
+    screenshot_load_cache_raw, screenshot_pick_list, screenshot_register_pin_shortcut,
-    screenshot_save_png, screenshot_set_editor_image, screenshot_unregister_pin_shortcut,
+    screenshot_register_shortcut,
-    screenshot_unregister_shortcut, screenshot_window_from_point,
+    screenshot_save_cache, screenshot_save_png, screenshot_scroll_capture,
+    screenshot_scroll_cancel, screenshot_scroll_finish, screenshot_scroll_start,
+    screenshot_set_scroll_hole, screenshot_show_overlay, screenshot_take_editor_image_raw,
+    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_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_get_thumb,
-    clipboard_paste_to_target, clipboard_register_shortcut, clipboard_save_settings, clipboard_search,
+    clipboard_hide_popup, clipboard_hide_preview, clipboard_paste_to_target,
-    clipboard_set_pinned, clipboard_show_popup, clipboard_show_window, clipboard_start,
+    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::{
@@ -79,7 +104,62 @@ use quickpanel::{
     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};
+use terminal::commands::{
+    terminal_attach_session, terminal_clear_known_hosts, terminal_clear_session,
+    terminal_close_session, terminal_confirm_host_key, terminal_default_cwd, terminal_delete_host,
+    terminal_delete_key, terminal_delete_shell, terminal_detach_session,
+    terminal_export_known_hosts, terminal_forget_host, terminal_generate_key,
+    terminal_get_settings, terminal_import_key, terminal_import_known_hosts,
+    terminal_import_ssh_config, terminal_key_public, terminal_list_hosts,
+    terminal_list_known_hosts, terminal_list_keys, terminal_list_sessions,
+    terminal_list_shells, terminal_new_host_id, terminal_open_local,
+    terminal_open_ssh, terminal_open_local_path, terminal_reveal_local_path,
+    terminal_refresh_shells, terminal_rename_key, terminal_rename_session,
+    terminal_resize, terminal_save_appearance, terminal_save_host, terminal_save_layout,
+    terminal_save_security, terminal_save_selection, terminal_save_settings,
+    terminal_save_shell, terminal_save_shortcuts, terminal_send_key, terminal_session_alive,
+    terminal_session_cwd, terminal_session_cwd_value, terminal_set_host_password,
+    terminal_set_encoding,
+    terminal_set_key_passphrase,
+    terminal_set_last_shell, terminal_test_shell, terminal_write,
+    // SFTP 文件管理（P1）
+    terminal_sftp_close, terminal_sftp_delete, terminal_sftp_download, terminal_sftp_is_open,
+    terminal_sftp_list, terminal_sftp_mkdir, terminal_sftp_open, terminal_sftp_parent,
+    terminal_sftp_read_link, terminal_sftp_rename, terminal_sftp_upload,
+    // 命令片段（P1）
+    terminal_delete_snippet, terminal_list_snippets, terminal_render_snippet,
+    terminal_restore_default_snippets, terminal_run_snippet, terminal_save_snippet,
+    // 命令历史（P1）
+    terminal_history_clear, terminal_history_delete, terminal_history_query,
+    terminal_history_run, terminal_history_sources, terminal_history_toggle_favorite,
+    // 端口转发（P2）
+    terminal_add_forward, terminal_list_forwards, terminal_remove_forward,
+    // 会话日志（P2）
+    terminal_log_path, terminal_toggle_logging,
+    // 主机配置同步（P2）
+    terminal_export_hosts, terminal_import_hosts,
+    // 会话模板（P2）
+    terminal_delete_template, terminal_save_template,
+    // AI 命令助手（P2）
+    terminal_ai_engines, terminal_ai_suggest,
+};
+use terminal::TerminalManager;
+use translate::{
+    translate_abort, translate_apply_shortcuts, translate_copy_text, translate_engine_delete,
+    translate_engine_models, translate_engine_save, translate_engine_test_config,
+    translate_engines_list,
+    translate_get_settings, translate_history_clear, translate_history_delete,
+    translate_history_list, translate_history_set_favorited, translate_ocr_languages,
+    translate_paste_back, translate_popup_edit_mode, translate_popup_hide,
+    translate_popup_prefs_set, translate_popup_ready, translate_popup_resize,
+    translate_popup_set_pinned, translate_preview_popup, translate_run, translate_save_settings,
+    translate_screenshot_region, translate_secret_clear, translate_secret_set,
+    translate_stream_start,
+};
+use updater::{
+    app_version, update_check, update_install, update_thinghk_apply, update_thinghk_cancel,
+    update_thinghk_confirm, ThinghkUpdateState,
+};
 
 #[tauri::command]
 fn quit_app(app: tauri::AppHandle) {
@@ -88,11 +168,16 @@ fn quit_app(app: tauri::AppHandle) {
 }
 
 /// 导出 tauri-specta 生成的 TypeScript 类型与命令绑定（仅 debug 构建，开发时自动刷新）。
-/// 覆盖 proxy / quickpanel / clipboard / download_engine / screenshot 五个模块；
+/// 覆盖 proxy / quickpanel / clipboard / download_engine / screenshot / translate 等模块；
 /// 豁免清单（返回 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）。
+/// screenshot_get_fullscreen_bmp（返回 ipc::Response）/ screenshot_compose_copy（接收 ipc::Request）、
+/// music_ping / music_get_sources / music_search（返回 serde_json::Value）。
+///
+/// 注意：export 结果写入 `../src/lib/bindings.ts`，因此**新增模块的命令后需至少以 debug
+/// 构建运行一次**，前端才能用 `commands.xxx` 拿到类型。在此之前前端若需调用，
+/// 只能退回原生 `invoke`（返回类型需自行声明）。
 #[cfg(debug_assertions)]
 fn export_bindings() {
     use specta_typescript::Typescript;
@@ -104,15 +189,16 @@ fn export_bindings() {
         // 生成命令失败时直接 throw，与原生 invoke 一致，前端无需解包 helper
         .error_handling(ErrorHandlingMode::Throw)
         .commands(collect_commands![
-            // 应用更新（4）
+            // 应用更新（6）
-            app_version, update_check, update_install, update_thinghk,
+            app_version, update_check, update_install, update_thinghk_apply,
+            update_thinghk_confirm, update_thinghk_cancel,
             // proxy（20）
-            proxy_activate_profile, proxy_check_kernel_update, proxy_clear_system_proxy,
+            proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
-            proxy_close_connection, proxy_delete_profile, proxy_get_settings,
+            proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_settings,
-            proxy_get_system_proxy, proxy_import_profile, proxy_install_kernel,
+            proxy_get_system_proxy, proxy_import_profile, proxy_kernel_info,
-            proxy_kernel_info, proxy_restart, proxy_save_settings,
+            proxy_restart, proxy_save_settings,
-            proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop,
+            proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop, proxy_traffic,
-            proxy_test_delay, proxy_update_kernel, proxy_update_profile,
+            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,
@@ -124,26 +210,73 @@ fn export_bindings() {
             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（20）
+            // clipboard（23）
             clipboard_get_history, clipboard_get_pinned, clipboard_search, clipboard_get_item,
-            clipboard_set_pinned, clipboard_delete, clipboard_clear, clipboard_copy_back,
+            clipboard_get_thumb, clipboard_set_pinned, clipboard_delete, clipboard_clear,
-            clipboard_count, clipboard_get_settings, clipboard_save_settings, clipboard_status,
+            clipboard_copy_back, clipboard_count, clipboard_get_settings, clipboard_save_settings,
-            clipboard_start, clipboard_stop, clipboard_register_shortcut,
+            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_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_resume_task, downloader_cancel_task, downloader_redownload, downloader_remove_task, downloader_get_settings,
-            downloader_save_settings, downloader_open_dir, downloader_open_url,
+            downloader_save_settings, downloader_open_dir, downloader_open_url, downloader_focus_window, downloader_inspect, downloader_select_bt_files,
-            // screenshot（21，豁免 2：get_fullscreen_bmp 返回 ipc::Response、compose_copy 接收 ipc::Request）
+            // music（6，豁免 3：music_ping / music_get_sources / music_search 返回 serde_json::Value）
-            screenshot_disable_transitions, screenshot_register_shortcut,
+            music_env_status, music_install_runtime, music_cancel_runtime_install,
+            music_stop_bridge, music_get_settings, music_save_settings,
+            // screenshot（23，豁免 3：get_fullscreen_bmp / take_editor_image_raw 返回 ipc::Response、
+            // compose_copy / compose_png 接收 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_window_from_point, screenshot_cursor_pos,
+            screenshot_crop_copy_stored, screenshot_pick_list, screenshot_cursor_pos,
-            screenshot_enum_windows, screenshot_capture_window, screenshot_set_editor_image,
+            screenshot_enum_windows, screenshot_capture_window, screenshot_scroll_capture,
-            screenshot_get_editor_image, screenshot_copy_image, screenshot_save_png,
+            screenshot_scroll_cancel, screenshot_scroll_finish, screenshot_scroll_start,
+            screenshot_set_scroll_hole,
+            screenshot_copy_image, screenshot_save_png,
             screenshot_save_cache, screenshot_load_cache, screenshot_delete_cache,
+            // translate（20）
+            translate_get_settings, translate_save_settings, translate_apply_shortcuts,
+            translate_engines_list, translate_engine_save, translate_engine_delete,
+            translate_secret_set, translate_secret_clear, translate_engine_test_config,
+            translate_engine_models, translate_run, translate_copy_text,
+            translate_preview_popup, translate_popup_ready, translate_popup_hide,
+            translate_popup_edit_mode, translate_popup_set_pinned, translate_popup_prefs_set,
+            translate_popup_resize, translate_screenshot_region, translate_ocr_languages,
+            translate_history_list, translate_history_delete, translate_history_clear,
+            translate_history_set_favorited,
+            translate_stream_start, translate_abort, translate_paste_back,
+            // terminal（41：39 业务 + key_public / new_host_id 两个辅助）
+            terminal_get_settings, terminal_save_settings, terminal_save_appearance,
+            terminal_save_layout, terminal_save_selection, terminal_save_security,
+            terminal_save_shortcuts,
+            terminal_list_shells, terminal_refresh_shells, terminal_save_shell,
+            terminal_delete_shell, terminal_set_last_shell, terminal_test_shell,
+            terminal_default_cwd,
+            terminal_open_local, terminal_open_ssh, terminal_list_sessions,
+            terminal_close_session, terminal_write, terminal_resize, terminal_rename_session,
+            terminal_detach_session, terminal_attach_session, terminal_session_cwd,
+            terminal_send_key, terminal_clear_session, terminal_session_alive,
+            terminal_set_encoding,
+            terminal_list_hosts, terminal_save_host, terminal_delete_host,
+            terminal_set_host_password, terminal_import_ssh_config,
+            terminal_list_keys, terminal_generate_key, terminal_import_key,
+            terminal_delete_key, terminal_rename_key, terminal_set_key_passphrase,
+            terminal_key_public, terminal_new_host_id,
+            terminal_list_known_hosts, terminal_forget_host, terminal_clear_known_hosts,
+            terminal_export_known_hosts, terminal_import_known_hosts,
+            terminal_confirm_host_key,
+            // 命令历史（6 个）
+            //
+            // 注意：这 6 个命令**必须与 `run()` 里那份 `collect_commands!` 同时登记**。
+            // 只登记其中一处不会报错：漏了这里 = 运行时能调但 `bindings.ts` 里没有类型；
+            // 漏了那边 = 有类型但调用失败。两种都是「编译/启动全绿但功能静默不可用」。
+            terminal_history_query, terminal_history_sources,
+            terminal_history_toggle_favorite, terminal_history_delete,
+            terminal_history_clear, terminal_history_run,
         ])
         .export(Typescript::default(), "../src/lib/bindings.ts")
         .expect("failed to export bindings");
@@ -168,12 +301,15 @@ pub fn run() {
                 .build()
         )
         .manage(ProcessManager::new())
+        .manage(ThinghkUpdateState::new())
         .invoke_handler(tauri::generate_handler![
             quit_app,
             app_version,
             update_check,
             update_install,
-            update_thinghk,
+            update_thinghk_apply,
+            update_thinghk_confirm,
+            update_thinghk_cancel,
             process_start,
             process_stop,
             process_status,
@@ -187,11 +323,13 @@ pub fn run() {
             proxy_save_settings,
             proxy_kernel_info,
             proxy_check_kernel_update,
-            proxy_update_kernel,
+            proxy_apply_kernel_update,
-            proxy_install_kernel,
+            proxy_cancel_kernel_install,
+            proxy_confirm_install,
             proxy_status,
             proxy_start,
             proxy_stop,
+            proxy_traffic,
             proxy_restart,
             proxy_version,
             proxy_get_proxies,
@@ -214,6 +352,7 @@ pub fn run() {
             monitor_elevate_self,
             monitor_stop,
             monitor_get_status,
+            monitor_repair_pawnio,
             monitor_get_snapshot,
             monitor_get_elevate_on_launch,
             monitor_set_elevate_on_launch,
@@ -221,19 +360,62 @@ pub fn run() {
             monitor_set_auto_start,
             monitor_get_hardware_config,
             monitor_set_hardware_config,
+            music_env_status,
+            music_install_runtime,
+            music_cancel_runtime_install,
+            music_update_musicdl,
+            music_ping,
+            music_stop_bridge,
+            music_get_sources,
+            music_search,
+            music_parse_playlist,
+            music_resolve,
+            music_get_settings,
+            music_save_settings,
+            music_download,
+            music_download_cancel,
+            feiniu_list_connections,
+            feiniu_save_connection,
+            feiniu_delete_connection,
+            feiniu_activate_connection,
+            feiniu_test_connection,
+            feiniu_login,
+            feiniu_logout,
+            feiniu_get_config,
+            feiniu_list_tracks,
+            feiniu_lyric,
+            feiniu_media_prefix,
+            feiniu_scan_local,
+            feiniu_list_audio_files,
+            feiniu_cache_status,
+            feiniu_cache_clear,
+            feiniu_cache_fetch,
+            feiniu_fnconnect_resolve,
+            webdav_test,
+            webdav_upload,
+            webdav_delete,
+            webdav_get_secret,
+            webdav_save_secret,
+            music_secret_get,
+            music_secret_set,
+            feiniu_delete_local,
             network_status,
             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_start_game_watch,
             osd_stop_watch,
             downloader_get_tasks,
             downloader_add_task,
             downloader_check_url,
             downloader_pause_task,
             downloader_resume_task,
+            downloader_cancel_task,
+            downloader_redownload,
             downloader_remove_task,
             downloader_get_settings,
             downloader_save_settings,
@@ -241,10 +423,14 @@ pub fn run() {
             downloader_get_extension_info,
             downloader_open_dir,
             downloader_open_url,
+            downloader_focus_window,
+            downloader_inspect,
+            downloader_select_bt_files,
             clipboard_get_history,
             clipboard_get_pinned,
             clipboard_search,
             clipboard_get_item,
+            clipboard_get_thumb,
             clipboard_set_pinned,
             clipboard_delete,
             clipboard_clear,
@@ -261,6 +447,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,
@@ -300,29 +491,161 @@ 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,
-            screenshot_set_editor_image,
+            screenshot_scroll_capture,
-            screenshot_get_editor_image,
+            screenshot_scroll_cancel,
+            screenshot_scroll_finish,
+            screenshot_scroll_start,
+            screenshot_set_scroll_hole,
+            screenshot_take_editor_image_raw,
             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
+            screenshot_compose_copy,
+            screenshot_compose_png,
+            translate_get_settings,
+            translate_save_settings,
+            translate_apply_shortcuts,
+            translate_engines_list,
+            translate_engine_save,
+            translate_engine_delete,
+            translate_secret_set,
+            translate_secret_clear,
+            translate_engine_test_config,
+            translate_engine_models,
+            translate_run,
+            translate_copy_text,
+            translate_preview_popup,
+            translate_popup_ready,
+            translate_popup_hide,
+            translate_popup_edit_mode,
+            translate_popup_set_pinned,
+            translate_popup_prefs_set,
+            translate_popup_resize,
+            translate_screenshot_region,
+            translate_ocr_languages,
+            translate_history_list,
+            translate_history_delete,
+            translate_history_clear,
+            translate_history_set_favorited,
+            translate_stream_start,
+            translate_abort,
+            translate_paste_back,
+            terminal_get_settings,
+            terminal_save_settings,
+            terminal_save_appearance,
+            terminal_save_layout,
+            terminal_save_selection,
+            terminal_save_security,
+            terminal_save_shortcuts,
+            terminal_list_shells,
+            terminal_refresh_shells,
+            terminal_save_shell,
+            terminal_delete_shell,
+            terminal_set_last_shell,
+            terminal_test_shell,
+            terminal_default_cwd,
+            terminal_open_local,
+            terminal_open_ssh,
+            terminal_list_sessions,
+            terminal_close_session,
+            terminal_write,
+            terminal_resize,
+            terminal_rename_session,
+            terminal_detach_session,
+            terminal_attach_session,
+            terminal_session_cwd,
+            terminal_set_encoding,
+            terminal_send_key,
+            terminal_clear_session,
+            terminal_session_alive,
+            terminal_list_hosts,
+            terminal_save_host,
+            terminal_delete_host,
+            terminal_set_host_password,
+            terminal_import_ssh_config,
+            terminal_list_keys,
+            terminal_generate_key,
+            terminal_import_key,
+            terminal_delete_key,
+            terminal_rename_key,
+            terminal_set_key_passphrase,
+            terminal_key_public,
+            terminal_new_host_id,
+            terminal_list_known_hosts,
+            terminal_forget_host,
+            terminal_clear_known_hosts,
+            terminal_export_known_hosts,
+            terminal_import_known_hosts,
+            terminal_confirm_host_key,
+            // SFTP 文件管理（P1）
+            terminal_sftp_is_open,
+            terminal_sftp_open,
+            terminal_sftp_close,
+            terminal_sftp_list,
+            terminal_sftp_parent,
+            terminal_sftp_read_link,
+            terminal_sftp_mkdir,
+            terminal_sftp_delete,
+            terminal_sftp_rename,
+            terminal_sftp_upload,
+            terminal_sftp_download,
+            terminal_session_cwd_value,
+            // 本地文件操作（SFTP 面板的「打开 / 在资源管理器中显示」）
+            terminal_open_local_path,
+            terminal_reveal_local_path,
+            // 命令片段（P1）
+            terminal_list_snippets,
+            terminal_save_snippet,
+            terminal_delete_snippet,
+            terminal_render_snippet,
+            terminal_run_snippet,
+            terminal_restore_default_snippets,
+            // 命令历史（P1）
+            terminal_history_query,
+            terminal_history_sources,
+            terminal_history_toggle_favorite,
+            terminal_history_delete,
+            terminal_history_clear,
+            terminal_history_run,
+            // 端口转发（P2）
+            terminal_add_forward,
+            terminal_list_forwards,
+            terminal_remove_forward,
+            // 会话日志（P2）
+            terminal_log_path,
+            terminal_toggle_logging,
+            // 主机配置同步（P2）
+            terminal_export_hosts,
+            terminal_import_hosts,
+            // 会话模板（P2）
+            terminal_delete_template,
+            terminal_save_template,
+            // AI 命令助手（P2）
+            terminal_ai_engines,
+            terminal_ai_suggest
         ])
         .setup(setup::init)
         .on_window_event(|window, event| {
-            if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+            // 仅主窗口拦截关闭（隐藏到托盘）。其他窗口（截图编辑器/OSD 等）
-                window.hide().ok();
+            // 调用 close() 是真实销毁语义，全局拦截会导致隐藏窗口累积泄漏。
-                api.prevent_close();
+            if window.label() == constants::windows::MAIN {
+                if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+                    window.hide().ok();
+                    api.prevent_close();
+                }
             }
         })
         .build(tauri::generate_context!())
@@ -337,16 +660,28 @@ pub fn run() {
                 }
                 if let Some(monitor) = app.try_state::<MonitorKernel>() {
                     // cleanup_on_exit 是 async；在事件循环回调中直接 block_on 有 panic 风险且阻塞退出，
-                    // 放到独立 OS 线程执行并限时等待（与托盘旧实现同模式）。
+                    // 放到独立 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(());
-                    .join()
+                    });
-                    .ok();
+                    let _ = rx.recv_timeout(std::time::Duration::from_secs(3));
+                }
+                if let Some(music) = app.try_state::<MusicManager>() {
+                    // 停止音乐桥接进程（kill 快速返回，wait 在后台线程完成）
+                    music.cleanup_on_exit();
+                }
+                if let Some(term) = app.try_state::<TerminalManager>() {
+                    // 关闭全部终端会话。**不等待**：ConPTY 的 ClosePseudoConsole 会
+                    // 阻塞到所有句柄关闭，退出路径上等待会卡死（会话侧已把关闭动作
+                    // 放进后台线程，进程终止时 OS 回收剩余资源）。
+                    term.cleanup_on_exit();
                 }
                 if let Some(clip) = app.try_state::<ClipboardManager>() {
                     clip.stop();

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

@@ -4,10 +4,18 @@ 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,
+    KernelInfo, KernelUpdateInfo, MihomoManager, ProfileMeta, ProxySettings, ProxyStatus, TrafficSnapshot,
 };
 
-use crate::process_manager::{ProcessInfo, ProcessManager};
+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]
@@ -41,25 +49,33 @@ pub async fn proxy_check_kernel_update(
     state.check_kernel_update().await
 }
 
+/// 取消内核下载/安装（设置取消标志，下载循环轮询后中止）
 #[tauri::command]
 #[specta::specta]
-pub async fn proxy_update_kernel(
+pub fn proxy_cancel_kernel_install(state: State<'_, MihomoManager>) -> Result<(), String> {
-    state: State<'_, MihomoManager>,
+    state.cancel_kernel_install();
-    app: AppHandle,
+    Ok(())
-    mirror_prefix: Option<String>,
-) -> Result<KernelInfo, String> {
-    state.install_kernel(&app, mirror_prefix.unwrap_or_default()).await
 }
 
-/// 首次安装内核（与 update_kernel 共用 install_kernel 实现，语义独立便于前端区分场景）
+/// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换。
+/// （下载阶段允许 mihomo 运行以便走系统代理，解压替换前必须停止 mihomo，否则 exe 被占用）
 #[tauri::command]
 #[specta::specta]
-pub async fn proxy_install_kernel(
+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,
-    mirror_prefix: Option<String>,
+    zip_path: String,
 ) -> Result<KernelInfo, String> {
-    state.install_kernel(&app, mirror_prefix.unwrap_or_default()).await
+    let path = std::path::PathBuf::from(zip_path);
+    state.apply_kernel_update(&app, path).await
 }
 
 #[tauri::command]
@@ -87,12 +103,19 @@ pub fn proxy_start(
     app: AppHandle,
 ) -> Result<ProcessInfo, String> {
     let params = state.prepare_for_start(&app)?;
-    pm.start(params)
+    let info = pm.start(params)?;
+    // 手动启动也遵循「启动时自动开启系统代理」设置
+    state.apply_auto_system_proxy();
+    Ok(info)
 }
 
 #[tauri::command]
 #[specta::specta]
-pub fn proxy_stop(pm: State<'_, ProcessManager>) -> Result<(), String> {
+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")
 }
 
@@ -110,8 +133,65 @@ pub async fn proxy_restart(
     })
     .await
     .map_err(|e| format!("sleep 失败: {}", e))?;
-    let params = state.prepare_for_start(&app)?;
+
-    pm.start(params)
+    // 启动并等待 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]
@@ -158,6 +238,14 @@ pub async fn proxy_get_connections(
     state.get_connections().await
 }
 
+#[tauri::command]
+#[specta::specta]
+pub async fn proxy_traffic(
+    state: State<'_, MihomoManager>,
+) -> Result<TrafficSnapshot, String> {
+    state.traffic_snapshot().await
+}
+
 #[tauri::command]
 #[specta::specta]
 pub async fn proxy_close_connection(
@@ -220,7 +308,12 @@ pub fn proxy_activate_profile(
 #[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)?;

src-tauri/src/mihomo_manager/kernel.rs

@@ -1,15 +1,18 @@
 //! 内核（mihomo.exe）安装 / 更新 / 版本查询。
 //! 子模块通过 `impl super::MihomoManager` 为管理器追加方法，可访问父模块私有字段。
 
-use futures_util::StreamExt;
 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 {
@@ -203,57 +206,15 @@ impl MihomoManager {
         }
     }
 
-    /// 下载并安装内核（首次安装与更新共用此方法）
+    /// 应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。
-    /// - mirror_prefix: 用户选择的镜像源前缀（空串=直连 GitHub）
+    /// zip_path: 下载模块下载完成的 zip 文件路径。
-    /// - 流式下载：实时推送下载进度到前端
+    /// 任何阶段失败都会 emit error 事件，避免前端进度卡住。
-    /// - zip crate 解压：替代 PowerShell，避免执行策略问题
+    pub async fn apply_kernel_update(&self, app: &AppHandle, zip_path: PathBuf) -> Result<KernelInfo, String> {
-    /// - 备份旧内核：替换前备份为 .bak
+        self.kernel_cancel.store(false, Ordering::SeqCst);
-    /// 任何阶段失败都会 emit error 事件，避免前端进度卡在初始状态
+        let _ = self.kernel_cancel_tx.send(false);
-    pub async fn install_kernel(&self, app: &AppHandle, mirror_prefix: String) -> Result<KernelInfo, String> {
+        let result = self.apply_kernel_inner(app, zip_path).await;
-        let result = self.install_kernel_inner(app, mirror_prefix).await;
         if let Err(ref e) = result {
-            let _ = app.emit(
+            if e != KERNEL_CANCELLED {
-                KERNEL_INSTALL_PROGRESS,
-                InstallProgress {
-                    stage: "error".into(),
-                    percent: 0,
-                    downloaded_bytes: 0,
-                    total_bytes: None,
-                    message: e.clone(),
-                },
-            );
-        }
-        result
-    }
-
-    async fn install_kernel_inner(&self, app: &AppHandle, mirror_prefix: String) -> Result<KernelInfo, String> {
-        let info = self.check_kernel_update().await?;
-        let zip_path = self.cores_dir().join("mihomo-update.zip");
-        let extract_dir = self.cores_dir().join("mihomo-update-tmp");
-
-        // 拼接用户选择的镜像源 URL
-        let url = if mirror_prefix.is_empty() {
-            info.download_url.clone()
-        } else {
-            format!("{}{}", mirror_prefix, info.download_url)
-        };
-        let label = if mirror_prefix.is_empty() { "GitHub 直连".to_string() } else { mirror_prefix.clone() };
-        let _ = app.emit(
-            KERNEL_INSTALL_PROGRESS,
-            InstallProgress {
-                stage: "downloading".into(),
-                percent: 0,
-                downloaded_bytes: 0,
-                total_bytes: None,
-                message: format!("正在下载：{}", label),
-            },
-        );
-
-        // 单源下载（用户已选择）
-        match self.download_with_progress(app, &url, &zip_path).await {
-            Ok(()) => {}
-            Err(e) => {
-                let msg = format!("下载失败（{}）：{}", label, e);
                 let _ = app.emit(
                     KERNEL_INSTALL_PROGRESS,
                     InstallProgress {
@@ -261,11 +222,50 @@ impl MihomoManager {
                         percent: 0,
                         downloaded_bytes: 0,
                         total_bytes: None,
-                        message: msg.clone(),
+                        message: e.clone(),
                     },
                 );
-                let _ = fs::remove_file(&zip_path);
+            }
-                return Err(msg);
+        }
+        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() => {}
             }
         }
 
@@ -299,8 +299,6 @@ impl MihomoManager {
         }
 
         // 在解压目录中递归查找 exe 文件
-        // mihomo zip 内的 exe 名字通常与 zip 同名（如 mihomo-windows-amd64-v3-v1.19.13.exe），
-        // 不是固定的 mihomo.exe，所以查找唯一的 .exe 文件即可
         let new_exe = self
             .find_exe_in_dir(&extract_dir)
             .ok_or_else(|| "解压后未找到任何 .exe 文件".to_string())?;
@@ -313,7 +311,7 @@ impl MihomoManager {
                 percent: 96,
                 downloaded_bytes: 0,
                 total_bytes: None,
-                message: "正在安装...".into(),
+                message: "正在替换内核...".into(),
             },
         );
         let kernel = self.kernel_path();
@@ -345,57 +343,6 @@ impl MihomoManager {
         Ok(final_info)
     }
 
-    /// 流式下载并实时推送进度事件
-    async fn download_with_progress(
-        &self,
-        app: &AppHandle,
-        url: &str,
-        dest: &PathBuf,
-    ) -> Result<(), String> {
-        let resp = self
-            .client
-            .get(url)
-            .header("User-Agent", "thing-app")
-            .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 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;
-            // 下载占总进度的 0-90%
-            let percent = match total {
-                Some(t) if t > 0 => ((downloaded as f64 / t as f64) * 90.0) as u8,
-                _ => 0,
-            };
-            // 仅在变化超过 1% 时 emit，避免事件轰炸
-            if percent >= last_percent + 1 {
-                last_percent = percent;
-                let _ = app.emit(
-                    KERNEL_INSTALL_PROGRESS,
-                    InstallProgress {
-                        stage: "downloading".into(),
-                        percent,
-                        downloaded_bytes: downloaded,
-                        total_bytes: total,
-                        message: format!("已下载 {:.2} MB", downloaded as f64 / 1024.0 / 1024.0),
-                    },
-                );
-            }
-        }
-        file.flush().map_err(|e| format!("flush 失败: {}", e))?;
-        Ok(())
-    }
-
     /// 用 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))?;

src-tauri/src/mihomo_manager/mod.rs

@@ -6,6 +6,7 @@
 //! - [`system_proxy`]：Windows 系统代理开关
 //! - [`commands`]：Tauri 命令层
 
+mod autoswitch;
 mod commands;
 mod kernel;
 mod profiles;
@@ -13,22 +14,24 @@ 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 types::{InstallProgress, KernelInfo, KernelUpdateInfo, ProfileMeta, ProxySettings, ProxyStatus, TrafficSnapshot};
 pub use commands::{
-    proxy_activate_profile, proxy_check_kernel_update, proxy_clear_system_proxy, proxy_close_connection,
+    proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
-    proxy_delete_profile, proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy,
+    proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies,
-    proxy_import_profile, proxy_install_kernel, proxy_kernel_info, proxy_patch_configs, proxy_restart,
+    proxy_get_settings, proxy_get_system_proxy, proxy_import_profile, proxy_kernel_info, proxy_traffic,
-    proxy_save_settings, proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop,
+    proxy_patch_configs, proxy_restart, proxy_save_settings, proxy_select_proxy, proxy_set_system_proxy,
-    proxy_test_delay, proxy_update_kernel, proxy_update_profile, proxy_version,
+    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::Mutex;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use tauri::AppHandle;
 
@@ -42,10 +45,29 @@ struct SettingsCacheEntry {
     settings: ProxySettings,
 }
 
+/// 流量速率差分基线：记录上次采样的会话总量与时刻，用于计算实时速率
+struct TrafficBaseline {
+    download_total: u64,
+    upload_total: u64,
+    at: Instant,
+}
+
 pub struct MihomoManager {
     root: PathBuf,
     client: Client,
     settings_cache: Mutex<Option<SettingsCacheEntry>>,
+    /// 流量速率差分基线：记录上次采样总量与时刻，由两次 /connections 总量差异计算实时速率
+    traffic_baseline: Mutex<Option<TrafficBaseline>>,
+    /// 内核安装/更新的取消标志（前端「停止下载」置位，下载循环轮询后中止）
+    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 {
@@ -62,6 +84,24 @@ impl MihomoManager {
                 .build()
                 .unwrap_or_else(|_| Client::new()),
             settings_cache: Mutex::new(None),
+            traffic_baseline: 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(());
         }
     }
 
@@ -274,6 +314,29 @@ impl MihomoManager {
         })
     }
 
+    /// mihomo 启动成功后，若配置了「启动时自动开启系统代理」且当前未开，则开启系统代理。
+    /// 手动启动与 App 自启共用，保证设置语义一致（mihomo 运行期间自动跟随系统代理）。
+    pub fn apply_auto_system_proxy(&self) {
+        let settings = self.load_settings();
+        if !settings.auto_system_proxy {
+            return;
+        }
+        // 以注册表实际状态为准判断是否已开启：settings.system_proxy 是会话内标志，
+        // 上次退出 cleanup_on_exit 只清注册表不会回写该标志，重启后会残留 true，
+        // 若用它做守卫会导致「启动时自动开启系统代理」永远被短路而不生效。
+        if system_proxy::get_system_proxy_windows() {
+            return;
+        }
+        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();
@@ -284,13 +347,9 @@ impl MihomoManager {
             Ok(params) => {
                 if let Err(e) = pm.start(params) {
                     crate::logger::log_error("mihomo", &format!("自动启动失败: {}", e));
-                } else if settings.auto_system_proxy {
+                } else {
-                    // 启动成功后开启系统代理
+                    // 启动成功后按「启动时自动开启系统代理」设置决定是否开启系统代理
-                    let addr = format!("127.0.0.1:{}", settings.mixed_port);
+                    self.apply_auto_system_proxy();
-                    let _ = system_proxy::set_system_proxy_windows(&addr);
-                    let mut s = settings;
-                    s.system_proxy = true;
-                    let _ = self.save_settings(&s);
                 }
             }
             Err(e) => {
@@ -408,6 +467,48 @@ impl MihomoManager {
         self.api_get("/connections").await
     }
 
+    /// 拉取 /connections 并计算实时流量快照。
+    /// 速率由两次采样的会话总量差分得出；mihomo 重启导致总量回退时自动重置基线。
+    pub async fn traffic_snapshot(&self) -> Result<TrafficSnapshot, String> {
+        let conns = self.get_connections().await?;
+        let upload_total = conns["uploadTotal"].as_u64().unwrap_or(0);
+        let download_total = conns["downloadTotal"].as_u64().unwrap_or(0);
+        let active_connections = conns["connections"].as_array().map(|a| a.len()).unwrap_or(0);
+
+        let (upload_speed, download_speed) = {
+            let base = self.traffic_baseline.lock().unwrap();
+            match base.as_ref() {
+                // 正常差分：总量单调递增才计算速率
+                Some(b) if upload_total >= b.upload_total && download_total >= b.download_total => {
+                    let dt = b.at.elapsed().as_secs_f64();
+                    if dt > 0.0 {
+                        let up = ((upload_total - b.upload_total) as f64 / dt).max(0.0) as u64;
+                        let down = ((download_total - b.download_total) as f64 / dt).max(0.0) as u64;
+                        (up, down)
+                    } else {
+                        (0, 0)
+                    }
+                }
+                // 无基线或总量回退（mihomo 重启）：本帧速率为 0，下方重置基线
+                _ => (0, 0),
+            }
+        };
+
+        *self.traffic_baseline.lock().unwrap() = Some(TrafficBaseline {
+            download_total,
+            upload_total,
+            at: Instant::now(),
+        });
+
+        Ok(TrafficSnapshot {
+            download_total,
+            upload_total,
+            download_speed,
+            upload_speed,
+            active_connections,
+        })
+    }
+
     pub async fn close_connection(&self, id: &str) -> Result<(), String> {
         self.api_request(
             reqwest::Method::DELETE,

src-tauri/src/mihomo_manager/types.rs

@@ -124,6 +124,22 @@ pub struct ProxyStatus {
     pub restart_count: u32,
 }
 
+/// 实时流量快照（由 /connections 的会话总量差分得出实时速率）
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct TrafficSnapshot {
+    /// 本次会话累计下载字节数
+    pub download_total: u64,
+    /// 本次会话累计上传字节数
+    pub upload_total: u64,
+    /// 实时下载速率（字节/秒）
+    pub download_speed: u64,
+    /// 实时上传速率（字节/秒）
+    pub upload_speed: u64,
+    /// 当前活跃连接数
+    pub active_connections: usize,
+}
+
 /// 内核安装进度事件载荷
 /// - stage: downloading | extracting | replacing | done | error
 /// - percent: 0-100（无 total_bytes 时为 0，前端按 downloadedBytes 显示）

src-tauri/src/monitor_kernel.rs

@@ -228,6 +228,8 @@ pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
 pub struct KernelStatus {
     pub ready: bool,
     pub is_admin: bool,
+    /// PawnIO 驱动是否已安装；旧版内核无此字段，Option 兼容
+    pub pawn_io_installed: Option<bool>,
     pub uptime_ms: f64,
     pub group_count: u32,
     pub sensor_count: u32,
@@ -370,7 +372,9 @@ impl MonitorKernel {
         self.root.join("hardware-config.json")
     }
 
-    /// 确保内核就位：若 cores/ 无内核或版本过期（源文件较新），从资源目录复制
+    /// 确保内核就位：若 cores/ 无内核或版本过期（源文件较新），从资源目录复制。
+    /// 同时把 PawnIO_setup.exe（可选资源）复制过去——内核提权启动时会静默安装它，
+    /// 作为 WinRing0 被系统/杀软拦截时读取温度/频率的替代驱动。
     pub fn prepare_kernel(&self, app: &AppHandle) -> Result<MonitorKernelInfo, String> {
         let kernel = self.kernel_path();
         if let Ok(src) = app.path().resolve("binaries/ThingHK.exe", BaseDirectory::Resource) {
@@ -385,6 +389,24 @@ impl MonitorKernel {
                 }
             }
         }
+
+        // PawnIO 安装器：可选资源，缺失时仅影响自动安装能力（不影响内核运行）
+        if let Ok(setup_src) = app.path().resolve("binaries/PawnIO_setup.exe", BaseDirectory::Resource) {
+            if setup_src.exists() {
+                let setup_dest = self.cores_dir().join("PawnIO_setup.exe");
+                let need_copy = !setup_dest.exists()
+                    || fs::metadata(&setup_src)
+                        .and_then(|s| fs::metadata(&setup_dest).map(|d| s.len() != d.len()))
+                        .unwrap_or(true);
+                if need_copy {
+                    fs::create_dir_all(self.cores_dir()).ok();
+                    if let Err(e) = fs::copy(&setup_src, &setup_dest) {
+                        crate::logger::log_warn("monitor", &format!("复制 PawnIO_setup.exe 失败: {}", e));
+                    }
+                }
+            }
+        }
+
         Ok(MonitorKernelInfo {
             path: kernel.to_string_lossy().to_string(),
             exists: kernel.exists(),
@@ -489,12 +511,20 @@ impl MonitorKernel {
                 Ok(resp) if resp.status().is_success() => {
                     match resp.json::<KernelStatus>().await {
                         Ok(s) if s.ready => {
+                            // PawnIO 诊断：已提权但驱动缺失时，温度/频率等 ring0 传感器大概率无法读取
+                            if s.is_admin && s.pawn_io_installed == Some(false) {
+                                crate::logger::log_warn(
+                                    "monitor",
+                                    "Kernel 已提权但 PawnIO 驱动未安装，CPU 温度/频率可能无法读取（检查 cores/PawnIO_setup.exe 是否随包部署）",
+                                );
+                            }
                             let _ = app.emit(
                                 crate::constants::events::MONITOR_READY,
                                 serde_json::json!({
                                     "isAdmin": s.is_admin,
                                     "sensorCount": s.sensor_count,
                                     "providers": s.providers,
+                                    "pawnIoInstalled": s.pawn_io_installed,
                                 }),
                             );
                             return Ok(());
@@ -988,6 +1018,52 @@ pub async fn monitor_get_status(state: tauri::State<'_, MonitorKernel>) -> Resul
     state.get_status().await
 }
 
+/// 检测并修复 PawnIO 驱动：确保安装器随内核部署 → 静默安装 → 重启监控内核
+/// （LHM 打开一次后不会重新发现驱动，装完必须重启才能恢复 CPU 温度/功耗读取）。
+/// 返回 { installed, needReboot }；installed=false 说明未提权或安装失败，交由内核启动自装。
+#[tauri::command]
+pub async fn monitor_repair_pawnio(
+    state: tauri::State<'_, MonitorKernel>,
+    pm: tauri::State<'_, ProcessManager>,
+    app: AppHandle,
+) -> Result<serde_json::Value, String> {
+    // 1. 确保 PawnIO_setup.exe 随内核部署
+    state.prepare_kernel(&app)?;
+    let setup = state.cores_dir().join("PawnIO_setup.exe");
+    if !setup.exists() {
+        return Err("未找到 PawnIO_setup.exe 安装器（binaries 资源未随包部署），请重新部署监控内核".into());
+    }
+
+    // 2. 静默安装驱动（继承当前进程权限；Thing 已提权则直接成功）
+    let mut cmd = std::process::Command::new(&setup);
+    cmd.args(["-install", "-silent"]);
+    crate::process_manager::setup_creation_flags(&mut cmd);
+    let (installed, need_reboot) = match cmd.status() {
+        Ok(status) => {
+            let code = status.code().unwrap_or(-1);
+            match code {
+                3010 => (true, true), // ERROR_SUCCESS_REBOOT_REQUIRED
+                0 => (true, false),
+                _ => (false, false),
+            }
+        }
+        Err(e) => return Err(format!("运行 PawnIO 安装器失败: {}", e)),
+    };
+
+    // 3. 重启监控内核，使 LHM 以 PawnIO 重新打开传感器
+    state.stop_subscription(&app).await;
+    if state.is_elevated() && !is_thing_elevated() {
+        state.shutdown_kernel().await?;
+        state.elevated.store(false, Ordering::SeqCst);
+        state.start_elevated(&app).await?;
+    } else {
+        pm.stop(PROCESS_ID)?;
+        state.start_with_subscription(&app).await?;
+    }
+
+    Ok(serde_json::json!({ "installed": installed, "needReboot": need_reboot }))
+}
+
 #[tauri::command]
 pub async fn monitor_get_snapshot(state: tauri::State<'_, MonitorKernel>) -> Result<SensorSnapshot, String> {
     state.get_snapshot().await

src-tauri/src/music/bridge.rs

@@ -0,0 +1,262 @@
+//! 桥接进程生命周期：spawn（stdio JSON-Lines 协议）→ 请求分发 → 事件转发 → 停止。
+//! 子模块通过 `impl super::MusicManager` 追加方法。
+//!
+//! 协议（与 bridge.py 对应）：
+//! 请求 `{"id":1,"method":"ping","params":{}}`
+//! 响应 `{"id":1,"ok":true,"result":{...}}` 或 `{"id":1,"ok":false,"error":"..."}`
+//! 无 id 的事件行 `{"event":"download","type":"progress",...}` 由 reader 线程
+//! 原样转发为 Tauri 事件 `music-download-event`（见 constants::events）。
+
+use std::io::{BufRead, BufReader, Write};
+use std::process::{Command, Stdio};
+use tauri::Emitter;
+
+use super::{BridgeEntry, MusicManager, PythonEnv};
+
+/// 桥接脚本源码（内置，运行时写出到 {root}/bridge.py，避免资源目录配置）
+const BRIDGE_SCRIPT: &str = include_str!("bridge.py");
+
+/// 桥接请求错误分类：决定是否允许重启桥接进程重试。
+/// 应用层错误与超时绝不能触发重启——重启会杀掉正在进行的下载任务。
+pub(crate) enum BridgeError {
+    /// 传输层错误（进程退出/管道损坏/写入失败/通道关闭）→ 可重启重试
+    Transport(String),
+    /// 应用层错误（桥接正常响应 ok:false）→ 不重启
+    App(String),
+    /// 响应超时 → 不重启（进程可能只是忙，如正在执行长耗时搜索）
+    Timeout(String),
+}
+
+impl BridgeError {
+    fn into_message(self) -> String {
+        match self {
+            BridgeError::Transport(m) | BridgeError::App(m) | BridgeError::Timeout(m) => m,
+        }
+    }
+}
+
+impl MusicManager {
+    /// 桥接进程是否在运行（存在且未退出）
+    pub fn bridge_running(&self) -> bool {
+        let mut guard = match self.bridge.lock() {
+            Ok(g) => g,
+            Err(_) => return false,
+        };
+        match guard.as_mut() {
+            Some(entry) => entry.child.try_wait().ok().map(|w| w.is_none()).unwrap_or(false),
+            None => false,
+        }
+    }
+
+    /// 确保桥接进程已启动（已启动则直接返回；并发调用由 start_lock 串行化）
+    pub fn ensure_bridge(&self) -> Result<(), String> {
+        if self.bridge_running() {
+            return Ok(());
+        }
+        let _guard = self.start_lock().lock().map_err(|e| e.to_string())?;
+        // 二次检查（等待锁期间可能已被其他调用方启动）
+        if self.bridge_running() {
+            return Ok(());
+        }
+        // 清理可能残留的旧条目
+        self.bridge.lock().map_err(|e| e.to_string())?.take();
+        let python = self.resolve_python()?;
+        self.spawn_bridge(&python)
+    }
+
+    /// 启动桥接进程：stdin/stdout 管道直连，stderr 写入 runtime/bridge_stderr.log
+    fn spawn_bridge(&self, python: &PythonEnv) -> Result<(), String> {
+        let script = self.bridge_script_path();
+        // 每次启动前重写脚本，保证与当前版本一致（内容固定，成本极低）
+        std::fs::write(&script, BRIDGE_SCRIPT).map_err(|e| format!("写出桥接脚本失败: {}", e))?;
+
+        let stderr_log = self.runtime_dir().join("bridge_stderr.log");
+        let stderr_file = std::fs::File::create(&stderr_log).map_err(|e| e.to_string())?;
+
+        let mut cmd = Command::new(&python.exe);
+        cmd.arg(&script);
+        cmd.stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::from(stderr_file));
+        crate::process_manager::setup_creation_flags(&mut cmd);
+        // cwd 统一设为模块根目录：musicdl 会在 cwd 落 search_results.pkl 等缓存文件，
+        // 不设置时（系统 Python）会污染应用工作目录（开发期为仓库根目录）
+        if let Some(parent) = script.parent() {
+            cmd.current_dir(parent);
+        }
+
+        let mut child = cmd
+            .spawn()
+            .map_err(|e| format!("启动桥接进程失败 (python: {}): {}", python.exe.display(), e))?;
+        crate::process_manager::assign_to_job(&child);
+
+        let stdin = child.stdin.take().ok_or_else(|| "无法获取桥接 stdin".to_string())?;
+        let stdout = child.stdout.take().ok_or_else(|| "无法获取桥接 stdout".to_string())?;
+
+        *self.bridge.lock().map_err(|e| e.to_string())? = Some(BridgeEntry { child, stdin });
+
+        // 启动 stdout reader 线程：按行读取，按 id 分发到 pending；无 id 的事件行转发到前端
+        let pending = self.pending.clone();
+        let app = self.app_handle();
+        std::thread::spawn(move || {
+            let reader = BufReader::new(stdout);
+            for line in reader.lines() {
+                let Ok(line) = line else { break };
+                let Ok(v) = serde_json::from_str::<serde_json::Value>(&line) else {
+                    crate::logger::log_warn("music-bridge", &format!("无法解析 stdout: {}", line));
+                    continue;
+                };
+                if let Some(id) = v.get("id").and_then(|i| i.as_u64()) {
+                    if let Some(tx) = pending.lock().ok().and_then(|mut m| m.remove(&id)) {
+                        let _ = tx.send(v);
+                    }
+                } else if v.get("event").is_some() {
+                    // 事件行（下载进度等）：原样转发给前端
+                    if let Some(app) = app.as_ref() {
+                        let _ = app.emit(crate::constants::events::MUSIC_DOWNLOAD_EVENT, &v);
+                    }
+                } else {
+                    // 其他无 id 行仅记日志
+                    crate::logger::log_info("music-bridge", &line);
+                }
+            }
+            crate::logger::log_info("music-bridge", "stdout 已关闭，reader 线程退出");
+        });
+
+        crate::logger::log_info(
+            "music-bridge",
+            &format!("桥接进程已启动 (python: {})", python.exe.display()),
+        );
+        Ok(())
+    }
+
+    /// 停止桥接进程：kill 快速返回，wait 移到后台线程；所有 pending 请求置为失败
+    pub fn stop_bridge(&self) {
+        let entry = self.bridge.lock().ok().and_then(|mut b| b.take());
+        if let Some(mut entry) = entry {
+            let _ = entry.child.kill();
+            // drop stdin/stdout 关闭管道端，reader 线程读到 EOF 退出
+            drop(entry.stdin);
+            std::thread::spawn(move || {
+                let _ = entry.child.wait();
+            });
+            crate::logger::log_info("music-bridge", "桥接进程已停止");
+        }
+        // 通知前端：活动中的下载任务应标记为中断
+        if let Some(app) = self.app_handle() {
+            let _ = app.emit(
+                crate::constants::events::MUSIC_DOWNLOAD_EVENT,
+                serde_json::json!({ "event": "download", "type": "bridge-stopped" }),
+            );
+        }
+        // 唤醒所有等待中的请求（以 Null 表示已中止）
+        if let Ok(mut map) = self.pending.lock() {
+            for (_, tx) in map.drain() {
+                let _ = tx.send(serde_json::Value::Null);
+            }
+        }
+    }
+
+    /// 发送一条请求并等待响应（默认 5s 超时）。传输层错误时自动重启重试一次。
+    pub async fn request(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<serde_json::Value, String> {
+        self.request_with_timeout(method, params, std::time::Duration::from_secs(5))
+            .await
+    }
+
+    /// 发送一条请求并等待响应（自定义超时，供 search 等长耗时操作使用）。
+    /// 仅传输层错误（进程退出/管道损坏）会重启桥接并重试一次；
+    /// 应用层错误（桥接返回 ok:false）与超时不重启——重启会误杀正在下载的任务。
+    pub async fn request_with_timeout(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+        timeout: std::time::Duration,
+    ) -> Result<serde_json::Value, String> {
+        self.ensure_bridge()?;
+        match self.request_inner(method, params.clone(), timeout).await {
+            Ok(v) => Ok(v),
+            Err(BridgeError::Transport(_)) => {
+                // 一次重启机会（进程可能已退出/管道损坏）
+                self.stop_bridge();
+                self.ensure_bridge()?;
+                self.request_inner(method, params, timeout)
+                    .await
+                    .map_err(BridgeError::into_message)
+            }
+            Err(e) => Err(e.into_message()),
+        }
+    }
+
+    async fn request_inner(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+        timeout: std::time::Duration,
+    ) -> Result<serde_json::Value, BridgeError> {
+        let id = self.next_id.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        let (tx, rx) = tokio::sync::oneshot::channel::<serde_json::Value>();
+        self.pending
+            .lock()
+            .map_err(|e| BridgeError::Transport(e.to_string()))?
+            .insert(id, tx);
+
+        // 写入 stdin（同步函数，MutexGuard 在返回时释放，避免跨 await 持有非 Send 值）
+        self.write_request(id, method, &params)
+            .map_err(BridgeError::Transport)?;
+
+        let v = tokio::time::timeout(timeout, rx)
+            .await
+            .map_err(|_| BridgeError::Timeout("桥接响应超时".to_string()))?
+            .map_err(|_| BridgeError::Transport("桥接响应通道已关闭".to_string()))?;
+
+        // 停止桥接时发送 Null 表示中止
+        if v.is_null() {
+            return Err(BridgeError::Transport("桥接进程已停止".into()));
+        }
+        if v.get("ok").and_then(|o| o.as_bool()).unwrap_or(false) {
+            Ok(v.get("result").cloned().unwrap_or(serde_json::Value::Null))
+        } else {
+            Err(BridgeError::App(
+                v.get("error")
+                    .and_then(|e| e.as_str())
+                    .unwrap_or("桥接返回未知错误")
+                    .to_string(),
+            ))
+        }
+    }
+
+    /// 写入一条请求到桥接 stdin（同步；进程已退出 / 管道损坏时返回错误）
+    fn write_request(&self, id: u64, method: &str, params: &serde_json::Value) -> Result<(), String> {
+        let line = format!(
+            "{{\"id\":{},\"method\":{},\"params\":{}}}\n",
+            id,
+            serde_json::to_string(method).map_err(|e| e.to_string())?,
+            params
+        );
+        let mut guard = self.bridge.lock().map_err(|e| e.to_string())?;
+        let Some(entry) = guard.as_mut() else {
+            return Err("桥接进程未启动".into());
+        };
+        // 进程已退出 → 立即失败，交给外层重启
+        if entry.child.try_wait().map_err(|e| e.to_string())?.is_some() {
+            return Err("桥接进程已退出".into());
+        }
+        entry
+            .stdin
+            .write_all(line.as_bytes())
+            .map_err(|e| format!("写入桥接 stdin 失败: {}", e))?;
+        entry.stdin.flush().map_err(|e| format!("刷新桥接 stdin 失败: {}", e))?;
+        Ok(())
+    }
+
+    /// ping 桥接进程（P0 环境层连通性验证）
+    pub async fn ping(&self) -> Result<serde_json::Value, String> {
+        let v = self.request("ping", serde_json::Value::Null).await?;
+        crate::logger::log_info("music-bridge", &format!("ping 成功: {}", v));
+        Ok(v)
+    }
+}

src-tauri/src/music/commands.rs

@@ -0,0 +1,730 @@
+//! 音乐模块 Tauri 命令层。
+
+use serde_json::json;
+use std::time::{SystemTime, UNIX_EPOCH};
+use tauri::{AppHandle, State};
+
+use super::{
+    normalize_base_url, resolve_base_url, extract_fn_id, FeiniuConnection, MusicEnvStatus,
+    MusicManager, MusicSettings,
+};
+
+/// 查询环境状态（Python / musicdl / FFmpeg / 桥接进程），设置页「环境检查」面板调用。
+/// 异步命令：子进程探测在阻塞线程池执行，避免冻结主线程/UI。
+#[tauri::command]
+#[specta::specta]
+pub async fn music_env_status(state: State<'_, MusicManager>) -> Result<MusicEnvStatus, String> {
+    state.env_status().await
+}
+
+/// 安装便携 Python + musicdl（幂等），全程推送 music-runtime-install-progress 事件
+#[tauri::command]
+#[specta::specta]
+pub async fn music_install_runtime(
+    state: State<'_, MusicManager>,
+    app: AppHandle,
+) -> Result<MusicEnvStatus, String> {
+    state.install_runtime(&app).await?;
+    Ok(state.env_status().await?)
+}
+
+/// 取消便携运行时安装/下载
+#[tauri::command]
+#[specta::specta]
+pub fn music_cancel_runtime_install(state: State<'_, MusicManager>) -> Result<(), String> {
+    state.cancel();
+    Ok(())
+}
+
+/// 把 musicdl 对齐到本应用锁定的版本（`force = true` 表示强制重装）。
+///
+/// 与「安装便携版」的区别：安装的闸门是「能否 import」，所以版本不一致时它什么都不做；
+/// 更新则是显式对齐到 `MUSICDL_VERSION`。**只升到锁定版本，不升 PyPI 最新版**
+/// （bridge.py 的 monkey patch 与 musicdl 版本强耦合，见 `update_musicdl` 的说明）。
+///
+/// 成功后顺手停掉桥接进程：它可能已经 import 了旧版 musicdl 并缓存了 MusicClient，
+/// 不重启就会继续用旧代码跑。下一次搜索/下载会自动拉起新进程。
+///
+/// 返回更新后的环境状态，前端一次往返即可刷新面板。
+#[tauri::command]
+pub async fn music_update_musicdl(
+    state: State<'_, MusicManager>,
+    app: AppHandle,
+    force: Option<bool>,
+) -> Result<MusicEnvStatus, String> {
+    state.update_musicdl(&app, force.unwrap_or(false)).await?;
+    state.stop_bridge();
+    state.env_status().await
+}
+
+/// ping 桥接进程（未启动则自动拉起），返回 {"version","python"}；
+/// 返回 Value 且未标注 specta：前端直接按 JSON 使用
+#[tauri::command]
+pub async fn music_ping(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    state.ping().await
+}
+
+/// 停止桥接进程
+#[tauri::command]
+#[specta::specta]
+pub fn music_stop_bridge(state: State<'_, MusicManager>) -> Result<(), String> {
+    state.stop_bridge();
+    Ok(())
+}
+
+/// 列出 musicdl 已注册的全部搜索源（客户端名）；返回 Value，未标注 specta
+#[tauri::command]
+pub async fn music_get_sources(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    state.request("get_sources", serde_json::Value::Null).await
+}
+
+/// 多源搜索（最长 90s）。sources 为空时桥接使用默认 3 个大陆源；返回 Value，未标注 specta
+#[tauri::command]
+pub async fn music_search(
+    state: State<'_, MusicManager>,
+    keyword: String,
+    sources: Option<Vec<String>>,
+    proxy_url: Option<String>,
+    qq_cookie: Option<String>,
+) -> Result<serde_json::Value, String> {
+    // proxy_url 为空串表示「明确不走代理」（桥接侧会强制直连、屏蔽系统代理）；
+    // qq_cookie 为空表示游客身份（桥接侧不注入 Cookie）
+    let params = serde_json::json!({
+        "keyword": keyword,
+        "sources": sources.unwrap_or_default(),
+        "proxy": proxy_url.unwrap_or_default(),
+        "cookies": qq_cookie.unwrap_or_default(),
+    });
+    state
+        .request_with_timeout("search", params, std::time::Duration::from_secs(90))
+        .await
+}
+
+/// 解析歌单链接（网易云/QQ 等），返回歌曲列表；返回 Value，未标注 specta
+#[tauri::command]
+pub async fn music_parse_playlist(
+    state: State<'_, MusicManager>,
+    url: String,
+    sources: Option<Vec<String>>,
+    proxy_url: Option<String>,
+    qq_cookie: Option<String>,
+) -> Result<serde_json::Value, String> {
+    let params = serde_json::json!({
+        "url": url,
+        "sources": sources.unwrap_or_default(),
+        "proxy": proxy_url.unwrap_or_default(),
+        "cookies": qq_cookie.unwrap_or_default(),
+    });
+    state
+        .request_with_timeout("parse_playlist", params, std::time::Duration::from_secs(90))
+        .await
+}
+
+/// 读取音乐模块设置
+#[tauri::command]
+#[specta::specta]
+pub fn music_get_settings(state: State<'_, MusicManager>) -> MusicSettings {
+    state.load_settings()
+}
+
+/// 保存音乐模块设置（立即生效）
+///
+/// 飞牛音乐**连接相关字段一律以磁盘为准**，不接受前端传值：
+/// 连接列表 / 激活连接 / 旧版单连接字段只由 `feiniu_save_connection`、
+/// `feiniu_activate_connection`、`feiniu_delete_connection`、`feiniu_login`
+/// 等专用命令维护。
+///
+/// 原因：前端 `musicStore` 只在 init 时读一次整份设置并长期复用快照，
+/// 若允许它整份回写，删除连接后任意一次设置保存（哪怕是切页触发的）
+/// 都会把已删除的连接从旧快照里写回来。
+#[tauri::command]
+#[specta::specta]
+pub fn music_save_settings(
+    state: State<'_, MusicManager>,
+    settings: MusicSettings,
+) -> Result<(), String> {
+    let persisted = state.load_settings();
+    let mut next = settings;
+    next.feiniu_connections = persisted.feiniu_connections;
+    next.feiniu_active_id = persisted.feiniu_active_id;
+    next.feiniu_base_url = persisted.feiniu_base_url;
+    next.feiniu_token = persisted.feiniu_token;
+    next.feiniu_username = persisted.feiniu_username;
+    next.feiniu_device_id = persisted.feiniu_device_id;
+    next.feiniu_access_code = persisted.feiniu_access_code;
+    state.save_settings(&next)
+}
+
+/// 解析歌曲真实下载链接（懒解析：搜索只取元数据，试听/下载前调用）。
+/// song（单曲）或 songs（批量）二选一；返回 Value，未标注 specta。
+#[tauri::command]
+pub async fn music_resolve(
+    state: State<'_, MusicManager>,
+    song: Option<serde_json::Value>,
+    songs: Option<Vec<serde_json::Value>>,
+    quality: Option<String>,
+    proxy_url: Option<String>,
+    qq_cookie: Option<String>,
+) -> Result<serde_json::Value, String> {
+    let mut list: Vec<serde_json::Value> = songs.unwrap_or_default();
+    if let Some(s) = song {
+        list.insert(0, s);
+    }
+    if list.is_empty() {
+        return Err("未提供歌曲".into());
+    }
+    let params = serde_json::json!({
+        "songs": list,
+        "quality": quality.unwrap_or_default(),
+        "proxy": proxy_url.unwrap_or_default(),
+        "cookies": qq_cookie.unwrap_or_default(),
+    });
+    state
+        .request_with_timeout("resolve", params, std::time::Duration::from_secs(180))
+        .await
+}
+
+/// 启动下载任务（桥接后台工作池执行，立即返回 taskId；进度经 music-download-event 推送）。
+/// songs 为搜索结果的歌曲 dict（桥接端用 SongInfo.fromdict 重建）。
+/// 返回 Value，未标注 specta。
+#[tauri::command]
+pub async fn music_download(
+    state: State<'_, MusicManager>,
+    task_id: String,
+    songs: Vec<serde_json::Value>,
+    savedir: String,
+    lyric: Option<bool>,
+    cover: Option<bool>,
+    proxy_url: Option<String>,
+    max_concurrent: Option<u32>,
+    quality: Option<String>,
+    qq_cookie: Option<String>,
+) -> Result<serde_json::Value, String> {
+    if songs.is_empty() {
+        return Err("未选择任何歌曲".into());
+    }
+    let params = serde_json::json!({
+        "taskId": task_id,
+        "songs": songs,
+        "savedir": savedir,
+        "lyric": lyric.unwrap_or(true),
+        "cover": cover.unwrap_or(true),
+        "proxy": proxy_url.unwrap_or_default(),
+        "maxConcurrent": max_concurrent.unwrap_or(1).clamp(1, 16),
+        "quality": quality.unwrap_or_default(),
+        "cookies": qq_cookie.unwrap_or_default(),
+    });
+    state
+        .request_with_timeout("download", params, std::time::Duration::from_secs(15))
+        .await
+}
+
+/// 取消下载任务（队列级：正在下载的歌曲会完成，其余标记取消）
+#[tauri::command]
+pub async fn music_download_cancel(
+    state: State<'_, MusicManager>,
+    task_id: String,
+) -> Result<serde_json::Value, String> {
+    state
+        .request("cancel", serde_json::json!({ "taskId": task_id }))
+        .await
+}
+
+// ============ 飞牛音乐(NAS)客户端（多连接） ============
+// 全部命令返回 serde_json::Value、不加 specta：前端用裸 invoke，映射在 feiniuStore。
+
+/// 连接列表 + 激活 id。返回 `{ activeId, list: [{id,name,kind,baseUrl,username,loggedIn,accessCode,insecure}] }`。
+/// `loggedIn` 的权威是系统凭据管理器里的 token（结构体字段只在凭据库不可用降级时才有值）。
+#[tauri::command]
+pub fn feiniu_list_connections(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    let s = state.load_settings();
+    let list: Vec<_> = s
+        .feiniu_connections
+        .iter()
+        .map(|c| {
+            json!({
+                "id": c.id,
+                "name": c.name,
+                "kind": c.kind,
+                "baseUrl": c.base_url,
+                "username": c.username,
+                "loggedIn": !c.token.is_empty() || crate::music::secrets::has_feiniu_token(&c.id),
+                "accessCode": c.access_code,
+                "insecure": c.insecure,
+                "fnId": c.fn_id,
+                "relay": c.relay,
+            })
+        })
+        .collect();
+    Ok(json!({ "activeId": s.feiniu_active_id, "list": list }))
+}
+
+/// 新增/更新一条连接（不触碰已登录的 token；改地址后需重新登录）。
+#[tauri::command]
+pub fn feiniu_save_connection(
+    state: State<'_, MusicManager>,
+    connection: FeiniuConnection,
+) -> Result<serde_json::Value, String> {
+    let mut settings = state.load_settings();
+    let mut conn = connection;
+    conn.base_url = normalize_base_url(&conn.base_url);
+    if conn.id.is_empty() {
+        conn.id = new_conn_id();
+    }
+    let id = conn.id.clone();
+    if let Some(existing) = settings.feiniu_connections.iter_mut().find(|c| c.id == conn.id) {
+        conn.token = existing.token.clone(); // 保留既有 token
+        // relay 是解析结果而非用户输入：同为 fnconnect 时沿用，切换类型则重置
+        conn.relay = conn.kind == "fnconnect" && existing.kind == "fnconnect" && existing.relay;
+        *existing = conn;
+    } else {
+        settings.feiniu_connections.push(conn);
+    }
+    state.save_settings(&settings)?;
+    // 回传 id：新建时前端无需按「地址 + 名称」反查，避免 FnConnect（地址为空）匹配失败
+    Ok(json!({ "ok": true, "id": id }))
+}
+
+/// 删除一条连接；若删的是激活连接，自动切换激活到第一条。
+#[tauri::command]
+pub fn feiniu_delete_connection(
+    state: State<'_, MusicManager>,
+    id: String,
+) -> Result<serde_json::Value, String> {
+    let mut settings = state.load_settings();
+    settings.feiniu_connections.retain(|c| c.id != id);
+    if settings.feiniu_active_id == id {
+        settings.feiniu_active_id = settings
+            .feiniu_connections
+            .first()
+            .map(|c| c.id.clone())
+            .unwrap_or_default();
+    }
+    // 旧版单连接字段是迁移逻辑的输入：残留会让「列表为空」再次被迁移出一条连接。
+    // 删除是明确意图，顺手清掉，保证删了就是删了。
+    settings.feiniu_base_url.clear();
+    settings.feiniu_token.clear();
+    settings.feiniu_username.clear();
+    settings.feiniu_device_id.clear();
+    settings.feiniu_access_code.clear();
+    state.save_settings(&settings)?;
+    // 顺带清掉该连接在系统凭据管理器里的 token，避免留下孤儿凭据
+    let _ = crate::music::secrets::secret_delete(&crate::music::secrets::feiniu_token_key(&id));
+    state.feiniu.sync_with_settings(&settings);
+    Ok(json!({ "ok": true }))
+}
+
+/// 设某连接为激活连接。
+#[tauri::command]
+pub fn feiniu_activate_connection(
+    state: State<'_, MusicManager>,
+    id: String,
+) -> Result<serde_json::Value, String> {
+    let mut settings = state.load_settings();
+    if !settings.feiniu_connections.iter().any(|c| c.id == id) {
+        return Err("连接不存在".into());
+    }
+    settings.feiniu_active_id = id;
+    state.save_settings(&settings)?;
+    state.feiniu.sync_with_settings(&settings);
+    Ok(json!({ "ok": true }))
+}
+
+/// 登录激活/某连接：校验通过后写回该连接的 token/device_id 并启动本地流代理。
+/// fnconnect 连接会先用 fnId 解析出可达 base_url 再登录。
+#[tauri::command]
+pub async fn feiniu_login(
+    state: State<'_, MusicManager>,
+    connection_id: String,
+    username: String,
+    password: String,
+) -> Result<serde_json::Value, String> {
+    let mut settings = state.load_settings();
+    let mut conn = settings
+        .feiniu_connections
+        .iter()
+        .find(|c| c.id == connection_id)
+        .cloned()
+        .ok_or_else(|| "连接不存在，请先保存连接".to_string())?;
+    // fnconnect：用 fnId 解析 base_url
+    if conn.kind == "fnconnect" {
+        let fid = extract_fn_id(&conn.fn_id).ok_or_else(|| "FnConnect 连接缺少有效 fnId".to_string())?;
+        let (url, relay) = resolve_base_url(&fid).await?;
+        conn.base_url = url;
+        conn.relay = relay;
+        if let Some(c) = settings.feiniu_connections.iter_mut().find(|c| c.id == connection_id) {
+            c.base_url = conn.base_url.clone();
+            c.relay = relay;
+        }
+        state.save_settings(&settings)?;
+    }
+    // 用该连接配置装备运行期
+    let mut tmp = settings.clone();
+    tmp.feiniu_active_id = conn.id.clone();
+    state.feiniu.sync_with_settings(&tmp);
+
+    let (token, device_id) = state.feiniu.login(&conn.base_url, &username, &password).await?;
+
+    // token 存进系统凭据管理器；只有写入失败才降级为明文落 settings.json（并记日志）。
+    // 顺序很重要：先确认凭据库写成功，再决定要不要把明文留在结构体里。
+    let token_key = crate::music::secrets::feiniu_token_key(&connection_id);
+    let token_protected = crate::music::secrets::try_store(&token_key, &token);
+    if let Some(existing) = settings.feiniu_connections.iter_mut().find(|c| c.id == connection_id) {
+        existing.token = if token_protected { String::new() } else { token.clone() };
+        existing.device_id = device_id;
+        existing.username = username;
+    }
+    settings.feiniu_active_id = connection_id.clone();
+    state.save_settings(&settings)?;
+    state.feiniu.sync_with_settings(&settings);
+    let prefix = state.feiniu.media_prefix().await?;
+    // 不把 token 回传前端：前端除了 mediaPrefix 之外不需要它，少一处明文暴露面
+    Ok(json!({ "ok": true, "mediaPrefix": prefix, "protected": token_protected }))
+}
+
+/// 登出某连接（清 token，保留地址/账号），代理 Cookie 同步失效。
+///
+/// 顺序有讲究：**必须先删凭据库里的 token 再 sync**，
+/// 否则 `sync_with_settings` 会从凭据库把刚登出的 token 又读回运行期（看起来「登出无效」）。
+#[tauri::command]
+pub fn feiniu_logout(
+    state: State<'_, MusicManager>,
+    connection_id: String,
+) -> Result<serde_json::Value, String> {
+    let mut settings = state.load_settings();
+    let _ = crate::music::secrets::secret_delete(&crate::music::secrets::feiniu_token_key(
+        &connection_id,
+    ));
+    if let Some(c) = settings.feiniu_connections.iter_mut().find(|c| c.id == connection_id) {
+        c.token.clear();
+    }
+    state.save_settings(&settings)?;
+    state.feiniu.sync_with_settings(&settings);
+    state.feiniu.logout();
+    Ok(json!({ "ok": true }))
+}
+
+/// 测试一条连接**草案**能否登录（不持久化任何变更）。
+///
+/// 入参是编辑对话框里的完整草案而非连接 id：新建连接在保存前没有 id，
+/// 若按 id 查库，对话框里的「测试」在保存前必然报 missing required key。
+/// 探测以「草案作为唯一连接」装备运行期，结束后恢复持久化的激活连接。
+#[tauri::command]
+pub async fn feiniu_test_connection(
+    state: State<'_, MusicManager>,
+    connection: FeiniuConnection,
+    username: String,
+    password: String,
+) -> Result<serde_json::Value, String> {
+    let mut conn = connection;
+    conn.base_url = normalize_base_url(&conn.base_url);
+    // fnconnect：先解析 fnId（解析结果只用于本次探测，不回写设置）
+    if conn.kind == "fnconnect" {
+        let fid = extract_fn_id(&conn.fn_id).ok_or_else(|| "FnConnect 连接缺少有效 fnId".to_string())?;
+        let (url, relay) = resolve_base_url(&fid).await?;
+        conn.base_url = url;
+        conn.relay = relay;
+    }
+    if conn.base_url.trim().is_empty() {
+        return Err("请先填写服务器地址或飞牛 ID".to_string());
+    }
+
+    let settings = state.load_settings();
+    let mut tmp = settings.clone();
+    tmp.feiniu_connections = vec![conn.clone()];
+    tmp.feiniu_active_id = conn.id.clone();
+    state.feiniu.sync_with_settings(&tmp);
+
+    let r = state.feiniu.login(&conn.base_url, &username, &password).await;
+    // 探测可能污染运行期：恢复为持久化的激活连接
+    state.feiniu.sync_with_settings(&state.load_settings());
+    match r {
+        Ok(_) => Ok(json!({ "ok": true })),
+        Err(e) => Err(e),
+    }
+}
+
+/// 查询当前激活连接配置：{ activeId, baseUrl, username, loggedIn }。
+#[tauri::command]
+pub fn feiniu_get_config(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    let settings = state.load_settings();
+    state.feiniu.sync_with_settings(&settings);
+    let active_id = settings.feiniu_active_id;
+    let mut cfg = state.feiniu.config();
+    cfg["activeId"] = json!(active_id);
+    Ok(cfg)
+}
+
+/// 分页拉取激活连接曲目列表：{ page, size, keyword? } → NAS 原始 data。
+#[tauri::command]
+pub async fn feiniu_list_tracks(
+    state: State<'_, MusicManager>,
+    page: Option<u32>,
+    size: Option<u32>,
+    keyword: Option<String>,
+) -> Result<serde_json::Value, String> {
+    state.feiniu.sync_with_settings(&state.load_settings());
+    state
+        .feiniu
+        .list_tracks(
+            page.unwrap_or(1).max(1),
+            size.unwrap_or(50).clamp(1, 100),
+            keyword.as_deref(),
+        )
+        .await
+}
+
+/// 获取某曲目歌词：{ lyric }（无则空字符串）。
+#[tauri::command]
+pub async fn feiniu_lyric(
+    state: State<'_, MusicManager>,
+    guid: String,
+) -> Result<serde_json::Value, String> {
+    state.feiniu.sync_with_settings(&state.load_settings());
+    let text = state.feiniu.lyric(&guid).await?;
+    Ok(json!({ "lyric": text }))
+}
+
+/// 本地媒体地址前缀：{ mediaPrefix }（首次调用惰性启动本地流代理）。
+#[tauri::command]
+pub async fn feiniu_media_prefix(
+    state: State<'_, MusicManager>,
+) -> Result<serde_json::Value, String> {
+    state.feiniu.sync_with_settings(&state.load_settings());
+    let prefix = state.feiniu.media_prefix().await?;
+    Ok(json!({ "mediaPrefix": prefix }))
+}
+
+/// 允许访问的本地目录（下载目录 + 自定义曲库目录）。
+/// 本地文件的**列举与删除**都限定在其中——前端只应能操作曲库范围内的文件。
+fn allowed_local_roots(state: &MusicManager) -> Vec<String> {
+    let s = state.load_settings();
+    let mut dirs: Vec<String> = vec![s.savedir.clone()];
+    for d in &s.feiniu_local_dirs {
+        if !dirs.iter().any(|x| x == d) {
+            dirs.push(d.clone());
+        }
+    }
+    dirs.into_iter().filter(|d| !d.trim().is_empty()).collect()
+}
+
+/// 路径是否位于允许的根目录之下。
+/// 两侧都先 `canonicalize`：`..` 与符号链接因此无法越出根目录。
+fn is_within_roots(path: &std::path::Path, roots: &[String]) -> bool {
+    let Ok(target) = std::fs::canonicalize(path) else {
+        return false;
+    };
+    roots.iter().any(|r| {
+        std::fs::canonicalize(r)
+            .map(|root| target.starts_with(&root))
+            .unwrap_or(false)
+    })
+}
+
+/// 列出某个下载目录中的音频文件（非递归）：`{ items: [{path,name,size,mtim}] }`。
+///
+/// 供上传编排在下载目录里定位「刚落盘的文件」——用 `feiniu_scan_local` 会递归遍历
+/// 整个曲库并解析标签，为一次上传扫全库是纯浪费。不解析标签（匹配只需要文件名与时间）。
+#[tauri::command]
+pub async fn feiniu_list_audio_files(
+    state: State<'_, MusicManager>,
+    dir: String,
+) -> Result<serde_json::Value, String> {
+    let roots = allowed_local_roots(&state);
+    if roots.is_empty() || !is_within_roots(std::path::Path::new(&dir), &roots) {
+        return Err(format!("拒绝列举曲库目录之外的路径：{dir}"));
+    }
+    tauri::async_runtime::spawn_blocking(move || crate::music::feiniu::list_audio_files(&dir))
+        .await
+        .map_err(|e| format!("列举目录失败: {e}"))
+}
+
+/// 扫描本地曲库目录中的音频文件：{ items }（目录 = 下载 savedir + 用户自定义 dirs）。
+/// 标签解析结果缓存在 CacheManager（size+mtim 未变即复用）。
+///
+/// **必须 async + spawn_blocking**：Tauri 中不带 async 的命令在主线程执行，
+/// 而 walkdir 递归 + lofty 全量标签解析在万级曲库下会阻塞数秒——UI 直接冻住。
+/// 目录与缓存路径都先取出为自有值，避免把 `State` 借进 'static 的阻塞任务。
+#[tauri::command]
+pub async fn feiniu_scan_local(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    let dirs = allowed_local_roots(&state);
+    let tags_cache = state.feiniu.local_tags_path();
+    tauri::async_runtime::spawn_blocking(move || {
+        crate::music::scan_local_dirs(&dirs, Some(tags_cache.as_path()))
+    })
+    .await
+    .map_err(|e| format!("本地曲库扫描任务失败: {e}"))
+}
+
+/// 播放缓存状态：{ count, usedBytes, usedMb }。
+#[tauri::command]
+pub fn feiniu_cache_status(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    Ok(state.feiniu.cache_status())
+}
+
+/// 清空播放缓存。
+#[tauri::command]
+pub fn feiniu_cache_clear(state: State<'_, MusicManager>) -> Result<serde_json::Value, String> {
+    state.feiniu.cache_clear();
+    Ok(json!({ "ok": true }))
+}
+
+/// 缓存一首歌（命中则直接返回）：{ path } 或 { cached }。
+#[tauri::command]
+pub async fn feiniu_cache_fetch(
+    state: State<'_, MusicManager>,
+    guid: String,
+) -> Result<serde_json::Value, String> {
+    state.feiniu.sync_with_settings(&state.load_settings());
+    let max_gb = state.load_settings().feiniu_cache_max_gb;
+    let hit = state.feiniu.cache_fetch(&guid, max_gb).await?;
+    Ok(json!({ "path": hit, "cached": hit.is_some() }))
+}
+
+/// 生成一条新连接的 id（时间戳 + 进程号，避免引 rand）。
+fn new_conn_id() -> String {
+    let n = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    format!("c{n:x}")
+}
+
+// ============ P6：下载到飞牛 + 曲库增删（WebDAV，无状态） ============
+
+/// 测试 WebDAV 连接与目标目录是否可达。
+#[tauri::command]
+#[specta::specta]
+pub async fn webdav_test(
+    config: crate::music::feiniu::webdav::WebDavConfig,
+    dir: String,
+) -> Result<serde_json::Value, String> {
+    let msg = crate::music::feiniu::webdav::test(&config, &dir).await?;
+    Ok(json!({ "ok": true, "message": msg }))
+}
+
+/// 上传本地文件到 WebDAV 目标目录（流式，不整载内存）。
+#[tauri::command]
+#[specta::specta]
+pub async fn webdav_upload(
+    config: crate::music::feiniu::webdav::WebDavConfig,
+    local_path: String,
+    remote_path: String,
+) -> Result<serde_json::Value, String> {
+    let name = crate::music::feiniu::webdav::upload_file(
+        &config,
+        std::path::Path::new(&local_path),
+        &remote_path,
+    )
+    .await?;
+    Ok(json!({ "ok": true, "name": name }))
+}
+
+/// 删除 WebDAV 远程文件（404 视为已删除）。
+#[tauri::command]
+#[specta::specta]
+pub async fn webdav_delete(
+    config: crate::music::feiniu::webdav::WebDavConfig,
+    remote_path: String,
+) -> Result<serde_json::Value, String> {
+    crate::music::feiniu::webdav::delete(&config, &remote_path).await?;
+    Ok(json!({ "ok": true }))
+}
+
+// ============ 敏感串（系统凭据管理器，DPAPI 保护） ============
+// 统一实现在 crate::music::secrets：WebDAV 账号密码、QQ 音乐 Cookie、飞牛登录 token
+// 三类凭据同构存放，不再出现「一类进凭据库、另一类明文落盘」的双标。
+
+/// 读取 WebDAV 凭据。未配置时 username/password 为 null。
+#[tauri::command]
+pub fn webdav_get_secret() -> Result<serde_json::Value, String> {
+    let parsed = crate::music::secrets::secret_read(crate::music::secrets::KEY_WEBDAV)
+        .unwrap_or(None)
+        .and_then(|raw| serde_json::from_str::<serde_json::Value>(&raw).ok());
+    Ok(parsed.unwrap_or_else(|| json!({ "username": null, "password": null })))
+}
+
+/// 保存 WebDAV 凭据（账号 + 密码整体覆盖）。
+#[tauri::command]
+pub fn webdav_save_secret(username: String, password: String) -> Result<serde_json::Value, String> {
+    let blob = json!({ "username": username, "password": password }).to_string();
+    crate::music::secrets::secret_write(crate::music::secrets::KEY_WEBDAV, &blob)?;
+    Ok(json!({ "ok": true }))
+}
+
+/// 校验前端可访问的凭据键：只允许白名单内的键（见 `secrets::FRONTEND_KEYS`）。
+///
+/// 白名单刻意不含 `webdav-credentials` 与飞牛 token——
+/// 前端因此无法通过这两个通用命令去读写它们，只能碰自己的 QQ 音乐 Cookie。
+fn assert_frontend_secret_key(key: &str) -> Result<(), String> {
+    if crate::music::secrets::frontend_key_allowed(key) {
+        Ok(())
+    } else {
+        Err(format!("不允许访问的凭据键：{key}"))
+    }
+}
+
+/// 读取一个音乐模块的敏感串（如 QQ 音乐 Cookie）：{ value }（未设置 → null）。
+#[tauri::command]
+pub fn music_secret_get(key: String) -> Result<serde_json::Value, String> {
+    assert_frontend_secret_key(&key)?;
+    Ok(json!({ "value": crate::music::secrets::secret_read(&key)? }))
+}
+
+/// 写入 / 清除一个音乐模块的敏感串。`value` 为空表示删除该凭据。
+#[tauri::command]
+pub fn music_secret_set(key: String, value: String) -> Result<serde_json::Value, String> {
+    assert_frontend_secret_key(&key)?;
+    if value.is_empty() {
+        crate::music::secrets::secret_delete(&key)?;
+    } else {
+        crate::music::secrets::secret_write(&key, &value)?;
+    }
+    Ok(json!({ "ok": true }))
+}
+
+/// 删除本地媒体文件（「下载到飞牛」落地即传流程的收尾）。
+/// 仅允许音频 / 歌词 / 封面扩展名，拒绝目录，且**必须落在已配置的下载/曲库目录内**——
+/// 只校验扩展名的话，前端一旦传错路径就能删掉用户的任意音乐文件。
+#[tauri::command]
+#[specta::specta]
+pub fn feiniu_delete_local(
+    state: State<'_, MusicManager>,
+    path: String,
+) -> Result<serde_json::Value, String> {
+    const ALLOWED: [&str; 13] = [
+        "mp3", "flac", "wav", "m4a", "aac", "ogg", "ape", "wma", "lrc", "jpg", "jpeg", "png", "webp",
+    ];
+    let p = std::path::Path::new(&path);
+    let ext_ok = p
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| ALLOWED.contains(&e.to_lowercase().as_str()))
+        .unwrap_or(false);
+    if !ext_ok {
+        return Err(format!("拒绝删除非媒体文件：{path}"));
+    }
+    let meta = std::fs::metadata(p).map_err(|e| format!("文件不存在: {e}"))?;
+    if meta.is_dir() {
+        return Err("拒绝删除目录".to_string());
+    }
+    if !is_within_roots(p, &allowed_local_roots(&state)) {
+        return Err(format!("拒绝删除曲库目录之外的文件：{path}"));
+    }
+    std::fs::remove_file(p).map_err(|e| format!("删除失败: {e}"))?;
+    Ok(json!({ "ok": true }))
+}
+
+// ============ P7：FnConnect 远程连接解析 ============
+
+/// 解析 fnId → 可达 base_url（探测后返回）。命令层在 fnconnect 连接登录前调用。
+#[tauri::command]
+pub async fn feiniu_fnconnect_resolve(
+    state: State<'_, MusicManager>,
+    fn_id: String,
+) -> Result<serde_json::Value, String> {
+    let _ = &state;
+    let (url, relay) = resolve_base_url(&fn_id).await?;
+    Ok(json!({ "baseUrl": url, "relay": relay }))
+}
+

src-tauri/src/music/feiniu/cache.rs

@@ -0,0 +1,162 @@
+//! 飞牛音乐播放缓存（容量限制 + LRU 逐出）。
+//!
+//! 缓存目录：`{app_data}/music/cache`，文件 `guid.<ext>`（ext 缺省记 `bin`）。
+//! 元数据：`index.json` → `{ "guid": { "size", "lastUsed", "file" } }`。
+//! 超上限按 lastUsed 升序逐出，直到总占用低于上限。
+
+use std::collections::HashMap;
+use std::fs;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+
+/// 单条缓存元数据
+#[derive(Serialize, Deserialize, Clone)]
+pub struct CacheEntry {
+    pub size: u64,
+    pub last_used: u64,
+    pub file: String,
+}
+
+pub struct CacheManager {
+    root: PathBuf,
+    index_path: PathBuf,
+}
+
+impl CacheManager {
+    pub fn new(app_data_dir: &Path) -> Self {
+        let root = app_data_dir.join("music").join("cache");
+        fs::create_dir_all(&root).ok();
+        let index_path = root.join("index.json");
+        Self { root, index_path }
+    }
+
+    /// 本地曲库标签缓存文件：{cache_root}/local-tags.json。
+    /// 记录 path -> {size, mtim, 标签}，扫描时未变化的文件直接复用，
+    /// 避免万级曲库每次都重新解析音频标签。
+    pub fn local_tags_path(&self) -> PathBuf {
+        self.root.join("local-tags.json")
+    }
+
+    fn load_index(&self) -> HashMap<String, CacheEntry> {
+        fs::read_to_string(&self.index_path)
+            .ok()
+            .and_then(|s| serde_json::from_str(&s).ok())
+            .unwrap_or_default()
+    }
+
+    fn save_index(&self, idx: &HashMap<String, CacheEntry>) {
+        if let Ok(s) = serde_json::to_string(idx) {
+            fs::write(&self.index_path, s).ok();
+        }
+    }
+
+    fn now_ms(&self) -> u64 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_millis() as u64)
+            .unwrap_or(0)
+    }
+
+    /// 命中缓存：更新 lastUsed 并返回文件路径。
+    pub fn hit(&self, guid: &str) -> Option<String> {
+        let mut idx = self.load_index();
+        if let Some(e) = idx.get_mut(guid) {
+            let path = self.root.join(&e.file);
+            if path.exists() {
+                e.last_used = self.now_ms();
+                self.save_index(&idx);
+                return Some(path.to_string_lossy().to_string());
+            }
+            idx.remove(guid);
+            self.save_index(&idx);
+        }
+        None
+    }
+
+    /// 写入缓存（流式 chunk）；按上限（GB）逐出。返回写入总字节数。
+    pub async fn put<E: std::fmt::Display>(
+        &self,
+        guid: &str,
+        ext: &str,
+        max_gb: u32,
+        mut stream: impl futures_util::Stream<Item = Result<bytes::Bytes, E>> + Unpin,
+    ) -> Result<u64, String> {
+        let safe_guid = sanitize(guid);
+        let ext = if ext.is_empty() { "bin" } else { ext };
+        let file = format!("{safe_guid}.{ext}");
+        let path = self.root.join(&file);
+        let mut total: u64 = 0;
+        let mut f = fs::File::create(&path).map_err(|e| format!("创建缓存文件失败: {e}"))?;
+        while let Some(chunk) = futures_util::StreamExt::next(&mut stream).await {
+            let chunk = chunk.map_err(|e| format!("读取流失败: {e}"))?;
+            total += chunk.len() as u64;
+            f.write_all(chunk.as_ref()).map_err(|e| format!("写入缓存失败: {e}"))?;
+        }
+        f.flush().ok();
+
+        let mut idx = self.load_index();
+        idx.insert(
+            guid.to_string(),
+            CacheEntry {
+                size: total,
+                last_used: self.now_ms(),
+                file,
+            },
+        );
+        self.save_index(&idx);
+        self.evict(max_gb);
+        Ok(total)
+    }
+
+    /// 按上限（GB）逐出。max_gb==0 视为全部清空。
+    fn evict(&self, max_gb: u32) {
+        if max_gb == 0 {
+            self.clear();
+            return;
+        }
+        let max_bytes = max_gb as u64 * 1024 * 1024 * 1024;
+        let mut idx = self.load_index();
+        let mut total: u64 = idx.values().map(|e| e.size).sum();
+        let mut order: Vec<(String, u64)> = idx.iter().map(|(g, e)| (g.clone(), e.last_used)).collect();
+        order.sort_by_key(|(_, t)| *t);
+        for (guid, _) in order {
+            if total <= max_bytes {
+                break;
+            }
+            if let Some(e) = idx.remove(&guid) {
+                let _ = fs::remove_file(self.root.join(&e.file));
+                total = total.saturating_sub(e.size);
+            }
+        }
+        self.save_index(&idx);
+    }
+
+    /// 当前占用与条目数。
+    pub fn status(&self) -> serde_json::Value {
+        let idx = self.load_index();
+        let total: u64 = idx.values().map(|e| e.size).sum();
+        json!({
+            "count": idx.len(),
+            "usedBytes": total,
+            "usedMb": (total as f64 / 1024.0 / 1024.0 * 10.0).round() / 10.0,
+        })
+    }
+
+    pub fn clear(&self) {
+        let idx = self.load_index();
+        for e in idx.values() {
+            let _ = fs::remove_file(self.root.join(&e.file));
+        }
+        fs::remove_file(&self.index_path).ok();
+    }
+}
+
+fn sanitize(s: &str) -> String {
+    s.chars()
+        .map(|c| if c.is_ascii_alphanumeric() || c == '-' || c == '_' { c } else { '_' })
+        .collect()
+}

src-tauri/src/music/feiniu/conn.rs

@@ -0,0 +1,31 @@
+//! 飞牛音乐原生接口纯函数工具（登录签名、地址规范化、设备 ID）。
+//! 接口路径/认证方式对照 FeiNiuMusic(Flutter) `api_client.dart` 的第三方实现。
+
+use sha2::{Digest, Sha256};
+
+/// 规范化服务器地址：去首尾空白、去尾部各层斜杠、去误粘贴的 `/music/api/v1` 后缀。
+pub fn normalize_base_url(input: &str) -> String {
+    let mut u = input.trim().trim_end_matches('/').to_string();
+    let lower = u.to_lowercase();
+    if lower.ends_with("/music/api/v1") {
+        u = u[..u.len() - "/music/api/v1".len()].to_string();
+    }
+    u.trim_end_matches('/').to_string()
+}
+
+/// SHA-256 十六进制（登录时密码签名，对齐原生客户端 `sha256Hex(password)`）。
+pub fn sha256_hex(input: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(input.as_bytes());
+    format!("{:x}", hasher.finalize())
+}
+
+/// 32 位 hex 设备 ID（首次生成后落 settings 复用；不依赖 rand，用时间戳+进程号哈希）。
+pub fn generate_device_id() -> String {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    sha256_hex(&format!("{}-{}", nanos, std::process::id()))[..32].to_string()
+}

src-tauri/src/music/feiniu/fnconnect.rs

@@ -0,0 +1,295 @@
+//! FnConnect 远程连接解析。
+//!
+//! 链路参考第三方客户端 FnMusic 的 `fn_connection_probe_service.dart`：
+//! fnId → 网关 `<网关>/api/v1/fn/con`（authx md5 签名）→ 内网 / 公网 IPv6 / 公网 IPv4 / 中继
+//! 候选 → 并发探测（按优先级早停）→ 首个可达的 base_url。
+//!
+//! 关键约束（实测确认）：
+//! 1. authx 原文为 `PREFIX_url_nonce_timestamp_md5(body)_API_KEY`，
+//!    md5 与 API_KEY 之间是**单个**下划线；多一个下划线网关即返回 `invalid sign`。
+//! 2. 中继地址（`<fnId>.fnos.net`）必须携带 `Cookie: mode=relay` 才会被网关转发到
+//!    NAS 音乐后端，否则网关直接 302 回登录页。
+
+use std::time::Duration;
+
+use futures_util::stream::{FuturesUnordered, StreamExt};
+use md5::{Digest, Md5};
+use rand::RngCore;
+use serde_json::{json, Value};
+
+/// 网关主机（按序回退；5ddd.com 与 fnos.net 为同一服务的不同集群入口）。
+const FN_CONNECT_HOSTS: [&str; 2] = ["https://5ddd.com", "https://fnos.net"];
+/// 连接参数接口路径（签名原文中的 url 部分）。
+const FN_CON_PATH: &str = "/api/v1/fn/con";
+/// 签名常量（对齐第三方实现）。
+const FN_AUTHX_PREFIX: &str = "NDzZTVxnRKP8Z0jXg1VAMonaG8akvh";
+const FN_API_KEY: &str = "zIGtkc3dqZnJpd29qZXJqa2w7c";
+
+/// 网关查询超时。
+const FN_QUERY_TIMEOUT: Duration = Duration::from_secs(10);
+/// 直连候选（内网/公网 IP）探测超时。
+const FN_PROBE_TIMEOUT_DIRECT: Duration = Duration::from_secs(3);
+/// 中继候选探测超时（走公网网关，放宽）。
+const FN_PROBE_TIMEOUT_RELAY: Duration = Duration::from_secs(10);
+
+fn md5_hex(input: &str) -> String {
+    let mut h = Md5::new();
+    h.update(input.as_bytes());
+    format!("{:x}", h.finalize())
+}
+
+/// 从输入识别 fnId：`fnos.net/<id>`、`5ddd.com/<id>`、`<id>.fnos.net`、`<id>.5ddd.com`、或裸 fnId。
+pub fn extract_fn_id(input: &str) -> Option<String> {
+    let s = input.trim();
+    if s.is_empty() {
+        return None;
+    }
+    // 去协议后统一按「可能带路径的 host」处理
+    let mut t = s;
+    for p in ["https://", "http://"] {
+        if let Some(r) = t.strip_prefix(p) {
+            t = r;
+            break;
+        }
+    }
+    let t = t.trim_end_matches('/');
+    // 形如 <网关>/<id>
+    for gw in ["fnos.net/", "5ddd.com/"] {
+        if let Some((_, rest)) = t.split_once(gw) {
+            let id = rest.split('/').next().unwrap_or("").trim();
+            if !id.is_empty() {
+                return Some(id.to_string());
+            }
+        }
+    }
+    // 形如 <id>.<网关>
+    for suffix in [".fnos.net", ".5ddd.com"] {
+        if let Some(id) = t.strip_suffix(suffix) {
+            if !id.is_empty() {
+                return Some(id.to_string());
+            }
+        }
+    }
+    // 裸 fnId
+    if s.len() >= 3 && s.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
+        return Some(s.to_string());
+    }
+    None
+}
+
+/// 计算网关 authx 签名。
+///
+/// 原文（下划线连接，**注意 md5 与 API_KEY 之间只有一个下划线**）：
+/// `PREFIX_url_nonce_timestamp_md5(body)_API_KEY` → 取 md5 作为 sign。
+fn fn_authx(method: &str, url: &str, data: &Value) -> String {
+    let body = if method.eq_ignore_ascii_case("get") {
+        String::new()
+    } else {
+        serde_json::to_string(data).unwrap_or_default()
+    };
+    let mut nonce = String::new();
+    let mut rng = rand::thread_rng();
+    for _ in 0..6 {
+        nonce.push(char::from(b'0' + (rng.next_u32() % 10) as u8));
+    }
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis().to_string())
+        .unwrap_or_default();
+    let raw = format!(
+        "{FN_AUTHX_PREFIX}_{url}_{nonce}_{timestamp}_{}_{FN_API_KEY}",
+        md5_hex(&body)
+    );
+    format!("nonce={nonce}&timestamp={timestamp}&sign={}", md5_hex(&raw))
+}
+
+/// 从网关查询 fnId 的连接参数（多网关按序回退）。
+pub async fn query_fn_connect(fn_id: &str) -> Result<Value, String> {
+    let client = reqwest::Client::builder()
+        .timeout(FN_QUERY_TIMEOUT)
+        .build()
+        .map_err(|e| e.to_string())?;
+    let body = json!({ "fnId": fn_id });
+    let authx = fn_authx("post", FN_CON_PATH, &body);
+
+    let mut last_err = String::from("FnConnect 网关不可达");
+    for host in FN_CONNECT_HOSTS {
+        let resp = match client
+            .post(format!("{host}{FN_CON_PATH}"))
+            .header("Content-Type", "application/json")
+            .header("authx", authx.clone())
+            .json(&body)
+            .send()
+            .await
+        {
+            Ok(r) => r,
+            Err(e) => {
+                last_err = format!("FnConnect 网关不可达: {e}");
+                continue;
+            }
+        };
+        let b: Value = match resp.json().await {
+            Ok(v) => v,
+            Err(e) => {
+                last_err = format!("FnConnect 网关响应异常: {e}");
+                continue;
+            }
+        };
+        if b["code"].as_i64().unwrap_or(-1) != 0 {
+            last_err = b["msg"]
+                .as_str()
+                .filter(|s| !s.is_empty())
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| "FnConnect 网关返回错误".to_string());
+            continue;
+        }
+        return Ok(b["data"].clone());
+    }
+    Err(last_err)
+}
+
+/// 去掉 `host:port` 形式的端口（仅用于中继域名，中继恒走 443）。
+fn strip_port(addr: &str) -> &str {
+    match addr.rsplit_once(':') {
+        Some((host, port)) if !host.is_empty() && port.chars().all(|c| c.is_ascii_digit()) => host,
+        _ => addr,
+    }
+}
+
+/// 构建候选 base_url 列表。返回 `(url, is_relay)`，顺序即优先级：
+/// 内网 IPv4 → 公网 IPv6 → 公网 IPv4 → 中继。
+///
+/// IP 直连地址 HTTP 优先、HTTPS 兜底（自签证书场景 HTTP 更易通）；
+/// `forbbidPublicIpv6` 为真时跳过公网 IPv6。
+pub fn build_candidates(data: &Value, fn_id: &str) -> Vec<(String, bool)> {
+    let mut out: Vec<(String, bool)> = Vec::new();
+    let port = &data["port"];
+    let http = port["httpPort"].as_u64().unwrap_or(5666);
+    let https = port["httpsPort"].as_u64().unwrap_or(5667);
+    let empty: Vec<Value> = Vec::new();
+
+    let strings = |key: &str| -> Vec<String> {
+        data[key]
+            .as_array()
+            .unwrap_or(&empty)
+            .iter()
+            .filter_map(|v| v.as_str())
+            .map(|s| s.to_string())
+            .collect()
+    };
+
+    // 1) 内网 IPv4
+    for ip in strings("ipv4") {
+        out.push((format!("http://{ip}:{http}"), false));
+        out.push((format!("https://{ip}:{https}"), false));
+    }
+    // 2) 公网 IPv6（NAS 侧可禁用）
+    if !data["forbbidPublicIpv6"].as_bool().unwrap_or(false) {
+        for ip in strings("publicIpv6") {
+            out.push((format!("http://[{ip}]:{http}"), false));
+            out.push((format!("https://[{ip}]:{https}"), false));
+        }
+    }
+    // 3) 公网 IPv4
+    for ip in strings("publicIpv4") {
+        out.push((format!("http://{ip}:{http}"), false));
+        out.push((format!("https://{ip}:{https}"), false));
+    }
+    // 4) 中继：仅 HTTPS；网关未返回时按两种集群域名兜底
+    let mut relays = strings("fn");
+    if relays.is_empty() {
+        relays = vec![
+            format!("{fn_id}.fnos.net"),
+            format!("{fn_id}.5ddd.com"),
+        ];
+    }
+    for addr in relays {
+        let domain = strip_port(&addr);
+        if !domain.is_empty() {
+            out.push((format!("https://{domain}"), true));
+        }
+    }
+    out
+}
+
+/// 探测单个 base_url 是否可用（中继候选携带 `mode=relay` 才会被网关转发）。
+///
+/// 判据必须排除 3xx：重定向说明请求**没有真正落到 NAS 音乐后端**
+/// （中继缺 `mode=relay` 时网关 302 回登录页；端口上实际是 fnOS Web UI 时同样 302）。
+/// 早先把「任何 < 500」都当可达，结果候选探测通过、紧接着登录报 `HTTP 302 Found`。
+async fn probe(client: &reqwest::Client, url: &str, relay: bool) -> bool {
+    let timeout = if relay {
+        FN_PROBE_TIMEOUT_RELAY
+    } else {
+        FN_PROBE_TIMEOUT_DIRECT
+    };
+    let full = format!(
+        "{}/music/api/v1/track/list?page=1&size=1",
+        url.trim_end_matches('/')
+    );
+    let mut rb = client.get(&full).timeout(timeout);
+    if relay {
+        rb = rb.header("cookie", "mode=relay");
+    }
+    match rb.send().await {
+        // 未登录时中继会返回 401（已触达 NAS 音乐后端），直连返回 200/401，
+        // 均视为链路可达；3xx（重定向）与 5xx 视为不可达。
+        Ok(resp) => {
+            let code = resp.status().as_u16();
+            code < 500 && !(300..400).contains(&code)
+        }
+        Err(_) => false,
+    }
+}
+
+/// 解析 fnId → 首个可达的 base_url；返回 `(base_url, is_relay)`。
+///
+/// 所有候选并发探测，按优先级（索引越小越优先）取首个确认可达者并早停，
+/// 避免远程场景下顺序探测逐个等待超时。
+pub async fn resolve_base_url(fn_id: &str) -> Result<(String, bool), String> {
+    let data = query_fn_connect(fn_id).await?;
+    let candidates = build_candidates(&data, fn_id);
+    if candidates.is_empty() {
+        return Err("FnConnect 未返回可用地址".into());
+    }
+
+    let client = reqwest::Client::builder()
+        .timeout(FN_PROBE_TIMEOUT_RELAY)
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let mut pending = FuturesUnordered::new();
+    for (i, (url, relay)) in candidates.iter().enumerate() {
+        let client = client.clone();
+        let url = url.clone();
+        let relay = *relay;
+        pending.push(async move {
+            let ok = probe(&client, &url, relay).await;
+            (i, url, relay, ok)
+        });
+    }
+
+    let mut undecided: Vec<usize> = (0..candidates.len()).collect();
+    let mut best: Option<(usize, String, bool)> = None;
+
+    while let Some((i, url, relay, ok)) = pending.next().await {
+        undecided.retain(|x| *x != i);
+        if ok && best.as_ref().map_or(true, |(bi, _, _)| i < *bi) {
+            best = Some((i, url, relay));
+        }
+        // 早停：已有可达候选，且不存在索引更小（优先级更高）的未决候选
+        if let Some((bi, _, _)) = best.as_ref() {
+            if !undecided.iter().any(|x| x < bi) {
+                break;
+            }
+        }
+    }
+
+    match best {
+        Some((idx, url, relay)) => {
+            let _ = idx;
+            Ok((url, relay))
+        }
+        None => Err(format!("FnConnect 候选均不可达（{} 个）", candidates.len())),
+    }
+}

src-tauri/src/music/feiniu/mod.rs

@@ -0,0 +1,743 @@
+//! 飞牛音乐(NAS)原生接口客户端 + 本地流代理的运行期。
+//!
+//! 支持多连接（本地 / frp / 预留 FnConnect），当前以"激活连接"为准。
+//! 原生接口路径/认证（`music-token` Cookie、`x-access-code` 安全码、`/user/password-login` 登录）
+//! 对照 FeiNiuMusic(Flutter) `api_client.dart` 的第三方纯前端实现翻译。
+//! 所有对 NAS 的 HTTP 请求在本模块收敛（页面/命令层不直接发请求）。
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use axum::http::StatusCode;
+use lofty::file::{AudioFile, TaggedFileExt};
+use lofty::tag::Accessor;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use serde_json::{json, Value};
+
+use super::MusicSettings;
+
+pub use conn::normalize_base_url;
+mod cache;
+mod conn;
+mod fnconnect;
+pub mod proxy;
+pub mod webdav;
+
+pub use cache::CacheManager;
+pub use fnconnect::{extract_fn_id, resolve_base_url};
+
+use conn::{generate_device_id, sha256_hex};
+use proxy::{ProxyCfg, ProxyShared};
+
+/// 一条飞牛音乐连接（持久化在 `MusicSettings`）。
+#[derive(Serialize, Deserialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct FeiniuConnection {
+    pub id: String,
+    pub name: String,
+    /// "lan" | "frp" | "fnconnect"（fnconnect 预留）
+    pub kind: String,
+    /// 服务器地址（http://192.168.x.x:5666 或 https://域名）
+    pub base_url: String,
+    pub username: String,
+    pub token: String,
+    pub device_id: String,
+    pub access_code: String,
+    /// https 遇到自签证书时忽略校验
+    pub insecure: bool,
+    /// fnconnect 连接的 fnId（如 fnos.net/<id> 或裸 id）
+    #[serde(default)]
+    pub fn_id: String,
+    /// 是否经由 FnConnect 中继链路（`<fnId>.fnos.net`）。
+    /// 中继要求所有请求携带 `Cookie: mode=relay`，否则网关 302 回登录页。
+    #[serde(default)]
+    pub relay: bool,
+}
+
+impl Default for FeiniuConnection {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            name: String::new(),
+            kind: "lan".to_string(),
+            base_url: String::new(),
+            username: String::new(),
+            token: String::new(),
+            device_id: String::new(),
+            access_code: String::new(),
+            insecure: false,
+            fn_id: String::new(),
+            relay: false,
+        }
+    }
+}
+
+/// 当前激活连接信息（运行期副本，与 `MusicSettings` 的激活连接一致）。
+struct Conn {
+    base_url: String,
+    token: String,
+    username: String,
+    device_id: String,
+    access_code: String,
+    insecure: bool,
+    /// FnConnect 中继链路标记
+    relay: bool,
+}
+
+/// LAN 直连，`no_proxy` 避免被代理模块(mihomo)拦走；按 insecure 惰性重建（支持自签证书）。
+struct ClientSlot {
+    insecure: bool,
+    client: reqwest::Client,
+}
+
+/// 构建飞牛请求 client。
+///
+/// `streaming = true` 时不设**总超时**：reqwest 的 `timeout` 覆盖到响应体读完为止，
+/// 用来取整首音频会把流式中途掐断（大文件/慢链路下播放器会一直缓冲）。
+/// 流式只限制建连时间。
+fn build_client(insecure: bool, streaming: bool) -> reqwest::Client {
+    let mut b = reqwest::Client::builder()
+        .no_proxy()
+        .connect_timeout(Duration::from_secs(10))
+        .danger_accept_invalid_certs(insecure);
+    if !streaming {
+        b = b.timeout(Duration::from_secs(10));
+    }
+    b.build().unwrap_or_else(|_| reqwest::Client::new())
+}
+
+pub struct Feiniu {
+    client: Mutex<Option<ClientSlot>>,
+    /// 流代理专用 client（无总超时）
+    stream_client: Mutex<Option<ClientSlot>>,
+    conn: Mutex<Conn>,
+    proxy: Mutex<Option<(u16, ProxyShared)>>,
+    cache: CacheManager,
+}
+
+impl Default for Feiniu {
+    fn default() -> Self {
+        Self {
+            client: Mutex::new(None),
+            stream_client: Mutex::new(None),
+            conn: Mutex::new(Conn {
+                base_url: String::new(),
+                token: String::new(),
+                username: String::new(),
+                device_id: String::new(),
+                access_code: String::new(),
+                insecure: false,
+                relay: false,
+            }),
+            proxy: Mutex::new(None),
+            cache: CacheManager::new(Path::new("placeholder")), // 由 set_cache_root 重建
+        }
+    }
+}
+
+/// 按 insecure 惰性构建 client（`streaming` 决定是否免总超时）。
+fn slot_client(slot: &Mutex<Option<ClientSlot>>, insecure: bool, streaming: bool) -> reqwest::Client {
+    let mut g = slot.lock().unwrap_or_else(|e| e.into_inner());
+    let hit = g.as_ref().map(|s| s.insecure == insecure).unwrap_or(false);
+    if !hit {
+        *g = Some(ClientSlot {
+            insecure,
+            client: build_client(insecure, streaming),
+        });
+    }
+    g.as_ref().unwrap().client.clone()
+}
+
+impl Feiniu {
+    /// 设置缓存根目录（{app_data}/music/cache），应用启动时调用一次。
+    pub fn set_cache_root(&mut self, app_data_dir: &Path) {
+        self.cache = CacheManager::new(app_data_dir);
+    }
+    /// 本地曲库标签缓存文件路径（{cache_root}/local-tags.json）。
+    pub fn local_tags_path(&self) -> PathBuf {
+        self.cache.local_tags_path()
+    }
+    /// 取（并惰性构建）对应 insecure 的 reqwest client（普通请求，10s 总超时）。
+    fn client(&self, insecure: bool) -> reqwest::Client {
+        slot_client(&self.client, insecure, false)
+    }
+
+    /// 取流式请求专用 client（无总超时）。
+    fn stream_client(&self, insecure: bool) -> reqwest::Client {
+        slot_client(&self.stream_client, insecure, true)
+    }
+
+    /// 从持久化设置刷新运行期连接与代理配置（以激活连接为准；幂等）。
+    pub fn sync_with_settings(&self, s: &MusicSettings) {
+        let (base_url, token, username, device_id, access_code, insecure, relay) =
+            match s.feiniu_active() {
+                Some(c) => (
+                    c.base_url.clone(),
+                    // token 常态存放在系统凭据管理器（见 crate::music::secrets），
+                    // 结构体字段为空；只有凭据库不可用（降级）时才回落到明文。
+                    if c.token.is_empty() {
+                        super::secrets::read_feiniu_token(&c.id)
+                    } else {
+                        c.token.clone()
+                    },
+                    c.username.clone(),
+                    c.device_id.clone(),
+                    c.access_code.clone(),
+                    c.insecure,
+                    c.relay,
+                ),
+                None => (
+                    String::new(),
+                    String::new(),
+                    String::new(),
+                    String::new(),
+                    String::new(),
+                    false,
+                    false,
+                ),
+            };
+        if let Ok(mut c) = self.conn.lock() {
+            c.base_url = base_url;
+            c.token = token;
+            c.username = username;
+            c.device_id = device_id;
+            c.access_code = access_code;
+            c.insecure = insecure;
+            c.relay = relay;
+        }
+        // 确保 client 构建到位（insecure 变化时重建）
+        self.client(insecure);
+        self.sync_proxy_cfg();
+        self.sync_proxy_client();
+    }
+
+    fn sync_proxy_cfg(&self) {
+        if let Ok(g) = self.proxy.lock() {
+            if let Some((_, shared)) = g.as_ref() {
+                let cfg = self.current_cfg();
+                if let Ok(mut c) = shared.cfg.lock() {
+                    *c = cfg;
+                }
+            }
+        }
+    }
+
+    fn sync_proxy_client(&self) {
+        // 代理必须用流式 client：普通 client 的 10s 总超时会把长音频流掐断
+        let (_, client) = self.conn_stream_client();
+        if let Ok(mut g) = self.proxy.lock() {
+            if let Some((_, shared)) = g.as_mut() {
+                shared.client = client;
+            }
+        }
+    }
+
+    fn conn_client(&self) -> (bool, reqwest::Client) {
+        let insecure = self.conn.lock().unwrap_or_else(|e| e.into_inner()).insecure;
+        (insecure, self.client(insecure))
+    }
+
+    fn conn_stream_client(&self) -> (bool, reqwest::Client) {
+        let insecure = self.conn.lock().unwrap_or_else(|e| e.into_inner()).insecure;
+        (insecure, self.stream_client(insecure))
+    }
+
+    fn current_cfg(&self) -> ProxyCfg {
+        let c = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        ProxyCfg {
+            base_url: c.base_url.clone(),
+            token: c.token.clone(),
+            access_code: c.access_code.clone(),
+            relay: c.relay,
+        }
+    }
+
+    /// 构造鉴权 Cookie 头。
+    ///
+    /// 中继链路需把 `mode=relay` 与 `music-token` 合并进**同一个** Cookie 头
+    /// （拆成两个 Cookie 头会互相覆盖）；未登录的中继请求只带 `mode=relay`。
+    /// 无 token 且非中继时返回 None，表示无需携带 Cookie。
+    fn auth_cookie(token: &str, relay: bool) -> Option<String> {
+        match (token.is_empty(), relay) {
+            (false, true) => Some(format!("music-token={token}; mode=relay")),
+            (false, false) => Some(format!("music-token={token}")),
+            (true, true) => Some("mode=relay".to_string()),
+            (true, false) => None,
+        }
+    }
+
+    /// 鉴权上下文：`(base_url, token, access_code, relay)`。
+    fn auth_triple(&self) -> (String, String, String, bool) {
+        let c = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        (
+            c.base_url.clone(),
+            c.token.clone(),
+            c.access_code.clone(),
+            c.relay,
+        )
+    }
+
+    /// 对某个 base_url 执行登录（探测/登录连接共用）。
+    /// 成功返回 `(userToken, device_id)` 并更新运行期 conn；命令层负责落回对应连接持久化。
+    pub async fn login(
+        &self,
+        base_url: &str,
+        username: &str,
+        password: &str,
+    ) -> Result<(String, String), String> {
+        let base = normalize_base_url(base_url);
+        let (device_id, insecure) = {
+            let c = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+            let d = if c.device_id.is_empty() {
+                generate_device_id()
+            } else {
+                c.device_id.clone()
+            };
+            (d, c.insecure)
+        };
+        let body = json!({
+            "username": username,
+            "password": sha256_hex(password),
+            "deviceId": device_id,
+        });
+        let relay = self
+            .conn
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .relay;
+        let mut rb = self
+            .client(insecure)
+            .post(format!("{base}/music/api/v1/user/password-login"))
+            .json(&body);
+        // 中继链路：登录请求也需带 mode=relay，否则网关 302 回登录页
+        if let Some(cookie) = Self::auth_cookie("", relay) {
+            rb = rb.header("cookie", cookie);
+        }
+        let resp = rb
+            .send()
+            .await
+            .map_err(|e| {
+                let kind = if e.is_timeout() {
+                    "连接超时（NAS 不可达？）"
+                } else {
+                    "连接失败"
+                };
+                format!("{kind}: {e}")
+            })?;
+        let status = resp.status();
+        let b: Value = resp
+            .json()
+            .await
+            .unwrap_or_else(|_| json!({ "code": status.as_u16() }));
+        let code = b["code"].as_i64().unwrap_or(i64::from(status.as_u16()));
+        if code != 0 {
+            if code == 120001 {
+                return Err("用户名或密码错误".into());
+            }
+            let msg = b["msg"]
+                .as_str()
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| format!("HTTP {status}"));
+            return Err(msg);
+        }
+        let token = b["data"]["userToken"]
+            .as_str()
+            .ok_or_else(|| "登录失败：未返回 token".to_string())?
+            .to_string();
+
+        if let Ok(mut c) = self.conn.lock() {
+            c.base_url = base;
+            c.token = token.clone();
+            c.username = username.to_string();
+            c.device_id = device_id.clone();
+        }
+        self.sync_proxy_cfg();
+        Ok((token, device_id))
+    }
+
+    /// 登出：仅清运行期 token（保留连接信息与账号）。
+    pub fn logout(&self) {
+        if let Ok(mut c) = self.conn.lock() {
+            c.token.clear();
+        }
+        self.sync_proxy_cfg();
+    }
+
+    /// 当前激活连接配置（前端状态展示 + 是否已登录）。
+    pub fn config(&self) -> Value {
+        let c = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        json!({
+            "baseUrl": c.base_url,
+            "username": c.username,
+            "loggedIn": !c.token.is_empty(),
+        })
+    }
+
+    /// 分页拉取曲目列表：`GET /music/api/v1/track/list`（可选关键词）。
+    pub async fn list_tracks(&self, page: u32, size: u32, keyword: Option<&str>) -> Result<Value, String> {
+        let mut query = vec![
+            ("page".to_string(), page.to_string()),
+            ("size".to_string(), size.to_string()),
+        ];
+        let kw = keyword.unwrap_or("").trim().to_string();
+        if !kw.is_empty() {
+            query.push(("keyword".to_string(), kw));
+        }
+        self.authed_get("/music/api/v1/track/list", query).await
+    }
+
+    /// 歌词：`GET /music/api/v1/lyric/list?trackGUID=<guid>`。
+    pub async fn lyric(&self, guid: &str) -> Result<String, String> {
+        let v = self
+            .authed_get(
+                "/music/api/v1/lyric/list",
+                vec![("trackGUID".to_string(), guid.to_string())],
+            )
+            .await?;
+        Ok(extract_lyric_text(&v))
+    }
+
+    /// 本地媒体地址前缀：`http://127.0.0.1:<port>/feiniu`。首次调用惰性启动代理。
+    pub async fn media_prefix(&self) -> Result<String, String> {
+        let port = self.ensure_proxy().await?;
+        Ok(format!("http://127.0.0.1:{port}/feiniu"))
+    }
+
+
+    /// 缓存状态。
+    pub fn cache_status(&self) -> Value {
+        self.cache.status()
+    }
+
+    /// 清空缓存。
+    pub fn cache_clear(&self) {
+        self.cache.clear();
+    }
+
+    /// 命中缓存直接返回文件路径；未命中则从 NAS 流式拉取写入缓存后返回。
+    /// 返回缓存文件路径。失败返回 Err。
+    pub async fn cache_fetch(&self, guid: &str, max_gb: u32) -> Result<Option<String>, String> {
+        if let Some(hit) = self.cache.hit(guid) {
+            return Ok(Some(hit));
+        }
+        let (base, token, access_code, relay) = self.auth_triple();
+        if base.is_empty() || token.is_empty() {
+            return Err("未登录".into());
+        }
+        // 整首拉取写入缓存：同样用无总超时的 client，否则大文件会被 10s 超时截断
+        let (_, client) = self.conn_stream_client();
+        let mut rb = client.get(format!("{base}/music/api/v1/track/stream?guid={guid}"));
+        if let Some(cookie) = Self::auth_cookie(&token, relay) {
+            rb = rb.header("cookie", cookie);
+        }
+        if !access_code.is_empty() {
+            use base64::Engine;
+            rb = rb
+                .header(
+                    "x-access-code",
+                    base64::engine::general_purpose::STANDARD.encode(access_code.as_bytes()),
+                )
+                .header("x-access-source", "app");
+        }
+        let resp = rb.send().await.map_err(|e| format!("拉取失败: {e}"))?;
+        if !resp.status().is_success() {
+            return Err(format!("拉取失败（HTTP {}）", resp.status().as_u16()));
+        }
+        let ct = resp
+            .headers()
+            .get("content-type")
+            .and_then(|v| v.to_str().ok())
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+        let ext = match ct.split('/').last() {
+            Some("flac") => "flac",
+            Some("mpeg") => "mp3",
+            Some("wav") => "wav",
+            Some("ogg") => "ogg",
+            Some("mp4") => "m4a",
+            Some("aac") => "aac",
+            _ => "bin",
+        };
+        let stream = resp.bytes_stream();
+        let path = self
+            .cache
+            .put(guid, ext, max_gb, stream)
+            .await
+            .map_err(|e| e)?;
+        let _ = path;
+        Ok(self.cache.hit(guid))
+    }
+
+    // ===== WebDAV 传输（下载到飞牛 / 曲库增删）=====
+    // 无状态：配置由前端每次调用传入，实现在 webdav 模块，命令层直接调用。
+
+    async fn ensure_proxy(&self) -> Result<u16, String> {
+        if let Ok(g) = self.proxy.lock() {
+            if let Some((port, _)) = g.as_ref() {
+                return Ok(*port);
+            }
+        }
+        // 流代理用无总超时的 client（见 build_client）
+        let (_, client) = self.conn_stream_client();
+        let shared = ProxyShared {
+            client,
+            cfg: Arc::new(Mutex::new(self.current_cfg())),
+        };
+        let port = proxy::start(shared.clone()).await?;
+        if let Ok(mut g) = self.proxy.lock() {
+            *g = Some((port, shared));
+        }
+        Ok(port)
+    }
+
+    async fn authed_get(&self, path: &str, query: Vec<(String, String)>) -> Result<Value, String> {
+        let (base, token, access_code, relay) = self.auth_triple();
+        if base.is_empty() || token.is_empty() {
+            return Err("未登录".into());
+        }
+        let (_, client) = self.conn_client();
+        let qrefs: Vec<(&str, &str)> = query.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
+        let mut rb = client.get(format!("{base}{path}")).query(&qrefs);
+        if let Some(cookie) = Self::auth_cookie(&token, relay) {
+            rb = rb.header("cookie", cookie);
+        }
+        if !access_code.is_empty() {
+            use base64::Engine;
+            rb = rb
+                .header(
+                    "x-access-code",
+                    base64::engine::general_purpose::STANDARD.encode(access_code.as_bytes()),
+                )
+                .header("x-access-source", "app");
+        }
+        let resp = rb.send().await.map_err(|e| format!("请求失败: {e}"))?;
+        let status = resp.status();
+        let body: Value = resp
+            .json()
+            .await
+            .unwrap_or_else(|_| json!({ "code": status.as_u16() }));
+        let code = body["code"].as_i64().unwrap_or(i64::from(status.as_u16()));
+        if code != 0 {
+            if status == StatusCode::UNAUTHORIZED || status == StatusCode::FORBIDDEN {
+                return Err("登录已过期，请重新登录".into());
+            }
+            let msg = body["msg"]
+                .as_str()
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| format!("请求失败（HTTP {status}）"));
+            return Err(msg);
+        }
+        Ok(body["data"].clone())
+    }
+}
+
+/// 本地曲库 / 下载目录里认可的音频扩展名。
+/// 扫描（递归）与单目录列举共用同一份，避免两处判定不一致。
+pub const AUDIO_EXTS: [&str; 7] = ["mp3", "flac", "wav", "m4a", "aac", "ogg", "ape"];
+
+/// 该路径是否为认可的音频文件（只看扩展名，不校验存在性）。
+pub fn is_audio_path(path: &Path) -> bool {
+    path.extension()
+        .and_then(|e| e.to_str())
+        .map(|e| AUDIO_EXTS.contains(&e.to_lowercase().as_str()))
+        .unwrap_or(false)
+}
+
+/// 列出一个**目录**（非递归）下的音频文件：`{ items: [{path,name,size,mtim}] }`。
+///
+/// 与 [`scan_local_dirs`] 的分工：那个是「曲库全量扫描 + 标签解析」，
+/// 用于曲库视图；这个是「只看一层目录、不读标签」的轻量列举，
+/// 用于上传编排（只需在下载目录里找到刚落盘的文件）。
+/// 为一次上传去递归遍历整个曲库目录是纯浪费。
+pub fn list_audio_files(dir: &str) -> Value {
+    let mut items: Vec<Value> = Vec::new();
+    let p = Path::new(dir);
+    if !p.is_dir() {
+        return json!({ "items": items });
+    }
+    let Ok(entries) = fs::read_dir(p) else {
+        return json!({ "items": items });
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if !path.is_file() || !is_audio_path(&path) {
+            continue;
+        }
+        let size = entry.metadata().map(|m| m.len()).unwrap_or(0);
+        let mtim = entry
+            .metadata()
+            .ok()
+            .and_then(|m| m.modified().ok())
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+        let name = path
+            .file_stem()
+            .and_then(|n| n.to_str())
+            .unwrap_or("未知")
+            .to_string();
+        items.push(json!({
+            "path": path.to_string_lossy(),
+            "name": name,
+            "size": size,
+            "mtim": mtim,
+        }));
+    }
+    json!({ "items": items })
+}
+
+/// 递归扫描本地曲库目录中的音频文件，返回轻量条目。
+///
+/// 元数据（标题/歌手/专辑/时长/是否有内嵌封面）用 lofty 解析音频标签；
+/// 结果按 path 缓存（size+mtim 未变即复用），避免万级曲库每次全量重解析。
+/// `tags_cache_path` 为标签缓存文件路径（由命令层传入 CacheManager）。
+///
+/// **纯函数（不依赖 &self）**：全量解析是重活，命令层必须把它放进
+/// `spawn_blocking`（Tauri 的同步命令在主线程执行，会冻结 UI）。
+pub fn scan_local_dirs(dirs: &[String], tags_cache_path: Option<&Path>) -> Value {
+    // ---- 标签缓存 ----
+    let mut tag_cache: serde_json::Map<String, Value> = tags_cache_path
+        .and_then(|p| fs::read_to_string(p).ok())
+        .and_then(|s| serde_json::from_str(&s).ok())
+        .unwrap_or_default();
+    let cache_hit = |cache: &serde_json::Map<String, Value>,
+                     path: &str,
+                     size: u64,
+                     mtim: u64|
+     -> Option<Value> {
+        cache
+            .get(path)
+            .and_then(|v| v.as_object())
+            .filter(|e| {
+                e.get("size").and_then(|x| x.as_u64()) == Some(size)
+                    && e.get("mtim").and_then(|x| x.as_u64()) == Some(mtim)
+            })
+            .map(|e| Value::Object(e.clone()))
+    };
+
+    let mut items: Vec<Value> = Vec::new();
+    // 本次扫描命中的音频路径：用于修剪缓存（见函数末尾）
+    let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
+    // 至少有一个目录可访问才允许修剪，避免目录临时不可用（外接盘未挂载）时清空整个缓存
+    let mut scanned_any_dir = false;
+    for dir in dirs {
+        let p = Path::new(dir);
+        if !p.is_dir() {
+            continue;
+        }
+        scanned_any_dir = true;
+        for entry in walkdir::WalkDir::new(p).follow_links(false) {
+            let Ok(entry) = entry else { continue };
+            if !entry.file_type().is_file() {
+                continue;
+            }
+                let path = entry.path();
+                if !is_audio_path(path) {
+                    continue;
+                }
+            let size = entry.metadata().map(|m| m.len()).unwrap_or(0);
+            let mtim = entry
+                .metadata()
+                .ok()
+                .and_then(|m| m.modified().ok())
+                .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                .map(|d| d.as_secs())
+                .unwrap_or(0);
+            let path_str = path.to_string_lossy().to_string();
+            let name = path
+                .file_stem()
+                .and_then(|n| n.to_str())
+                .unwrap_or("未知")
+                .to_string();
+            seen.insert(path_str.clone());
+
+            // 标签：命中缓存直接复用；否则 lofty 解析并写回缓存
+            let tags = match cache_hit(&tag_cache, &path_str, size, mtim) {
+                Some(hit) => hit,
+                None => {
+                    let mut t = json!({
+                        "size": size,
+                        "mtim": mtim,
+                        "title": name,
+                        "artist": "",
+                        "album": "",
+                        "durationS": 0,
+                        "cover": false,
+                    });
+                    if let Ok(tagged) = lofty::read_from_path(path) {
+                        let tag = tagged.primary_tag().or_else(|| tagged.first_tag());
+                        if let Some(tag) = tag {
+                            if let Some(v) = tag.title().filter(|s| !s.trim().is_empty()) {
+                                t["title"] = json!(v.trim());
+                            }
+                            if let Some(v) = tag.artist().filter(|s| !s.trim().is_empty()) {
+                                t["artist"] = json!(v.trim());
+                            }
+                            if let Some(v) = tag.album().filter(|s| !s.trim().is_empty()) {
+                                t["album"] = json!(v.trim());
+                            }
+                            t["cover"] = json!(!tag.pictures().is_empty());
+                        }
+                        let secs = tagged.properties().duration().as_secs();
+                        if secs > 0 {
+                            t["durationS"] = json!(secs);
+                        }
+                    }
+                    tag_cache.insert(path_str.clone(), t.clone());
+                    t
+                }
+            };
+
+            items.push(json!({
+                "path": path_str,
+                "name": name,
+                "title": tags.get("title").cloned().unwrap_or(json!(name)),
+                "artist": tags.get("artist").cloned().unwrap_or(json!("")),
+                "album": tags.get("album").cloned().unwrap_or(json!("")),
+                "durationS": tags.get("durationS").cloned().unwrap_or(json!(0)),
+                "cover": tags.get("cover").cloned().unwrap_or(json!(false)),
+                "size": size,
+                "mtim": mtim,
+                "dir": dir,
+            }));
+        }
+    }
+    // 修剪：删掉本次扫描中未再出现的缓存条目（文件已删除/改名/移出曲库目录）。
+    // 只增不减的缓存会随使用时间无限膨胀，且每次扫描都要整份读写。
+    if scanned_any_dir {
+        tag_cache.retain(|k, _| seen.contains(k));
+    }
+    if let Some(p) = tags_cache_path {
+        if let Ok(s) = serde_json::to_string(&tag_cache) {
+            fs::write(p, s).ok();
+        }
+    }
+    json!({ "items": items })
+}
+
+/// 尽力从 /lyric/list 响应中取第一段歌词文本（响应结构未文档化，做宽松映射）。
+fn extract_lyric_text(v: &Value) -> String {
+    match v {
+        Value::Array(arr) => arr
+            .first()
+            .map(|it| {
+                it["content"]
+                    .as_str()
+                    .or_else(|| it["lyric"].as_str())
+                    .or_else(|| it["text"].as_str())
+                    .unwrap_or("")
+                    .to_string()
+            })
+            .unwrap_or_default(),
+        Value::Object(_) => v["content"]
+            .as_str()
+            .or_else(|| v["lyric"].as_str())
+            .or_else(|| v["text"].as_str())
+            .unwrap_or("")
+            .to_string(),
+        _ => String::new(),
+    }
+}

src-tauri/src/music/feiniu/proxy.rs

@@ -0,0 +1,237 @@
+//! 飞牛音乐本地流代理（axum）。
+//!
+//! 原生 `/track/stream`、`/static/cover` 需要 `Cookie: music-token=<token>`，而
+//! WebView 的 `<audio>/<img>` 无法设置 Cookie。本模块绑定 `127.0.0.1:<动态端口>`，
+//! 转发请求时注入 Cookie 与可选的安全码头，前端直接用本地地址播放/显示，天然支持 Range/seek。
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use axum::{
+    extract::{Query, State},
+    http::{header, HeaderMap, StatusCode},
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+
+use lofty::file::TaggedFileExt;
+
+use super::conn::normalize_base_url;
+
+/// 由 Feiniu 运行期与代理 handler 共享的连接配置（登录更新、登出置空）。
+#[derive(Clone, Default)]
+pub struct ProxyCfg {
+    pub base_url: String,
+    pub token: String,
+    pub access_code: String,
+    /// FnConnect 中继链路：所有请求需携带 `Cookie: mode=relay`
+    pub relay: bool,
+}
+
+#[derive(Clone)]
+pub struct ProxyShared {
+    pub client: reqwest::Client,
+    pub cfg: Arc<Mutex<ProxyCfg>>,
+}
+
+/// 启动本地流代理，绑定到 `127.0.0.1:0`（动态空闲端口），返回实际端口。
+/// 代理以独立 tokio 任务常驻应用存活期；token 变化经共享 `ProxyCfg` 即时生效，无需重启。
+pub async fn start(shared: ProxyShared) -> Result<u16, String> {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+        .await
+        .map_err(|e| format!("绑定本地端口失败: {e}"))?;
+    let port = listener
+        .local_addr()
+        .map_err(|e| e.to_string())?
+        .port();
+    let app = Router::new()
+        .route("/feiniu/stream", get(proxy_stream))
+        .route("/feiniu/cover", get(proxy_cover))
+        .route("/feiniu/local-cover", get(proxy_local_cover))
+        .with_state(shared);
+    tokio::spawn(async move {
+        if let Err(e) = axum::serve(listener, app).await {
+            crate::logger::log_error("music", &format!("飞牛流代理异常: {e}"));
+        }
+    });
+    Ok(port)
+}
+
+/// 本地音频文件的内嵌封面：`GET /feiniu/local-cover?path=<绝对路径>`。
+///
+/// 供「本地曲库」列表显示封面（无需 NAS 登录）。只接受音频扩展名，且必须
+/// 能被 lofty 解析出内嵌图片——非音频文件在这里必然 404，不构成任意文件读取。
+/// 响应带 immutable 缓存头：path 不变时 WebView 直接复用。
+async fn proxy_local_cover(Query(q): Query<HashMap<String, String>>) -> Response {
+    const AUDIO_EXTS: [&str; 7] = ["mp3", "flac", "wav", "m4a", "aac", "ogg", "ape"];
+    let Some(path) = q.get("path") else {
+        return (StatusCode::BAD_REQUEST, "missing path").into_response();
+    };
+    let p = std::path::Path::new(path);
+    let ext_ok = p
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| AUDIO_EXTS.contains(&e.to_lowercase().as_str()))
+        .unwrap_or(false);
+    if !ext_ok || !p.is_file() {
+        return StatusCode::NOT_FOUND.into_response();
+    }
+    let picture = lofty::read_from_path(p).ok().and_then(|tagged| {
+        tagged
+            .primary_tag()
+            .or_else(|| tagged.first_tag())
+            .and_then(|t| t.pictures().first())
+            .cloned()
+    });
+    let Some(pic) = picture else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+    // lofty 0.22 的 mime_type 返回 Option<MimeType>
+    let mime = pic
+        .mime_type()
+        .map(|m| m.to_string())
+        .unwrap_or_else(|| "image/jpeg".to_string());
+    let mut resp = ([(header::CONTENT_TYPE, mime)], pic.data().to_vec()).into_response();
+    resp.headers_mut().insert(
+        header::CACHE_CONTROL,
+        header::HeaderValue::from_static("public, max-age=2592000, immutable"),
+    );
+    resp
+}
+
+async fn proxy_stream(
+    State(s): State<ProxyShared>,
+    Query(q): Query<HashMap<String, String>>,
+    headers: HeaderMap,
+) -> Response {
+    let guid = q.get("guid").cloned().unwrap_or_default().trim().to_string();
+    if guid.is_empty() {
+        return (StatusCode::BAD_REQUEST, "missing guid").into_response();
+    }
+    forward(
+        &s,
+        "/music/api/v1/track/stream",
+        vec![("guid".to_string(), guid)],
+        &headers,
+    )
+    .await
+}
+
+async fn proxy_cover(
+    State(s): State<ProxyShared>,
+    Query(q): Query<HashMap<String, String>>,
+    headers: HeaderMap,
+) -> Response {
+    let cover_id = q
+        .get("coverId")
+        .cloned()
+        .unwrap_or_default()
+        .trim()
+        .to_string();
+    if cover_id.is_empty() {
+        return (StatusCode::BAD_REQUEST, "missing coverId").into_response();
+    }
+    let size = q.get("size").cloned().unwrap_or_else(|| "320".into());
+    forward(
+        &s,
+        "/music/api/v1/static/cover",
+        vec![
+            ("coverId".to_string(), cover_id),
+            ("size".to_string(), size),
+        ],
+        &headers,
+    )
+    .await
+}
+
+/// 统一转发：向 NAS 发起上游 GET，注入 Cookie/安全码，透传 Range 与响应头，流式回传 body。
+async fn forward(
+    s: &ProxyShared,
+    path: &str,
+    query: Vec<(String, String)>,
+    headers: &HeaderMap,
+) -> Response {
+    let cfg = match s.cfg.lock() {
+        Ok(g) => g.clone(),
+        Err(e) => e.into_inner().clone(),
+    };
+    if cfg.base_url.is_empty() || cfg.token.is_empty() {
+        return (StatusCode::UNAUTHORIZED, "飞牛音乐未登录").into_response();
+    }
+
+    let base = normalize_base_url(&cfg.base_url);
+    let url = format!("{base}{path}");
+    let qrefs: Vec<(&str, &str)> = query.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
+
+    let mut rb = s.client.get(&url).query(&qrefs);
+    // 中继链路必须带 mode=relay，网关据此转发到 NAS（与 music-token 合并进同一个 Cookie 头）。
+    rb = rb.header(
+        "cookie",
+        if cfg.relay {
+            format!("music-token={}; mode=relay", cfg.token)
+        } else {
+            format!("music-token={}", cfg.token)
+        },
+    );
+    if !cfg.access_code.is_empty() {
+        use base64::Engine;
+        rb = rb
+            .header(
+                "x-access-code",
+                base64::engine::general_purpose::STANDARD.encode(cfg.access_code.as_bytes()),
+            )
+            .header("x-access-source", "app");
+    }
+    if let Some(range) = headers.get(header::RANGE) {
+        rb = rb.header(header::RANGE, range.clone());
+    }
+    drop(cfg);
+
+    let resp = match rb.send().await {
+        Ok(r) => r,
+        Err(e) => return (StatusCode::BAD_GATEWAY, format!("上游错误: {e}")).into_response(),
+    };
+    let status = resp.status();
+
+    let ct = resp.headers().get(header::CONTENT_TYPE).cloned();
+    let cl = resp.headers().get(header::CONTENT_LENGTH).cloned();
+    let cr = resp.headers().get(header::CONTENT_RANGE).cloned();
+    let ar = resp.headers().get(header::ACCEPT_RANGES).cloned();
+    // 缓存头必须透传：NAS 的封面接口带 `public, max-age=2592000, immutable`，
+    // 丢掉它就等于告诉 WebView「这个响应不可缓存」——每次进曲库页都要重新下载全部封面。
+    let cc = resp.headers().get(header::CACHE_CONTROL).cloned();
+    let et = resp.headers().get(header::ETAG).cloned();
+    let lm = resp.headers().get(header::LAST_MODIFIED).cloned();
+    let ex = resp.headers().get(header::EXPIRES).cloned();
+
+    let body = axum::body::Body::from_stream(resp.bytes_stream());
+    let mut out = Response::new(body);
+    *out.status_mut() = status;
+    let h = out.headers_mut();
+    if let Some(v) = ct {
+        h.insert(header::CONTENT_TYPE, v);
+    }
+    if let Some(v) = cl {
+        h.insert(header::CONTENT_LENGTH, v);
+    }
+    if let Some(v) = cr {
+        h.insert(header::CONTENT_RANGE, v);
+    }
+    if let Some(v) = ar {
+        h.insert(header::ACCEPT_RANGES, v);
+    }
+    if let Some(v) = cc {
+        h.insert(header::CACHE_CONTROL, v);
+    }
+    if let Some(v) = et {
+        h.insert(header::ETAG, v);
+    }
+    if let Some(v) = lm {
+        h.insert(header::LAST_MODIFIED, v);
+    }
+    if let Some(v) = ex {
+        h.insert(header::EXPIRES, v);
+    }
+    out
+}

src-tauri/src/music/feiniu/webdav.rs

@@ -0,0 +1,205 @@
+//! WebDAV 客户端（无状态）——用于把音乐传输到 fnOS NAS 的曲库目录。
+//!
+//! 选择 WebDAV 而非 SMB/FTP/NFS 的原因：
+//! - 纯 HTTP 语义，`reqwest` 即可实现，无原生依赖（SMB 在 Rust 侧生态差）；
+//! - **无会话**：Basic 认证随每个请求携带，没有"重启后要重新登录"的问题；
+//! - fnOS 原生支持：系统设置 → 文件服务 → WebDAV（HTTP 5005 / HTTPS 5006）。
+//!
+//! fnOS 侧需要的设置（作为 UI 提示展示）：
+//! 1. 开启 WebDAV 服务并记下端口；
+//! 2. 目标文件夹必须在「可见文件夹范围」内（团队文件夹需勾选
+//!    「允许通过文件共享协议(SMB、WebDAV、FTP)挂载到其他设备上」）；
+//! 3. 账号对该文件夹有读写权限。
+
+use bytes::Bytes;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+/// WebDAV 连接配置（由前端每次调用时传入，后端不持有状态）。
+#[derive(Debug, Clone, Deserialize, Serialize, specta::Type)]
+pub struct WebDavConfig {
+    /// 服务地址，如 `http://192.168.110.100:5005`
+    pub url: String,
+    pub username: String,
+    pub password: String,
+}
+
+/// WebDAV 操作结果状态码相关的可读错误。
+fn status_err(action: &str, status: u16, url: &str) -> String {
+    match status {
+        401 => format!("WebDAV 认证失败（401）：请检查账号与密码"),
+        403 => format!("WebDAV 拒绝访问（403）：账号可能没有该目录的写入权限"),
+        404 => format!("WebDAV 目标不存在（404）：{url}（目录需要先在 NAS 上创建，且在 WebDAV 可见范围内）"),
+        409 => format!("WebDAV 父目录不存在（409）：{url}"),
+        _ => format!("WebDAV {action}失败（HTTP {status}）：{url}"),
+    }
+}
+
+fn dav_client(_cfg: &WebDavConfig) -> Result<reqwest::Client, String> {
+    // NAS 通常在内网，默认禁用系统代理（走代理会连不上）；Basic 认证在请求级设置
+    reqwest::Client::builder()
+        .timeout(Duration::from_secs(600))
+        .connect_timeout(Duration::from_secs(10))
+        .no_proxy()
+        .build()
+        .map_err(|e| e.to_string())
+}
+
+/// 拼接 WebDAV 完整 URL：base + 远程路径（逐段百分号编码，保留 `/`）。
+fn dav_url(cfg: &WebDavConfig, remote_path: &str) -> String {
+    let base = cfg.url.trim_end_matches('/');
+    let path = remote_path.trim_start_matches('/');
+    let encoded: Vec<String> = path
+        .split('/')
+        .filter(|s| !s.is_empty())
+        .map(|seg| {
+            let mut out = String::new();
+            for b in seg.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!("%{b:02X}")),
+                }
+            }
+            out
+        })
+        .collect();
+    format!("{base}/{}", encoded.join("/"))
+}
+
+fn with_auth(mut rb: reqwest::RequestBuilder, cfg: &WebDavConfig) -> reqwest::RequestBuilder {
+    if !cfg.username.is_empty() {
+        rb = rb.basic_auth(&cfg.username, Some(&cfg.password));
+    }
+    rb
+}
+
+/// 逐级 MKCOL 创建远程目录（已存在会被忽略）。
+async fn ensure_dirs(cfg: &WebDavConfig, remote_path: &str) -> Result<(), String> {
+    let path = remote_path.trim_start_matches('/');
+    let segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
+    // 最后一段是文件名，只建目录部分
+    let dirs: Vec<String> = segs
+        .iter()
+        .take(segs.len().saturating_sub(1))
+        .fold(Vec::new(), |mut acc, s| {
+            let prev = acc.last().cloned().unwrap_or_default();
+            acc.push(if prev.is_empty() {
+                s.to_string()
+            } else {
+                format!("{prev}/{s}")
+            });
+            acc
+        });
+    let client = dav_client(cfg)?;
+    for d in dirs {
+        let url = dav_url(cfg, &d);
+        let method = reqwest::Method::from_bytes(b"MKCOL").expect("MKCOL 是合法的 HTTP 方法");
+        let resp = with_auth(client.request(method, &url), cfg)
+            .send()
+            .await
+            .map_err(|e| format!("WebDAV MKCOL 失败: {e}"))?;
+        // 201 创建成功；405 已存在；其余只记不阻断（权限问题会在 PUT 时暴露）
+        let code = resp.status().as_u16();
+        if code != 201 && code != 405 && code != 301 && code != 409 && code != 200 {
+            return Err(status_err("创建目录", code, &url));
+        }
+    }
+    Ok(())
+}
+
+/// 测试连接：PROPFIND 目标目录（Depth 0）。成功返回目录确认信息。
+pub async fn test(cfg: &WebDavConfig, dir: &str) -> Result<String, String> {
+    let url = dav_url(cfg, dir);
+    let client = dav_client(cfg)?;
+    let resp = with_auth(
+        client
+            .request(reqwest::Method::from_bytes(b"PROPFIND").unwrap(), &url)
+            .header("Depth", "0")
+            .body(String::new()),
+        cfg,
+    )
+    .send()
+    .await
+    .map_err(|e| format!("无法连接 WebDAV 服务：{e}（请确认地址与端口）"))?;
+    let code = resp.status().as_u16();
+    match code {
+        207 | 200 => Ok(format!("连接成功：{url}")),
+        404 => Err(format!(
+            "WebDAV 服务可达，但目标目录不存在（404）：{url}\n请先在 NAS 上创建该目录，并确认它在 WebDAV「可见文件夹范围」内"
+        )),
+        401 => Err("WebDAV 认证失败（401）：请检查账号与密码".to_string()),
+        403 => Err("WebDAV 拒绝访问（403）：账号可能没有该目录的读取权限".to_string()),
+        _ => Err(status_err("连接", code, &url)),
+    }
+}
+
+/// 上传本地文件（流式读取，不整载内存）。返回远程路径。
+pub async fn upload_file(
+    cfg: &WebDavConfig,
+    local_path: &std::path::Path,
+    remote_path: &str,
+) -> Result<String, String> {
+    ensure_dirs(cfg, remote_path).await?;
+    let file = tokio::fs::File::open(local_path)
+        .await
+        .map_err(|e| format!("读取本地文件失败: {e}"))?;
+    // 128KB 分块流：用 unfold 把 AsyncRead 转 Stream，避免引入 tokio-util
+    let stream = futures_util::stream::unfold(file, |mut f| async move {
+        use tokio::io::AsyncReadExt;
+        let mut buf = vec![0u8; 128 * 1024];
+        match f.read(&mut buf).await {
+            Ok(0) => None,
+            Ok(n) => Some((Ok::<Bytes, std::io::Error>(Bytes::copy_from_slice(&buf[..n])), f)),
+            Err(e) => Some((Err(e), f)),
+        }
+    });
+    let url = dav_url(cfg, remote_path);
+    let client = dav_client(cfg)?;
+    let resp = with_auth(client.put(&url), cfg)
+        .header("Content-Type", mime_of(remote_path))
+        .body(reqwest::Body::wrap_stream(stream))
+        .send()
+        .await
+        .map_err(|e| format!("WebDAV 上传失败: {e}"))?;
+    let code = resp.status().as_u16();
+    if !(200..300).contains(&code) {
+        return Err(status_err("上传", code, &url));
+    }
+    Ok(remote_path.to_string())
+}
+
+/// 删除远程文件（404 视为已删除）。
+pub async fn delete(cfg: &WebDavConfig, remote_path: &str) -> Result<(), String> {
+    let url = dav_url(cfg, remote_path);
+    let client = dav_client(cfg)?;
+    let resp = with_auth(client.delete(&url), cfg)
+        .send()
+        .await
+        .map_err(|e| format!("WebDAV 删除失败: {e}"))?;
+    let code = resp.status().as_u16();
+    if code == 404 {
+        return Ok(());
+    }
+    if !(200..300).contains(&code) {
+        return Err(status_err("删除", code, &url));
+    }
+    Ok(())
+}
+
+pub fn mime_of(name: &str) -> &'static str {
+    let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+    match ext.as_str() {
+        "mp3" => "audio/mpeg",
+        "flac" => "audio/flac",
+        "wav" => "audio/wav",
+        "m4a" => "audio/mp4",
+        "aac" => "audio/aac",
+        "ogg" => "audio/ogg",
+        "ape" => "audio/x-ape",
+        _ => "application/octet-stream",
+    }
+}
+
+

src-tauri/src/music/mod.rs

@@ -0,0 +1,682 @@
+//! 音乐下载模块（musicdl 桥接）。
+//!
+//! 架构：Vue 前端 → Tauri 命令 → [MusicManager] → stdio JSON-Lines → `bridge.py`
+//! → musicdl（纯 Python 聚合下载器）。
+//!
+//! 目录布局（{app_data_dir}/music/）：
+//! - `bridge.py`：桥接脚本（include_str! 内置，运行时写出）
+//! - `runtime/python/`：便携 Python（python.org embeddable，含 pip）
+//! - `runtime/get-pip.py`：pip 引导脚本（下载后删除）
+//! - `runtime/*.zip`：下载过程中的临时安装包（完成后删除）
+//! - `outputs/`：默认音乐下载目录
+//!
+//! 子模块：
+//! - [`runtime`]：Python 运行时探测与便携版安装
+//! - [`bridge`]：桥接进程生命周期（spawn / JSON 协议 / ping / 停止）
+//! - [`commands`]：Tauri 命令层
+
+mod bridge;
+mod commands;
+mod feiniu;
+mod runtime;
+mod secrets;
+
+pub use feiniu::{
+    extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection,
+};
+
+pub use commands::{
+    feiniu_activate_connection, feiniu_cache_clear, feiniu_cache_fetch, feiniu_cache_status,
+    feiniu_delete_connection, feiniu_delete_local, feiniu_fnconnect_resolve, feiniu_get_config,
+    feiniu_list_connections, feiniu_list_audio_files, feiniu_list_tracks, feiniu_login,
+    feiniu_logout, feiniu_lyric,
+    feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection,
+    music_cancel_runtime_install, music_download, music_download_cancel, music_env_status,
+    music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping,
+    music_resolve, music_save_settings, music_search, music_secret_get, music_secret_set,
+    music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret,
+    webdav_save_secret, webdav_test, webdav_upload,
+};
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use std::process::{Child, ChildStdin};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+use tauri::AppHandle;
+
+/// 便携 Python 版本（python.org embeddable，含 pip 引导）
+pub const BUNDLED_PY_VERSION: &str = "3.12.10";
+/// musicdl 锁定版本（其 API 每周都在变，必须锁版本并定期升级）
+pub const MUSICDL_VERSION: &str = "2.13.11";
+/// pip 镜像源（国内网络直连 PyPI 较慢，默认用清华镜像，可改回官方）
+pub const PIP_INDEX_URL: &str = "https://pypi.tuna.tsinghua.edu.cn/simple";
+/// 默认搜索源（网易云 / QQ音乐 / 酷狗）
+pub const DEFAULT_SOURCES: [&str; 3] = [
+    "NeteaseMusicClient",
+    "QQMusicClient",
+    "KugouMusicClient",
+];
+
+/// 桥接进程条目（自管 stdio，不走 ProcessManager）
+pub(crate) struct BridgeEntry {
+    pub child: Child,
+    pub stdin: ChildStdin,
+}
+
+/// 解析出的 Python 运行时信息（内部使用，不序列化）
+pub(crate) struct PythonEnv {
+    pub source: &'static str, // "system" | "bundled"
+    pub exe: PathBuf,
+    pub version: String,
+}
+
+/// 环境状态（返回前端，设置页「环境检查」面板展示）
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct MusicEnvStatus {
+    /// 系统 Python 版本（如 "3.14.5"），无则 None
+    pub python: Option<String>,
+    /// python 来源："system" | "bundled" | "none"
+    pub python_source: String,
+    /// 便携 Python 可执行文件路径（未安装则 None）
+    pub bundled_python: Option<String>,
+    /// musicdl 是否可导入
+    pub musicdl_installed: bool,
+    /// musicdl 版本
+    pub musicdl_version: Option<String>,
+    /// 本应用锁定的 musicdl 版本（`MUSICDL_VERSION`）：是否过期、更新到哪个版本都以它为准
+    pub musicdl_expected: String,
+    /// 已装 musicdl 是否与锁定版本不一致。
+    /// 未安装时恒为 false（那是「安装」引导的事，不是「更新」）。
+    pub musicdl_outdated: bool,
+    /// FFmpeg 是否可用（部分音源需要，非必需）
+    pub ffmpeg: Option<String>,
+    /// 桥接进程是否在运行
+    pub bridge_running: bool,
+    /// 运行时目录（{app_data_dir}/music）
+    pub runtime_dir: String,
+}
+
+/// 运行时安装进度事件负载（对应 events::MUSIC_RUNTIME_INSTALL_PROGRESS）
+#[derive(Serialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct MusicInstallProgress {
+    pub stage: String,
+    pub percent: u32,
+    pub downloaded_bytes: u64,
+    pub total_bytes: Option<u64>,
+    pub message: String,
+}
+
+/// 音乐模块设置（settings.json 持久化；变更即时生效）
+#[derive(Serialize, Deserialize, Clone, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct MusicSettings {
+    /// 下载保存目录
+    pub savedir: String,
+    /// 搜索源（musicdl 客户端名，如 NeteaseMusicClient）
+    pub sources: Vec<String>,
+    /// 下载时同步保存歌词
+    pub lyric_download: bool,
+    /// 下载时同步保存封面
+    pub cover_download: bool,
+    /// 搜索/下载请求是否走代理模块（mihomo mixed 端口）
+    pub use_proxy: bool,
+    /// 最大并发下载数
+    pub max_concurrent: u32,
+    /// 下载引擎："musicdl" | "rust"（P2 生效）
+    pub download_engine: String,
+    /// 下载时是否弹窗选择音质（默认关；开启后点下载弹出所选歌曲档位并集选择）
+    pub select_quality_on_download: bool,
+    /// 下载时默认音质："" 表示最高；否则为搜索音质档位 label（如 "无损"、"320K"）
+    pub default_download_quality: String,
+    /// QQ 音乐 Cookie（可选）：用于解析需要登录的歌单（含自己的隐私歌单）与 VIP 音质。
+    /// 传给 musicdl 的 default_search/parse/download_cookies；空=游客身份。
+    #[serde(default)]
+    pub qq_cookie: String,
+    /// 飞牛音乐(NAS)连接：服务器地址（如 http://192.168.1.10:5666，空=未配置）
+    #[serde(default)]
+    pub feiniu_base_url: String,
+    /// 飞牛音乐登录 token（登录成功后保存）
+    #[serde(default)]
+    pub feiniu_token: String,
+    /// 飞牛音乐登录账号（展示 + 重新登录回填用）
+    #[serde(default)]
+    pub feiniu_username: String,
+    /// 飞牛音乐设备 ID（32 位 hex，登录签名用，一次生成复用）
+    #[serde(default)]
+    pub feiniu_device_id: String,
+    /// 飞牛音乐访问安全码（可选；仅需访问码的库才填，LAN 通常为空）
+    #[serde(default)]
+    pub feiniu_access_code: String,
+    /// 飞牛音乐连接列表（多连接：局域网 / FnConnect）
+    #[serde(default)]
+    pub feiniu_connections: Vec<FeiniuConnection>,
+    /// 当前激活连接的 id
+    #[serde(default)]
+    pub feiniu_active_id: String,
+    /// 本地曲库扫描目录（默认含音乐下载 savedir）
+    #[serde(default)]
+    pub feiniu_local_dirs: Vec<String>,
+    /// 播放缓存开关
+    #[serde(default)]
+    pub feiniu_cache_enabled: bool,
+    /// 缓存上限（GB）
+    #[serde(default)]
+    pub feiniu_cache_max_gb: u32,
+    /// 播放模式："stream" 直连流式 | "cache" 缓存后播放
+    #[serde(default)]
+    pub feiniu_play_mode: String,
+    /// 飞牛曲库目标目录（NAS 绝对路径，如 vol1/1000/Music；上传到飞牛用）
+    #[serde(default)]
+    pub feiniu_library_nas_path: String,
+    /// 下载完成后自动上传到飞牛曲库
+    #[serde(default)]
+    pub feiniu_auto_upload: bool,
+}
+
+impl MusicSettings {
+    /// 取激活连接：优先按 active_id，否则回退到第一条。
+    pub fn feiniu_active(&self) -> Option<&FeiniuConnection> {
+        self.feiniu_connections
+            .iter()
+            .find(|c| c.id == self.feiniu_active_id)
+            .or_else(|| self.feiniu_connections.first())
+    }
+
+    /// 兼容旧版单连接字段：把旧字段迁移成列表里的一条连接，并**清除旧字段**。
+    ///
+    /// 必须是「一次性」的：旧字段一旦残留，用户把连接删光后，下一次 `load_settings()`
+    /// 会再次命中「列表为空 + 旧字段非空」而重新造出一条连接，
+    /// 表现为「删掉的连接切个页又回来了」。因此迁移完成后要清空旧字段，
+    /// 且返回是否发生变更，由 `load_settings` 负责落盘。
+    pub fn migrate_feiniu(&mut self) -> bool {
+        let mut changed = false;
+
+        // 1) 旧单连接字段 → 连接列表（仅在列表为空时迁移）
+        if self.feiniu_connections.is_empty() && !self.feiniu_base_url.trim().is_empty() {
+            let base = self.feiniu_base_url.clone();
+            self.feiniu_connections.push(FeiniuConnection {
+                id: "default".to_string(),
+                name: base.clone(),
+                kind: "lan".to_string(),
+                base_url: base,
+                username: self.feiniu_username.clone(),
+                token: self.feiniu_token.clone(),
+                device_id: self.feiniu_device_id.clone(),
+                access_code: self.feiniu_access_code.clone(),
+                insecure: false,
+                fn_id: String::new(),
+                relay: false,
+            });
+            self.feiniu_active_id = "default".to_string();
+            changed = true;
+        }
+
+        // 2) 无论列表是否为空，旧字段都已无意义（内容已并入连接，或本就没有连接），
+        //    一律清空并落盘，杜绝其再次触发迁移。
+        for v in [
+            &mut self.feiniu_base_url,
+            &mut self.feiniu_token,
+            &mut self.feiniu_username,
+            &mut self.feiniu_device_id,
+            &mut self.feiniu_access_code,
+        ] {
+            if !v.is_empty() {
+                v.clear();
+                changed = true;
+            }
+        }
+
+        // 3) 激活 id 兜底（内存态修正，无需落盘）
+        if self.feiniu_active_id.is_empty()
+            || !self.feiniu_connections.iter().any(|c| c.id == self.feiniu_active_id)
+        {
+            if let Some(c) = self.feiniu_connections.first() {
+                self.feiniu_active_id = c.id.clone();
+            }
+        }
+
+        changed
+    }
+
+    /// 把明文凭据迁入系统凭据管理器，并从结构体里清掉（返回是否有变更）。
+    ///
+    /// 与 `migrate_feiniu` 同一套「一次性迁移」原则：**凭据库写入成功才清明文**，
+    /// 并由 `load_settings` 落盘，避免每次读取反复尝试。
+    /// 写失败时保留明文——宁可姿态不一致，也不能让用户莫名掉登录态。
+    pub fn migrate_secrets(&mut self) -> bool {
+        let mut changed = false;
+        for c in self.feiniu_connections.iter_mut() {
+            let token = c.token.trim().to_string();
+            if token.is_empty() {
+                continue;
+            }
+            let key = secrets::feiniu_token_key(&c.id);
+            // 凭据库已有值时不覆盖：它可能比 settings.json 里的明文更新
+            let stored = secrets::secret_read(&key).ok().flatten().unwrap_or_default();
+            if stored.is_empty() && !secrets::try_store(&key, &token) {
+                continue;
+            }
+            c.token.clear();
+            changed = true;
+        }
+        changed
+    }
+}
+
+/// settings 内存缓存条目（短时复用，避免高频调用反复读盘）
+struct SettingsCacheEntry {
+    read_at: Instant,
+    settings: MusicSettings,
+}
+
+/// 音乐模块管理器
+pub struct MusicManager {
+    root: PathBuf,
+    client: reqwest::Client,
+    /// 桥接进程（stdio 自管）
+    bridge: Mutex<Option<BridgeEntry>>,
+    /// 待响应请求表：id → oneshot（reader 线程按 id 分发）
+    pending: Arc<Mutex<HashMap<u64, tokio::sync::oneshot::Sender<serde_json::Value>>>>,
+    /// 请求 id 自增
+    next_id: AtomicU64,
+    /// 便携运行时安装/下载取消标志
+    runtime_cancel: Arc<AtomicBool>,
+    /// 正在执行的 pip/python 子进程 pid（取消时 taskkill）
+    install_pid: Arc<AtomicU64>,
+    /// 桥接启动互斥锁（防止并发 ensure_bridge 双重 spawn）
+    start_lock: Mutex<()>,
+    /// settings 内存缓存
+    settings_cache: Mutex<Option<SettingsCacheEntry>>,
+    /// 飞牛音乐(NAS)播放器运行期（连接 + 本地流代理）
+    feiniu: Feiniu,
+    /// AppHandle（桥接 reader 线程据此将事件转发给前端；setup 时设置）
+    app: Mutex<Option<AppHandle>>,
+}
+
+impl MusicManager {
+    pub fn new(app_data_dir: PathBuf) -> Self {
+        let root = app_data_dir.join("music");
+        for d in ["runtime", "outputs"] {
+            fs::create_dir_all(root.join(d)).ok();
+        }
+        let mut feiniu = Feiniu::default();
+        feiniu.set_cache_root(&app_data_dir);
+        Self {
+            root,
+            client: reqwest::Client::builder()
+                // 默认 30s 兜底超时；流式下载按块推进，不受此限制
+                .timeout(std::time::Duration::from_secs(30))
+                .build()
+                .unwrap_or_else(|_| reqwest::Client::new()),
+            bridge: Mutex::new(None),
+            pending: Arc::new(Mutex::new(HashMap::new())),
+            next_id: AtomicU64::new(1),
+            runtime_cancel: Arc::new(AtomicBool::new(false)),
+            install_pid: Arc::new(AtomicU64::new(0)),
+            start_lock: Mutex::new(()),
+            settings_cache: Mutex::new(None),
+            feiniu,
+            app: Mutex::new(None),
+        }
+    }
+
+    /// 设置 AppHandle（setup 阶段调用；桥接 reader 线程据此转发事件到前端）
+    pub fn set_app(&self, app: AppHandle) {
+        if let Ok(mut guard) = self.app.lock() {
+            *guard = Some(app);
+        }
+    }
+
+    pub(crate) fn app_handle(&self) -> Option<AppHandle> {
+        self.app.lock().ok().and_then(|g| g.clone())
+    }
+
+    // ---------- 设置 ----------
+    /// 默认保存目录：系统「下载」目录（不可用时退回 {root}/outputs）
+    fn default_savedir(&self) -> String {
+        dirs::download_dir()
+            .unwrap_or_else(|| self.outputs_dir())
+            .to_string_lossy()
+            .to_string()
+    }
+
+    fn default_settings(&self) -> MusicSettings {
+        MusicSettings {
+            savedir: self.default_savedir(),
+            sources: DEFAULT_SOURCES.iter().map(|s| s.to_string()).collect(),
+            lyric_download: true,
+            cover_download: true,
+            use_proxy: false,
+            max_concurrent: 4,
+            download_engine: "musicdl".to_string(),
+            select_quality_on_download: false,
+            default_download_quality: "最高".to_string(), // 默认下载最高音质
+            qq_cookie: String::new(),
+            feiniu_base_url: String::new(),
+            feiniu_token: String::new(),
+            feiniu_username: String::new(),
+            feiniu_device_id: String::new(),
+            feiniu_access_code: String::new(),
+            feiniu_connections: Vec::new(),
+            feiniu_active_id: String::new(),
+            feiniu_local_dirs: Vec::new(),
+            feiniu_cache_enabled: false,
+            feiniu_cache_max_gb: 5,
+            feiniu_play_mode: "stream".to_string(),
+            feiniu_library_nas_path: String::new(),
+            feiniu_auto_upload: false,
+        }
+    }
+
+    fn settings_path(&self) -> PathBuf {
+        self.root.join("settings.json")
+    }
+
+    /// 读取设置（500ms 内存缓存；文件缺失/损坏时回退默认值）
+    pub fn load_settings(&self) -> MusicSettings {
+        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 defaults = self.default_settings();
+        let settings = fs::read_to_string(self.settings_path())
+            .ok()
+            .and_then(|s| serde_json::from_str::<MusicSettings>(&s).ok())
+            .unwrap_or_else(|| defaults.clone());
+        // 自愈：保存目录为空 / 源为空时补默认值
+        let mut settings = settings;
+        if settings.savedir.trim().is_empty() {
+            settings.savedir = defaults.savedir;
+        }
+        // 迁移：旧默认保存目录（{root}/outputs）→ 系统下载目录
+        if settings.savedir == self.outputs_dir().to_string_lossy() {
+            settings.savedir = self.default_savedir();
+        }
+        if settings.sources.is_empty() {
+            settings.sources = defaults.sources;
+        }
+        // 飞牛音乐多连接迁移：旧单连接字段 → 连接列表，并清除旧字段。
+        // 变更必须落盘，否则每次读取都会重新迁移，导致删掉的连接"复活"。
+        let migrated = settings.migrate_feiniu();
+        // 明文凭据（连接 token）→ 系统凭据管理器，成功后从结构体清除。
+        let secrets_migrated = settings.migrate_secrets();
+        if let Ok(mut cache) = self.settings_cache.lock() {
+            *cache = Some(SettingsCacheEntry {
+                read_at: Instant::now(),
+                settings: settings.clone(),
+            });
+        }
+        if migrated || secrets_migrated {
+            if let Err(e) = self.save_settings(&settings) {
+                crate::logger::log_error("music", &format!("迁移飞牛连接设置落盘失败: {e}"));
+            }
+        }
+        settings
+    }
+
+    /// 保存设置并更新缓存
+    pub fn save_settings(&self, settings: &MusicSettings) -> Result<(), String> {
+        let json = serde_json::to_string_pretty(settings).map_err(|e| format!("序列化设置失败: {}", e))?;
+        fs::write(self.settings_path(), json).map_err(|e| format!("写入设置失败: {}", e))?;
+        if let Ok(mut cache) = self.settings_cache.lock() {
+            *cache = Some(SettingsCacheEntry {
+                read_at: Instant::now(),
+                settings: settings.clone(),
+            });
+        }
+        Ok(())
+    }
+
+    // ---------- 目录 ----------
+    pub fn runtime_dir(&self) -> PathBuf {
+        self.root.join("runtime")
+    }
+    /// 默认音乐下载目录
+    pub fn outputs_dir(&self) -> PathBuf {
+        self.root.join("outputs")
+    }
+    pub fn bridge_script_path(&self) -> PathBuf {
+        self.root.join("bridge.py")
+    }
+    pub fn bundled_python_exe(&self) -> PathBuf {
+        self.runtime_dir().join("python").join("python.exe")
+    }
+
+    // ---------- Python 探测 ----------
+    /// 解析桥接要用的 Python 运行时。
+    /// 便携版优先：musicdl 只装入便携运行时，系统 Python 无法保证装有 musicdl；
+    /// 无便携版时退回系统 Python（此时 search 会报 musicdl 未安装，引导用户装便携版）。
+    pub fn resolve_python(&self) -> Result<PythonEnv, String> {
+        if let Some(env) = self.detect_bundled_python() {
+            return Ok(env);
+        }
+        if let Some(env) = detect_system_python() {
+            return Ok(env);
+        }
+        Err("未找到 Python 运行时：系统未安装 Python，且便携版未安装。请点击「安装便携版」".into())
+    }
+
+    /// 便携 Python 是否可用（exe 存在且能跑 --version）
+    pub fn detect_bundled_python(&self) -> Option<PythonEnv> {
+        detect_bundled_python_at(&self.bundled_python_exe())
+    }
+
+    // ---------- 环境状态 ----------
+    /// 查询环境状态。子进程探测（python/musicdl/ffmpeg，便携 Python 冷启动可达数秒）
+    /// 放入阻塞线程池执行，避免阻塞主线程导致 UI 冻结。
+    pub async fn env_status(&self) -> Result<MusicEnvStatus, String> {
+        let bundled_exe = self.bundled_python_exe();
+        let bridge_running = self.bridge.lock().map(|b| b.is_some()).unwrap_or(false);
+        let runtime_dir = self.root.to_string_lossy().to_string();
+        let probe =
+            tauri::async_runtime::spawn_blocking(move || probe_env_blocking(bundled_exe))
+                .await
+                .map_err(|e| format!("环境探测任务失败: {}", e))?;
+        Ok(MusicEnvStatus {
+            python: probe.python,
+            python_source: probe.python_source.to_string(),
+            bundled_python: probe.bundled_python,
+            musicdl_installed: probe.musicdl_installed,
+            musicdl_outdated: probe.musicdl_installed
+                && !version_matches(probe.musicdl_version.as_deref(), MUSICDL_VERSION),
+            musicdl_version: probe.musicdl_version,
+            musicdl_expected: MUSICDL_VERSION.to_string(),
+            ffmpeg: probe.ffmpeg,
+            bridge_running,
+            runtime_dir,
+        })
+    }
+
+    // ---------- 退出清理 ----------
+    /// 应用退出时停止桥接进程（stdin/stdout 随 child drop 关闭，reader 线程读到 EOF 自行退出）
+    pub fn cleanup_on_exit(&self) {
+        self.stop_bridge();
+    }
+
+    // ---------- 内部工具 ----------
+    pub(crate) fn cancel(&self) {
+        self.runtime_cancel.store(true, Ordering::SeqCst);
+        let pid = self.install_pid.load(Ordering::SeqCst);
+        if pid != 0 {
+            // 杀掉正在执行的 pip/python 子进程，避免安装流程挂住
+            let _ = std::process::Command::new("taskkill")
+                .args(["/F", "/T", "/PID", &pid.to_string()])
+                .stdout(std::process::Stdio::null())
+                .stderr(std::process::Stdio::null())
+                .status();
+        }
+    }
+
+    pub(crate) fn is_cancelled(&self) -> bool {
+        self.runtime_cancel.load(Ordering::SeqCst)
+    }
+
+    pub(crate) fn start_lock(&self) -> &Mutex<()> {
+        &self.start_lock
+    }
+}
+
+/// 环境探测结果（spawn_blocking 跨线程返回）
+struct EnvProbe {
+    python: Option<String>,
+    python_source: &'static str,
+    bundled_python: Option<String>,
+    musicdl_installed: bool,
+    musicdl_version: Option<String>,
+    ffmpeg: Option<String>,
+}
+
+/// 阻塞式环境探测（串行 spawn 多个子进程，必须在阻塞线程池执行，禁止占用主线程）
+fn probe_env_blocking(bundled_exe: PathBuf) -> EnvProbe {
+    let bundled = detect_bundled_python_at(&bundled_exe);
+    let sys_py = detect_system_python();
+    // 便携版优先（与 resolve_python 一致）：musicdl 只装入便携运行时，
+    // 若按系统优先检查，装好便携版后 UI 仍会误报 musicdl 未安装
+    let python = bundled.as_ref().or(sys_py.as_ref());
+
+    let (musicdl_installed, musicdl_version) = match python {
+        Some(env) => check_musicdl(&env.exe),
+        None => (false, None),
+    };
+    EnvProbe {
+        python: python.map(|e| e.version.clone()),
+        python_source: match python {
+            Some(e) => e.source,
+            None => "none",
+        },
+        bundled_python: bundled.map(|e| e.exe.to_string_lossy().to_string()),
+        musicdl_installed,
+        musicdl_version,
+        ffmpeg: check_ffmpeg(),
+    }
+}
+
+/// 指定路径的便携 Python 是否可用（exe 存在且能跑 --version）
+fn detect_bundled_python_at(exe: &PathBuf) -> Option<PythonEnv> {
+    if !exe.exists() {
+        return None;
+    }
+    let version = run_python_version(exe)?;
+    Some(PythonEnv {
+        source: "bundled",
+        exe: exe.clone(),
+        version,
+    })
+}
+
+/// 探测系统 Python：依次尝试 python / py / python3，解析 `--version` 输出。
+/// 注意：Windows 的「应用商店别名」python 会在无安装时打印提示并以非零码退出，会被自然过滤。
+fn detect_system_python() -> Option<PythonEnv> {
+    for candidate in ["python", "py", "python3"] {
+        let mut cmd = std::process::Command::new(candidate);
+        cmd.arg("--version");
+        crate::process_manager::setup_creation_flags(&mut cmd);
+        cmd.stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .stdin(std::process::Stdio::null());
+        let out = cmd.output().ok()?;
+        let text = format!(
+            "{}{}",
+            String::from_utf8_lossy(&out.stdout),
+            String::from_utf8_lossy(&out.stderr)
+        );
+        if let Some(version) = parse_python_version(&text) {
+            return Some(PythonEnv {
+                source: "system",
+                exe: PathBuf::from(candidate),
+                version,
+            });
+        }
+    }
+    None
+}
+
+/// 运行 `python --version` 并解析版本号
+fn run_python_version(exe: &PathBuf) -> Option<String> {
+    let mut cmd = std::process::Command::new(exe);
+    cmd.arg("--version");
+    crate::process_manager::setup_creation_flags(&mut cmd);
+    cmd.stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .stdin(std::process::Stdio::null());
+    let out = cmd.output().ok()?;
+    let text = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    parse_python_version(&text)
+}
+
+/// 从 "Python 3.14.5" 文本中提取 "3.14.5"
+fn parse_python_version(text: &str) -> Option<String> {
+    text.split_whitespace().find_map(|w| {
+        let mut parts = w.split('.');
+        let major = parts.next()?.parse::<u32>().ok()?;
+        let minor = parts.next()?.parse::<u32>().ok()?;
+        if (major, minor) >= (3, 8) {
+            Some(w.to_string())
+        } else {
+            None
+        }
+    })
+}
+
+/// 已装版本是否就是本应用锁定的版本。
+///
+/// `unknown` / 空值一律视为**不匹配**：`check_musicdl` 拿不到 `__version__` 时
+/// 无法确认它是不是受支持的那一版，宁可提示更新。
+/// 兼容 `v2.13.11` 这类带前缀的写法。
+fn version_matches(installed: Option<&str>, expected: &str) -> bool {
+    let v = installed.unwrap_or("").trim().trim_start_matches('v');
+    !v.is_empty() && !v.eq_ignore_ascii_case("unknown") && v == expected
+}
+
+/// 检查指定 Python 能否导入 musicdl（同步子进程调用，仅在设置页触发）
+fn check_musicdl(exe: &PathBuf) -> (bool, Option<String>) {
+    let mut cmd = std::process::Command::new(exe);
+    cmd.args([
+        "-c",
+        "import musicdl; print(getattr(musicdl, '__version__', 'unknown'))",
+    ]);
+    crate::process_manager::setup_creation_flags(&mut cmd);
+    cmd.stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::null())
+        .stdin(std::process::Stdio::null());
+    match cmd.output() {
+        Ok(out) if out.status.success() => {
+            let version = String::from_utf8_lossy(&out.stdout).trim().to_string();
+            (true, Some(version))
+        }
+        _ => (false, None),
+    }
+}
+
+/// 检查 FFmpeg 是否可用（部分海外音源需要，非必需）
+fn check_ffmpeg() -> Option<String> {
+    let mut cmd = std::process::Command::new("ffmpeg");
+    cmd.arg("-version");
+    crate::process_manager::setup_creation_flags(&mut cmd);
+    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()
+                .next()
+                .map(|l| l.trim().to_string())
+                .filter(|l| !l.is_empty())
+        })
+}

src-tauri/src/music/runtime.rs

@@ -0,0 +1,478 @@
+//! 便携 Python 运行时安装：流式下载 → 解压 → _pth 补丁 → get-pip 引导 → musicdl 安装。
+//! 子模块通过 `impl super::MusicManager` 追加方法。
+//!
+//! 依赖下载源（已验证）：
+//! - https://www.python.org/ftp/python/{ver}/python-{ver}-embed-amd64.zip
+//! - https://bootstrap.pypa.io/get-pip.py
+//!
+//! 取消：`MusicManager::cancel()` 置标志 + taskkill 当前 pip/python 子进程。
+
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use futures_util::StreamExt;
+use tauri::{AppHandle, Emitter};
+
+use super::{MusicInstallProgress, MusicManager, PIP_INDEX_URL};
+use crate::constants::events::MUSIC_RUNTIME_INSTALL_PROGRESS;
+
+/// 用户主动取消安装的标记错误信息（前端据此静默处理）
+pub(crate) const RUNTIME_CANCELLED: &str = "安装已取消";
+
+impl MusicManager {
+    /// 安装便携 Python + musicdl（幂等：已就绪的步骤自动跳过），全程推送进度事件。
+    pub async fn install_runtime(&self, app: &AppHandle) -> Result<(), String> {
+        self.runtime_cancel.store(false, std::sync::atomic::Ordering::SeqCst);
+        let result = self.install_runtime_inner(app).await;
+        if let Err(ref e) = result {
+            if e != RUNTIME_CANCELLED {
+                let _ = app.emit(
+                    MUSIC_RUNTIME_INSTALL_PROGRESS,
+                    MusicInstallProgress {
+                        stage: "error".into(),
+                        percent: 0,
+                        downloaded_bytes: 0,
+                        total_bytes: None,
+                        message: e.clone(),
+                    },
+                );
+            }
+        }
+        result
+    }
+
+    async fn install_runtime_inner(&self, app: &AppHandle) -> Result<(), String> {
+        let runtime_dir = self.runtime_dir();
+        fs::create_dir_all(&runtime_dir).map_err(|e| e.to_string())?;
+
+        let python_exe = self.bundled_python_exe();
+
+        // ---------- 1. 便携 Python 已就绪则跳过下载/解压 ----------
+        if !(python_exe.exists() && super::run_python_version(&python_exe).is_some()) {
+            self.emit_progress(app, "download", 2, 0, None, "开始下载便携 Python...").await;
+
+            // 下载 embeddable zip（~11MB，流式写入）
+            let zip_path = runtime_dir.join(format!("python-{}-embed.zip", super::BUNDLED_PY_VERSION));
+            let zip_url = format!(
+                "https://www.python.org/ftp/python/{}/python-{}-embed-amd64.zip",
+                super::BUNDLED_PY_VERSION,
+                super::BUNDLED_PY_VERSION
+            );
+            self.download_stream(app, &zip_url, &zip_path).await?;
+
+            // 解压到 runtime/python/
+            self.emit_progress(app, "extract", 42, 0, None, "正在解压便携 Python...").await;
+            let python_dir = runtime_dir.join("python");
+            if python_dir.exists() {
+                fs::remove_dir_all(&python_dir).ok();
+            }
+            fs::create_dir_all(&python_dir).map_err(|e| e.to_string())?;
+            self.extract_zip(&zip_path, &python_dir)?;
+            fs::remove_file(&zip_path).ok();
+
+            // _pth 补丁：启用 site（否则无法识别 site-packages 与 pip）
+            self.emit_progress(app, "patch", 52, 0, None, "正在配置 Python 环境...").await;
+            self.patch_pth(&python_dir)?;
+
+            // 下载 get-pip.py 并引导 pip（只装 pip 本体，走官方源，包很小）
+            self.emit_progress(app, "pip", 54, 0, None, "正在引导 pip...").await;
+            let get_pip = runtime_dir.join("get-pip.py");
+            self.download_bytes(&"https://bootstrap.pypa.io/get-pip.py".to_string(), &get_pip)
+                .await?;
+            let pip_py = python_exe.clone();
+            let pip_py2 = pip_py.clone(); // 供 setuptools 步骤闭包使用（先于 move 克隆）
+            let get_pip2 = get_pip.clone();
+            self.run_blocking_step(
+                app,
+                "pip",
+                55,
+                60,
+                move |pid| {
+                    let mut cmd = std::process::Command::new(&pip_py);
+                    cmd.arg(&get_pip2).args(["--no-warn-script-location"]);
+                    run_cmd_blocking(cmd, pid)
+                },
+                "正在安装 pip...",
+            )
+            .await?;
+            fs::remove_file(&get_pip).ok();
+
+            // 安装 setuptools（musicdl 的 setup.py 构建依赖 setuptools.build_meta，
+            // 必须先于 musicdl 就位，否则构建阶段报 BackendUnavailable）
+            self.run_blocking_step(
+                app,
+                "pip",
+                62,
+                66,
+                move |pid| {
+                    let mut cmd = std::process::Command::new(&pip_py2);
+                    cmd.args([
+                        "-m", "pip", "install", "--no-warn-script-location",
+                        "--timeout", "60",
+                        "--index-url", PIP_INDEX_URL,
+                        "setuptools",
+                    ]);
+                    run_cmd_blocking(cmd, pid)
+                },
+                "正在安装 setuptools...",
+            )
+            .await?;
+        } else {
+            self.emit_progress(app, "check", 2, 0, None, "便携 Python 已就绪").await;
+        }
+
+        // ---------- 2. 安装 musicdl（幂等：已安装则跳过） ----------
+        if !self.musicdl_ready(&python_exe).await {
+            let pip_py = python_exe.clone();
+            self.run_blocking_step(
+                app,
+                "musicdl",
+                68,
+                95,
+                move |pid| {
+                    let mut cmd = std::process::Command::new(&pip_py);
+                    cmd.args([
+                        "-m", "pip", "install", "--no-warn-script-location",
+                        "--timeout", "60",
+                        "--index-url", PIP_INDEX_URL,
+                        &format!("musicdl=={}", super::MUSICDL_VERSION),
+                    ]);
+                    run_cmd_blocking(cmd, pid)
+                },
+                "正在安装 musicdl（下载依赖较多，可能需几分钟）...",
+            )
+            .await?;
+        }
+
+        self.emit_progress(app, "done", 100, 0, None, "环境就绪").await;
+        crate::logger::log_info("music", "便携 Python + musicdl 安装完成");
+        Ok(())
+    }
+
+    /// 检查便携 Python 能否导入 musicdl
+    async fn musicdl_ready(&self, python_exe: &PathBuf) -> bool {
+        let exe = python_exe.clone();
+        let (ok, _) = super::check_musicdl(&exe);
+        ok
+    }
+
+    /// 把已装的 musicdl 对齐到本应用锁定的版本（`MUSICDL_VERSION`）。
+    ///
+    /// 为什么必须有这个动作：`install_runtime_inner` 的闸门是「能否 import」而不是
+    /// 「版本是否一致」——仅升级应用（哪怕代码里的锁定版本提高了）**不会**触发 pip，
+    /// 已装环境会永远停在旧版本。这里显式执行 `pip install --upgrade musicdl==<pinned>`；
+    /// `force = true` 用 `--force-reinstall` 兜住「能 import 但依赖已损坏」的灰区
+    /// （`check_musicdl` 只验证 `import musicdl` 与 `__version__`，证明不了子模块可用）。
+    ///
+    /// 只允许升到**锁定版本**，绝不升到 PyPI 最新：`bridge.py` 对 musicdl 的 monkey patch
+    /// 与版本强耦合（第三方解析链方法名、各源搜索字段映射、音质常量前缀），
+    /// 任意升版会静默破坏解析链。升锁定版本时必须同步核对那些补丁。
+    pub async fn update_musicdl(&self, app: &AppHandle, force: bool) -> Result<(), String> {
+        self.runtime_cancel.store(false, std::sync::atomic::Ordering::SeqCst);
+        let result = self.update_musicdl_inner(app, force).await;
+        if let Err(ref e) = result {
+            if e != RUNTIME_CANCELLED {
+                let _ = app.emit(
+                    MUSIC_RUNTIME_INSTALL_PROGRESS,
+                    MusicInstallProgress {
+                        stage: "error".into(),
+                        percent: 0,
+                        downloaded_bytes: 0,
+                        total_bytes: None,
+                        message: e.clone(),
+                    },
+                );
+            }
+        }
+        result
+    }
+
+    async fn update_musicdl_inner(&self, app: &AppHandle, force: bool) -> Result<(), String> {
+        let python_exe = self.bundled_python_exe();
+        // 便携 Python 不可用（或跑不起来）：直接走完整安装流程，
+        // 它会把 Python / pip / setuptools / musicdl 一次装齐
+        if !(python_exe.exists() && super::run_python_version(&python_exe).is_some()) {
+            return self.install_runtime_inner(app).await;
+        }
+
+        let mut args: Vec<String> = vec![
+            "-m".into(),
+            "pip".into(),
+            "install".into(),
+            "--no-warn-script-location".into(),
+            "--timeout".into(),
+            "60".into(),
+            "--index-url".into(),
+            PIP_INDEX_URL.into(),
+        ];
+        args.push(if force {
+            "--force-reinstall".into()
+        } else {
+            "--upgrade".into()
+        });
+        args.push(format!("musicdl=={}", super::MUSICDL_VERSION));
+        let msg = if force {
+            "正在修复 musicdl（强制重装，依赖较多，可能需几分钟）...".to_string()
+        } else {
+            format!("正在更新 musicdl 到 {}...", super::MUSICDL_VERSION)
+        };
+
+        let exe = python_exe.clone();
+        self.run_blocking_step(
+            app,
+            "musicdl",
+            10,
+            95,
+            move |pid| {
+                let mut cmd = std::process::Command::new(&exe);
+                cmd.args(&args);
+                run_cmd_blocking(cmd, pid)
+            },
+            &msg,
+        )
+        .await?;
+        self.emit_progress(app, "done", 100, 0, None, "musicdl 已对齐到锁定版本")
+            .await;
+        Ok(())
+    }
+
+    // ---------- 阶段工具 ----------
+    async fn emit_progress(
+        &self,
+        app: &AppHandle,
+        stage: &str,
+        percent: u32,
+        downloaded_bytes: u64,
+        total_bytes: Option<u64>,
+        message: &str,
+    ) {
+        let _ = app.emit(
+            MUSIC_RUNTIME_INSTALL_PROGRESS,
+            MusicInstallProgress {
+                stage: stage.into(),
+                percent,
+                downloaded_bytes,
+                total_bytes,
+                message: message.into(),
+            },
+        );
+    }
+
+    /// 流式下载（带取消 + 进度事件，percent 0-40 区间），复用内核下载模式
+    async fn download_stream(
+        &self,
+        app: &AppHandle,
+        url: &str,
+        dest: &Path,
+    ) -> Result<(), String> {
+        let resp = self
+            .client
+            .get(url)
+            .timeout(std::time::Duration::from_secs(300))
+            .send()
+            .await
+            .map_err(|e| format!("请求下载失败: {}", e))?;
+        let status = resp.status();
+        if !status.is_success() {
+            return Err(format!("下载返回 HTTP {}", status.as_u16()));
+        }
+        let total: Option<u64> = resp.content_length();
+        let mut file = fs::File::create(dest).map_err(|e| format!("创建文件失败: {}", e))?;
+        let mut stream = resp.bytes_stream();
+        let mut downloaded: u64 = 0;
+        let mut last_percent: u32 = 0;
+        while let Some(chunk) = stream.next().await {
+            if self.is_cancelled() {
+                drop(file);
+                fs::remove_file(dest).ok();
+                return Err(RUNTIME_CANCELLED.to_string());
+            }
+            let chunk = chunk.map_err(|e| format!("下载中断: {}", e))?;
+            file.write_all(&chunk).map_err(|e| format!("写入文件失败: {}", e))?;
+            downloaded += chunk.len() as u64;
+            let percent = total
+                .filter(|t| *t > 0)
+                .map(|t| ((downloaded as f64 / t as f64) * 38.0) as u32)
+                .unwrap_or(0)
+                .min(38);
+            if percent >= last_percent + 1 {
+                last_percent = percent;
+                self.emit_progress(
+                    app,
+                    "download",
+                    percent,
+                    downloaded,
+                    total,
+                    &format!("正在下载便携 Python ({:.1} MB)", downloaded as f64 / 1048576.0),
+                )
+                .await;
+            }
+        }
+        file.flush().ok();
+        self.emit_progress(app, "download", 40, downloaded, total, "下载完成").await;
+        Ok(())
+    }
+
+    /// 小文件整体下载（get-pip.py），无进度
+    async fn download_bytes(&self, url: &str, dest: &Path) -> Result<(), String> {
+        let resp = self
+            .client
+            .get(url)
+            .timeout(std::time::Duration::from_secs(120))
+            .send()
+            .await
+            .map_err(|e| format!("请求下载失败: {}", e))?;
+        let status = resp.status();
+        if !status.is_success() {
+            return Err(format!("下载返回 HTTP {}", status.as_u16()));
+        }
+        let bytes = resp.bytes().await.map_err(|e| format!("读取响应失败: {}", e))?;
+        fs::write(dest, &bytes).map_err(|e| format!("写入文件失败: {}", e))?;
+        Ok(())
+    }
+
+    /// 解压 zip（复用内核解压逻辑）
+    fn extract_zip(&self, 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(())
+    }
+
+    /// 修改 pythonXY._pth：启用 `import site`（embeddable 默认注释掉，
+    /// 不启用则无法识别 site-packages / pip 安装的包）
+    fn patch_pth(&self, python_dir: &Path) -> Result<(), String> {
+        let entries = fs::read_dir(python_dir).map_err(|e| e.to_string())?;
+        let pth = entries
+            .filter_map(|e| e.ok())
+            .map(|e| e.path())
+            .find(|p| {
+                p.extension()
+                    .and_then(|e| e.to_str())
+                    .map(|e| e.eq_ignore_ascii_case("_pth"))
+                    .unwrap_or(false)
+            })
+            .ok_or_else(|| "解压目录中未找到 ._pth 文件".to_string())?;
+
+        let content = fs::read_to_string(&pth).map_err(|e| e.to_string())?;
+        let mut patched = content.replace("#import site", "import site");
+        if !patched.contains("import site") {
+            patched.push_str("import site\n");
+        }
+        // 显式把 site-packages 加入 sys.path（pip 默认安装位置）
+        if !patched.contains("Lib\\site-packages") && !patched.contains("Lib/site-packages") {
+            patched.push_str("Lib\\site-packages\n");
+        }
+        fs::write(&pth, patched).map_err(|e| format!("写入 _pth 失败: {}", e))?;
+        crate::logger::log_info("music", &format!("已补丁 _pth: {}", pth.display()));
+        Ok(())
+    }
+
+    /// 执行一个阻塞子进程步骤（get-pip / setuptools / musicdl），带进度推送、取消检查与超时看门狗。
+    /// start_percent / end_percent：本步骤的进度区间（完成前推进到 end_percent）。
+    /// run 闭包接收「子进程 pid 记录器」，供取消时 taskkill。
+    async fn run_blocking_step<F>(
+        &self,
+        app: &AppHandle,
+        stage: &str,
+        start_percent: u32,
+        end_percent: u32,
+        run: F,
+        msg: &str,
+    ) -> Result<(), String>
+    where
+        F: FnOnce(Arc<std::sync::atomic::AtomicU64>) -> Result<(), String> + Send + 'static,
+    {
+        if self.is_cancelled() {
+            return Err(RUNTIME_CANCELLED.to_string());
+        }
+        let pid_ref = self.install_pid.clone();
+        self.emit_progress(app, stage, start_percent, 0, None, msg).await;
+        let result = tauri::async_runtime::spawn_blocking(move || run(pid_ref.clone()))
+            .await
+            .map_err(|e| format!("任务执行失败: {}", e))?;
+        self.install_pid.store(0, std::sync::atomic::Ordering::SeqCst);
+        if self.is_cancelled() {
+            return Err(RUNTIME_CANCELLED.to_string());
+        }
+        result?;
+        self.emit_progress(app, stage, end_percent, 0, None, "完成").await;
+        Ok(())
+    }
+}
+
+/// 同步运行子进程，带超时看门狗（超时 taskkill），并记录 pid 供取消。
+/// 输出（stdout+stderr 尾部）写入日志；失败返回错误信息。
+fn run_cmd_blocking(
+    mut cmd: std::process::Command,
+    pid_ref: Arc<std::sync::atomic::AtomicU64>,
+) -> Result<(), String> {
+    cmd.stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .stdin(std::process::Stdio::null());
+    crate::process_manager::setup_creation_flags(&mut cmd);
+
+    let child = cmd.spawn().map_err(|e| format!("启动子进程失败: {}", e))?;
+    pid_ref.store(child.id() as u64, std::sync::atomic::Ordering::SeqCst);
+
+    // 超时看门狗：30 分钟后仍未结束则强杀（慢网络下 pip 装 musicdl 依赖可能超过 10 分钟）
+    let pid = child.id();
+    let (tx, rx) = std::sync::mpsc::channel::<()>();
+    let watcher = std::thread::spawn(move || {
+        if rx.recv_timeout(std::time::Duration::from_secs(1800)).is_err() {
+            let _ = std::process::Command::new("taskkill")
+                .args(["/F", "/T", "/PID", &pid.to_string()])
+                .stdout(std::process::Stdio::null())
+                .stderr(std::process::Stdio::null())
+                .status();
+        }
+    });
+
+    let output = child.wait_with_output();
+    let _ = tx.send(());
+    let _ = watcher.join();
+
+    match output {
+        Ok(out) => {
+            let text = format!(
+                "{}{}",
+                String::from_utf8_lossy(&out.stdout),
+                String::from_utf8_lossy(&out.stderr)
+            );
+            if out.status.success() {
+                Ok(())
+            } else {
+                // 截取尾部 800 字符，便于定位 pip 报错
+                let tail: String = text.chars().rev().take(800).collect::<String>().chars().rev().collect();
+                Err(format!("子进程退出码 {}: {}", out.status.code().unwrap_or(-1), tail))
+            }
+        }
+        Err(e) => Err(format!("读取子进程输出失败: {}", e)),
+    }
+}

src-tauri/src/music/secrets.rs

@@ -0,0 +1,54 @@
+//! 音乐模块的凭据键约定与便捷读取。
+//!
+//! 底层读写原语已抽到 crate 级 [`crate::secrets`]（同一套 `Thing` 服务名与迁移
+//! 策略，翻译模块等其他使用者共享）。本文件只保留**音乐自己的键名**与
+//! 「前端可达范围」这道闸门，读写一律委托给公共模块，避免出现第二套实现。
+//!
+//! 约定：
+//! - 一律使用 `Thing` 作为凭据服务名，`key` 作为用户名（Entry 的 account）。
+//!   服务名是历史值，改动会导致已有凭据读不到。
+//! - 明文只允许存在于内存与系统凭据库，禁止回写 `settings.json` / localStorage。
+//! - 迁移采用「先写凭据库成功、再清明文」的顺序；**写失败时保留明文**，
+//!   宁可牺牲一致性也不能把用户已登录的会话弄丢。
+//! - 非 Windows 平台没有凭据管理器：读取返回 None、写入报错，
+//!   调用方据此退化为「明文存 settings」（功能优先）。
+
+pub use crate::secrets::{secret_delete, secret_read, secret_write, try_store};
+
+/// WebDAV 凭据的 key（**历史值，不可更改**）。
+pub const KEY_WEBDAV: &str = "webdav-credentials";
+/// QQ 音乐 Cookie 的 key（前端 `musicStore` 使用）。
+pub const KEY_QQ_COOKIE: &str = "music-qq-cookie";
+
+/// 允许**前端**通过 `music_secret_*` 命令读写的凭据键白名单。
+///
+/// 用白名单而不是前缀匹配：前端不该有能力枚举/试探凭据库，
+/// `webdav-credentials` 与飞牛 token 因此都在前端的可达范围之外。
+/// 新增键必须在此显式登记（改 Rust 代码），这是一道有意的闸门。
+pub const FRONTEND_KEYS: [&str; 1] = [KEY_QQ_COOKIE];
+
+/// 飞牛连接 token 的 key 前缀（**只由后端使用**，不暴露给前端）。
+const TOKEN_KEY_PREFIX: &str = "music-feiniu-token-";
+
+/// 某条飞牛连接的登录 token 的 key。
+pub fn feiniu_token_key(connection_id: &str) -> String {
+    format!("{TOKEN_KEY_PREFIX}{connection_id}")
+}
+
+/// 前端是否允许访问该凭据键。
+pub fn frontend_key_allowed(key: &str) -> bool {
+    FRONTEND_KEYS.contains(&key)
+}
+
+/// 读取飞牛连接 token；未配置或读取失败 → 空串（等价于未登录）。
+pub fn read_feiniu_token(connection_id: &str) -> String {
+    if connection_id.is_empty() {
+        return String::new();
+    }
+    crate::secrets::read_or_empty(&feiniu_token_key(connection_id))
+}
+
+/// 该连接是否已有可用 token（供前端展示「已登录」）。
+pub fn has_feiniu_token(connection_id: &str) -> bool {
+    !read_feiniu_token(connection_id).is_empty()
+}

src-tauri/src/osd_window.rs

@@ -15,9 +15,12 @@ use tauri::{AppHandle, Emitter};
 static DRAG_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
 /// 任务栏覆盖监视线程停止标志
 static TOPMOST_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
+/// 游戏全屏监视线程停止标志
+static GAME_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);
+static GAME_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
 
 fn drag_stop() -> &'static Arc<AtomicBool> {
     DRAG_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
@@ -27,6 +30,10 @@ fn topmost_stop() -> &'static Arc<AtomicBool> {
     TOPMOST_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
 }
 
+fn game_stop() -> &'static Arc<AtomicBool> {
+    GAME_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
+}
+
 /// 停止右键拖动监视线程并等待其退出（标志置位后线程最迟一个轮询周期退出）
 fn stop_drag_thread() {
     drag_stop().store(true, Ordering::SeqCst);
@@ -51,18 +58,35 @@ fn stop_topmost_thread() {
     }
 }
 
+/// 停止游戏全屏监视线程并等待其退出
+fn stop_game_thread() {
+    game_stop().store(true, Ordering::SeqCst);
+    if let Some(h) = GAME_HANDLE
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .take()
+    {
+        let _ = h.join();
+    }
+}
+
 #[cfg(windows)]
 mod win_api {
     use tauri::{AppHandle, Manager};
     use windows_sys::Win32::Foundation::{POINT, RECT};
+    use windows_sys::Win32::Graphics::Gdi::{
+        GetMonitorInfoW, MonitorFromWindow, MONITORINFO, MONITOR_DEFAULTTONEAREST,
+    };
     use windows_sys::Win32::UI::Input::KeyboardAndMouse::{GetAsyncKeyState, VK_RBUTTON};
     use windows_sys::Win32::UI::WindowsAndMessaging::{
-        GetClassNameW, GetCursorPos, GetForegroundWindow, GetWindowLongPtrW,
+        GetClassNameW, GetCursorPos, GetForegroundWindow, GetWindowLongPtrW, GetWindowLongW,
-        GetWindowRect, SendMessageW, SetWindowLongPtrW, SetWindowPos,
+        GetWindowRect, GetWindowThreadProcessId, SendMessageW, SetWindowLongPtrW, SetWindowPos,
-        GWL_EXSTYLE, HTCAPTION, HWND_NOTOPMOST, HWND_TOPMOST, SWP_NOACTIVATE, SWP_NOMOVE,
+        GWL_EXSTYLE, GWL_STYLE, HTCAPTION, HWND_NOTOPMOST, HWND_TOPMOST, SWP_NOACTIVATE,
-        SWP_NOSIZE, SWP_SHOWWINDOW, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
+        SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE,
-        WS_EX_TRANSPARENT,
+        WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT,
     };
+    /// 供模块外全屏判定使用的窗口样式常量（pub re-export）
+    pub use windows_sys::Win32::UI::WindowsAndMessaging::WS_CAPTION;
 
     /// windows-sys 的 HWND 类型别名（isize）
     pub type Hwnd = isize;
@@ -165,6 +189,10 @@ mod win_api {
             } else {
                 HWND_NOTOPMOST
             };
+            // 注意：不传 SWP_SHOWWINDOW，仅调整 Z 序，绝不改变窗口可见性。
+            // 否则当 OSD 被 .hide() 隐藏后，任务栏覆盖监视线程在系统 UI 前景切换时
+            // （点击任务栏/托盘关闭主界面、打开托盘菜单）会重新显示已隐藏的 OSD，
+            // 表现为"托盘关闭 OSD 无效 / 关闭主界面后 OSD 又出现"。
             SetWindowPos(
                 hwnd,
                 insert_after,
@@ -172,7 +200,7 @@ mod win_api {
                 0,
                 0,
                 0,
-                SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_SHOWWINDOW,
+                SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE,
             );
         }
     }
@@ -190,6 +218,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!(
@@ -203,6 +249,41 @@ mod win_api {
             | "Windows.UI.Shell.ShellFlyoutWindow" // Win11 Shell 弹出
         )
     }
+
+    /// 获取窗口样式（GWL_STYLE）
+    pub fn get_window_style(hwnd: Hwnd) -> isize {
+        unsafe { GetWindowLongW(hwnd, GWL_STYLE) as isize }
+    }
+
+    /// 判断窗口是否属于本进程（Thing 自身窗口不参与全屏判定）
+    pub fn is_own_process(hwnd: Hwnd) -> bool {
+        let mut pid: u32 = 0;
+        unsafe {
+            GetWindowThreadProcessId(hwnd, &mut pid);
+        }
+        pid != 0 && pid == std::process::id()
+    }
+
+    /// 获取窗口所在显示器（最近匹配）的矩形（物理像素）
+    pub fn get_monitor_rect(hwnd: Hwnd) -> Option<RECT> {
+        let monitor = unsafe { MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) };
+        if monitor == 0 {
+            return None;
+        }
+        let mut info = MONITORINFO {
+            cbSize: std::mem::size_of::<MONITORINFO>() as u32,
+            rcMonitor: RECT { left: 0, top: 0, right: 0, bottom: 0 },
+            rcWork: RECT { left: 0, top: 0, right: 0, bottom: 0 },
+            dwFlags: 0,
+        };
+        unsafe {
+            if GetMonitorInfoW(monitor, &mut info) != 0 {
+                Some(info.rcMonitor)
+            } else {
+                None
+            }
+        }
+    }
 }
 
 /// 应用 OSD 悬浮窗的原生样式（NoActivate + ToolWindow）
@@ -347,11 +428,98 @@ pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
+/// 判断窗口是否为全屏应用（无边框/独占全屏游戏）
+///
+/// 判定条件（全部满足）：
+/// 1. 无 WS_CAPTION 样式 —— 排除普通应用的"最大化"（即使系统任务栏设为自动隐藏，
+///    最大化窗口覆盖率也接近 100%，但它们带标题栏，靠样式即可区分）
+/// 2. 非本进程窗口（Thing 主窗口/悬浮窗自身）
+/// 3. 窗口矩形与所在显示器矩形的交集覆盖率 ≥ 95%（兼容缩放/1px 误差）
+#[cfg(windows)]
+fn is_fullscreen_game_window(hwnd: isize) -> bool {
+    if win_api::get_window_style(hwnd) & (win_api::WS_CAPTION as isize) != 0 {
+        return false;
+    }
+    if win_api::is_own_process(hwnd) {
+        return false;
+    }
+    let (Some(win_rect), Some(mon_rect)) = (
+        win_api::get_window_rect(hwnd),
+        win_api::get_monitor_rect(hwnd),
+    ) else {
+        return false;
+    };
+    let iw = (win_rect.right.min(mon_rect.right) - win_rect.left.max(mon_rect.left)).max(0) as i64;
+    let ih = (win_rect.bottom.min(mon_rect.bottom) - win_rect.top.max(mon_rect.top)).max(0) as i64;
+    let mw = (mon_rect.right - mon_rect.left).max(0) as i64;
+    let mh = (mon_rect.bottom - mon_rect.top).max(0) as i64;
+    let mon_area = (mw * mh).max(1);
+    iw * ih * 100 >= mon_area * 95
+}
+
+/// 启动游戏全屏监视
+///
+/// 轮询检测前景窗口是否为全屏应用（无边框/独占全屏游戏），
+/// 状态变化时发出 `osd-game-active` / `osd-game-inactive` 事件。
+/// 前端据此隐藏/恢复 OSD：透明置顶 WebView 悬浮窗会占用 DWM 合成路径，
+/// 禁用游戏的独立翻转（MPO），是游戏中掉帧的根源；隐藏悬浮窗即可排除影响。
+#[tauri::command]
+pub fn osd_start_game_watch(app: AppHandle) -> Result<(), String> {
+    // 停止旧线程，等待其退出后再启动新线程
+    stop_game_thread();
+    let stop_flag = game_stop().clone();
+    stop_flag.store(false, Ordering::SeqCst);
+
+    let app_handle = app.clone();
+
+    let handle = thread::spawn(move || {
+        let mut fullscreen_active = false;
+
+        loop {
+            if stop_flag.load(Ordering::SeqCst) {
+                break;
+            }
+
+            #[cfg(windows)]
+            {
+                let fg = win_api::get_foreground_window();
+                let fullscreen = fg != 0
+                    && win_api::get_class_name(fg)
+                        .map_or(false, |c| !win_api::is_system_ui_class(&c))
+                    && is_fullscreen_game_window(fg);
+
+                if fullscreen != fullscreen_active {
+                    fullscreen_active = fullscreen;
+                    let event = if fullscreen {
+                        crate::constants::events::OSD_GAME_ACTIVE
+                    } else {
+                        crate::constants::events::OSD_GAME_INACTIVE
+                    };
+                    let _ = app_handle.emit(event, ());
+                    crate::logger::log_info(
+                        "osd",
+                        &format!("全屏应用前台: {}", if fullscreen { "是 → 隐藏 OSD" } else { "否 → 恢复 OSD" }),
+                    );
+                }
+            }
+
+            thread::sleep(Duration::from_millis(1000));
+        }
+    });
+
+    if let Ok(mut guard) = GAME_HANDLE.lock() {
+        *guard = Some(handle);
+    }
+
+    Ok(())
+}
+
 /// 停止所有 OSD 监视线程
 #[tauri::command]
 pub fn osd_stop_watch() {
     stop_drag_thread();
     stop_topmost_thread();
+    stop_game_thread();
 }
 
 /// 设置点击穿透（Rust 侧原生 WS_EX_TRANSPARENT，比 JS setIgnoreCursorEvents 更可靠）
@@ -378,6 +546,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

@@ -11,6 +11,11 @@ use tauri::{AppHandle, Emitter, Manager};
 // CREATE_NO_WINDOW = 0x08000000，阻止子进程创建新的控制台窗口
 #[cfg(windows)]
 pub const CREATE_NO_WINDOW: u32 = 0x08000000;
+// CREATE_NEW_CONSOLE = 0x00000010，强制为控制台类子进程新开一个可见控制台窗口。
+// 从 GUI 宿主（无控制台）直接 spawn cmd/powershell 等控制台程序时若不设置，
+// 子进程会挂到隐藏控制台/不显示窗口，表现为"点击没反应"。
+#[cfg(windows)]
+pub const CREATE_NEW_CONSOLE: u32 = 0x00000010;
 
 // Windows Job Object 相关常量，用于异常退出时自动清理子进程
 #[cfg(windows)]
@@ -122,8 +127,9 @@ pub fn setup_creation_flags(_cmd: &mut Command) {
 
 /// 将已启动的子进程加入 Job Object（异常退出时自动清理）
 /// 在 Windows 上调用，非 Windows 平台为空操作
+/// pub(crate)：音乐模块的桥接进程（自管 stdio，不走 ProcessManager）也需加入 Job
 #[cfg(windows)]
-fn assign_to_job(child: &Child) {
+pub(crate) fn assign_to_job(child: &Child) {
     use std::os::windows::io::AsRawHandle;
     if let Some(job) = get_job_handle() {
         let child_handle = child.as_raw_handle() as winapi::HANDLE;

src-tauri/src/quickpanel/commands.rs

@@ -1,6 +1,6 @@
 //! Tauri 命令：快速面板模块
 
-use tauri::{AppHandle, Manager};
+use tauri::{AppHandle, Emitter, Manager};
 
 use super::popup::{self, QuickPanelSettings};
 use super::{file_index, app_scanner, icon_extractor};
@@ -22,14 +22,17 @@ pub async fn quickpanel_get_settings(app: AppHandle) -> Result<QuickPanelSetting
     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 {
@@ -41,6 +44,10 @@ pub async fn quickpanel_save_settings(
             popup::ensure_window(&app);
         }
     }
+    // 索引目录变更：闲时自动重建（新增/移除路径后无需手动点"构建索引"）
+    if dirs_changed {
+        schedule_auto_build(app, true);
+    }
     Ok(())
 }
 
@@ -125,33 +132,98 @@ 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]
 #[specta::specta]
 pub async fn quickpanel_init_file_index(app: AppHandle) -> Result<(), String> {
-    tauri::async_runtime::spawn_blocking(move || {
+    let app_for_build = app.clone();
-        file_index::init(&app);
+    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))
+    .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 = resolve_index_dirs(&app);
-    let dirs = if settings.index_dirs.is_empty() {
-        popup::QuickPanelSettings::default().index_dirs
-    } else {
-        settings.index_dirs
-    };
     // 懒加载：首次构建时自动初始化 DB 连接
     file_index::ensure_initialized(&app);
     // 阻塞操作放到 spawn_blocking
@@ -433,11 +505,35 @@ pub fn quickpanel_run_custom_command(command: String, args: Vec<String>) -> Resu
 
 /// 运行系统命令（不设置 CREATE_NO_WINDOW，使 cmd/powershell/regedit 等显示自身窗口）
 /// 适用于内置系统工具：regedit、shutdown、cmd、powershell、taskmgr 等。
+/// - 控制台类交互程序（cmd/powershell/pwsh）额外设置 CREATE_NEW_CONSOLE，
+///   否则从 GUI 宿主启动时无可见控制台窗口（表现为"点击没反应"）。
+/// - .msc 控制台文件（如 devmgmt.msc）不可被 CreateProcess 直接执行，
+///   改由 mmc 打开（路径解析到 System32，不受当前工作目录影响）。
 #[tauri::command]
 #[specta::specta]
 pub fn quickpanel_run_system_command(command: String, args: Vec<String>) -> Result<(), String> {
+    let lower = command.to_lowercase();
+    if lower.ends_with(".msc") {
+        // 控制台文件：通过 mmc 打开（GUI 程序，无需新控制台）
+        let system_root = std::env::var("SystemRoot").unwrap_or_else(|_| "C:\\Windows".into());
+        let path = format!("{}\\System32\\{}", system_root, command);
+        let mut c = std::process::Command::new("mmc");
+        c.arg(&path);
+        return c
+            .spawn()
+            .map(|_| ())
+            .map_err(|e| format!("运行系统命令失败: {}", e));
+    }
     let mut cmd = std::process::Command::new(&command);
     cmd.args(&args);
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        let c = lower;
+        if c == "cmd" || c == "powershell" || c == "pwsh" {
+            cmd.creation_flags(crate::process_manager::CREATE_NEW_CONSOLE);
+        }
+    }
     cmd.spawn().map_err(|e| format!("运行系统命令失败: {}", e))?;
     Ok(())
 }

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};
@@ -118,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()

src-tauri/src/quickpanel/popup.rs

@@ -13,6 +13,7 @@
 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};
@@ -57,6 +58,48 @@ static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
 /// 避免窗口重建后仍停留在屏幕外 (-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, Type)]
 #[serde(rename_all = "camelCase")]
@@ -184,10 +227,14 @@ fn create_popup_window(app: &AppHandle) {
     };
 
     // 监听窗口失焦：自动隐藏
+    // 距上次 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(crate::constants::events::QUICKPANEL_HIDE, ());
         }
@@ -209,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";
 
@@ -253,8 +301,7 @@ pub fn show_popup(app: &AppHandle) {
             x: x as i32,
             y: y as i32,
         }));
-        let _ = win.show();
+        show_and_focus(&win);
-        let _ = win.set_focus();
         return;
     }
 
@@ -267,12 +314,24 @@ pub fn show_popup(app: &AppHandle) {
 }
 
 /// 显示已创建的弹窗窗口（由前端 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) {
         // 应用 show_popup 计算的兜底位置（物理坐标），避免停留在屏幕外
         let pos = PENDING_POS.lock().ok().and_then(|p| *p);
@@ -284,8 +343,7 @@ pub fn show_window(app: &AppHandle) {
         }
         // 同样先检测 Explorer 目录再显示，避免面板抢焦点导致检测失败。
         emit_show(app);
-        let _ = win.show();
+        show_and_focus(&win);
-        let _ = win.set_focus();
     }
 }
 

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 转换
 //!
@@ -17,9 +18,9 @@
 use std::sync::Mutex;
 use windows_sys::Win32::Foundation::{BOOL, HWND, POINT, RECT};
 use windows_sys::Win32::Graphics::Gdi::{
-    BitBlt, CreateCompatibleBitmap, CreateCompatibleDC, DeleteDC, DeleteObject, GetDC, GetDIBits,
+    BitBlt, CombineRgn, CreateCompatibleBitmap, CreateCompatibleDC, CreateRectRgn, DeleteDC,
-    PatBlt, ReleaseDC, SelectObject, BITMAPINFO, BITMAPINFOHEADER, BLACKNESS, DIB_RGB_COLORS,
+    DeleteObject, GetDC, GetDIBits, PatBlt, ReleaseDC, SelectObject, SetWindowRgn, BITMAPINFO,
-    RGBQUAD, SRCCOPY,
+    BITMAPINFOHEADER, BLACKNESS, DIB_RGB_COLORS, RGBQUAD, RGN_DIFF, SRCCOPY,
 };
 use windows_sys::Win32::Storage::Xps::PrintWindow;
 use windows_sys::Win32::System::DataExchange::{
@@ -33,7 +34,7 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
     WS_EX_TOOLWINDOW,
 };
 
-use super::{CaptureData, ScreenRect, WindowInfo};
+use super::{CaptureData, ScreenRect, ScrollRegion, WindowInfo};
 
 /// 捕获结果（PNG 字节 + 原始 BGRA 像素，像素用于剪贴板 DIB 构造，避免重复解码）
 pub struct CapturedImage {
@@ -110,7 +111,7 @@ fn bgra_to_bmp(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String>
 ///
 /// 使用 Fast 压缩 + 无过滤：历史缩略图/自动保存不需要最优压缩比，
 /// 大幅降低"点击完成 → 关闭窗口"的编码延迟。
-fn bgra_to_png(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String> {
+pub(crate) fn bgra_to_png(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String> {
     use image::codecs::png::{CompressionType, FilterType, PngEncoder};
     use image::ImageEncoder;
     if width <= 0 || height <= 0 {
@@ -137,7 +138,7 @@ fn bgra_to_png(bgra: &[u8], width: i32, height: i32) -> Result<Vec<u8>, String>
 }
 
 /// 从 HBITMAP 提取 32bpp BGRA top-down 像素
-unsafe fn extract_pixels(
+pub(crate) unsafe fn extract_pixels(
     hdc_mem: isize,
     hbm: isize,
     width: i32,
@@ -181,7 +182,16 @@ unsafe fn extract_pixels(
 }
 
 /// 捕获整个虚拟屏（所有显示器拼接为一张图）
+///
+/// 优先走 BitBlt（SDR 全屏一次捕获、低延迟）；检测到任一显示器为 HDR 时改用 WGC
+/// （RGBA16F + HDR→sRGB 色调映射，避免 BitBlt 把 scRGB 线性像素当 sRGB 直出导致过曝）。
+/// WGC 失败时回退到 BitBlt。
 pub fn capture_virtual_screen() -> Result<CapturedImage, String> {
+    if super::wgc_capture::is_hdr_enabled() {
+        if let Ok(img) = super::wgc_capture::capture_virtual_screen_wgc() {
+            return Ok(img);
+        }
+    }
     unsafe {
         let x = GetSystemMetrics(SM_XVIRTUALSCREEN);
         let y = GetSystemMetrics(SM_YVIRTUALSCREEN);
@@ -231,6 +241,19 @@ pub fn capture_virtual_screen() -> Result<CapturedImage, String> {
 
 /// 捕获指定窗口（PrintWindow + PW_RENDERFULLCONTENT，覆盖硬件加速窗口）
 pub fn capture_window(hwnd: isize) -> Result<CapturedImage, String> {
+    let img = capture_window_bgra(hwnd)?;
+    let png = bgra_to_png(&img.bgra, img.width, img.height)?;
+    Ok(CapturedImage {
+        width: img.width,
+        height: img.height,
+        png,
+        bgra: img.bgra,
+    })
+}
+
+/// 捕获指定窗口的原始 BGRA（不做 PNG 编码）。
+/// 滚动截图每帧只需像素数据做匹配拼接，跳过编码可显著降低单帧耗时。
+pub fn capture_window_bgra(hwnd: isize) -> Result<CapturedImage, String> {
     unsafe {
         let mut rect: RECT = std::mem::zeroed();
         if GetWindowRect(hwnd, &mut rect) == 0 {
@@ -258,13 +281,11 @@ pub fn capture_window(hwnd: isize) -> Result<CapturedImage, String> {
         let result = if ok == 0 {
             Err("PrintWindow 失败（可能窗口无响应或权限不足）".into())
         } else {
-            extract_pixels(hdc_mem, hbm, w, h).and_then(|bgra| {
+            extract_pixels(hdc_mem, hbm, w, h).map(|bgra| CapturedImage {
-                bgra_to_png(&bgra, w, h).map(|png| CapturedImage {
+                width: w,
-                    width: w,
+                height: h,
-                    height: h,
+                png: Vec::new(),
-                    png,
+                bgra,
-                    bgra,
-                })
             })
         };
 
@@ -276,18 +297,16 @@ pub fn capture_window(hwnd: isize) -> Result<CapturedImage, String> {
     }
 }
 
-/// 获取指定屏幕坐标下的顶层窗口（窗口拾取）
+/// 枚举可拾取的顶层窗口（Z 序顶→底）
 ///
-/// 入参 x/y 为物理屏幕坐标（前端需按显示器 scaleFactor 从逻辑坐标换算）。
+/// 与逐点拾取同语义：排除本进程窗口（覆盖层/主窗口/编辑器）、不可见窗口、工具窗口。
-///
+/// 前端在截图开始时缓存该列表，鼠标移动时在 JS 侧做命中测试（rect 包含点，取 Z 序
-/// 不能直接用 WindowFromPoint：覆盖层是 alwaysOnTop 全屏窗口，会命中覆盖层自身。
+/// 最顶的第一个命中），消除逐帧 window_from_point 的 IPC 往返；且列表与冻结底图
-/// 改为 EnumWindows 按 Z 序（顶→底）枚举顶层窗口做命中测试，并排除本进程
+/// 同一时刻生成，命中结果与画面严格一致。
-/// （覆盖层/主窗口/编辑器）的窗口，从而取到覆盖层下面的目标窗口。
+pub fn pick_windows() -> Vec<WindowInfo> {
-pub fn window_from_point(x: i32, y: i32) -> Option<WindowInfo> {
     struct PickContext {
         my_pid: u32,
-        pt: POINT,
+        out: Vec<WindowInfo>,
-        found: Option<WindowInfo>,
     }
 
     extern "system" fn enum_proc(hwnd: HWND, lparam: isize) -> i32 {
@@ -311,30 +330,24 @@ pub fn window_from_point(x: i32, y: i32) -> Option<WindowInfo> {
             if GetWindowRect(hwnd, &mut rect) == 0 {
                 return 1;
             }
-            // 命中测试（物理坐标），Z 序最顶层的第一个命中即为目标
+            ctx.out.push(WindowInfo {
-            let pt = ctx.pt;
+                hwnd,
-            if pt.x >= rect.left && pt.x < rect.right && pt.y >= rect.top && pt.y < rect.bottom {
+                title: get_window_title(hwnd),
-                ctx.found = Some(WindowInfo {
+                rect: ScreenRect::from(rect),
-                    hwnd,
+                visual_rect: extended_frame_bounds(hwnd),
-                    title: get_window_title(hwnd),
+            });
-                    rect: ScreenRect::from(rect),
-                    visual_rect: extended_frame_bounds(hwnd),
-                });
-                return 0; // 停止枚举
-            }
         }
         1
     }
 
     let mut ctx = PickContext {
         my_pid: std::process::id(),
-        pt: POINT { x, y },
+        out: Vec::new(),
-        found: None,
     };
     unsafe {
         EnumWindows(Some(enum_proc), &mut ctx as *mut _ as isize);
     }
-    ctx.found
+    ctx.out
 }
 
 /// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口）
@@ -393,6 +406,71 @@ pub fn disable_window_transitions(hwnd: isize) -> Result<(), String> {
     }
 }
 
+/// 滚动截图模式：在覆盖层窗口上挖出选区带的"真孔"（内缩 INSET 保留蓝框），或清除恢复整窗。
+///
+/// 背景：Chromium 系浏览器（Edge/Chrome）的原生窗口遮挡检测（occlusion tracking）
+/// 会把被**完全覆盖**的窗口标记为 occluded 并暂停渲染合成——滚动截图时覆盖层
+/// 铺满全屏盖住目标窗口，网页"看起来完全不滚动"，PrintWindow 抓到的也是静止帧。
+/// 覆盖层并非 layered 窗口，即使其内容视觉透明，窗口矩形对遮挡检测仍算不透明覆盖。
+/// 挖孔后目标窗口仅部分被覆盖（Chromium 要求完全覆盖才判 occluded，实测 60x60
+/// 的小孔即可解除），恢复渲染与滚轮响应，拼接匹配随之正常。
+///
+/// - `region = Some`：孔 = 选区带内缩 INSET（保留 2px 蓝框 + 1px 白描边）；
+///   选区过小（< 2*INSET+8）时不挖孔，避免退化区域
+/// - `region = None`：SetWindowRgn(NULL) 清除窗口区域（恢复整窗）
+///
+/// 坐标：region 为屏幕物理像素（与滚动会话同源），按覆盖层窗口原点换算成窗口坐标。
+/// 区域设置在窗口上持续有效，会话结束/新一轮截图开始时必须传 None 复位。
+pub fn set_scroll_hole(hwnd: isize, region: Option<ScrollRegion>) -> Result<(), String> {
+    unsafe {
+        match region {
+            Some(r) => {
+                let mut wr: RECT = std::mem::zeroed();
+                if GetWindowRect(hwnd, &mut wr) == 0 {
+                    return Err("GetWindowRect 失败".into());
+                }
+                const INSET: i32 = 4;
+                let hx1 = r.x - wr.left + INSET;
+                let hy1 = r.y - wr.top + INSET;
+                let hx2 = r.x + r.width - wr.left - INSET;
+                let hy2 = r.y + r.height - wr.top - INSET;
+                if hx2 - hx1 < 8 || hy2 - hy1 < 8 {
+                    // 选区太小：不挖孔（保持整窗）
+                    if SetWindowRgn(hwnd, 0, 1) == 0 {
+                        return Err("SetWindowRgn 失败".into());
+                    }
+                    return Ok(());
+                }
+                let full = CreateRectRgn(0, 0, wr.right - wr.left, wr.bottom - wr.top);
+                let hole = CreateRectRgn(hx1, hy1, hx2, hy2);
+                if full == 0 || hole == 0 {
+                    if full != 0 {
+                        DeleteObject(full);
+                    }
+                    if hole != 0 {
+                        DeleteObject(hole);
+                    }
+                    return Err("CreateRectRgn 失败".into());
+                }
+                CombineRgn(full, full, hole, RGN_DIFF);
+                // 组合结果 full 归 SetWindowRgn 所有；hole 用完即删
+                DeleteObject(hole);
+                if SetWindowRgn(hwnd, full, 1) == 0 {
+                    DeleteObject(full);
+                    return Err("SetWindowRgn 失败".into());
+                }
+                Ok(())
+            }
+            None => {
+                if SetWindowRgn(hwnd, 0, 1) == 0 {
+                    return Err("SetWindowRgn 失败".into());
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
 /// 枚举所有可见、有标题的顶层窗口（供窗口列表选择）
 pub fn enum_visible_windows() -> Vec<WindowInfo> {
     extern "system" fn enum_proc(hwnd: HWND, lparam: isize) -> i32 {
@@ -530,7 +608,7 @@ fn bgra_to_dib(bgra: &[u8], width: i32, height: i32) -> Vec<u8> {
     dib
 }
 
-fn crop_bgra(
+pub(crate) fn crop_bgra(
     src: &[u8],
     src_width: usize,
     x: i32,
@@ -674,6 +752,20 @@ pub fn compose_copy_rgba(rgba: &[u8], width: i32, height: i32) -> Result<Capture
     }
     let dib = rgba_raw_to_dib(rgba, width, height);
     write_dib_to_clipboard(&dib)?;
+    rgba_raw_to_png_checked(rgba, width, height)
+}
+
+/// 有标注导出：raw RGBA → PNG base64（仅编码，不写剪贴板；编辑器「保存到文件」用）
+pub fn compose_png_rgba(rgba: &[u8], width: i32, height: i32) -> Result<CaptureData, String> {
+    let expected = (width as usize) * (height as usize) * 4;
+    if rgba.len() < expected {
+        return Err(format!("像素数据不足: {} < {}", rgba.len(), expected));
+    }
+    rgba_raw_to_png_checked(rgba, width, height)
+}
+
+/// raw RGBA → PNG base64（带长度校验的封装，供 compose_copy/compose_png 共用）
+fn rgba_raw_to_png_checked(rgba: &[u8], width: i32, height: i32) -> Result<CaptureData, String> {
     let png = rgba_raw_to_png(rgba, width, height)?;
     Ok(CaptureData {
         png_base64: base64_encode(&png),

src-tauri/src/screenshot/commands.rs

@@ -1,21 +1,26 @@
 //! 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：编辑器图片传递
+//! - screenshot_scroll_capture / screenshot_scroll_start / screenshot_scroll_finish /
+//!   screenshot_scroll_cancel：滚动截图（同步一次调用 / 会话式：启动、完成、取消）
+//! - screenshot_set_scroll_hole：滚动模式遮罩挖孔（防 Chromium 遮挡检测冻结目标窗口）
+//! - screenshot_take_editor_image_raw：取出编辑器图片（raw IPC，滚动截图会话直接写入）
+//! - screenshot_compose_png / screenshot_compose_copy：raw RGBA → PNG（仅编码 / 剪贴板+编码）
 //! - screenshot_copy_image：写入剪贴板（CF_DIB）
 //! - screenshot_save_png：写入文件
 //! - screenshot_disable_transitions：禁用窗口显示/隐藏过渡动画（消除覆盖层缩放动画）
 
-use super::{CaptureData, WindowInfo};
+use super::{CaptureData, CaptureStart, WindowInfo};
-use tauri::{Emitter, Manager};
+use tauri::{AppHandle, Emitter, Manager};
 
 /// 禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画
 #[tauri::command]
@@ -88,16 +93,19 @@ pub async fn screenshot_unregister_pin_shortcut(app: tauri::AppHandle) -> Result
     Ok(())
 }
 
-/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码
+/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码。
+/// 同时返回捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返）。
 #[tauri::command]
 #[specta::specta]
-pub async fn screenshot_capture_fullscreen() -> Result<(), String> {
+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))?
@@ -205,29 +213,39 @@ pub async fn screenshot_crop_copy_stored(
     }
 }
 
-/// 拾取指定物理屏幕坐标下的顶层窗口
+/// 枚举可拾取的顶层窗口（Z 序顶→底，排除本进程/不可见/工具窗口）。
+/// 前端在截图开始时缓存列表，鼠标移动时在 JS 侧本地命中测试，消除逐帧 IPC 往返。
 #[tauri::command]
 #[specta::specta]
-pub async fn screenshot_window_from_point(
+pub async fn screenshot_pick_list() -> Result<Vec<WindowInfo>, String> {
-    x: i32,
-    y: i32,
-) -> Result<Option<WindowInfo>, String> {
     #[cfg(windows)]
     {
-        tauri::async_runtime::spawn_blocking(move || {
+        tauri::async_runtime::spawn_blocking(super::capture::pick_windows)
-            Ok(super::capture::window_from_point(x, y))
+            .await
-        })
+            .map_err(|e| format!("枚举失败: {}", e))
-        .await
-        .map_err(|e| format!("查询失败: {}", e))?
     }
     #[cfg(not(windows))]
     {
-        let _ = (x, y);
+        Ok(vec![])
-        Ok(None)
     }
 }
 
-/// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口）
+/// 一次 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> {
@@ -283,19 +301,138 @@ pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, Strin
     }
 }
 
-/// 存入编辑器图片（base64 PNG）
+/// 滚动截图：从窗口当前滚动位置向下拼接到底部，返回超长 PNG。
+/// `region` 为 Some 时仅在框选区域（屏幕物理坐标）内捕捉，宽 = 选区宽；
+/// 为 None 时捕捉整个客户区。结束后会把窗口滚回起始位置，不打扰用户。
 #[tauri::command]
 #[specta::specta]
-pub async fn screenshot_set_editor_image(png_base64: String) -> Result<(), String> {
+pub async fn screenshot_scroll_capture(
-    super::set_editor_image(png_base64);
+    hwnd: isize,
-    Ok(())
+    region: Option<super::ScrollRegion>,
+) -> Result<CaptureData, String> {
+    #[cfg(windows)]
+    {
+        tauri::async_runtime::spawn_blocking(move || {
+            super::scroll_capture::scroll_capture(hwnd, region)
+        })
+        .await
+        .map_err(|e| format!("滚动截图任务失败: {}", e))?
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = hwnd;
+        let _ = region;
+        Err("截图仅支持 Windows".into())
+    }
 }
 
-/// 取出编辑器图片（编辑器窗口加载时调用，取出即清除）
+/// 启动滚动截图会话（后台线程持续捕捉拼接，实时推进度事件）。
+/// `auto = true` 为自动滚动（线程主动下滚拼到底部）；`false` 为手动（等用户滚动窗口）。
 #[tauri::command]
 #[specta::specta]
-pub async fn screenshot_get_editor_image() -> Result<Option<String>, String> {
+pub fn screenshot_scroll_start(
-    Ok(super::take_editor_image())
+    app: AppHandle,
+    hwnd: isize,
+    region: Option<super::ScrollRegion>,
+    auto: bool,
+) -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        super::scroll_session::start(app, hwnd, region, auto)
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = (app, hwnd, region, auto);
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 结束滚动截图会话并导出结果。
+#[tauri::command]
+#[specta::specta]
+pub fn screenshot_scroll_finish() -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        super::scroll_session::finish()
+    }
+    #[cfg(not(windows))]
+    {
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 取消滚动截图会话（不导出）。
+#[tauri::command]
+#[specta::specta]
+pub fn screenshot_scroll_cancel() -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        super::scroll_session::cancel_now()
+    }
+    #[cfg(not(windows))]
+    {
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 滚动模式遮罩挖孔：在截图覆盖层窗口上挖出选区带的真孔（region = None 时复位整窗）。
+///
+/// Chromium 系浏览器（Edge/Chrome）的窗口遮挡检测会把被完全覆盖的窗口标记为
+/// occluded 并暂停渲染——滚动截图时覆盖层铺满全屏，网页"看起来完全不滚动"。
+/// 挖孔后目标窗口仅部分被覆盖，恢复渲染与滚轮响应（详见 capture::set_scroll_hole）。
+/// 进入滚动模式时带选区调用，会话结束/新一轮截图开始时必须传 None 复位。
+#[tauri::command]
+#[specta::specta]
+pub fn screenshot_set_scroll_hole(
+    app: AppHandle,
+    region: Option<super::ScrollRegion>,
+) -> Result<(), String> {
+    #[cfg(windows)]
+    {
+        use raw_window_handle::HasWindowHandle;
+
+        let mut hwnds: Vec<isize> = Vec::new();
+        for (label, win) in app.webview_windows() {
+            if label.starts_with(crate::constants::windows::SCREENSHOT_OVERLAY) {
+                let hwnd = win
+                    .window_handle()
+                    .ok()
+                    .and_then(|h| match h.as_raw() {
+                        raw_window_handle::RawWindowHandle::Win32(w) => {
+                            Some(w.hwnd.get() as isize)
+                        }
+                        _ => None,
+                    });
+                if let Some(h) = hwnd {
+                    hwnds.push(h);
+                }
+            }
+        }
+        if hwnds.is_empty() {
+            return Err("截图覆盖层窗口不存在".into());
+        }
+        for h in hwnds {
+            super::capture::set_scroll_hole(h, region)?;
+        }
+        Ok(())
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = (app, region);
+        Ok(())
+    }
+}
+
+/// 取出编辑器图片（原始 PNG 字节，raw IPC → 前端 ArrayBuffer → Blob URL，取出即清除）
+///
+/// 长图（滚动截图）可达数十 MB：raw IPC 相比 base64 JSON 事件传输省 ~33% 体积，
+/// 且避免 JSON 序列化/多次广播。注：返回 ipc::Response，specta 无法生成，豁免标注。
+#[tauri::command]
+pub async fn screenshot_take_editor_image_raw() -> Result<tauri::ipc::Response, String> {
+    match super::take_editor_image_raw() {
+        Some(bytes) => Ok(tauri::ipc::Response::new(bytes)),
+        None => Err("无待编辑的截图".into()),
+    }
 }
 
 /// 将 PNG base64 写入系统剪贴板（转 CF_DIB）
@@ -325,6 +462,39 @@ pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
 #[tauri::command]
 pub async fn screenshot_compose_copy(
     request: tauri::ipc::Request<'_>,
+) -> Result<super::CaptureData, String> {
+    #[cfg(windows)]
+    {
+        let body = match request.body() {
+            tauri::ipc::InvokeBody::Raw(data) => data.clone(),
+            _ => return Err("需要 raw body（ArrayBuffer）".into()),
+        };
+        if body.len() < 8 {
+            return Err("数据不足：缺少尺寸头".into());
+        }
+        let width = i32::from_le_bytes([body[0], body[1], body[2], body[3]]);
+    let height = i32::from_le_bytes([body[4], body[5], body[6], body[7]]);
+    let rgba = body[8..].to_vec();
+    tauri::async_runtime::spawn_blocking(move || {
+        super::capture::compose_copy_rgba(&rgba, width, height)
+    })
+    .await
+    .map_err(|e| format!("合成复制任务失败: {}", e))?
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = request;
+        Err("截图仅支持 Windows".into())
+    }
+}
+
+/// 有标注导出（仅编码）：接收 raw RGBA（前端 canvas.getImageData 直传），一次完成 PNG 编码。
+/// 与 screenshot_compose_copy 的区别：不写剪贴板（编辑器「保存到文件」用）。
+/// body 格式：前 8 字节 = width(i32 LE) + height(i32 LE)，之后为 raw RGBA 像素。
+/// 注：参数为 tauri::ipc::Request（原始 body），specta 无法生成，豁免标注。
+#[tauri::command]
+pub async fn screenshot_compose_png(
+    request: tauri::ipc::Request<'_>,
 ) -> Result<super::CaptureData, String> {
     #[cfg(windows)]
     {
@@ -339,10 +509,10 @@ pub async fn screenshot_compose_copy(
         let height = i32::from_le_bytes([body[4], body[5], body[6], body[7]]);
         let rgba = body[8..].to_vec();
         tauri::async_runtime::spawn_blocking(move || {
-            super::capture::compose_copy_rgba(&rgba, width, height)
+            super::capture::compose_png_rgba(&rgba, width, height)
         })
         .await
-        .map_err(|e| format!("合成复制任务失败: {}", e))?
+        .map_err(|e| format!("合成编码任务失败: {}", e))?
     }
     #[cfg(not(windows))]
     {
@@ -433,6 +603,22 @@ pub async fn screenshot_load_cache(
     .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]

src-tauri/src/screenshot/mod.rs

@@ -9,6 +9,12 @@ use specta::Type;
 
 #[cfg(windows)]
 pub mod capture;
+#[cfg(windows)]
+pub mod wgc_capture;
+#[cfg(windows)]
+pub mod scroll_capture;
+#[cfg(windows)]
+pub mod scroll_session;
 pub mod commands;
 
 /// 前端可见的捕获数据
@@ -20,6 +26,14 @@ 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, Type)]
 #[serde(rename_all = "camelCase")]
@@ -40,17 +54,28 @@ pub struct ScreenRect {
     pub height: i32,
 }
 
-/// 编辑器图片静态存储（覆盖层裁剪后存入 → 编辑器窗口加载取出）
+/// 滚动截图区域（屏幕物理像素坐标，通常为覆盖层框选区平移到屏幕）
-static EDITOR_IMAGE: Mutex<Option<String>> = Mutex::new(None);
+#[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ScrollRegion {
+    pub x: i32,
+    pub y: i32,
+    pub width: i32,
+    pub height: i32,
+}
 
-/// 存储编辑器图片（base64 PNG）
+/// 编辑器图片静态存储：原始 PNG 字节（滚动截图会话完成后直接写入，
-pub fn set_editor_image(png_base64: String) {
+/// 编辑器窗口通过 raw IPC 取出 → Blob URL 显示，全程不经 base64/JSON 事件传输）
-    if let Ok(mut g) = EDITOR_IMAGE.lock() {
+static EDITOR_IMAGE_RAW: Mutex<Option<Vec<u8>>> = Mutex::new(None);
-        *g = Some(png_base64);
+
+/// 存储编辑器图片（原始 PNG 字节）
+pub fn set_editor_image_raw(png: Vec<u8>) {
+    if let Ok(mut g) = EDITOR_IMAGE_RAW.lock() {
+        *g = Some(png);
     }
 }
 
-/// 取出并清除编辑器图片
+/// 取出并清除编辑器图片（原始 PNG 字节）
-pub fn take_editor_image() -> Option<String> {
+pub fn take_editor_image_raw() -> Option<Vec<u8>> {
-    EDITOR_IMAGE.lock().ok()?.take()
+    EDITOR_IMAGE_RAW.lock().ok()?.take()
 }

src-tauri/src/screenshot/scroll_capture.rs

@@ -0,0 +1,469 @@
+//! 滚动截图（垂直长图拼接）底层设施（仅 Windows）
+//!
+//! ## 原理
+//! 目标窗口的**客户区**内容往往是可分页垂直滚动的。算法：
+//! 1. 用 PrintWindow（PW_RENDERFULLCONTENT）抓客户区为 BGRA（不做 PNG 编码）；
+//! 2. 向窗口发送 `WM_MOUSEWHEEL` 使其向下滚动；
+//! 3. 再抓一帧，用**框选带内多列采样行信号**做一维模板匹配，求出两帧间的垂直
+//!    滚动像素偏移 `d`：`cur[y] ≈ prev[y+d]`，故把 `cur` 底部新出现的 `d` 行拼到画布末尾；
+//! 4. 重复直到内容不再变化（滚到底部），把各帧拼成一张超高纵轴图像。
+//!
+//! 固定表头/粘性头部由拼接语义天然处理——只追加 `cur` 底部的 `d` 行，
+//! 表头保留在第一帧中，不会重复。
+//!
+//! ## 滚轮投递
+//! `WM_MOUSEWHEEL` 优先发给**框选带中心处的最深子窗口**（如 Chromium 的
+//! RenderWidgetHostHWND）：很多程序的顶层窗口过程不转发滚轮消息，
+//! 直接发顶层会导致"完全不滚动"。坐标一律用屏幕物理坐标（lParam 语义）。
+
+use std::thread::sleep;
+use std::time::Duration;
+
+use windows_sys::Win32::Foundation::{HWND, POINT, RECT};
+use windows_sys::Win32::Graphics::Gdi::{ClientToScreen, ScreenToClient};
+use windows_sys::Win32::UI::WindowsAndMessaging::{
+    ChildWindowFromPointEx, GetClientRect, GetWindowRect, PostMessageW, SendMessageTimeoutW,
+    WM_MOUSEWHEEL, WHEEL_DELTA, CWP_SKIPDISABLED, CWP_SKIPINVISIBLE, CWP_SKIPTRANSPARENT,
+    SMTO_ABORTIFHUNG,
+};
+
+use super::{CaptureData, ScrollRegion};
+use super::capture::{base64_encode, bgra_to_png, capture_window_bgra, crop_bgra};
+
+/// 窗口客户区上下文：客户区尺寸 + 客户区在窗口位图内的偏移。
+pub(crate) struct BandCtx {
+    pub cw: i32,
+    pub ch: i32,
+    pub ox: i32,
+    pub oy: i32,
+}
+
+/// 解析框选带：把可选区域（屏幕物理坐标）换算成客户区内的裁剪带。
+/// 区域未命中客户区时返回错误；`None` 表示整客户区。
+/// 返回 (ctx, band_x, band_y, band_w, band_h)，band_* 为客户区内坐标。
+pub(crate) fn resolve_band(
+    hwnd: isize,
+    region: Option<ScrollRegion>,
+) -> Result<(BandCtx, i32, i32, i32, i32), String> {
+    let (cw, ch, ox, oy) = client_info(hwnd)
+        .ok_or_else(|| "无法获取窗口客户区（窗口可能被最小化或已销毁）".to_string())?;
+    if cw <= 0 || ch <= 0 {
+        return Err("窗口客户区尺寸无效".into());
+    }
+    let (wr_x, wr_y) = window_rect_origin(hwnd).ok_or_else(|| "无法获取窗口矩形".to_string())?;
+    let band = match region {
+        Some(r) => {
+            let wbx = r.x - wr_x;
+            let wby = r.y - wr_y;
+            let bx0 = wbx.max(ox);
+            let by0 = wby.max(oy);
+            let bx1 = (wbx + r.width).min(ox + cw);
+            let by1 = (wby + r.height).min(oy + ch);
+            if bx1 <= bx0 || by1 <= by0 {
+                return Err("选区未命中窗口客户区".into());
+            }
+            (bx0 - ox, by0 - oy, bx1 - bx0, by1 - by0)
+        }
+        None => (0, 0, cw, ch),
+    };
+    Ok((
+        BandCtx { cw, ch, ox, oy },
+        band.0,
+        band.1,
+        band.2,
+        band.3,
+    ))
+}
+
+/// 客户区内坐标 → 屏幕物理坐标。
+pub(crate) fn client_pt_to_screen(hwnd: isize, cx: i32, cy: i32) -> Option<(i32, i32)> {
+    unsafe {
+        let mut pt = POINT { x: cx, y: cy };
+        if ClientToScreen(hwnd as HWND, &mut pt) == 0 {
+            return None;
+        }
+        Some((pt.x, pt.y))
+    }
+}
+
+/// 递归下钻：找到客户区坐标 (cx, cy) 处最深的子窗口（跳过不可见/禁用/透明子窗口）。
+/// WM_MOUSEWHEEL 优先发给真正处理滚轮的子窗口——顶层窗口过程往往不转发滚轮，
+/// 这是"自动滚动一开始就不动"的主因之一。
+pub(crate) fn deep_child_at_point(top: isize, mut cx: i32, mut cy: i32) -> isize {
+    let mut cur = top;
+    for _ in 0..16 {
+        let child = unsafe {
+            ChildWindowFromPointEx(
+                cur as HWND,
+                POINT { x: cx, y: cy },
+                CWP_SKIPINVISIBLE | CWP_SKIPDISABLED | CWP_SKIPTRANSPARENT,
+            )
+        };
+        if child == 0 || child == cur as HWND {
+            break;
+        }
+        // 坐标换算到子窗口客户区
+        let mut pt = POINT { x: cx, y: cy };
+        unsafe {
+            if ClientToScreen(cur as HWND, &mut pt) == 0 {
+                break;
+            }
+            if ScreenToClient(child, &mut pt) == 0 {
+                break;
+            }
+        }
+        cx = pt.x;
+        cy = pt.y;
+        cur = child as isize;
+    }
+    cur
+}
+
+/// 构造 WM_MOUSEWHEEL 的 wParam/lParam（lParam 为屏幕坐标）。
+fn wheel_params(sx: i32, sy: i32, delta: i32) -> (usize, isize) {
+    // wParam 高位字 = 有符号 delta，低位字 = 按键 0
+    let wparam = ((delta as u16) as usize) << 16;
+    // lParam 低 16 位 = x（屏幕），高 16 位 = y（屏幕）
+    let lparam = ((((sy as u32) & 0xFFFF) << 16) | ((sx as u32) & 0xFFFF)) as isize;
+    (wparam, lparam)
+}
+
+/// 发送滚轮消息（SendMessageTimeout：目标线程短暂忙/挂起时不至于卡死调用线程）。
+/// delta > 0 向上滚，delta < 0 向下滚。
+pub(crate) fn send_wheel(hwnd: isize, sx: i32, sy: i32, delta: i32) {
+    let (wparam, lparam) = wheel_params(sx, sy, delta);
+    let mut result = 0usize;
+    unsafe {
+        let _ = SendMessageTimeoutW(
+            hwnd as HWND,
+            WM_MOUSEWHEEL,
+            wparam,
+            lparam,
+            SMTO_ABORTIFHUNG,
+            80,
+            &mut result,
+        );
+    }
+}
+
+/// 异步投递滚轮消息（部分程序只处理经消息泵排队的事件）。
+pub(crate) fn post_wheel(hwnd: isize, sx: i32, sy: i32, delta: i32) {
+    let (wparam, lparam) = wheel_params(sx, sy, delta);
+    unsafe {
+        let _ = PostMessageW(hwnd as HWND, WM_MOUSEWHEEL, wparam, lparam);
+    }
+}
+
+// ===== 单次同步滚动截图（一次调用拼到底）=====
+
+/// 每次向下滚动的「格数」（WHEEL_DELTA=120/格）。
+const WHEEL_STROKE: i32 = 2;
+/// 滚动后等待窗口重绘的时间。
+const SETTLE_MS: u64 = 70;
+/// 保护上限：最大迭代轮数。
+const MAX_ITERS: usize = 140;
+/// 保护上限：最大拼接段数。
+const MAX_STITCHES: usize = 90;
+/// 保护上限：拼接后总高（像素）。
+const MAX_TOTAL_H: u32 = 30000;
+/// 连续多少次滚动无位移判定为「已到底部」。
+const NO_CHANGE_STOP: u32 = 2;
+
+/// 执行滚动截图：把窗口当前滚动位置向下拼接到底部，返回超长 PNG（同步，一次调用）。
+///
+/// - `region` 为 `Some` 时，只在**框选区域**内捕捉（列带 + 该区域的纵向视口），
+///   输出宽度 = 选区宽度；为 `None` 时捕捉整个客户区。
+///   偏移检测始终优先使用带内信号，保证滚动量在窄带下也能稳健匹配。
+/// - 结束时把窗口滚回起始位置，不打扰用户。
+pub fn scroll_capture(hwnd: isize, region: Option<ScrollRegion>) -> Result<CaptureData, String> {
+    let (ctx, band_x, band_y, band_w, band_h) = resolve_band(hwnd, region)?;
+    let (cw, ch) = (ctx.cw, ctx.ch);
+    let (client_ox, client_oy) = (ctx.ox, ctx.oy);
+
+    // 滚轮目标：带中心的最深子窗口 + 屏幕坐标
+    let bcx = band_x + band_w / 2;
+    let bcy = band_y + band_h / 2;
+    let wheel_hwnd = deep_child_at_point(hwnd, bcx, bcy);
+    let (sx, sy) = client_pt_to_screen(hwnd, bcx, bcy)
+        .ok_or_else(|| "无法换算屏幕坐标".to_string())?;
+
+    // 第一帧（全客户区）→ 画布（裁剪到框选带）
+    let first = capture_client_bgra(hwnd, client_ox, client_oy, cw, ch)?;
+    let mut canvas = crop_bgra(&first, cw as usize, band_x, band_y, band_w, band_h)?;
+    let mut prev = first;
+    let mut total_h = band_h as u32;
+    let mut total_stitches = 0usize;
+    let mut no_change = 0u32;
+    let mut moved: u32 = 0;
+    let mut iters = 0usize;
+
+    while iters < MAX_ITERS && total_stitches < MAX_STITCHES && total_h < MAX_TOTAL_H {
+        iters += 1;
+
+        send_wheel(wheel_hwnd, sx, sy, -(WHEEL_DELTA as i32) * WHEEL_STROKE);
+        sleep(Duration::from_millis(SETTLE_MS));
+
+        let cur = match capture_client_bgra(hwnd, client_ox, client_oy, cw, ch) {
+            Ok(f) => f,
+            Err(_) => break, // 窗口中途被关闭/失去客户区
+        };
+
+        match detect_vscroll_offset(
+            &prev,
+            &cur,
+            cw as usize,
+            ch as usize,
+            band_x as usize,
+            band_y as usize,
+            band_w as usize,
+            band_h as usize,
+        ) {
+            Some(0) => {
+                no_change += 1;
+                if no_change >= NO_CHANGE_STOP {
+                    break; // 已到底部
+                }
+                prev = cur;
+            }
+            Some(d) => {
+                no_change = 0;
+                total_stitches += 1;
+                moved += 1;
+                // 追加框选带底部新出现的 d 行（在客户区帧内的带区间 [band_y, band_y+band_h)）
+                let new_rows = (d as i32).min(band_h) as usize;
+                let new_y = band_y + band_h - new_rows as i32;
+                let rows = crop_bgra(&cur, cw as usize, band_x, new_y, band_w, new_rows as i32)?;
+                canvas.extend_from_slice(&rows);
+                total_h += new_rows as u32;
+                prev = cur;
+            }
+            None => {
+                // 匹配失败（内容大幅变化/动画等）：不拼接、不累计 no_change，下一轮继续
+                prev = cur;
+            }
+        }
+    }
+
+    // 结束回滚：上滚与下滚相同数量的手势
+    for _ in 0..moved {
+        send_wheel(wheel_hwnd, sx, sy, WHEEL_DELTA as i32 * WHEEL_STROKE);
+        sleep(Duration::from_millis(20));
+    }
+
+    if total_h <= band_h as u32 {
+        return Err("区域内容未能滚动（可能不支持鼠标滚轮或已到底部）".into());
+    }
+
+    let png = bgra_to_png(&canvas, band_w as i32, total_h as i32)?;
+    Ok(CaptureData {
+        png_base64: base64_encode(&png),
+        width: band_w as i32,
+        height: total_h as i32,
+    })
+}
+
+/// 窗口矩形左上角的屏幕坐标（用于把屏幕区域换算成窗口位图内的裁剪坐标）。
+fn window_rect_origin(hwnd: isize) -> Option<(i32, i32)> {
+    unsafe {
+        let mut wr: RECT = std::mem::zeroed();
+        if GetWindowRect(hwnd as HWND, &mut wr) == 0 {
+            return None;
+        }
+        Some((wr.left, wr.top))
+    }
+}
+
+/// 获取窗口客户区尺寸与客户区左上角屏幕坐标。
+fn client_info(hwnd: isize) -> Option<(i32, i32, i32, i32)> {
+    unsafe {
+        let h = hwnd as HWND;
+        let mut cr: RECT = std::mem::zeroed();
+        if GetClientRect(h, &mut cr) == 0 {
+            return None;
+        }
+        let (cw, ch) = (cr.right - cr.left, cr.bottom - cr.top);
+        let mut pt: POINT = std::mem::zeroed();
+        if ClientToScreen(h, &mut pt) == 0 {
+            return None;
+        }
+        let mut wr: RECT = std::mem::zeroed();
+        if GetWindowRect(h, &mut wr) == 0 {
+            return None;
+        }
+        Some((cw, ch, pt.x - wr.left, pt.y - wr.top))
+    }
+}
+
+/// 抓取窗口客户区内容（PrintWindow + 裁剪，不做 PNG 编码）。
+pub(crate) fn capture_client_bgra(
+    hwnd: isize,
+    client_ox: i32,
+    client_oy: i32,
+    cw: i32,
+    ch: i32,
+) -> Result<Vec<u8>, String> {
+    let img = capture_window_bgra(hwnd)?;
+    // 客户区在窗口位图内的偏移（PrintWindow 从窗口左上角绘制）
+    crop_bgra(
+        &img.bgra,
+        img.width as usize,
+        client_ox,
+        client_oy,
+        cw.min(img.width),
+        ch.min(img.height),
+    )
+}
+
+// ===== 帧间垂直偏移检测 =====
+
+/// 行信号采样列数：每行采 16 列亮度（B+G+R），保留横向细节（文字边缘、分隔线）。
+/// 相比旧的"整行平均"，多列采样大幅降低重复纹理/大面积纯色区的误匹配率。
+const SIG_COLS: usize = 16;
+/// 单周期可检测的最大偏移（像素）。超过即匹配失败（调用方自适应降速）。
+const MAX_OFFSET: usize = 512;
+
+/// 检测两帧之间的垂直滚动像素偏移 `d`，使 `cur[y] ≈ prev[y+d]`。
+///
+/// 匹配范围优先限定在**框选带**（行=带内行、列=带内列）：带外内容（工具栏、
+/// 状态栏、不随滚动的区域）不参与匹配，避免污染信号。带太小/带内匹配失败时
+/// 逐级回退（全行+带列 → 全行+全列）。
+///
+/// 返回：
+/// - `Some(0)`：两帧实质相同（未滚动 / 已到底部）
+/// - `Some(d)` d>0：检测到向下滚动了 d 像素
+/// - `None`：无法可靠匹配（内容动画 / 位移超上限等），调用方跳过本轮
+pub(crate) fn detect_vscroll_offset(
+    prev: &[u8],
+    cur: &[u8],
+    w: usize,
+    h: usize,
+    band_l: usize,
+    band_t: usize,
+    band_w: usize,
+    band_h: usize,
+) -> Option<usize> {
+    if w < 4 || h < 16 {
+        return None;
+    }
+    let band_ok = band_w >= 8 && band_h >= 24 && band_t + band_h <= h && band_l + band_w <= w;
+    if band_ok {
+        // 主匹配：行、列都限定在带内（带外内容不随滚动变化，会污染匹配信号）
+        let ps = row_signals(prev, w, band_t, band_h, band_l, band_w);
+        let cs = row_signals(cur, w, band_t, band_h, band_l, band_w);
+        if let Some(r) = match_signals(&ps, &cs) {
+            return Some(r);
+        }
+        // 回退（带内匹配失败：快速滚动位移超上限 / 带内大面积动画）：
+        // 全客户区行只用于**找位移**，不判"无变化"——带外静止内容会把误差拉低，
+        // 误报 Some(0) 造成假"到底"
+        if band_l + band_w <= w {
+            let ps = row_signals(prev, w, 0, h, band_l, band_w);
+            let cs = row_signals(cur, w, 0, h, band_l, band_w);
+            if let Some(d) = match_signals(&ps, &cs).filter(|d| *d > 0) {
+                return Some(d);
+            }
+        }
+        let ps = row_signals(prev, w, 0, h, 0, w);
+        let cs = row_signals(cur, w, 0, h, 0, w);
+        return match_signals(&ps, &cs).filter(|d| *d > 0);
+    }
+    // 带太小：全客户区回退（此时允许 Some(0)，否则永远判不了"到底"）
+    if band_w >= 8 && band_l + band_w <= w {
+        let ps = row_signals(prev, w, 0, h, band_l, band_w);
+        let cs = row_signals(cur, w, 0, h, band_l, band_w);
+        if let Some(r) = match_signals(&ps, &cs) {
+            return Some(r);
+        }
+    }
+    let ps = row_signals(prev, w, 0, h, 0, w);
+    let cs = row_signals(cur, w, 0, h, 0, w);
+    match_signals(&ps, &cs)
+}
+
+/// 每行采样 SIG_COLS 列的亮度（B+G+R，0..765），返回 rows × SIG_COLS 的信号矩阵。
+fn row_signals(bgra: &[u8], w: usize, y0: usize, rows: usize, l: usize, bw: usize) -> Vec<i32> {
+    // 均匀采样列（含两端）
+    let mut cols = [0usize; SIG_COLS];
+    for i in 0..SIG_COLS {
+        cols[i] = l + (i * (bw - 1)) / (SIG_COLS - 1).max(1);
+    }
+    let mut out = Vec::with_capacity(rows * SIG_COLS);
+    for y in y0..y0 + rows {
+        let base = y * w * 4;
+        for &c in &cols {
+            let i = base + c * 4;
+            // bgra: B,G,R（alpha 通常为 0，不计入亮度）
+            out.push(bgra[i] as i32 + bgra[i + 1] as i32 + bgra[i + 2] as i32);
+        }
+    }
+    out
+}
+
+/// 信号模板匹配：求 d 使 `cs[y] ≈ ps[y+d]`，取平均绝对误差最小者。
+fn match_signals(ps: &[i32], cs: &[i32]) -> Option<usize> {
+    let n = ps.len() / SIG_COLS;
+    if n < 16 {
+        return None;
+    }
+    let step = 2; // 隔行采样加速
+    let max_d = MAX_OFFSET.min(n * 3 / 4);
+    if max_d < 1 {
+        return None;
+    }
+
+    // d=0 基准误差：两帧几乎一致 → 未滚动（到底部）
+    let err0 = {
+        let (mut e, mut c) = (0i64, 0i64);
+        let mut y = 0;
+        while y < n {
+            for k in 0..SIG_COLS {
+                e += (cs[y * SIG_COLS + k] - ps[y * SIG_COLS + k]).abs() as i64;
+            }
+            c += SIG_COLS as i64;
+            y += step;
+        }
+        if c == 0 {
+            return None;
+        }
+        e as f64 / c as f64
+    };
+    if err0 < 4.0 {
+        return Some(0);
+    }
+
+    // 找最小平均误差的 d
+    let mut best_d = 0usize;
+    let mut best_err = f64::MAX;
+    for d in 1..=max_d {
+        let (mut e, mut c) = (0i64, 0i64);
+        let mut y = 0;
+        while y + d < n {
+            for k in 0..SIG_COLS {
+                e += (cs[y * SIG_COLS + k] - ps[(y + d) * SIG_COLS + k]).abs() as i64;
+            }
+            c += SIG_COLS as i64;
+            y += step;
+            // 早停：明显劣于当前最优则放弃该候选
+            if c >= 64 && e as f64 / c as f64 > best_err * 1.8 + 24.0 {
+                break;
+            }
+        }
+        if c >= 64 {
+            let ae = e as f64 / c as f64;
+            if ae < best_err {
+                best_err = ae;
+                best_d = d;
+            }
+        }
+    }
+
+    if best_d == 0 {
+        return None;
+    }
+    // 阈值按 3 通道和（0..765）标定：亚像素滚动会有轻微重采样模糊，阈值不宜过紧
+    if best_err < 30.0 && best_err * 2.0 < err0 {
+        Some(best_d)
+    } else {
+        None
+    }
+}

src-tauri/src/screenshot/scroll_session.rs

@@ -0,0 +1,647 @@
+//! 滚动截图会话（仅 Windows）：后台线程捕捉拼接 + 独立滚轮线程平滑滚动。
+//!
+//! 与 [super::scroll_capture::scroll_capture]（同步一次调用）不同，本模块把捕获循环
+//! 放进后台线程，通过事件把**实时进度**推给前端。
+//!
+//! ## 自动模式架构
+//! - **run_loop（会话线程）**：按节奏捕获客户区帧，与上一帧做带内偏移匹配，拼接新行；
+//! - **ticker（滚轮线程）**：以 ~16ms 间隔发送小步长 `WM_MOUSEWHEEL`，由目标程序自身的
+//!   平滑滚动动画呈现连续滚动（替代旧版"每 70ms 一整格"的跳变式滚动）；
+//! - **目标策略升级**：带中心最深子窗口（小步长 Send）→ 子窗口整格 → 顶层整格 Send →
+//!   顶层整格 Post。解决"一开始就不滚动"（顶层不转发滚轮 / 程序忽略非整格消息）；
+//! - **自适应速度**：按每周期实测位移调滚轮步长 / 捕获周期，逼近"带高 1/4"的理想重叠；
+//! - **停止补帧（settle）**：用户停止后等目标窗口滚动动画静止再补拼最后一帧，
+//!   保证最终图片结尾 = 用户停止时窗口实际停留的位置；
+//! - **精准回滚**：先按累计像素粗估上滚，再用帧匹配对初始帧校准回到起始位置。
+//!
+//! 事件（广播到所有窗口）：
+//! - `SCROLL_PROGRESS`：`{ width, height, auto }` 当前已拼接高度
+//! - `SCROLL_COMPLETE`：`{ width, height }` 完成导出（PNG 原始字节已存入编辑器图片槽，
+//!   由前端常驻编辑器窗口通过 raw IPC 取出，事件本身不携带图片数据）
+//! - `SCROLL_CANCELLED`：`{}` 取消（丢弃画布）
+
+use std::sync::atomic::{AtomicBool, AtomicI32, AtomicIsize, Ordering};
+use std::sync::Mutex;
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use tauri::{AppHandle, Emitter};
+use windows_sys::Win32::UI::WindowsAndMessaging::WHEEL_DELTA;
+
+use crate::constants::events as evts;
+use crate::logger::{log_error, log_info};
+use super::capture::{bgra_to_png, crop_bgra};
+use super::scroll_capture::{
+    capture_client_bgra, client_pt_to_screen, deep_child_at_point, detect_vscroll_offset,
+    post_wheel, resolve_band, send_wheel,
+};
+use super::ScrollRegion;
+
+// ===== 可调参数 =====
+
+/// 滚轮线程发送间隔（毫秒）。小步长 + 高频 → 目标程序的平滑滚动动画连贯不断帧。
+const TICK_MS: u64 = 16;
+/// 捕获周期基准（毫秒）。与滚轮解耦：滚动不因捕获/匹配而停顿。
+const CYCLE_MS: u64 = 130;
+/// 捕获周期上限（整格模式下按实测位移自适应放大）。
+const CYCLE_MS_MAX: u64 = 360;
+/// 每周期理想位移 = clamp(band_h / 4, TARGET_D_MIN, TARGET_D_MAX)。
+/// 太小 → 慢；太大 → 带内重叠不足、匹配易失败。
+const TARGET_D_MIN: usize = 32;
+const TARGET_D_MAX: usize = 180;
+/// 小步长模式：起始 / 上下限步长（WHEEL_DELTA=120 为一整格）。
+const DELTA_START: i32 = 20;
+const DELTA_MIN: i32 = 4;
+const DELTA_MAX: i32 = 72;
+/// 整格模式步长（部分程序忽略非整格滚轮消息，累不进小步长）。
+const DELTA_NOTCH: i32 = 120;
+/// 策略未锁定时：连续多少周期无位移 → 升级投递策略。
+const ESCALATE_CYCLES: u32 = 3;
+/// 策略已锁定时：连续多少周期无位移 → 判定到底。
+const NO_CHANGE_STOP: u32 = 3;
+/// 上限：拼接后总高（像素），超出即自动结束。
+const MAX_TOTAL_H: u32 = 30000;
+/// 进度事件节流。
+const PROGRESS_THROTTLE_MS: u64 = 120;
+/// 停止后等待滚动动画静止的超时（毫秒）。
+const SETTLE_TIMEOUT_MS: u64 = 900;
+/// 回滚粗估：每整格对应的滚动像素。
+const ROLLBACK_PX_PER_NOTCH: f64 = 55.0;
+
+// ===== 会话状态 =====
+
+/// 活动会话（会话线程独占读写；命令只改 STOP/CANCEL 原子标志）
+struct Session {
+    hwnd: isize,
+    /// 客户区尺寸与客户区在窗口位图内偏移
+    cw: i32,
+    ch: i32,
+    ox: i32,
+    oy: i32,
+    band_x: i32,
+    band_y: i32,
+    band_w: i32,
+    band_h: i32,
+    /// 已拼接像素（带宽 × total_h）
+    canvas: Vec<u8>,
+    total_h: u32,
+    /// 累计检测到的滚动像素
+    ttl_px: u32,
+    /// 上一帧（全客户区，匹配基准）
+    prev: Vec<u8>,
+    /// 初始帧（回滚校准用）
+    first: Vec<u8>,
+    auto_scroll: bool,
+    active: bool,
+}
+
+static SESSION: Mutex<Option<Session>> = Mutex::new(None);
+/// 请求线程结束（完成/取消共用）
+static STOP: AtomicBool = AtomicBool::new(false);
+/// 结束方式：true = 取消（不导出），false = 完成（导出）
+static CANCEL: AtomicBool = AtomicBool::new(false);
+
+// ===== 滚轮线程共享控制 =====
+
+static TICKER_STOP: AtomicBool = AtomicBool::new(false);
+static WHEEL_TARGET: AtomicIsize = AtomicIsize::new(0);
+/// 滚轮步长（有符号 delta，正值；发送时取负 = 向下滚）
+static WHEEL_STEP: AtomicI32 = AtomicI32::new(0);
+static WHEEL_POST: AtomicBool = AtomicBool::new(false);
+static WHEEL_SX: AtomicI32 = AtomicI32::new(0);
+static WHEEL_SY: AtomicI32 = AtomicI32::new(0);
+
+/// 会话线程每轮用的只读参数（启动时一次性读出）。
+struct Params {
+    hwnd: isize,
+    cw: i32,
+    ch: i32,
+    ox: i32,
+    oy: i32,
+    band_x: i32,
+    band_y: i32,
+    band_w: i32,
+    band_h: i32,
+    auto_scroll: bool,
+}
+
+fn read_params() -> Option<Params> {
+    let g = SESSION.lock().ok()?;
+    let s = g.as_ref().filter(|s| s.active)?;
+    Some(Params {
+        hwnd: s.hwnd,
+        cw: s.cw,
+        ch: s.ch,
+        ox: s.ox,
+        oy: s.oy,
+        band_x: s.band_x,
+        band_y: s.band_y,
+        band_w: s.band_w,
+        band_h: s.band_h,
+        auto_scroll: s.auto_scroll,
+    })
+}
+
+/// 会话是否仍活动（run_loop 每周期自检，异常路径提前退出）
+fn is_active() -> bool {
+    SESSION
+        .lock()
+        .map(|g| g.as_ref().map(|s| s.active).unwrap_or(false))
+        .unwrap_or(false)
+}
+
+/// 启动滚动截图会话。`auto = true` 时线程自动下滚拼到底部；否则等用户手动滚动。
+pub fn start(app: AppHandle, hwnd: isize, region: Option<ScrollRegion>, auto: bool) -> Result<(), String> {
+    {
+        let g = SESSION.lock().map_err(|e| e.to_string())?;
+        if g.as_ref().map(|s| s.active).unwrap_or(false) {
+            return Err("已有滚动截图进行中".into());
+        }
+    }
+    let (ctx, bx, by, bw, bh) = resolve_band(hwnd, region)?;
+    let first = capture_client_bgra(hwnd, ctx.ox, ctx.oy, ctx.cw, ctx.ch)?;
+    let canvas = crop_bgra(&first, ctx.cw as usize, bx, by, bw, bh)?;
+
+    {
+        let mut g = SESSION.lock().map_err(|e| e.to_string())?;
+        *g = Some(Session {
+            hwnd,
+            cw: ctx.cw,
+            ch: ctx.ch,
+            ox: ctx.ox,
+            oy: ctx.oy,
+            band_x: bx,
+            band_y: by,
+            band_w: bw,
+            band_h: bh,
+            canvas,
+            total_h: bh as u32,
+            ttl_px: 0,
+            first: first.clone(),
+            prev: first,
+            auto_scroll: auto,
+            active: true,
+        });
+    }
+    STOP.store(false, Ordering::Release);
+    CANCEL.store(false, Ordering::Release);
+
+    log_info("scroll-session", &format!(
+        "启动滚动截图 hwnd={} band={}x{} auto={}",
+        hwnd, bw, bh, auto
+    ));
+    std::thread::spawn(move || run_loop(app));
+    Ok(())
+}
+
+/// 请求结束会话并导出（完成）。立即返回，线程在下一轮感知并完成。
+pub fn finish() -> Result<(), String> {
+    if !running() {
+        return Err("没有进行中的滚动截图".into());
+    }
+    STOP.store(true, Ordering::Release);
+    CANCEL.store(false, Ordering::Release);
+    Ok(())
+}
+
+/// 请求取消会话（不导出）。立即返回，线程在下一轮感知并回滚终止。
+pub fn cancel_now() -> Result<(), String> {
+    if !running() {
+        return Err("没有进行中的滚动截图".into());
+    }
+    STOP.store(true, Ordering::Release);
+    CANCEL.store(true, Ordering::Release);
+    Ok(())
+}
+
+fn running() -> bool {
+    SESSION.lock().map(|g| g.as_ref().map(|s| s.active).unwrap_or(false)).unwrap_or(false)
+}
+
+/// 滚轮线程：高频小步长发送，滚动手感交给目标程序的平滑滚动动画。
+fn ticker_loop() {
+    loop {
+        if TICKER_STOP.load(Ordering::Acquire) {
+            break;
+        }
+        let target = WHEEL_TARGET.load(Ordering::Acquire);
+        let delta = WHEEL_STEP.load(Ordering::Acquire);
+        let sx = WHEEL_SX.load(Ordering::Acquire);
+        let sy = WHEEL_SY.load(Ordering::Acquire);
+        if target != 0 && delta != 0 {
+            if WHEEL_POST.load(Ordering::Acquire) {
+                post_wheel(target, sx, sy, -delta);
+            } else {
+                send_wheel(target, sx, sy, -delta);
+            }
+        }
+        sleep(Duration::from_millis(TICK_MS));
+    }
+}
+
+/// 应用滚轮投递策略（未检测到位移时逐级升级，直到找到能滚动的通道）。
+fn apply_strategy(strategy: u8, p: &Params, bcx: i32, bcy: i32) {
+    match strategy {
+        0 => {
+            // 子窗口 + 小步长（Chromium/WinUI 等会累加小步长并平滑滚动）
+            WHEEL_TARGET.store(deep_child_at_point(p.hwnd, bcx, bcy), Ordering::Release);
+            WHEEL_STEP.store(DELTA_START, Ordering::Release);
+            WHEEL_POST.store(false, Ordering::Release);
+        }
+        1 => {
+            // 子窗口 + 整格（经典 Win32 控件只认整格消息）
+            WHEEL_TARGET.store(deep_child_at_point(p.hwnd, bcx, bcy), Ordering::Release);
+            WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
+            WHEEL_POST.store(false, Ordering::Release);
+        }
+        2 => {
+            // 顶层 + 整格 Send（部分程序由顶层统一处理滚轮）
+            WHEEL_TARGET.store(p.hwnd, Ordering::Release);
+            WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
+            WHEEL_POST.store(false, Ordering::Release);
+        }
+        _ => {
+            // 顶层 + 整格 Post（只处理消息泵排队事件的程序）
+            WHEEL_TARGET.store(p.hwnd, Ordering::Release);
+            WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
+            WHEEL_POST.store(true, Ordering::Release);
+        }
+    }
+    log_info("scroll-session", &format!("滚轮策略升级为 {}", strategy));
+}
+
+/// 单周期匹配结果
+enum CycleResult {
+    /// 两帧一致（未滚动）
+    NoChange,
+    /// 向下滚了 d 像素（已拼接）
+    Moved(usize),
+    /// 匹配失败（动画 / 位移超上限）
+    MatchFail,
+}
+
+/// 一轮捕获-匹配-拼接。返回 (band_w, total_h, CycleResult)。
+fn stitch_cycle(p: &Params, cur: &[u8]) -> (i32, u32, CycleResult) {
+    let mut g = match SESSION.lock() {
+        Ok(g) => g,
+        Err(e) => {
+            log_error("scroll-session", &format!("会话锁异常: {}", e));
+            return (p.band_w, 0, CycleResult::MatchFail);
+        }
+    };
+    let s = match g.as_mut() {
+        Some(s) => s,
+        None => return (p.band_w, 0, CycleResult::MatchFail),
+    };
+    let prev = std::mem::take(&mut s.prev);
+    let (bx, by, bw, bh) = (s.band_x, s.band_y, s.band_w, s.band_h);
+    let off = detect_vscroll_offset(
+        &prev,
+        cur,
+        p.cw as usize,
+        p.ch as usize,
+        bx as usize,
+        by as usize,
+        bw as usize,
+        bh as usize,
+    );
+    match off {
+        Some(0) => {
+            s.prev = cur.to_vec();
+            (bw, s.total_h, CycleResult::NoChange)
+        }
+        Some(d) => {
+            // 一次最多拼接带的整高：单步滚动量超过带高时无法恢复中间内容，
+            // 以整带兜底（自适应速度会把位移压回安全区间）
+            let new_rows = (d as i32).min(bh) as usize;
+            let new_y = bh - new_rows as i32; // 带在客户区内的底对齐
+            match crop_bgra(cur, p.cw as usize, bx, s.band_y + new_y, bw, new_rows as i32) {
+                Ok(rows) => {
+                    s.canvas.extend_from_slice(&rows);
+                    s.total_h += new_rows as u32;
+                    s.ttl_px += d as u32;
+                    s.prev = cur.to_vec();
+                    (bw, s.total_h, CycleResult::Moved(d))
+                }
+                Err(_) => {
+                    s.prev = cur.to_vec();
+                    (bw, s.total_h, CycleResult::MatchFail)
+                }
+            }
+        }
+        None => {
+            // 匹配失败：保留旧基准帧（下一帧与更早的稳定帧比对，累积位移仍能对上）
+            s.prev = prev;
+            (bw, s.total_h, CycleResult::MatchFail)
+        }
+    }
+}
+
+fn run_loop(app: AppHandle) {
+    let p = match read_params() {
+        Some(p) => p,
+        None => return,
+    };
+
+    // 滚轮目标初始参数：带中心（客户区坐标）→ 屏幕坐标
+    let bcx = p.band_x + p.band_w / 2;
+    let bcy = p.band_y + p.band_h / 2;
+    let (bsx, bsy) = client_pt_to_screen(p.hwnd, bcx, bcy).unwrap_or((0, 0));
+    WHEEL_SX.store(bsx, Ordering::Release);
+    WHEEL_SY.store(bsy, Ordering::Release);
+
+    // 自动模式：启动滚轮线程（策略 0 起步）
+    let mut strategy: u8 = 0;
+    let mut ticker = None;
+    if p.auto_scroll {
+        apply_strategy(0, &p, bcx, bcy);
+        TICKER_STOP.store(false, Ordering::Release);
+        ticker = Some(std::thread::spawn(ticker_loop));
+    }
+
+    let mut no_change: u32 = 0; // 锁定后：连续无位移（到底判定）
+    let mut no_move: u32 = 0; // 未锁定：连续无位移（策略升级判定）
+    let mut locked = false; // 是否已确认当前策略能滚动
+    let mut gave_up = false; // 所有策略都滚不动
+    let mut cycle_ms = CYCLE_MS;
+    let mut capture_errors: u32 = 0;
+    let mut last_emit = Instant::now();
+
+    loop {
+        if STOP.load(Ordering::Acquire) || !is_active() {
+            break;
+        }
+        // 周期节拍：捕获+匹配耗时计入周期
+        let t0 = Instant::now();
+
+        let cur = match capture_client_bgra(p.hwnd, p.ox, p.oy, p.cw, p.ch) {
+            Ok(f) => {
+                capture_errors = 0;
+                f
+            }
+            Err(e) => {
+                // 瞬时失败先重试，连续多次失败才视为窗口关闭/失去客户区
+                capture_errors += 1;
+                log_error("scroll-session", &format!("捕获失败({}/3): {}", capture_errors, e));
+                if capture_errors >= 3 {
+                    break;
+                }
+                sleep(Duration::from_millis(100));
+                continue;
+            }
+        };
+
+        let (band_w, total_h, result) = stitch_cycle(&p, &cur);
+
+        // 目标位移：带高 1/4，夹在安全区间
+        let target_d = (p.band_h as usize / 4).clamp(TARGET_D_MIN, TARGET_D_MAX);
+
+        match result {
+            CycleResult::Moved(d) => {
+                if !locked {
+                    locked = true;
+                    log_info("scroll-session", &format!("策略 {} 生效，锁定", strategy));
+                }
+                no_change = 0;
+                no_move = 0;
+                if p.auto_scroll {
+                    if strategy == 0 {
+                        // 小步长模式：按实测位移调步长（sqrt 阻尼防过冲）
+                        let delta = WHEEL_STEP.load(Ordering::Acquire) as f64;
+                        let factor = target_d as f64 / d.max(6) as f64;
+                        let nd = (delta * factor.sqrt()).clamp(DELTA_MIN as f64, DELTA_MAX as f64);
+                        WHEEL_STEP.store(nd as i32, Ordering::Release);
+                    } else {
+                        // 整格模式：步长固定，按实测位移调捕获周期
+                        if d as f64 > p.band_h as f64 * 0.55 {
+                            cycle_ms = ((cycle_ms as f64) * 1.25).min(CYCLE_MS_MAX as f64) as u64;
+                        } else if d < target_d / 2 && cycle_ms > CYCLE_MS {
+                            cycle_ms = ((cycle_ms as f64) * 0.8).max(CYCLE_MS as f64) as u64;
+                        }
+                    }
+                }
+            }
+            CycleResult::NoChange => {
+                if locked {
+                    no_change += 1;
+                    if no_change >= NO_CHANGE_STOP && p.auto_scroll {
+                        break; // 已到底部
+                    }
+                    // 手动模式由用户控制，不自动结束
+                } else if p.auto_scroll {
+                    no_move += 1;
+                    if no_move >= ESCALATE_CYCLES {
+                        no_move = 0;
+                        strategy += 1;
+                        if strategy > 3 {
+                            gave_up = true; // 所有通道都滚不动 → 结束（前端提示）
+                            break;
+                        }
+                        apply_strategy(strategy, &p, bcx, bcy);
+                    }
+                }
+            }
+            CycleResult::MatchFail => {
+                // 内容大幅变化/动画/位移超上限：若持续失败则降速，
+                // 避免越滚越快导致匹配一直失败（表现即"滚动中断"）
+                if p.auto_scroll {
+                    if locked && strategy == 0 {
+                        let delta = WHEEL_STEP.load(Ordering::Acquire) as f64;
+                        let nd = (delta * 0.75).max(DELTA_MIN as f64);
+                        WHEEL_STEP.store(nd as i32, Ordering::Release);
+                    } else if !locked {
+                        // 未锁定：匹配失败也算"无位移"参与策略升级，
+                        // 防止动画页面导致升级判定永不触发
+                        no_move += 1;
+                        if no_move >= ESCALATE_CYCLES {
+                            no_move = 0;
+                            strategy += 1;
+                            if strategy > 3 {
+                                gave_up = true;
+                                break;
+                            }
+                            apply_strategy(strategy, &p, bcx, bcy);
+                        }
+                    }
+                }
+            }
+        }
+
+        // 进度事件（节流）
+        if matches!(result, CycleResult::Moved(_))
+            && last_emit.elapsed().as_millis() as u64 >= PROGRESS_THROTTLE_MS
+        {
+            last_emit = Instant::now();
+            emit_progress(&app, band_w, total_h, p.auto_scroll);
+        }
+        if total_h >= MAX_TOTAL_H {
+            break;
+        }
+
+        // 补足周期剩余时间
+        let el = t0.elapsed().as_millis() as u64;
+        if el < cycle_ms {
+            sleep(Duration::from_millis(cycle_ms - el));
+        }
+    }
+
+    // 停滚轮线程（join 等它退出，最多再发一拍）
+    if let Some(t) = ticker.take() {
+        TICKER_STOP.store(true, Ordering::Release);
+        let _ = t.join();
+    }
+
+    let cancel = CANCEL.load(Ordering::Acquire);
+    // 完成（非取消、非放弃）时：等滚动动画静止后补拼最后一帧，
+    // 保证图片结尾 = 用户停止时窗口实际停留的位置
+    if !cancel && !gave_up {
+        settle_and_stitch(&p);
+    }
+
+    // 取出会话数据
+    let mut s = match SESSION.lock().ok().and_then(|mut g| g.take()) {
+        Some(s) => s,
+        None => {
+            log_info("scroll-session", "会话已不存在（未导出）");
+            let _ = app.emit(evts::SCROLL_CANCELLED, serde_json::json!({}));
+            return;
+        }
+    };
+
+    // 编码与回滚并行：PNG 编码只依赖画布（已定格），回滚不依赖画布，
+    // 两者无数据依赖，并行可显著缩短「停止 → 打开编辑器」的等待
+    let (band_w, total_h) = (s.band_w, s.total_h);
+    let encode = if cancel {
+        None
+    } else {
+        let canvas = std::mem::take(&mut s.canvas);
+        Some(std::thread::spawn(move || {
+            bgra_to_png(&canvas, band_w, total_h as i32)
+        }))
+    };
+
+    // 回滚到起始位置（与编码并行）：先按累计像素粗估上滚，再帧匹配校准
+    if s.ttl_px > 0 {
+        rollback(&s);
+    }
+
+    STOP.store(false, Ordering::Release);
+    CANCEL.store(false, Ordering::Release);
+
+    // 等编码完成：PNG 原始字节直接存入编辑器图片槽（不经 base64 / JSON 事件传输）
+    let png = encode.and_then(|h| h.join().ok()).and_then(|r| r.ok());
+    match png {
+        Some(png) => {
+            log_info("scroll-session", &format!(
+                "完成导出 width={} height={}",
+                band_w, total_h
+            ));
+            super::set_editor_image_raw(png);
+            let _ = app.emit(
+                evts::SCROLL_COMPLETE,
+                serde_json::json!({ "width": band_w, "height": total_h }),
+            );
+        }
+        None => {
+            log_info("scroll-session", "会话已取消（未导出）");
+            let _ = app.emit(evts::SCROLL_CANCELLED, serde_json::json!({}));
+        }
+    }
+}
+
+/// 停止后等待目标窗口滚动动画静止，并把静止帧补拼进画布（结尾对齐停止位置）。
+fn settle_and_stitch(p: &Params) {
+    let deadline = Instant::now() + Duration::from_millis(SETTLE_TIMEOUT_MS);
+    loop {
+        sleep(Duration::from_millis(70));
+        if Instant::now() >= deadline || !is_active() {
+            return;
+        }
+        let cur = match capture_client_bgra(p.hwnd, p.ox, p.oy, p.cw, p.ch) {
+            Ok(f) => f,
+            Err(_) => return,
+        };
+        match stitch_cycle(p, &cur).2 {
+            CycleResult::NoChange => return, // 已静止且无新内容
+            CycleResult::Moved(_) | CycleResult::MatchFail => {
+                // 动画仍在进行（Moved 已拼接；MatchFail 继续等）
+                if Instant::now() >= deadline {
+                    return;
+                }
+            }
+        }
+    }
+}
+
+/// 回滚：粗估整格数上滚 → 与初始帧逐次比对校准，直到回到起始位置。
+/// 帧匹配校准消除"每格滚动像素因程序而异"带来的累计误差。
+fn rollback(s: &Session) {
+    let target = {
+        let t = WHEEL_TARGET.load(Ordering::Acquire);
+        if t != 0 { t } else { s.hwnd }
+    };
+    let mut sx = WHEEL_SX.load(Ordering::Acquire);
+    let mut sy = WHEEL_SY.load(Ordering::Acquire);
+    if sx == 0 && sy == 0 {
+        if let Some((x, y)) = client_pt_to_screen(
+            s.hwnd,
+            s.band_x + s.band_w / 2,
+            s.band_y + s.band_h / 2,
+        ) {
+            sx = x;
+            sy = y;
+        }
+    }
+
+    // 粗估上滚（宁可略少，剩余交给校准补齐）。
+    // 上限按累计像素推算：长图捕获（累计数万 px）也要能回滚到位，
+    // 固定小上限会导致超长捕获结束后窗口停在半途。
+    let notches = (((s.ttl_px as f64) / ROLLBACK_PX_PER_NOTCH).floor() as i32).clamp(1, 800);
+    for _ in 0..notches {
+        send_wheel(target, sx, sy, WHEEL_DELTA as i32);
+        sleep(Duration::from_millis(3));
+    }
+    sleep(Duration::from_millis(80));
+
+    // 帧匹配校准：d = 当前仍相对起始位置向下滚动的像素
+    let mut last_d = usize::MAX;
+    for _ in 0..12 {
+        let cur = match capture_client_bgra(s.hwnd, s.ox, s.oy, s.cw, s.ch) {
+            Ok(f) => f,
+            Err(_) => return,
+        };
+        let d = detect_vscroll_offset(
+            &s.first,
+            &cur,
+            s.cw as usize,
+            s.ch as usize,
+            s.band_x as usize,
+            s.band_y as usize,
+            s.band_w as usize,
+            s.band_h as usize,
+        );
+        match d {
+            Some(0) | None => return, // 已回到起始位置 / 无法匹配（视为完成）
+            Some(d) if d < 10 => return, // 误差 10px 内视为到位
+            Some(d) => {
+                if d >= last_d {
+                    return; // 不再下降：窗口可能不支持向上滚（虚拟化列表），放弃
+                }
+                last_d = d;
+                let more = (((d as f64) / ROLLBACK_PX_PER_NOTCH).ceil() as i32).clamp(1, 60);
+                for _ in 0..more {
+                    send_wheel(target, sx, sy, WHEEL_DELTA as i32);
+                    sleep(Duration::from_millis(3));
+                }
+                sleep(Duration::from_millis(60));
+            }
+        }
+    }
+}
+
+fn emit_progress(app: &AppHandle, width: i32, height: u32, auto: bool) {
+    let _ = app.emit(
+        evts::SCROLL_PROGRESS,
+        serde_json::json!({ "width": width, "height": height, "auto": auto }),
+    );
+}

src-tauri/src/screenshot/wgc_capture.rs

@@ -0,0 +1,363 @@
+//! HDR 全屏捕获实现（Windows Graphics Capture + HDR→sRGB 色调映射）
+//!
+//! ## 为什么需要它
+//! Windows 高级色彩（HDR）开启时，桌面由 DWM 用**线性 scRGB（RGBA16F）**合成。
+//! [crate::screenshot::capture] 的 `BitBlt` 从屏幕 DC 直接取出 8bit 像素，
+//! 把这些线性/scRGB 高亮值当 sRGB 编码，会导致亮部越界被裁、局部过曝失真。
+//!
+//! ## 方案
+//! 检测到任意显示器为 HDR 输出时，改用 WGC：
+//! 1. 以 `RGBA16F`（scRGB 线性）捕获每个显示器；
+//! 2. 按 SDR 参考白缩放（`÷ (sdr_white_nits / 80)`）后钳制到 [0,1]；
+//! 3. 做 sRGB 伽马编码，得到与屏幕观感一致的 BGRA8；
+//! 4. 按各显示器在虚拟屏上的偏移拼接到一整张虚拟屏图像（与 BitBlt 输出同构）。
+//!
+//! 仅当 HDR 时才走此路径；SDR 显示器仍用快速的 BitBlt。
+
+use std::ffi::c_void;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use windows_capture::capture::{Context, GraphicsCaptureApiHandler};
+use windows_capture::frame::Frame;
+use windows_capture::graphics_capture_api::InternalCaptureControl;
+use windows_capture::monitor::Monitor;
+use windows_capture::settings::{
+    ColorFormat, CursorCaptureSettings, DirtyRegionSettings, DrawBorderSettings,
+    MinimumUpdateIntervalSettings, SecondaryWindowSettings, Settings,
+};
+
+use super::capture::CapturedImage;
+
+// ===== 虚拟屏尺寸（与 capture.rs 一致）=====
+const SM_XVIRTUALSCREEN: i32 = 76;
+const SM_YVIRTUALSCREEN: i32 = 77;
+const SM_CXVIRTUALSCREEN: i32 = 78;
+const SM_CYVIRTUALSCREEN: i32 = 79;
+
+/// Windows「SDR 内容亮度」的默认参考白（nits）。未自定义时为 203。
+/// 严格值可用 DISPLAYCONFIG_SDR_WHITE_LEVEL 查询；此处取系统默认，覆盖绝大多数情况。
+const DEFAULT_SDR_WHITE_NITS: f32 = 203.0;
+
+/// 单帧捕获参数（作为 WGC handler 的 Flags 传入，把抓到的帧回传给调用线程）
+#[derive(Clone)]
+struct CaptureFlags {
+    tx: mpsc::SyncSender<Result<FramePixels, String>>,
+}
+
+/// 一帧 Rgba16F 像素（已去掉行尾 padding，top-down）
+struct FramePixels {
+    width: u32,
+    height: u32,
+    raw: Vec<u8>,
+}
+
+/// 一次性截图 handler：拿到第一帧即回传并停止捕获
+struct OneShot {
+    flags: CaptureFlags,
+}
+
+impl GraphicsCaptureApiHandler for OneShot {
+    type Flags = CaptureFlags;
+    type Error = String;
+
+    fn new(ctx: Context<Self::Flags>) -> Result<Self, Self::Error> {
+        Ok(Self { flags: ctx.flags })
+    }
+
+    fn on_frame_arrived(
+        &mut self,
+        frame: &mut Frame,
+        capture_control: InternalCaptureControl,
+    ) -> Result<(), Self::Error> {
+        let mut buffer = frame.buffer().map_err(|e| e.to_string())?;
+        let width = buffer.width();
+        let height = buffer.height();
+        let row_pitch = buffer.row_pitch() as usize;
+        let raw = buffer.as_raw_buffer();
+        // 拷贝并去掉行 padding（Rgba16F = 每像素 8 字节）
+        let row_bytes = (width as usize) * 8;
+        let mut packed = vec![0u8; row_bytes * (height as usize)];
+        for y in 0..(height as usize) {
+            let src = y * row_pitch;
+            let dst = y * row_bytes;
+            packed[dst..dst + row_bytes].copy_from_slice(&raw[src..src + row_bytes]);
+        }
+        let _ = self.flags.tx.send(Ok(FramePixels {
+            width,
+            height,
+            raw: packed,
+        }));
+        // 单帧足够，立即结束捕获（internal stop → 捕获线程退出）
+        capture_control.stop();
+        Ok(())
+    }
+}
+
+/// 捕获单个显示器（按 hmonitor），返回 tonemap 后的 BGRA8（top-down）
+fn capture_monitor_bgra(
+    hmonitor: *mut c_void,
+    sdr_white: f32,
+) -> Result<(Vec<u8>, u32, u32), String> {
+    let monitor = Monitor::from_raw_hmonitor(hmonitor);
+    let (tx, rx) = mpsc::sync_channel::<Result<FramePixels, String>>(1);
+    let flags = CaptureFlags { tx };
+    let settings = Settings::new(
+        monitor,
+        CursorCaptureSettings::WithCursor,
+        DrawBorderSettings::WithoutBorder,
+        SecondaryWindowSettings::Default,
+        MinimumUpdateIntervalSettings::Custom(Duration::from_millis(32)),
+        DirtyRegionSettings::Default,
+        ColorFormat::Rgba16F,
+        flags,
+    );
+
+    let control = OneShot::start_free_threaded(settings)
+        .map_err(|e| format!("WGC 捕获启动失败: {}", e))?;
+
+    let frame = match rx.recv_timeout(Duration::from_secs(10)) {
+        Ok(Ok(f)) => f,
+        Ok(Err(e)) => {
+            let _ = control.stop();
+            return Err(e);
+        }
+        Err(e) => {
+            let _ = control.stop();
+            return Err(format!("等待 WGC 帧超时: {}", e));
+        }
+    };
+    let _ = control.stop();
+
+    let bgra = tonemap_rgba16f_to_bgra(&frame.raw, frame.width, frame.height, sdr_white);
+    Ok((bgra, frame.width, frame.height))
+}
+
+/// 捕获整个虚拟屏（多显示器拼接），返回与 BitBlt 同构的 `CapturedImage`（BGRA top-down）。
+/// 仅当检测到 HDR 时由 [capture] 调用。
+pub fn capture_virtual_screen_wgc() -> Result<CapturedImage, String> {
+    // 用 QueryDisplayConfig 读系统实际 SDR 白电平（nits），取不到才回退系统默认 203
+    let sdr_white = query_sdr_white_level().unwrap_or(DEFAULT_SDR_WHITE_NITS);
+    let monitors = enum_monitors();
+    if monitors.is_empty() {
+        return Err("未检测到显示器".into());
+    }
+    use windows_sys::Win32::UI::WindowsAndMessaging::GetSystemMetrics as gsm;
+    let vx = unsafe { gsm(SM_XVIRTUALSCREEN) };
+    let vy = unsafe { gsm(SM_YVIRTUALSCREEN) };
+    let vw = unsafe { gsm(SM_CXVIRTUALSCREEN) };
+    let vh = unsafe { gsm(SM_CYVIRTUALSCREEN) };
+    if vw <= 0 || vh <= 0 {
+        return Err("无法获取虚拟屏尺寸".into());
+    }
+    let mut canvas = vec![0u8; (vw as usize) * (vh as usize) * 4]; // 透明区以黑填充
+    for m in &monitors {
+        let (bgra, mw, mh) = capture_monitor_bgra(m.handle as *mut c_void, sdr_white)?;
+        let ow = m.x - vx;
+        let oh = m.y - vy;
+        if mw as i32 != m.w || mh as i32 != m.h {
+            // 尺寸失配（极少见，如缩放中途）— 中止避免错位拼接
+            return Err(format!(
+                "显示器捕获尺寸不符: 枚举 {}x{} vs WGC {}x{}",
+                m.w, m.h, mw, mh
+            ));
+        }
+        let mw = mw as usize;
+        for row in 0..mh {
+            let src = (row as usize) * mw * 4;
+            let dst = ((oh + row as i32) as usize) * (vw as usize) * 4 + (ow as usize) * 4;
+            let len = mw * 4;
+            canvas[dst..dst + len].copy_from_slice(&bgra[src..src + len]);
+        }
+    }
+    Ok(CapturedImage {
+        width: vw,
+        height: vh,
+        png: Vec::new(),
+        bgra: canvas,
+    })
+}
+
+// ===== 显示器枚举与 HDR 检测 =====
+
+struct MonInfo {
+    handle: usize,
+    x: i32,
+    y: i32,
+    w: i32,
+    h: i32,
+}
+
+fn enum_monitors() -> Vec<MonInfo> {
+    let mut out: Vec<MonInfo> = Vec::new();
+    unsafe extern "system" fn cb(
+        hmon: isize,
+        _hdc: isize,
+        rect: *mut windows_sys::Win32::Foundation::RECT,
+        lparam: isize,
+    ) -> windows_sys::Win32::Foundation::BOOL {
+        let v = &mut *(lparam as *mut Vec<MonInfo>);
+        let r = *rect;
+        v.push(MonInfo {
+            handle: hmon as usize,
+            x: r.left,
+            y: r.top,
+            w: r.right - r.left,
+            h: r.bottom - r.top,
+        });
+        1
+    }
+    unsafe {
+        windows_sys::Win32::Graphics::Gdi::EnumDisplayMonitors(
+            0,
+            std::ptr::null(),
+            Some(cb),
+            &mut out as *mut _ as isize,
+        );
+    }
+    out
+}
+
+/// 枚举 DXGI 输出，任一显示器为 HDR（advanced color / PQ / HLG）输出则返回 true。
+/// 任何错误一律视为非 HDR（回退 BitBlt），保证普通 SDR 环境不受影响。
+pub fn is_hdr_enabled() -> bool {
+    #[allow(unused_imports)]
+    use windows::Win32::Graphics::Dxgi::Common::{
+        DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709, DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020,
+        DXGI_COLOR_SPACE_TYPE,
+    };
+
+    fn is_hdr_space(space: DXGI_COLOR_SPACE_TYPE) -> bool {
+        // HDR10（PQ，BT.2020 主色）与 scRGB 高级色彩工作空间即视为 HDR
+        matches!(
+            space,
+            DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 | DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
+        )
+    }
+
+    use windows::Win32::Graphics::Dxgi::IDXGIFactory1;
+    let Ok(factory) = (unsafe {
+        windows::Win32::Graphics::Dxgi::CreateDXGIFactory1::<IDXGIFactory1>()
+    }) else {
+        return false;
+    };
+    use windows::core::ComInterface;
+    unsafe {
+        let mut ai = 0u32;
+        while let Ok(adapter) = factory.EnumAdapters1(ai) {
+            ai += 1;
+            let mut oi = 0u32;
+            while let Ok(output) = adapter.EnumOutputs(oi) {
+                oi += 1;
+                if let Ok(out6) =
+                    output.cast::<windows::Win32::Graphics::Dxgi::IDXGIOutput6>()
+                {
+                    let mut desc: windows::Win32::Graphics::Dxgi::DXGI_OUTPUT_DESC1 =
+                        std::mem::zeroed();
+                    if out6.GetDesc1(&mut desc).is_ok() && is_hdr_space(desc.ColorSpace) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
+/// 通过 QueryDisplayConfig 读取 Windows 实际的 SDR 参考白电平（nits）。
+///
+/// SDR 白电平并非 union 的声明成员，而是系统/驱动写入在 DISPLAYCONFIG_MODE_INFO
+/// 的 union 尾部（desktopImageInfo 之后）的 4 字节（DISPLAYCONFIG_SDR_WHITE_LEVEL）。
+/// 取不到（非 HDR / 查询失败）时返回 None，由调用方回退系统默认 203。
+fn query_sdr_white_level() -> Option<f32> {
+    use windows_sys::Win32::Devices::Display::{
+        GetDisplayConfigBufferSizes, QueryDisplayConfig, DISPLAYCONFIG_MODE_INFO,
+        DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE, DISPLAYCONFIG_PATH_INFO,
+        DISPLAYCONFIG_SDR_WHITE_LEVEL, QDC_ONLY_ACTIVE_PATHS,
+    };
+    unsafe {
+        let mut num_paths = 0u32;
+        let mut num_modes = 0u32;
+        if GetDisplayConfigBufferSizes(QDC_ONLY_ACTIVE_PATHS, &mut num_paths, &mut num_modes) != 0
+        {
+            return None;
+        }
+        let mut paths = vec![std::mem::zeroed::<DISPLAYCONFIG_PATH_INFO>(); num_paths as usize];
+        let mut modes = vec![std::mem::zeroed::<DISPLAYCONFIG_MODE_INFO>(); num_modes as usize];
+        if QueryDisplayConfig(
+            QDC_ONLY_ACTIVE_PATHS,
+            &mut num_paths,
+            paths.as_mut_ptr(),
+            &mut num_modes,
+            modes.as_mut_ptr(),
+            std::ptr::null_mut(),
+        ) != 0
+        {
+            return None;
+        }
+        for mode in modes.iter().take(num_modes as usize) {
+            if mode.infoType == DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE {
+                let base = mode as *const DISPLAYCONFIG_MODE_INFO as *const u8;
+                let off = std::mem::size_of::<DISPLAYCONFIG_MODE_INFO>()
+                    - std::mem::size_of::<DISPLAYCONFIG_SDR_WHITE_LEVEL>();
+                let white = std::ptr::read_unaligned::<u32>(base.add(off) as *const u32);
+                if white > 0 {
+                    return Some(white as f32);
+                }
+            }
+        }
+    }
+    None
+}
+
+// ===== HDR→sRGB 色调映射 =====
+
+/// IEEE754 半精度 float → f32
+fn half_to_f32(h: u16) -> f32 {
+    let sign = (h & 0x8000) != 0;
+    let exp = (h >> 10) & 0x1f;
+    let man = (h & 0x3ff) as f32;
+    let v = match exp {
+        0 => man / 1024.0 * 2.0f32.powi(-14), // 次正规
+        0x1f => f32::NAN,                      // Inf/NaN，按 NaN 处理（后续 clamp 为 0~255 安全）
+        _ => (1.0 + man / 1024.0) * 2.0f32.powi(exp as i32 - 15),
+    };
+    if sign {
+        -v
+    } else {
+        v
+    }
+}
+
+/// 线性 scRGB 值 → sRGB 8bit（标准 sRGB OETF）
+fn srgb_encode(linear: f32) -> u8 {
+    let l = linear.clamp(0.0, 1.0);
+    let e = if l <= 0.003_130_8 {
+        12.92 * l
+    } else {
+        1.055 * l.powf(1.0 / 2.4) - 0.055
+    };
+    (e * 255.0 + 0.5) as u8
+}
+
+/// Rgba16F（scRGB 线性，top-down）→ BGRA8（sRGB），按 SDR 参考白缩放。
+fn tonemap_rgba16f_to_bgra(raw: &[u8], width: u32, height: u32, sdr_white: f32) -> Vec<u8> {
+    let inv_scale = 80.0 / sdr_white.max(1.0);
+    let n = (width as usize) * (height as usize);
+    let mut out = vec![0u8; n * 4];
+    for i in 0..n {
+        let pi = i * 8;
+        let r16 = u16::from_le_bytes([raw[pi], raw[pi + 1]]);
+        let g16 = u16::from_le_bytes([raw[pi + 2], raw[pi + 3]]);
+        let b16 = u16::from_le_bytes([raw[pi + 4], raw[pi + 5]]);
+        let b = srgb_encode(half_to_f32(b16) * inv_scale);
+        let g = srgb_encode(half_to_f32(g16) * inv_scale);
+        let r = srgb_encode(half_to_f32(r16) * inv_scale);
+        let oi = i * 4;
+        out[oi] = b;
+        out[oi + 1] = g;
+        out[oi + 2] = r;
+        out[oi + 3] = 255; // 强制不透明（与 BitBlt 路径一致）
+    }
+    out
+}

src-tauri/src/secrets.rs

@@ -0,0 +1,110 @@
+//! 敏感串的统一存放处（Windows 系统凭据管理器，DPAPI 保护）。
+//!
+//! 从 `music::secrets` 抽出为 crate 级公共模块。抽出的理由：本项目早期出现过
+//! **两种安全姿态**——WebDAV 账号密码走凭据管理器，而飞牛登录 token 与 QQ 音乐
+//! Cookie 明文躺在 `settings.json` / localStorage。同样是可冒充身份的凭据，不该
+//! 区别对待。此后翻译模块又要接入多家 AI 的 API Key，若每个模块自带一套实现，
+//! 姿态只会再次分叉，因此把「原语」收敛到这里，各模块只保留自己的键名约定。
+//!
+//! 约定：
+//! - 一律使用 `Thing` 作为凭据服务名，`key` 作为用户名（Entry 的 account）。
+//!   **服务名不可更改**：已有凭据（`webdav-credentials`、`music-feiniu-token-*`、
+//!   `music-qq-cookie`）都以它存盘，改动会导致这些凭据读不到。
+//! - 明文只允许存在于内存与系统凭据库，禁止回写 `settings.json` / localStorage。
+//! - 迁移采用「先写凭据库成功、再清明文」的顺序；**写失败时保留明文**，
+//!   宁可牺牲一致性也不能把用户已登录的会话弄丢。
+//! - 非 Windows 平台没有凭据管理器：读取返回 None、写入报错，
+//!   调用方据此退化为「明文存设置」（功能优先）。
+
+/// 凭据服务名（**历史值，不可更改**）。
+pub const SERVICE: &str = "Thing";
+
+/// 读取明文（未配置 → `Ok(None)`）。
+#[cfg(windows)]
+pub fn secret_read(key: &str) -> Result<Option<String>, String> {
+    let entry =
+        keyring::Entry::new(SERVICE, key).map_err(|e| format!("无法访问系统凭据管理器: {e}"))?;
+    match entry.get_password() {
+        Ok(v) => Ok(Some(v)),
+        Err(keyring::Error::NoEntry) => Ok(None),
+        Err(e) => Err(format!("读取凭据失败: {e}")),
+    }
+}
+
+/// 写入明文（覆盖式）。
+#[cfg(windows)]
+pub fn secret_write(key: &str, value: &str) -> Result<(), String> {
+    let entry =
+        keyring::Entry::new(SERVICE, key).map_err(|e| format!("无法访问系统凭据管理器: {e}"))?;
+    entry
+        .set_password(value)
+        .map_err(|e| format!("保存凭据失败: {e}"))
+}
+
+/// 删除凭据（不存在视为成功）。
+#[cfg(windows)]
+pub fn secret_delete(key: &str) -> Result<(), String> {
+    let entry =
+        keyring::Entry::new(SERVICE, key).map_err(|e| format!("无法访问系统凭据管理器: {e}"))?;
+    match entry.delete_credential() {
+        Ok(()) => Ok(()),
+        Err(keyring::Error::NoEntry) => Ok(()),
+        Err(e) => Err(format!("删除凭据失败: {e}")),
+    }
+}
+
+#[cfg(not(windows))]
+pub fn secret_read(_key: &str) -> Result<Option<String>, String> {
+    Ok(None)
+}
+
+#[cfg(not(windows))]
+pub fn secret_write(_key: &str, _value: &str) -> Result<(), String> {
+    Err("当前平台不支持系统凭据管理器".to_string())
+}
+
+#[cfg(not(windows))]
+pub fn secret_delete(_key: &str) -> Result<(), String> {
+    Ok(())
+}
+
+/// 把明文**尽力**迁入凭据库（失败只记日志，不抛错）。
+///
+/// 返回「明文是否可以安全清除」：只有写入成功才为 true。
+/// 调用方用这个返回值决定要不要清空内存/配置里的明文。
+pub fn try_store(key: &str, value: &str) -> bool {
+    if value.is_empty() {
+        return true;
+    }
+    match secret_write(key, value) {
+        Ok(()) => true,
+        Err(e) => {
+            crate::logger::log_error(
+                "secrets",
+                &format!("凭据 {key} 写入系统凭据管理器失败（保留明文作为降级）: {e}"),
+            );
+            false
+        }
+    }
+}
+
+/// 读取明文，失败或未配置一律退化为空串（调用方无需区分「没配」与「读不到」）。
+pub fn read_or_empty(key: &str) -> String {
+    secret_read(key).ok().flatten().unwrap_or_default()
+}
+
+/// 掩码展示：保留前 3 位与后 4 位，中间以圆点替代。
+/// 长度不足时全部打码，绝不泄露完整明文。
+pub fn mask(value: &str) -> String {
+    let v = value.trim();
+    let n = v.chars().count();
+    if n == 0 {
+        return String::new();
+    }
+    if n <= 8 {
+        return "•".repeat(n);
+    }
+    let head: String = v.chars().take(3).collect();
+    let tail: String = v.chars().skip(n - 4).collect();
+    format!("{head}••••{tail}")
+}

src-tauri/src/setup.rs

@@ -7,6 +7,7 @@
 //! - 下载：DownloadEngine + 扩展 HTTP API 服务
 //! - 剪贴板：ClipboardManager + 快捷键 + 预创建弹窗
 //! - 快速面板：快捷键 + 预创建弹窗 + 文件索引
+//! - 翻译：TranslateManager（设置与密钥按需读取，启动时不发网络请求）
 //! - 托盘：自定义菜单窗口
 //! - 进程：监控线程
 
@@ -17,8 +18,11 @@ 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::music::MusicManager;
 use crate::network_monitor::NetworkMonitor;
 use crate::process_manager::{ProcessManager, start_monitoring_thread};
+use crate::terminal::TerminalManager;
+use crate::translate::TranslateManager;
 
 /// 应用启动初始化入口（setup 闭包调用）。
 /// 初始化顺序即依赖顺序：日志 → 数据目录 → 各管理器 → 托盘 → 进程监控 → 自动启动。
@@ -53,6 +57,36 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
     let monitor = MonitorKernel::new(app_data_dir.clone());
     app.manage(monitor);
 
+    // ===== 音乐模块：MusicManager（Python 运行时 + 桥接进程） =====
+    // 仅注册状态，不主动启动桥接（由前端模块激活/首次请求时按需拉起）
+    let music = MusicManager::new(app_data_dir.clone());
+    // 注入 AppHandle：桥接 reader 线程把下载事件行转发给前端
+    music.set_app(app.handle().clone());
+    app.manage(music);
+
+    // ===== 翻译模块：TranslateManager =====
+    // 仅注册状态：设置与密钥都在命令调用时按需读取，启动阶段不发任何网络请求
+    // （模型可用性校验因此改为懒校验：首次翻译失败时解释原因 + 设置页手动拉取模型列表）。
+    let translate = TranslateManager::new(app_data_dir.clone());
+    app.manage(translate);
+    // 按设置注册「翻译取词 / 翻译剪贴板」两个全局快捷键并预创建悬浮窗。
+    // 失败只记日志（快捷键被占用不该阻断启动）。
+    crate::translate::init_on_launch(app.handle());
+
+    // ===== 终端模块：TerminalManager =====
+    // 仅注册状态 + 做一次 Shell 探测，**不建立任何 SSH 连接**
+    // （沿用 translate 的姿态：启动阶段不发网络请求，会话只在用户主动打开时创建）。
+    let terminal = TerminalManager::new(app_data_dir.clone());
+    // 初始化 known_hosts 存储（主机密钥信任库，非机密，明文 JSON）
+    crate::terminal::ssh::hostkey::init(terminal.root().join("known_hosts.json"));
+    app.manage(terminal);
+    // Shell 探测 + 清理上次运行遗留的 hook 脚本
+    if let Ok(t) = crate::terminal::manager(app.handle()) {
+        t.init_on_launch(app.handle());
+    } else {
+        crate::logger::log_warn("terminal", "终端模块初始化异常：State 未注册");
+    }
+
     // 网速采样不依赖提权，应用启动即开始
     let network_monitor = Arc::new(NetworkMonitor::new());
     app.manage(network_monitor.clone());
@@ -88,6 +122,8 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
         }
         // 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
         crate::clipboard::popup::ensure_popup_window(&app_handle);
+        // 同时预创建独立预览窗口（隐藏），弹窗悬停条目时直接显示
+        crate::clipboard::popup::ensure_preview_window(&app_handle);
     }
     app.manage(clipboard);
 
@@ -116,6 +152,9 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
     // ===== 进程监控线程 =====
     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>() {

src-tauri/src/terminal/assistant.rs

@@ -0,0 +1,207 @@
+//! AI 命令助手（P2）。
+//!
+//! 根据用户意图（+ 可选的终端上下文）生成可执行的命令建议。
+//! **复用翻译模块的 AI 引擎配置**：引擎列表、Base URL、模型、密钥
+//! （凭据管理器）全部来自 translate 的设置——用户只需配置一份 API。
+//!
+//! # 输出契约（与模型约定的 JSON）
+//!
+//! 模型被要求只输出 `[{"command":"...","description":"..."}]` 数组。
+//! 但模型不完全可靠，解析器做了三层防御：
+//! 1. 剥掉可能包裹的 Markdown 代码块标记（```json ... ```）；
+//! 2. 数组解析失败时尝试提取首个 `[...]` 子串再解析；
+//! 3. 条目字段校验（command 非空），并截断到 5 条防止异常输出刷屏。
+use serde::Serialize;
+use specta::Type;
+
+use crate::translate::chat_once;
+use crate::translate::TranslateEngineConfig;
+use crate::translate::TranslateSettings;
+
+/// 可用于命令生成的引擎（kind = "ai" 且配置完整）。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct AiEngineOption {
+    pub id: String,
+    pub name: String,
+    pub model: String,
+}
+
+/// 一条命令建议。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CommandSuggestion {
+    pub command: String,
+    pub description: String,
+}
+
+/// 系统提示词。
+///
+/// 输出契约写进 prompt 只是第一道防线；解析器（`parse_suggestions`）
+/// 才是真正的保证——两者都不假设模型 100% 遵守。
+const SYSTEM_PROMPT: &str = r#"你是终端命令助手。根据用户的意图和（可选的）终端最近输出，给出可在 shell 中执行的命令建议。
+
+严格规则：
+1. 只输出一个 JSON 数组，格式为 [{"command":"命令","description":"说明"}]，不要输出任何其他文字、不要使用 Markdown 代码块标记。
+2. 给 1~3 条建议：第一条是最直接的做法，其余是备选方案或更安全的变体。
+3. description 用简体中文，说明这条命令做什么；有风险的命令必须醒目标注风险。
+4. 命令默认面向 POSIX shell（bash）。仅当用户明确提到 Windows/PowerShell 时才用 PowerShell 语法。
+5. 命令中的路径、用户名等参数保持通用；不要编造用户环境里不存在的变量值。"#;
+
+/// 列出可用于命令生成的 AI 引擎（按翻译设置的优先级排序）。
+pub fn ai_engine_options(settings: &TranslateSettings) -> Vec<AiEngineOption> {
+    let mut opts: Vec<AiEngineOption> = settings
+        .engines
+        .iter()
+        .filter(|e| e.kind == "ai" && e.enabled && !e.base_url.trim().is_empty())
+        .map(|e| AiEngineOption {
+            id: e.id.clone(),
+            name: e.name.clone(),
+            model: e.model.clone(),
+        })
+        .collect();
+    opts.sort_by_key(|o| {
+        settings
+            .engines
+            .iter()
+            .find(|e| e.id == o.id)
+            .map(|e| e.priority)
+            .unwrap_or(100)
+    });
+    opts
+}
+
+/// 生成命令建议。
+///
+/// `context` 是可选的终端最近输出/选中文本（前端从 xterm 缓冲取），
+/// 帮助模型理解「接着上一步做什么」；为空则只看意图。
+pub async fn suggest(
+    engine: &TranslateEngineConfig,
+    intent: &str,
+    context: &str,
+) -> Result<Vec<CommandSuggestion>, String> {
+    if intent.trim().is_empty() {
+        return Err("请先描述你想做什么".to_string());
+    }
+
+    let mut user = format!("我的意图：{}", intent.trim());
+    if !context.trim().is_empty() {
+        // 上下文截断到 2 KB：太长的输出（cat 大文件）只会稀释意图，
+        // 且模型上下文窗口是按 token 计费的
+        let ctx: String = context.chars().take(2048).collect();
+        user.push_str(&format!("\n\n终端最近的输出（供参考）：\n{ctx}"));
+    }
+
+    let raw = chat_once(engine, vec![("system", SYSTEM_PROMPT.to_string()), ("user", user)]).await?;
+    parse_suggestions(&raw)
+}
+
+/// 解析模型输出为建议列表（纯函数，单测覆盖）。
+fn parse_suggestions(raw: &str) -> Result<Vec<CommandSuggestion>, String> {
+    let text = strip_code_fence(raw);
+    let parsed: Result<Vec<SuggestionRaw>, _> = serde_json::from_str(text);
+
+    let items = match parsed {
+        Ok(items) => items,
+        Err(_) => {
+            // 防御二：提取首个 [...] 子串（模型可能在 JSON 前后加了说明文字）
+            let start = text.find('[').ok_or_else(|| {
+                format!("模型未按约定输出 JSON。原始内容：{}", text.chars().take(300).collect::<String>())
+            })?;
+            let end = text.rfind(']').ok_or_else(|| "模型输出缺少 JSON 数组结尾".to_string())?;
+            if end <= start {
+                return Err("模型输出的 JSON 数组为空或格式错误".to_string());
+            }
+            serde_json::from_str(&text[start..=end])
+                .map_err(|e| format!("模型输出的 JSON 解析失败: {e}"))?
+        }
+    };
+
+    let out: Vec<CommandSuggestion> = items
+        .into_iter()
+        .map(|s| CommandSuggestion {
+            command: s.command.trim().to_string(),
+            description: s.description.trim().to_string(),
+        })
+        .filter(|s| !s.command.is_empty())
+        .take(5)
+        .collect();
+
+    if out.is_empty() {
+        return Err("模型没有给出有效的命令建议".to_string());
+    }
+    Ok(out)
+}
+
+/// 剥掉 Markdown 代码块围栏（```json / ```），以及首尾空白。
+fn strip_code_fence(raw: &str) -> &str {
+    let t = raw.trim();
+    let t = t.strip_prefix("```json").or_else(|| t.strip_prefix("```")).unwrap_or(t);
+    let t = t.strip_suffix("```").unwrap_or(t);
+    t.trim()
+}
+
+/// 模型输出的宽松条目结构（description 缺失时容忍为空串）。
+#[derive(serde::Deserialize)]
+struct SuggestionRaw {
+    command: String,
+    #[serde(default)]
+    description: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_plain_json_array() {
+        let raw = r#"[{"command":"ls -la","description":"列出文件"},{"command":"du -sh *","description":"查看各目录大小"}]"#;
+        let out = parse_suggestions(raw).unwrap();
+        assert_eq!(out.len(), 2);
+        assert_eq!(out[0].command, "ls -la");
+        assert_eq!(out[1].description, "查看各目录大小");
+    }
+
+    #[test]
+    fn parses_markdown_fenced_json() {
+        let raw = "```json\n[{\"command\":\"git status\",\"description\":\"查看状态\"}]\n```";
+        let out = parse_suggestions(raw).unwrap();
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].command, "git status");
+    }
+
+    #[test]
+    fn parses_json_with_surrounding_prose() {
+        // 防御二：模型在 JSON 前后加了说明文字
+        let raw = "好的，以下是建议：\n[{\"command\":\"df -h\",\"description\":\"查看磁盘\"}]\n希望有帮助";
+        let out = parse_suggestions(raw).unwrap();
+        assert_eq!(out[0].command, "df -h");
+    }
+
+    #[test]
+    fn tolerates_missing_description_and_blank_commands() {
+        let raw = r#"[{"command":"  ","description":"空命令应被过滤"},{"command":"pwd"}]"#;
+        let out = parse_suggestions(raw).unwrap();
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].command, "pwd");
+        assert_eq!(out[0].description, "");
+    }
+
+    #[test]
+    fn caps_at_five_and_reports_garbage() {
+        let items: Vec<String> = (0..8)
+            .map(|i| format!(r#"{{"command":"cmd{i}","description":""}}"#))
+            .collect();
+        let out = parse_suggestions(&format!("[{}]", items.join(","))).unwrap();
+        assert_eq!(out.len(), 5, "超出 5 条的异常输出应被截断");
+
+        assert!(parse_suggestions("这不是 JSON").is_err());
+    }
+
+    #[test]
+    fn fence_without_json_marker_also_stripped() {
+        let raw = "```\n[{\"command\":\"top\",\"description\":\"进程\"}]\n```";
+        let out = parse_suggestions(raw).unwrap();
+        assert_eq!(out[0].command, "top");
+    }
+}

src-tauri/src/terminal/audit.rs

@@ -0,0 +1,229 @@
+//! 会话日志与审计（P2）。
+//!
+//! 把会话的**原始输出字节流**（含 ANSI 序列）追加写入磁盘文件。
+//! 「审计」的另一半——命令文本与退出码——已由命令历史（OSC 133 落库）承担，
+//! 本模块补的是命令历史覆盖不了的部分：完整屏幕内容、非命令输出、时序原貌。
+//!
+//! # 设计取舍
+//!
+//! - **记原始字节，不做任何转义清洗**：与 PuTTY 的会话日志同策略。
+//!   清洗（剥 ANSI / 转可读文本）是**阅读时**的事，日志要保真——
+//!   排查「界面显示为什么这样」恰恰需要原始序列。
+//! - **只记输出不记输入**：PTY 会回显输入（本地与 SSH 皆然），
+//!   输出流已包含用户敲了什么。更重要的是，关闭回显的密码输入
+//!   **不会**出现在输出流里——这保证了日志不会意外存下密码。
+//! - **每批同步追加 + 即时 flush**：日志的价值在崩溃/断线后仍然完整，
+//!   攒缓冲反而丢最关键的最后几行。单批最大 4 MiB（聚合缓冲上限），
+//!   同步写无性能问题。
+//! - **不持久化开关状态**：会话结束日志自然终止，下次会话默认关闭。
+//!   自动记录所有会话涉及磁盘占用与隐私权衡（日志含屏幕上的一切），
+//!   交给用户显式开启更稳妥。
+//!
+//! # 挂点
+//!
+//! 本地 ConPTY 与 SSH 两个后端的 `flush_output` 是所有输出的必经之路
+//! （聚合 → 发前端事件），在此处写日志能保证**零遗漏**且与前端所见一致。
+use std::collections::HashMap;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::{Mutex, OnceLock};
+
+/// 注册表：会话 id → 日志条目。
+static LOGS: OnceLock<Mutex<HashMap<String, LogEntry>>> = OnceLock::new();
+
+struct LogEntry {
+    path: PathBuf,
+    file: std::fs::File,
+    /// 已写入字节数（预留：后续可做单文件上限保护）
+    #[allow(dead_code)]
+    written: u64,
+}
+
+fn registry() -> &'static Mutex<HashMap<String, LogEntry>> {
+    LOGS.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// 开启或关闭某会话的日志。
+///
+/// 开启：在 `dir` 下创建 `{session_id}_{时间戳}.log`，写入头部说明，
+/// 返回 `Some(路径)`。已在记录中则幂等（返回现有路径，不重复建文件）。
+/// 关闭：flush 并移除条目，返回 `None`。未在记录中时关闭是空操作。
+pub fn toggle(
+    session_id: &str,
+    enabled: bool,
+    dir: &PathBuf,
+    header: &str,
+) -> Result<Option<String>, String> {
+    let mut reg = registry().lock().unwrap_or_else(|e| e.into_inner());
+
+    if !enabled {
+        // flush 在 Drop（entry 被 remove）时完成；显式 flush 一次更稳
+        if let Some(e) = reg.remove(session_id) {
+            let mut e = e;
+            let _ = e.file.flush();
+        }
+        return Ok(None);
+    }
+
+    if let Some(e) = reg.get(session_id) {
+        return Ok(Some(e.path.to_string_lossy().to_string()));
+    }
+
+    std::fs::create_dir_all(dir).map_err(|e| format!("创建日志目录失败: {e}"))?;
+    let stamp = chrono::Local::now().format("%Y%m%d_%H%M%S");
+    let path = dir.join(format!("{session_id}_{stamp}.log"));
+    let mut file = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| format!("创建日志文件失败（{}）: {e}", path.display()))?;
+
+    // 头部人可读：定位「这是谁的日志」不需要任何工具
+    writeln!(
+        file,
+        "# 终端会话日志 | {header} | 开始于 {}",
+        chrono::Local::now().format("%Y-%m-%d %H:%M:%S")
+    )
+    .map_err(|e| format!("写入日志头部失败: {e}"))?;
+
+    let path_str = path.to_string_lossy().to_string();
+    reg.insert(
+        session_id.to_string(),
+        LogEntry {
+            path,
+            file,
+            written: 0,
+        },
+    );
+    Ok(Some(path_str))
+}
+
+/// 会话是否正在记录。
+pub fn is_logging(session_id: &str) -> bool {
+    registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .contains_key(session_id)
+}
+
+/// 当前日志文件路径（未记录时为 `None`）。
+pub fn path_of(session_id: &str) -> Option<String> {
+    registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .get(session_id)
+        .map(|e| e.path.to_string_lossy().to_string())
+}
+
+/// 追加一批输出（热路径：未开启时只付一次哈希查表的钱）。
+pub fn write(session_id: &str, bytes: &[u8]) {
+    if bytes.is_empty() {
+        return;
+    }
+    let mut reg = registry().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(entry) = reg.get_mut(session_id) else {
+        return;
+    };
+    if entry.file.write_all(bytes).is_ok() {
+        entry.written += bytes.len() as u64;
+    }
+    // 单条写入失败不中断会话：日志是尽力而为的旁路，不能反过来影响终端 I/O
+    let _ = entry.file.flush();
+}
+
+/// 会话关闭时的清理：flush 并移除条目。幂等。
+pub fn cleanup(session_id: &str) {
+    if let Some(mut e) = registry()
+        .lock()
+        .unwrap_or_else(|x| x.into_inner())
+        .remove(session_id)
+    {
+        let _ = e.file.flush();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn temp_dir(tag: &str) -> PathBuf {
+        let d = std::env::temp_dir().join(format!(
+            "thing-audit-test-{tag}-{}",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_dir_all(&d);
+        d
+    }
+
+    /// 每条测试用独立会话 id，避免注册表（全局静态）在测试间串扰
+    fn sid(tag: &str) -> String {
+        format!("{tag}-{}", std::process::id())
+    }
+
+    #[test]
+    fn toggle_write_and_stop_roundtrip() {
+        let id = sid("roundtrip");
+        let dir = temp_dir("roundtrip");
+
+        // 开启：返回路径，头部已写入
+        let path = toggle(&id, true, &dir, "测试会话 ops@example").unwrap().unwrap();
+        assert!(is_logging(&id));
+        assert_eq!(path_of(&id).unwrap(), path);
+        assert!(path.contains(&id));
+
+        // 写入：文件里能找到原始字节与头部
+        write(&id, b"hello \x1b[31mred\x1b[0m\n");
+        let content = std::fs::read(&path).unwrap();
+        let text = String::from_utf8_lossy(&content);
+        assert!(text.contains("# 终端会话日志"), "头部缺失");
+        assert!(text.contains("ops@example"), "头部信息缺失");
+        assert!(content.windows(5).any(|w| w == b"\x1b[31m"), "原始 ANSI 序列应原样保留");
+        assert!(text.contains("hello "));
+
+        // 关闭：条目移除，文件保留在磁盘上
+        assert!(toggle(&id, false, &dir, "").unwrap().is_none());
+        assert!(!is_logging(&id));
+        assert!(path_of(&id).is_none());
+        assert!(std::path::Path::new(&path).exists(), "关闭后日志文件应保留");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn write_without_log_is_noop() {
+        let id = sid("noop");
+        // 未开启时写入不应 panic、不应创建任何文件
+        write(&id, b"ignored");
+        assert!(!is_logging(&id));
+    }
+
+    #[test]
+    fn toggle_on_twice_is_idempotent() {
+        let id = sid("idempotent");
+        let dir = temp_dir("idempotent");
+        let p1 = toggle(&id, true, &dir, "a").unwrap().unwrap();
+        let p2 = toggle(&id, true, &dir, "b").unwrap().unwrap();
+        assert_eq!(p1, p2, "重复开启应返回同一路径而不是新建文件");
+        cleanup(&id);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn cleanup_and_off_when_not_logging_are_safe() {
+        let id = sid("safe");
+        cleanup(&id); // 未开启时清理是空操作
+        assert!(toggle(&id, false, &temp_dir("safe"), "").unwrap().is_none());
+    }
+
+    #[test]
+    fn disabled_log_file_keeps_bytes_after_cleanup() {
+        let id = sid("persist");
+        let dir = temp_dir("persist");
+        let path = toggle(&id, true, &dir, "h").unwrap().unwrap();
+        write(&id, b"line1\n");
+        write(&id, b"line2\n");
+        cleanup(&id); // 等价于会话关闭路径
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(text.contains("line1") && text.contains("line2"), "cleanup 后内容应完整落盘");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

src-tauri/src/terminal/encoding.rs

@@ -0,0 +1,170 @@
+//! 终端字符编码转换。
+//!
+//! # 为什么需要这个模块
+//!
+//! 终端输出在 SSH 场景下**不保证是 UTF-8**。国内的存量服务器（CentOS 6/7 时代装机、
+//! 未改 `LANG`）默认 `zh_CN.GBK`，`ls` 一个中文文件名就会吐出 GBK 字节。
+//! 若按 UTF-8 解码，得到的是 `测试` 这类不可逆的乱码——而且因为前端拿到的
+//! 是字符串，原始字节已经丢了，用户除了改服务器配置别无办法。
+//!
+//! 因此设计上做了两件事：
+//! 1. **Rust 侧始终以字节流发往前端**（base64），不在这里转 String；
+//! 2. 本模块只在**需要把字节解释成文本**的地方使用（当前是「标题」与
+//!    「cwd」这两处从 OSC 序列解析出的字段，它们是给 UI 直接显示/使用的）。
+//!
+//! 终端画面本身的编码转换放在前端做（xterm 支持自定义 `write` 解码），
+//! 因为那里才能拿到「用户当前是否切了编码」这一运行时状态。
+//!
+//! # 为什么不用 iconv
+//!
+//! `iconv` 绑定需要 C 工具链与系统库；`encoding_rs` 是纯 Rust（Firefox 的
+//! 实现抽出），且它按 WHATWG Encoding 标准处理 GBK 的**单双字节混合**与
+//! 非法序列替换，与浏览器行为一致——这在终端场景下很重要，因为服务端常会
+//! 混发半截多字节字符。
+
+/// 把指定编码的字节解码为 UTF-8 字符串。
+///
+/// 未知编码名一律按 UTF-8 处理（并做有损解码）：宁可显示替换字符，
+/// 也不要因为一个拼错的编码名让整个会话不可用。
+pub fn decode(bytes: &[u8], encoding: &str) -> String {
+    let enc = lookup(encoding);
+    match enc {
+        // UTF-8 走 `from_utf8_lossy`：它比 encoding_rs 的 UTF-8 解码器更快，
+        // 且对非法序列同样产出 U+FFFD（行为一致）。
+        Encoding::Utf8 | Encoding::Fallback => String::from_utf8_lossy(bytes).to_string(),
+        Encoding::Other(e) => {
+            let (cow, _, _) = e.decode(bytes);
+            cow.into_owned()
+        }
+    }
+}
+
+/// 把 UTF-8 字符串编码为目标编码的字节。
+///
+/// 用于「用户键入的内容发往远端」：若服务器是 GBK，输入的中文也必须以 GBK 发出，
+/// 否则远端会显示乱码（甚至把半个字符吃掉导致后续命令错位）。
+pub fn encode(text: &str, encoding: &str) -> Vec<u8> {
+    match lookup(encoding) {
+        Encoding::Utf8 | Encoding::Fallback => text.as_bytes().to_vec(),
+        Encoding::Other(e) => {
+            let (cow, _, _) = e.encode(text);
+            cow.into_owned()
+        }
+    }
+}
+
+/// 编码名是否被识别（供命令层做输入校验与 UI 提示）。
+pub fn is_supported(encoding: &str) -> bool {
+    !matches!(lookup(encoding), Encoding::Fallback)
+}
+
+/// 归一化编码名到标准写法（供 UI 显示与去重比较）。
+///
+/// 输入容忍 `gbk` / `GBK` / `gb18030` / `cp936` / `utf8` 等常见写法。
+pub fn normalize(encoding: &str) -> String {
+    let e = encoding.trim().to_ascii_lowercase();
+    match e.as_str() {
+        "" => "utf-8".to_string(),
+        "utf8" | "utf-8" | "utf_8" => "utf-8".to_string(),
+        "gbk" | "cp936" | "ms936" | "gb2312" | "gb_2312" => "gbk".to_string(),
+        "gb18030" => "gb18030".to_string(),
+        "big5" | "big-5" | "cp950" => "big5".to_string(),
+        "shift_jis" | "shift-jis" | "sjis" | "cp932" => "shift_jis".to_string(),
+        "euc-kr" | "euckr" | "cp949" => "euc-kr".to_string(),
+        "latin1" | "iso-8859-1" => "latin1".to_string(),
+        other => other.to_string(),
+    }
+}
+
+/// 前端设置页可选的编码列表（值与 `normalize` 的输出一致）。
+///
+/// 只列终端场景真实会遇到的：中文（GBK/GB18030）、港台（Big5）、
+/// 日韩（Shift_JIS/EUC-KR）。ISO-8859-1 保留给嵌入式设备（它们的 busybox
+/// 经常只有 C locale）。
+pub const SUPPORTED: &[&str] = &[
+    "utf-8",
+    "gbk",
+    "gb18030",
+    "big5",
+    "shift_jis",
+    "euc-kr",
+    "latin1",
+];
+
+enum Encoding {
+    Utf8,
+    Other(&'static encoding_rs::Encoding),
+    /// 未识别的编码名（回退到 UTF-8 语义，但 `is_supported` 会报 false）
+    Fallback,
+}
+
+fn lookup(encoding: &str) -> Encoding {
+    let e = normalize(encoding);
+    if e == "utf-8" {
+        return Encoding::Utf8;
+    }
+    match encoding_rs::Encoding::for_label(e.as_bytes()) {
+        // UTF-8 通过 label 也能查到，但我们要走更快的 from_utf8_lossy 分支
+        Some(enc) if enc == encoding_rs::UTF_8 => Encoding::Utf8,
+        Some(enc) => Encoding::Other(enc),
+        None => Encoding::Fallback,
+    }
+}
+
+// ===== 测试 =====
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn utf8_roundtrip() {
+        let s = "测试目录 /tmp";
+        assert_eq!(decode(&encode(s, "utf-8"), "utf-8"), s);
+    }
+
+    #[test]
+    fn gbk_roundtrip() {
+        let s = "测试";
+        let bytes = encode(s, "gbk");
+        // GBK 下「测试」是 4 字节（每字 2 字节），而 UTF-8 是 6 字节。
+        // 断言长度而非魔法数字，是为了让这条测试同时验证「确实用了 GBK」。
+        assert_eq!(bytes.len(), 4, "GBK 编码「测试」应为 4 字节");
+        assert_eq!(decode(&bytes, "gbk"), s);
+    }
+
+    #[test]
+    fn gbk_bytes_are_mojibake_under_utf8() {
+        // 反向验证：GBK 字节按 UTF-8 解读会失真。这正是前端必须知道
+        // 会话编码的原因（也是本模块存在的理由）。
+        let bytes = encode("测试", "gbk");
+        let as_utf8 = String::from_utf8_lossy(&bytes).to_string();
+        assert_ne!(as_utf8, "测试");
+    }
+
+    #[test]
+    fn alias_normalization() {
+        assert_eq!(normalize("GBK"), "gbk");
+        assert_eq!(normalize("cp936"), "gbk");
+        assert_eq!(normalize("utf8"), "utf-8");
+        assert_eq!(normalize(""), "utf-8");
+        assert_eq!(normalize("  UTF-8  "), "utf-8");
+    }
+
+    #[test]
+    fn all_supported_labels_resolve() {
+        for name in SUPPORTED {
+            assert!(is_supported(name), "{name} 应被识别");
+        }
+        assert!(!is_supported("not-a-real-encoding"));
+    }
+
+    #[test]
+    fn invalid_bytes_do_not_panic() {
+        // 终端输出经常在半截多字节字符处被切断，解码必须容错而不是 panic
+        let broken = [0xB2u8, 0xE2]; // GBK「测」的前 2 字节（完整），再截断一个
+        let _ = decode(&broken, "gbk");
+        let _ = decode(&[0xFF, 0xFE, 0xFD], "utf-8");
+        let _ = decode(&[0xC0], "gb18030");
+    }
+}

src-tauri/src/terminal/events.rs

@@ -0,0 +1,92 @@
+//! 终端模块 Tauri 事件定义与负载类型。
+//!
+//! 事件名常量集中在 `crate::constants::events`，这里只放负载结构与便捷发射函数。
+//! 命名口径与既有模块一致：kebab-case、`terminal-` 前缀。
+
+use serde::Serialize;
+use specta::Type;
+
+use super::session::SessionId;
+
+/// 事件名再导出，让两个后端可以写 `events::TERMINAL_OUTPUT` 而不必回退两层路径。
+///
+/// `allow(unused_imports)` 的原因：这是**模块对外的常量出口**，六个事件名成组
+/// 定义、成组暴露，便于调用方按同一路径取用；个别常量在当前代码路径上暂未被
+/// 本模块自身引用（如 `TERMINAL_CONFIRM_CLOSE` 由窗口层发射、
+/// `TERMINAL_CWD` 由 shell hook 发射），但都属于稳定契约，不应按使用情况逐个删改。
+#[allow(unused_imports)]
+pub use crate::constants::events::{
+    TERMINAL_CONFIRM_CLOSE, TERMINAL_CWD, TERMINAL_EXIT, TERMINAL_HOST_KEY_PROMPT,
+    TERMINAL_OUTPUT, TERMINAL_STATE, TERMINAL_TRANSFER_PROGRESS,
+};
+
+/// 发射 SFTP 传输进度事件。
+///
+/// 单独一个函数而不是在命令层直接 `emit`：事件名常量与负载类型分属两个模块，
+/// 集中在这里能让「事件名 ↔ 负载类型」的对应关系一眼可见（也是排查
+/// 「前端收到的字段对不上」这类问题的第一落点）。
+pub fn emit_transfer(app: &tauri::AppHandle, payload: &super::ssh::sftp::TransferProgress) {
+    use tauri::Emitter;
+    let _ = app.emit(TERMINAL_TRANSFER_PROGRESS, payload);
+}
+
+/// 会话输出批次（**发往前端**的形态）。
+///
+/// 字段与内部聚合缓冲一一对应但单独定义，是为了让「前端契约」与
+/// 「内部分批策略」可以独立演进（例如未来内部改成分块再组装，前端不必感知）。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct OutputPayload {
+    pub session_id: SessionId,
+    /// base64 编码的原始输出字节。
+    ///
+    /// **为什么用 base64 而不是直接给字符串**：终端输出可能是 GBK 等非 UTF-8
+    /// 编码（老服务器常见），若在 Rust 侧转 String 就永久丢失了原始字节，
+    /// 前端再做后处理也无从下手。用 base64 保持字节完整性，由前端按会话编码解码。
+    pub data: String,
+    /// 全局单调批次序号，前端据此检测丢包。
+    pub seq: u64,
+}
+
+/// 会话结束。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ExitPayload {
+    pub session_id: SessionId,
+    /// 退出码。本地会话通常有；SSH 通道关闭时多为 None。
+    pub exit_code: Option<i32>,
+    /// 结束原因："eof" | "process-exit" | "killed" | "disconnected" | "error"
+    pub reason: Option<String>,
+}
+
+/// 会话工作目录变化（由 OSC 7 hook 上报）。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CwdPayload {
+    pub session_id: SessionId,
+    pub cwd: String,
+}
+
+/// 状态变更事件直接复用 [`SessionInfo`] 作为负载——
+/// 前端拿到它就能刷新侧栏与标签，不必再发一次查询。
+
+/// SSH 主机密钥需要用户确认（首次连接或指纹变更）。
+///
+/// 这是一个**阻塞性的交互请求**：Rust 侧握手暂停，等前端调
+/// `terminal_confirm_host_key` 回传决定。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct HostKeyPromptPayload {
+    pub session_id: SessionId,
+    pub host: String,
+    pub port: u16,
+    /// 密钥算法（如 "ssh-ed25519" / "ssh-rsa"）
+    pub key_type: String,
+    /// 服务端出示的指纹（SHA256，OpenSSH 展示格式）
+    pub fingerprint: String,
+    /// 本次是「首次见到」还是「与记录不符」。
+    /// 后者是**高危信号**，前端必须以红色阻断式 UI 呈现。
+    pub reason: String,
+    /// 与记录不符时，给出先前记录的指纹以便用户对比
+    pub previous_fingerprint: Option<String>,
+}

src-tauri/src/terminal/history.rs

@@ -0,0 +1,857 @@
+//! 终端命令历史（SQLite）。
+//!
+//! 存储约定：`{app_data_dir}/terminal/history.db`，范式与 `translate/history.rs` 一致
+//! （WAL、`PRAGMA user_version` 作结构版本、FTS5 trigram 索引）。
+//!
+//! # 与翻译历史的关键差异：为什么不做整库重建式迁移
+//!
+//! 翻译历史用了「版本不等就 DROP 重建」的简化策略，理由是「历史属于可丢弃数据」。
+//! 终端历史**不能照抄**：翻译历史里一条记录是「一段译文」，重建丢的是可以重翻的东西；
+//! 终端历史里一条记录是**用户敲过的命令**，包含服务器地址、路径、以及偶尔泄露在
+//! 命令行里的凭据。用户可能恰恰是为了翻查这些才留着它。
+//!
+//! 因此这里从一开始就写**增量迁移**（`migrate`），不做 DROP。
+//!
+//! # 为什么存两列（command + cwd）
+//!
+//! 同一条命令在 `/var/log` 下和在 `~` 下含义完全不同（`ls`、`make`、`git status`
+//! 都是典型例子）。只存命令会让「我上次在哪个目录跑的那条命令」无从追查，
+//! 而 `cwd` 又是一次 OSC 7 就能免费拿到的信息。
+//!
+//! # 去重键的选择
+//!
+//! 用 `(command, cwd, host_id)` 而不是 `(command, host_id)`：在 A 目录跑过的命令，
+//! 换到 B 目录再跑应当各留一条 —— 它们对用户是两个不同的事实。
+//! 重复执行同一条命令（同一目录）只更新 `ts` 与 `count`，避免历史被刷屏。
+
+use std::path::Path;
+use std::sync::Mutex;
+
+use rusqlite::{params, Connection};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// 库结构版本（与 `PRAGMA user_version` 对应）。
+///
+/// **递增时必须同步在 `migrate` 里加分支**，否则旧库会因缺少新列而在查询时报
+/// 「no such column」，而报错点在读取路径上、远离真正的成因。
+const SCHEMA_VERSION: i64 = 1;
+
+/// 默认保留条数。超出后在写入路径上淘汰最旧的**非收藏**记录。
+const DEFAULT_MAX_ENTRIES: i64 = 5000;
+
+/// 走 FTS 索引所需的最小字符数。
+///
+/// trigram 分词器把文本切成连续 3 字符的 n-gram，长度小于 3 的查询词
+/// **不会报错、只会静默返回空**。而终端里两字符的命令恰恰是最常见的
+/// （`ls`、`cd`、`rm`），所以短词回退到 `LIKE` 前缀匹配。
+const FTS_MIN_CHARS: usize = 3;
+
+/// 一条命令历史。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CommandHistoryItem {
+    pub id: i64,
+    /// 毫秒时间戳（最后一次执行）
+    pub ts: i64,
+    pub command: String,
+    /// 执行时的工作目录（可能为空 —— OSC 7 未被远端 shell 上报时）
+    pub cwd: String,
+    /// 会话来源：本地 shell 的 id，或 SSH 主机的 id。
+    /// 为空串表示「来源未知」（如手工录入的历史）。
+    pub host_id: String,
+    /// 显示用的来源名（「PowerShell」/「生产服务器」），随记录一起存。
+    ///
+    /// # 为什么冗余存名字而不只存 id
+    ///
+    /// 主机被删除后，若只有 id，历史列表里那一列会变成一串无意义的 hash。
+    /// 存名字的代价是「主机改名后历史里的旧名字不会更新」—— 这里选择
+    /// **保留历史当时的名字**，因为「我在那台现在叫 X 的机器上跑过什么」
+    /// 本来就是一个有时间性的问题。
+    pub host_name: String,
+    /// 是否为 SSH 会话
+    pub ssh: bool,
+    /// 累计执行次数（同一命令在同一目录重复执行时累加）
+    pub count: i64,
+    /// 用户收藏（收藏项不参与容量淘汰）
+    pub favorited: bool,
+    /// 退出码。`None` 表示未捕获（如会话结束时命令仍在运行）
+    pub exit_code: Option<i32>,
+}
+
+/// 查询参数。
+///
+/// 用结构体而不是一长串位置参数：命令层要把前端 payload 原样转发，
+/// 而 5 个 `Option<String>` 的位置参数在调用点极易顺序写错，且编译器
+/// 无法发现（全是同类型）。
+#[derive(Debug, Clone, Default, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct HistoryQuery {
+    /// 关键词（对 command 做匹配；空则不过滤）
+    pub keyword: String,
+    /// 只看某个来源（host_id；空则全部）
+    pub host_id: String,
+    /// 只看收藏
+    pub favorited_only: bool,
+    /// 分页偏移
+    pub offset: i64,
+    /// 分页大小
+    pub limit: i64,
+}
+
+impl HistoryQuery {
+    /// 归一化：`limit` 兜底并设上限，`offset` 不为负。
+    ///
+    /// 上限 500：前端分页步长是 50~100，500 已远超一屏能展示的量，
+    /// 再大只会让 IPC 序列化成为瓶颈。
+    fn normalized(mut self) -> Self {
+        if self.limit <= 0 {
+            self.limit = 100;
+        }
+        if self.limit > 500 {
+            self.limit = 500;
+        }
+        if self.offset < 0 {
+            self.offset = 0;
+        }
+        self
+    }
+}
+
+/// 一次查询的结果（含总数，供前端显示「共 N 条」）。
+///
+/// # 为什么叫 `TerminalHistoryPage` 而不是 `HistoryPage`
+///
+/// `tauri-specta` 给 `Type` 派生的类型注册表是**全局按类型名索引**的，重名会让
+/// `export_bindings()` 直接 panic（`Detected multiple types with the same name`）。
+/// `clipboard::commands::HistoryPage`（`items: Vec<ClipboardItem>`）已占用这个名字。
+///
+/// specta 2.0.0-rc.25 **没有**给 struct 提供重命名手段 —— `#[specta(rename = ...)]`
+/// 只对**函数**宏生效（`specta-macros/src/specta.rs` 的 `parse_name_attrs`）；
+/// derive 路径下导出名直接取自 Rust 标识符
+/// （`specta-macros/src/type/mod.rs`：`let name = unraw_raw_ident(&format_ident!("{}", raw_ident.to_string()))`），
+/// 而 `ContainerAttr` 只认 `crate` / `type` / `inline` / `remote` / `collect` /
+/// `skip_attr` / `transparent`，且 `reject_unknown_specta_attrs` 会让未知属性直接编译失败。
+/// 因此**改名是唯一可行解**。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct TerminalHistoryPage {
+    pub items: Vec<CommandHistoryItem>,
+    /// 满足筛选条件的总条数（**不受 limit/offset 影响**）
+    pub total: i64,
+}
+
+/// 历史来源（供前端做筛选下拉）。
+///
+/// 单独定义而不是用元组：元组序列化成 JSON 会变成数组，前端得靠下标取值
+/// （`s[0]`/`s[1]`/`s[2]`），改一次顺序就静默错位。具名字段让前后端
+/// 各自独立演进而不怕顺序变动。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct HistorySource {
+    pub host_id: String,
+    pub host_name: String,
+    /// 该来源的命令条数
+    pub count: i64,
+    pub ssh: bool,
+}
+
+pub struct History {
+    conn: Mutex<Connection>,
+}
+
+/// 建表语句。
+///
+/// `v1` 即当前结构。后续版本只追加 `ALTER TABLE`，不重建（见模块头说明）。
+fn schema_v1() -> &'static str {
+    "
+    CREATE TABLE IF NOT EXISTS cmd_history (
+       id         INTEGER PRIMARY KEY,
+       ts         INTEGER NOT NULL,
+       command    TEXT NOT NULL,
+       cwd        TEXT NOT NULL DEFAULT '',
+       host_id    TEXT NOT NULL DEFAULT '',
+       host_name  TEXT NOT NULL DEFAULT '',
+       ssh        INTEGER NOT NULL DEFAULT 0,
+       count      INTEGER NOT NULL DEFAULT 1,
+       favorited  INTEGER NOT NULL DEFAULT 0,
+       exit_code  INTEGER,
+       UNIQUE(command, cwd, host_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_cmd_hist_ts   ON cmd_history(ts DESC);
+    CREATE INDEX IF NOT EXISTS idx_cmd_hist_host ON cmd_history(host_id, ts DESC);
+    CREATE INDEX IF NOT EXISTS idx_cmd_hist_fav  ON cmd_history(favorited, ts DESC);
+
+    -- 外部内容表：索引只存倒排表，正文仍只在 cmd_history 里一份。
+    -- 代价是不会自动感知主表变化，必须靠下面三个触发器手动同步。
+    CREATE VIRTUAL TABLE IF NOT EXISTS cmd_history_fts USING fts5(
+       command,
+       content='cmd_history', content_rowid='id',
+       tokenize='trigram'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS cmd_hist_fts_ai AFTER INSERT ON cmd_history BEGIN
+       INSERT INTO cmd_history_fts(rowid, command) VALUES (new.id, new.command);
+    END;
+    CREATE TRIGGER IF NOT EXISTS cmd_hist_fts_ad AFTER DELETE ON cmd_history BEGIN
+       INSERT INTO cmd_history_fts(cmd_history_fts, rowid, command)
+       VALUES ('delete', old.id, old.command);
+    END;
+    CREATE TRIGGER IF NOT EXISTS cmd_hist_fts_au AFTER UPDATE ON cmd_history BEGIN
+       INSERT INTO cmd_history_fts(cmd_history_fts, rowid, command)
+       VALUES ('delete', old.id, old.command);
+       INSERT INTO cmd_history_fts(rowid, command) VALUES (new.id, new.command);
+    END;
+    "
+}
+
+/// 转义 FTS5 查询串。
+///
+/// FTS5 的 `MATCH` 语法把 `"` `*` `(` `)` `:` `^` `-` `+` 等当操作符。
+/// 终端命令里这些字符**比比皆是**（`grep -v foo`、`ls *.rs`、`git log --oneline`），
+/// 不转义时会抛语法错误或产生完全意外的匹配。
+///
+/// 做法：整体包成双引号短语，并把内部的 `"` 转义为 `""`（FTS5 的转义约定，
+/// 与 SQL 的 `''` 同理）。包成短语后所有操作符都失去特殊含义，代价是不支持
+/// 用户手写布尔表达式 —— 对「搜我敲过的命令」这个场景，字面量匹配正是所需。
+fn fts_phrase(keyword: &str) -> String {
+    format!("\"{}\"", keyword.replace('"', "\"\""))
+}
+
+impl History {
+    pub fn new(dir: &Path) -> Result<Self, String> {
+        std::fs::create_dir_all(dir).map_err(|e| format!("创建终端目录失败: {e}"))?;
+        let conn =
+            Connection::open(dir.join("history.db")).map_err(|e| format!("打开历史库失败: {e}"))?;
+        conn.execute_batch("PRAGMA journal_mode = WAL;")
+            .map_err(|e| format!("初始化历史库失败: {e}"))?;
+
+        migrate(&conn)?;
+
+        Ok(Self {
+            conn: Mutex::new(conn),
+        })
+    }
+
+    fn conn(&self) -> std::sync::MutexGuard<'_, Connection> {
+        self.conn.lock().unwrap_or_else(|e| e.into_inner())
+    }
+
+    /// 记录一条命令（同 command+cwd+host 只累加计数并更新时间）。
+    ///
+    /// # 过滤规则
+    ///
+    /// - 空命令 / 纯空白：不记（回车空行不该进历史）
+    /// - 以空格开头：不记。这是 shell 的**惯例**（`HISTCONTROL=ignorespace`），
+    ///   用户用它来避免把含密码的命令写进 `.bash_history`。我们若不遵守，
+    ///   等于把用户对系统历史的信任**从背后捅穿** —— 这条规则不是可选项。
+    pub fn record(
+        &self,
+        command: &str,
+        cwd: &str,
+        host_id: &str,
+        host_name: &str,
+        ssh: bool,
+        exit_code: Option<i32>,
+    ) -> Result<(), String> {
+        let cmd = command.trim();
+        if cmd.is_empty() || command.starts_with(' ') {
+            return Ok(());
+        }
+        let now = chrono::Utc::now().timestamp_millis();
+        self.conn()
+            .execute(
+                "INSERT INTO cmd_history (ts, command, cwd, host_id, host_name, ssh, count,
+                     favorited, exit_code)
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, 1, 0, ?7)
+                 ON CONFLICT(command, cwd, host_id)
+                 DO UPDATE SET ts = excluded.ts,
+                     count = cmd_history.count + 1,
+                     ssh = excluded.ssh,
+                     host_name = excluded.host_name,
+                     exit_code = excluded.exit_code",
+                params![now, cmd, cwd, host_id, host_name, ssh as i64, exit_code],
+            )
+            .map_err(|e| format!("写入命令历史失败: {e}"))?;
+        Ok(())
+    }
+
+    /// 分页查询。
+    pub fn query(&self, q: HistoryQuery) -> Result<TerminalHistoryPage, String> {
+        let q = q.normalized();
+        let conn = self.conn();
+
+        // 动态拼 WHERE。所有用户输入一律走 `params!` 占位符绑定，
+        // **不做字符串插值** —— 命令历史里出现 `'` 是家常便饭
+        // （`awk '{print $1}'`），插值会直接语法错误甚至注入。
+        let mut wheres: Vec<String> = Vec::new();
+        let mut args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+
+        let keyword = q.keyword.trim();
+        if !keyword.is_empty() {
+            if keyword.chars().count() >= FTS_MIN_CHARS {
+                wheres.push(
+                    "id IN (SELECT rowid FROM cmd_history_fts WHERE cmd_history_fts MATCH ?)"
+                        .to_string(),
+                );
+                args.push(Box::new(fts_phrase(keyword)));
+            } else {
+                // 短词回退：trigram 索引里没有 2 字符以下的片段，走 FTS 只会
+                // 静默返回空。用 LIKE 做前缀匹配（`ls` 命中 `ls -la` 也命中 `lsof`）。
+                wheres.push("command LIKE ? ESCAPE '\\'".to_string());
+                args.push(Box::new(format!(
+                    "{}%",
+                    escape_like(keyword)
+                )));
+            }
+        }
+        if !q.host_id.trim().is_empty() {
+            wheres.push("host_id = ?".to_string());
+            args.push(Box::new(q.host_id.trim().to_string()));
+        }
+        if q.favorited_only {
+            wheres.push("favorited = 1".to_string());
+        }
+
+        let where_sql = if wheres.is_empty() {
+            String::new()
+        } else {
+            format!(" WHERE {}", wheres.join(" AND "))
+        };
+
+        // 总数单独查一次：`COUNT(*) OVER ()` 需要窗口函数支持（SQLite 3.25+，
+        // bundled 版本满足），但把 total 与分页放在同一查询里会让「无结果时
+        // total 也拿不到」，而前端在无结果时同样需要显示「共 0 条」。分开查更直白。
+        let total: i64 = {
+            let sql = format!("SELECT COUNT(*) FROM cmd_history{where_sql}");
+            let refs: Vec<&dyn rusqlite::ToSql> = args.iter().map(|b| b.as_ref()).collect();
+            conn.query_row(&sql, refs.as_slice(), |r| r.get(0))
+                .map_err(|e| format!("统计命令历史失败: {e}"))?
+        };
+
+        // 排序：收藏优先 → 时间倒序。收藏优先放在 SQL 而非前端排序，
+        // 否则「翻到第 3 页」的语义会变成「在未排序的集合里翻页」，结果不稳定。
+        let sql = format!(
+            "SELECT id, ts, command, cwd, host_id, host_name, ssh, count, favorited, exit_code
+             FROM cmd_history{where_sql}
+             ORDER BY favorited DESC, ts DESC
+             LIMIT ? OFFSET ?"
+        );
+        let mut refs: Vec<&dyn rusqlite::ToSql> = args.iter().map(|b| b.as_ref()).collect();
+        let limit = q.limit;
+        let offset = q.offset;
+        refs.push(&limit);
+        refs.push(&offset);
+
+        let mut stmt = conn
+            .prepare(&sql)
+            .map_err(|e| format!("准备查询失败: {e}"))?;
+        let items = stmt
+            .query_map(refs.as_slice(), |row| {
+                Ok(CommandHistoryItem {
+                    id: row.get(0)?,
+                    ts: row.get(1)?,
+                    command: row.get(2)?,
+                    cwd: row.get(3)?,
+                    host_id: row.get(4)?,
+                    host_name: row.get(5)?,
+                    ssh: row.get::<_, i64>(6)? != 0,
+                    count: row.get(7)?,
+                    favorited: row.get::<_, i64>(8)? != 0,
+                    exit_code: row.get(9)?,
+                })
+            })
+            .map_err(|e| format!("查询命令历史失败: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("读取命令历史失败: {e}"))?;
+
+        Ok(TerminalHistoryPage { items, total })
+    }
+
+    /// 切换收藏。返回切换后的值。
+    pub fn toggle_favorite(&self, id: i64) -> Result<bool, String> {
+        let conn = self.conn();
+        let cur: i64 = conn
+            .query_row("SELECT favorited FROM cmd_history WHERE id = ?1", params![id], |r| {
+                r.get(0)
+            })
+            .map_err(|e| format!("找不到历史记录 {id}: {e}"))?;
+        let next = if cur == 0 { 1 } else { 0 };
+        conn.execute(
+            "UPDATE cmd_history SET favorited = ?1 WHERE id = ?2",
+            params![next, id],
+        )
+        .map_err(|e| format!("更新收藏状态失败: {e}"))?;
+        Ok(next != 0)
+    }
+
+    /// 删除单条。返回是否真的删掉了（`false` = 该 id 不存在）。
+    pub fn delete(&self, id: i64) -> Result<bool, String> {
+        let n = self
+            .conn()
+            .execute("DELETE FROM cmd_history WHERE id = ?1", params![id])
+            .map_err(|e| format!("删除历史记录失败: {e}"))?;
+        Ok(n > 0)
+    }
+
+    /// 清空。`keep_favorites` 为真时保留收藏项。
+    ///
+    /// 返回删除条数，供前端提示「已清空 N 条」——只说「已清空」而不给数字，
+    /// 用户无法判断是否误删了收藏项之外的全部内容。
+    pub fn clear(&self, keep_favorites: bool) -> Result<i64, String> {
+        let conn = self.conn();
+        let n = if keep_favorites {
+            conn.execute("DELETE FROM cmd_history WHERE favorited = 0", [])
+        } else {
+            conn.execute("DELETE FROM cmd_history", [])
+        }
+        .map_err(|e| format!("清空历史失败: {e}"))?;
+        Ok(n as i64)
+    }
+
+    /// 淘汰超出容量上限的最旧非收藏记录。
+    ///
+    /// 在写入路径末尾调用（而非定时任务）：容量只会在写入时增长，
+    /// 挂一个定时器反而要处理「定时器与写入并发」的竞态。
+    ///
+    /// 用 `id NOT IN (SELECT id ... LIMIT n)` 的子查询形式而不是 `OFFSET`：
+    /// 后者在超大偏移下要扫描全部前置行，而这里每写一条就跑一次，
+    /// 不能让单次写入的代价随库增大而线性上升。
+    pub fn prune(&self, max: i64) -> Result<i64, String> {
+        let max = if max <= 0 { DEFAULT_MAX_ENTRIES } else { max };
+        let n = self
+            .conn()
+            .execute(
+                "DELETE FROM cmd_history
+                 WHERE favorited = 0 AND id NOT IN (
+                     SELECT id FROM cmd_history WHERE favorited = 0
+                     ORDER BY ts DESC LIMIT ?1
+                 )",
+                params![max],
+            )
+            .map_err(|e| format!("淘汰历史失败: {e}"))?;
+        Ok(n as i64)
+    }
+
+    /// 全部来源（供前端做筛选下拉，避免前端自己聚合而漏掉已删除主机的历史）。
+    pub fn sources(&self) -> Result<Vec<HistorySource>, String> {
+        let conn = self.conn();
+        let mut stmt = conn
+            .prepare(
+                "SELECT host_id, host_name, COUNT(*) AS n,
+                        MAX(CASE WHEN ssh THEN 1 ELSE 0 END) AS ssh
+                 FROM cmd_history
+                 WHERE host_id <> ''
+                 GROUP BY host_id, host_name
+                 ORDER BY n DESC",
+            )
+            .map_err(|e| format!("准备来源查询失败: {e}"))?;
+        let rows = stmt
+            .query_map([], |r| {
+                Ok(HistorySource {
+                    host_id: r.get(0)?,
+                    host_name: r.get(1)?,
+                    count: r.get(2)?,
+                    ssh: r.get::<_, i64>(3)? != 0,
+                })
+            })
+            .map_err(|e| format!("查询来源失败: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("读取来源失败: {e}"))?;
+        Ok(rows)
+    }
+}
+
+/// 转义 `LIKE` 模式里的通配符。
+///
+/// 调用方在 SQL 里写了 `ESCAPE '\'`，这里必须把 `\` `%` `_` 三个字符
+/// 各自加反斜杠前缀。**`\` 必须最先替换** —— 否则后两步插入的反斜杠
+/// 会被第三步再次转义，产生 `\\%` 这种把通配符当成字面量的错误结果。
+fn escape_like(s: &str) -> String {
+    s.replace('\\', "\\\\")
+        .replace('%', "\\%")
+        .replace('_', "\\_")
+}
+
+/// 增量迁移。
+///
+/// 从 `user_version` 逐级升到 `SCHEMA_VERSION`。首次打开（version = 0）
+/// 直接建 v1 结构并把版本置为 1。
+///
+/// # 为什么不复用翻译历史的「版本不等就 DROP」
+///
+/// 见模块头说明：终端历史里是用户敲过的命令，可能包含服务器地址与路径，
+/// 是可追溯的资产而非可丢弃的缓存。
+fn migrate(conn: &Connection) -> Result<(), String> {
+    let mut version: i64 = conn
+        .query_row("PRAGMA user_version", [], |row| row.get(0))
+        .map_err(|e| format!("读取历史库版本失败: {e}"))?;
+
+    if version == 0 {
+        // 全新库（或来自更早的、没有版本号的实验版本）。
+        // 用 `CREATE TABLE IF NOT EXISTS` 保证对已有表幂等 ——
+        // 若库文件存在但 user_version 丢了，这里不会因表已存在而失败。
+        conn.execute_batch(schema_v1())
+            .map_err(|e| format!("初始化命令历史表失败: {e}"))?;
+        version = 1;
+        conn.execute_batch(&format!("PRAGMA user_version = {version};"))
+            .map_err(|e| format!("写入历史库版本失败: {e}"))?;
+    }
+
+    // 后续版本在此追加：
+    // if version == 1 {
+    //     conn.execute_batch("ALTER TABLE cmd_history ADD COLUMN xxx TEXT NOT NULL DEFAULT '';")?;
+    //     version = 2;
+    //     conn.execute_batch(&format!("PRAGMA user_version = {version};"))?;
+    // }
+
+    if version < SCHEMA_VERSION {
+        // 走到这里说明有迁移分支被漏写了。**显式报错而不是静默继续** ——
+        // 静默继续会让「新加的列在运行时找不到」变成一个远离成因的报错。
+        return Err(format!(
+            "命令历史库版本 {version} 低于期望的 {SCHEMA_VERSION}，但缺少对应的迁移步骤"
+        ));
+    }
+
+    Ok(())
+}
+
+// ===== 后台 writer =====
+
+/// 一条待落库的命令记录（读线程 → writer 线程的通道载荷）。
+pub struct HistoryEntry {
+    pub command: String,
+    pub cwd: String,
+    pub host_id: String,
+    pub host_name: String,
+    pub ssh: bool,
+    pub exit_code: Option<i32>,
+}
+
+/// 攒批参数：到达任一阈值（条数 / 时间窗）就把积压写进 SQLite。
+const WRITER_BATCH_MAX: usize = 64;
+const WRITER_BATCH_WINDOW: std::time::Duration = std::time::Duration::from_millis(400);
+
+/// 把积压的记录写进历史库。
+///
+/// 放成模块级函数（而非闭包）：writer 循环的三个分支（满批 / 超时 / 断开）
+/// 都要走到它，闭包会被借用检查卡住（循环里持有 `&mut batch`）。
+fn flush_batch(app: &tauri::AppHandle, batch: &mut Vec<HistoryEntry>) {
+    use tauri::Manager as _;
+    if batch.is_empty() {
+        return;
+    }
+    let Some(mgr) = app.try_state::<crate::terminal::TerminalManager>() else {
+        // 应用正在退出（manager 已释放）：丢掉这批，历史是辅助功能
+        batch.clear();
+        return;
+    };
+    let guard = match mgr.history() {
+        Ok(g) => g,
+        Err(e) => {
+            crate::logger::log_error("terminal", &format!("打开历史库失败（丢弃一批记录）: {e}"));
+            batch.clear();
+            return;
+        }
+    };
+    let Some(h) = guard.as_ref() else {
+        batch.clear();
+        return;
+    };
+    for e in batch.drain(..) {
+        if let Err(err) = h.record(
+            &e.command,
+            &e.cwd,
+            &e.host_id,
+            &e.host_name,
+            e.ssh,
+            e.exit_code,
+        ) {
+            crate::logger::log_error("terminal", &format!("写入命令历史失败（不影响会话）: {err}"));
+        }
+    }
+    // 每批淘汰一次（而非每条）：把 prune 的 DELETE 子查询从「每命令一次」
+    // 降为「每批一次」，这是此前输出热路径上最贵的一步。
+    if let Err(err) = h.prune(0) {
+        crate::logger::log_error("terminal", &format!("淘汰历史容量失败: {err}"));
+    }
+}
+
+/// 启动后台历史 writer，返回入队端。
+///
+/// # 为什么需要它（此前的形态是同步写）
+///
+/// `record_command` 位于**输出热路径**上（OSC 133 的 D 标记到达时，读线程/SSH
+/// 读任务正在转发终端输出）。同步形态意味着：整份 settings 深拷贝 + SQLite
+/// 写入 + prune 的 DELETE 子查询都发生在转发线程上，`cat` 大文件时每条命令
+/// 都会让同一批输出多等一次磁盘 IO。
+///
+/// 改为通道 + 后台 writer 后，读线程只做一次 `mpsc::send`（非阻塞、无锁竞争）。
+/// 落库延迟最多一个攒批窗口（400ms），对「翻历史」场景无感。
+///
+/// 退出语义：所有入队端 drop 后（`cleanup_on_exit` 会 drop manager 里的那份），
+/// `recv` 返回 Err 且缓冲清空，writer 把剩余记录写完后自然退出。
+pub fn spawn_writer(app: tauri::AppHandle) -> std::sync::mpsc::Sender<HistoryEntry> {
+    use std::sync::mpsc::{channel, RecvTimeoutError};
+
+    let (tx, rx) = channel::<HistoryEntry>();
+    std::thread::spawn(move || {
+        let mut batch: Vec<HistoryEntry> = Vec::new();
+        loop {
+            match rx.recv_timeout(WRITER_BATCH_WINDOW) {
+                Ok(e) => {
+                    batch.push(e);
+                    if batch.len() >= WRITER_BATCH_MAX {
+                        flush_batch(&app, &mut batch);
+                    }
+                }
+                Err(RecvTimeoutError::Timeout) => {
+                    flush_batch(&app, &mut batch);
+                }
+                Err(RecvTimeoutError::Disconnected) => {
+                    // 入队端全部关闭：写完剩余的，退出
+                    flush_batch(&app, &mut batch);
+                    break;
+                }
+            }
+        }
+    });
+    tx
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 每个用例一个独立目录。
+    ///
+    /// 沿用 `translate/history.rs` 的做法（`std::env::temp_dir()` + 进程号 + 序号），
+    /// 而不是引入 `tempdir` dev-dependency：`History` 持有的连接在测试结束前不释放，
+    /// Windows 会拒绝删除仍被打开的文件，所以**本来就没法真正清理**。
+    /// 为一件做不到的事加一个依赖不划算。
+    fn open(tag: &str) -> History {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        static SEQ: AtomicUsize = AtomicUsize::new(0);
+        let n = SEQ.fetch_add(1, Ordering::Relaxed);
+        let dir = std::env::temp_dir().join(format!(
+            "thing-cmd-hist-test-{}-{tag}-{n}",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_dir_all(&dir);
+        History::new(&dir).expect("建库失败")
+    }
+
+    #[test]
+    fn record_and_query_roundtrip() {
+        let h = open("roundtrip");
+        h.record("ls -la", "/home/me", "h1", "服务器A", true, Some(0))
+            .unwrap();
+        h.record("git status", "/home/me", "h1", "服务器A", true, Some(0))
+            .unwrap();
+
+        let page = h.query(HistoryQuery::default()).unwrap();
+        assert_eq!(page.total, 2);
+        // 收藏优先 + 时间倒序：两条都不是收藏，按 ts 倒序 → 后插入的在前
+        assert_eq!(page.items[0].command, "git status");
+    }
+
+    #[test]
+    fn dedup_accumulates_count() {
+        let h = open("dedup");
+        h.record("make", "/proj", "h1", "A", true, Some(0)).unwrap();
+        h.record("make", "/proj", "h1", "A", true, Some(2)).unwrap();
+        let page = h.query(HistoryQuery::default()).unwrap();
+        assert_eq!(page.total, 1, "同 command+cwd+host 应复用同一行");
+        assert_eq!(page.items[0].count, 2);
+        assert_eq!(page.items[0].exit_code, Some(2), "退出码应为最后一次");
+    }
+
+    #[test]
+    fn same_command_different_cwd_is_separate() {
+        let h = open("cwd");
+        h.record("ls", "/a", "h1", "A", true, None).unwrap();
+        h.record("ls", "/b", "h1", "A", true, None).unwrap();
+        let page = h.query(HistoryQuery::default()).unwrap();
+        assert_eq!(page.total, 2, "不同目录下的同名命令是两条独立记录");
+    }
+
+    #[test]
+    fn leading_space_is_not_recorded() {
+        // shell 惯例：以空格开头的命令不进历史（HISTCONTROL=ignorespace）。
+        // 我们若不遵守，等于把用户对系统历史的信任从背后捅穿。
+        let h = open("leadspace");
+        h.record("  curl -u user:pass http://x", "/", "h1", "A", true, None)
+            .unwrap();
+        h.record("", "/", "h1", "A", true, None).unwrap();
+        h.record("   ", "/", "h1", "A", true, None).unwrap();
+        let page = h.query(HistoryQuery::default()).unwrap();
+        assert_eq!(page.total, 0, "带前导空格与空命令都不应入库");
+    }
+
+    #[test]
+    fn short_keyword_uses_like_fallback() {
+        // trigram 索引对 <3 字符的查询静默返回空，必须走 LIKE 回退，
+        // 否则「搜 ls」会得到空结果 —— 而这正是最常用的搜索词之一。
+        let h = open("shortkw");
+        h.record("ls -la", "/", "h1", "A", true, None).unwrap();
+        h.record("git log", "/", "h1", "A", true, None).unwrap();
+        let page = h
+            .query(HistoryQuery {
+                keyword: "ls".to_string(),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(page.total, 1);
+        assert_eq!(page.items[0].command, "ls -la");
+    }
+
+    #[test]
+    fn keyword_with_quotes_and_operators_is_safe() {
+        // 命令里出现 `'` `"` `*` 是家常便饭（`awk '{print $1}'`、`ls *.rs`）。
+        // 既不能造成 SQL 注入，也不能让 FTS 语法报错。
+        let h = open("meta");
+        h.record("awk '{print $1}' file.txt", "/", "h1", "A", true, None)
+            .unwrap();
+        h.record("ls *.rs", "/", "h1", "A", true, None).unwrap();
+
+        let p1 = h
+            .query(HistoryQuery {
+                keyword: "awk '{print $1}'".to_string(),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(p1.total, 1, "含单引号的查询必须能命中且不报错");
+
+        let p2 = h
+            .query(HistoryQuery {
+                keyword: "ls *.rs".to_string(),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(p2.total, 1, "含通配符的查询应按字面量匹配");
+    }
+
+    #[test]
+    fn favorite_survives_prune_and_clear() {
+        let h = open("fav");
+        for i in 0..5 {
+            h.record(&format!("cmd{i}"), "/", "h1", "A", true, None)
+                .unwrap();
+        }
+        let page = h.query(HistoryQuery::default()).unwrap();
+        let fav_id = page.items[0].id;
+        assert!(h.toggle_favorite(fav_id).unwrap());
+
+        // 容量淘汰到 2 条：收藏项必须留下（即使它不在最新的 2 条里）
+        h.prune(2).unwrap();
+        let after = h.query(HistoryQuery::default()).unwrap();
+        assert_eq!(after.total, 3, "2 条最新 + 1 条收藏");
+        assert!(
+            after.items.iter().any(|i| i.id == fav_id),
+            "收藏项不应被容量淘汰"
+        );
+
+        // 保留式清空：收藏仍在
+        let removed = h.clear(true).unwrap();
+        assert_eq!(removed, 2);
+        let final_page = h.query(HistoryQuery::default()).unwrap();
+        assert_eq!(final_page.total, 1);
+        assert_eq!(final_page.items[0].id, fav_id);
+    }
+
+    #[test]
+    fn like_escape_handles_backslash_first() {
+        // `\` 必须最先替换，否则后续插入的反斜杠会被再次转义。
+        assert_eq!(escape_like("a%b"), "a\\%b");
+        assert_eq!(escape_like("a_b"), "a\\_b");
+        assert_eq!(escape_like("a\\b"), "a\\\\b");
+        // 混合场景：反斜杠 + 通配符
+        assert_eq!(escape_like("\\%"), "\\\\\\%");
+    }
+
+    #[test]
+    fn fts_phrase_escapes_double_quotes() {
+        // FTS5 的短语转义约定：内部 `"` 写成 `""`。
+        assert_eq!(fts_phrase("a\"b"), "\"a\"\"b\"");
+    }
+
+    #[test]
+    fn query_limit_is_clamped() {
+        let q = HistoryQuery {
+            limit: 99999,
+            offset: -5,
+            ..Default::default()
+        }
+        .normalized();
+        assert_eq!(q.limit, 500, "limit 上限 500");
+        assert_eq!(q.offset, 0, "offset 不为负");
+
+        let q2 = HistoryQuery::default().normalized();
+        assert_eq!(q2.limit, 100, "未指定时默认 100");
+    }
+
+    #[test]
+    fn host_filter_and_favorite_filter() {
+        let h = open("filters");
+        h.record("a", "/", "h1", "A", true, None).unwrap();
+        h.record("b", "/", "h2", "B", true, None).unwrap();
+        h.record("c", "/", "h1", "A", true, None).unwrap();
+
+        let by_host = h
+            .query(HistoryQuery {
+                host_id: "h1".to_string(),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(by_host.total, 2);
+
+        let page = by_host.clone();
+        h.toggle_favorite(page.items[0].id).unwrap();
+        let favs = h
+            .query(HistoryQuery {
+                favorited_only: true,
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(favs.total, 1);
+    }
+
+    #[test]
+    fn sources_aggregates_by_host_id() {
+        let h = open("sources");
+        h.record("a", "/", "h1", "A", true, None).unwrap();
+        h.record("b", "/", "h1", "A", true, None).unwrap();
+        h.record("c", "/", "h2", "B", true, None).unwrap();
+        h.record("d", "/", "", "", false, None).unwrap(); // 无来源，不参与聚合
+
+        let s = h.sources().unwrap();
+        assert_eq!(s.len(), 2);
+        // 按条数倒序：h1 有 2 条
+        assert_eq!(s[0].host_id, "h1");
+        assert_eq!(s[0].count, 2);
+    }
+
+    #[test]
+    fn migration_is_idempotent_on_reopen() {
+        // 同一目录重复打开不应报错，也不应因重复建表而丢失数据。
+        // `migrate` 在 version != 0 时跳过建表，这条用例正是守着那个分支。
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        static SEQ: AtomicUsize = AtomicUsize::new(0);
+        let n = SEQ.fetch_add(1, Ordering::Relaxed);
+        let dir = std::env::temp_dir().join(format!(
+            "thing-cmd-hist-test-reopen-{}-{n}",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_dir_all(&dir);
+
+        {
+            let h = History::new(&dir).expect("首次打开");
+            h.record("keepme", "/", "h1", "A", true, None).unwrap();
+        }
+
+        let h2 = History::new(&dir).expect("二次打开（v0 分支不应再执行）");
+        let page = h2.query(HistoryQuery::default()).unwrap();
+        assert_eq!(page.total, 1, "重开库不应清空数据");
+        assert_eq!(page.items[0].command, "keepme");
+    }
+}

src-tauri/src/terminal/mod.rs

@@ -0,0 +1,431 @@
+//! 终端模块：SSH 与本地 Shell 多会话终端。
+//!
+//! # 模块结构
+//!
+//! | 文件 | 职责 |
+//! |---|---|
+//! | [`session`] | `Session` trait 抽象 + `SessionRegistry`（本地/SSH 共用） |
+//! | [`pty::conpty`] | 本地 ConPTY 后端（含三个已知坑的处理） |
+//! | [`shell`] | Shell 探测、命令行组装、OSC 7 cwd 跟踪 |
+//! | [`ssh`] | SSH 后端（russh）、认证、主机密钥校验、SFTP |
+//! | [`keys`] | SSH 密钥生成/导入/管理 |
+//! | [`settings`] | 设置模型与默认值（容器级 `#[serde(default)]`） |
+//! | [`events`] | 事件负载类型 |
+//! | [`commands`] | Tauri 命令层（薄：整形/校验/归类） |
+//!
+//! # 为什么自带一套会话管理而不复用 `ProcessManager`
+//!
+//! 见 [`session`] 模块注释。一句话：`ProcessManager` 是「单例守护进程」模型，
+//! 终端要的是「N 个独立会话 + 双向流式 I/O + 退出不重启」，语义不同。
+//!
+//! # 数据目录
+//!
+//! ```text
+//! {app_data_dir}/terminal/
+//! ├── settings.json     设置、主机列表、密钥元数据
+//! ├── known_hosts.json  主机密钥指纹库（非机密，人可读可导出）
+//! ├── keys/             SSH 私钥文件本体
+//! └── hooks/            Shell cwd 跟踪临时脚本（Git Bash 用）
+//! ```
+//!
+//! # 凭据存储
+//!
+//! SSH 密码、私钥 passphrase 一律走 [`crate::secrets`]（系统凭据管理器，DPAPI）。
+//! 键名约定：
+//! - `terminal-ssh-password-{hostId}`
+//! - `terminal-key-passphrase-{keyId}`
+//!
+//! **本模块不存在任何读取凭据明文的命令**：列表接口只回传是否已配置与掩码串。
+
+pub mod assistant;
+pub mod audit;
+pub mod commands;
+pub mod encoding;
+pub mod events;
+pub mod history;
+pub mod keys;
+pub mod pty;
+pub mod session;
+pub mod settings;
+pub mod shell;
+pub mod ssh;
+pub mod window;
+
+use std::path::PathBuf;
+use std::sync::{Mutex, MutexGuard};
+
+use tauri::{AppHandle, Emitter, Manager};
+
+use session::SessionRegistry;
+use settings::TerminalSettings;
+
+/// 供 `pty::conpty` 与 `ssh` 共用的事件常量入口。
+///
+/// 两个后端都要 emit 事件，逐处写 `super::super::events::...` 可读性差且容易写错层级，
+/// 因此在这里做一次再导出，后端内部统一用 `crate::terminal::events::TERMINAL_*`。
+///
+/// 注：当前两个后端已改为直接引用 `crate::terminal::events::TERMINAL_*`，
+/// 此别名保留为对外稳定出口（避免下游按路径引用时因重构断链）。
+#[allow(unused_imports)]
+pub use crate::constants::events as event_names;
+
+/// 输出事件负载（两个后端共用）。同样作为对外出口保留。
+#[allow(unused_imports)]
+pub use events::OutputPayload;
+
+/// 终端模块管理器（Tauri State）。
+///
+/// 与 `TranslateManager` / `MusicManager` 平级，在 `setup::init` 中构造并 `manage`。
+pub struct TerminalManager {
+    /// 模块自身目录：`{app_data_dir}/terminal`
+    root: PathBuf,
+    /// 会话注册表（本地 + SSH 共用一张表，id 全局唯一）
+    pub sessions: SessionRegistry,
+    /// 活跃的 SFTP 通道（按会话 id 索引）。
+    ///
+    /// 放在 `TerminalManager` 而不是 `SessionRegistry` 上：SFTP 是**可选能力**，
+    /// 只有 SSH 会话且用户打开了文件面板才存在。挂在会话注册表上会让「会话」
+    /// 这个概念背负一个大多数情况下为空的字段。
+    pub sftp: ssh::sftp::SftpRegistry,
+    /// SSH 连接池（P2 连接复用）：同身份的多个会话共享一条 SSH 连接。
+    ///
+    /// 挂在 `TerminalManager` 上与 SFTP 同理——它是**跨会话**的资源，
+    /// 生命周期由池内引用计数管理（最后一个使用它的会话关闭时才断开）。
+    pub ssh_pool: ssh::pool::ConnectionPool,
+    /// 命令历史库（SQLite）。懒加载：`None` 表示尚未打开连接。
+    ///
+    /// 与 `settings` 一样懒加载：大多数会话（尤其是刚启动就开标签的场景）
+    /// 在第一次写入命令之前根本用不到历史库，没必要在 `TerminalManager::new`
+    /// 里同步打开一个 SQLite 连接（含 WAL 初始化与建表检查）。
+    pub history: Mutex<Option<history::History>>,
+    /// 命令历史后台 writer 的入队端。
+    ///
+    /// `record_command` 位于输出热路径上，此前每次都同步「settings 深拷贝 +
+    /// SQLite 写 + prune」；现在改为 `mpsc::send` 入队，由 [`history::spawn_writer`]
+    /// 的 writer 线程攒批落库。`None` 表示尚未启动（init_on_launch 时启动）。
+    history_tx: Mutex<Option<std::sync::mpsc::Sender<history::HistoryEntry>>>,
+    /// 设置缓存。`None` 表示尚未加载（懒加载，避免启动时多做一次磁盘 IO）
+    settings: Mutex<Option<TerminalSettings>>,
+}
+
+impl TerminalManager {
+    pub fn new(app_data_dir: PathBuf) -> Self {
+        let root = app_data_dir.join("terminal");
+        // 目录先行创建：后续 keys/ 与 hooks/ 都依赖它
+        std::fs::create_dir_all(root.join("keys")).ok();
+        std::fs::create_dir_all(root.join("hooks")).ok();
+        // logs/ 由 audit::toggle 按需创建（首次开启日志才落盘），此处不预建
+        Self {
+            root,
+            sessions: SessionRegistry::new(),
+            sftp: ssh::sftp::SftpRegistry::new(),
+            ssh_pool: ssh::pool::ConnectionPool::default(),
+            history: Mutex::new(None),
+            history_tx: Mutex::new(None),
+            settings: Mutex::new(None),
+        }
+    }
+
+    /// 取（必要时打开）命令历史库。
+    ///
+    /// `&self` + 内部 `Mutex<Option<..>>` 而非 `&mut self`：命令层拿到的是
+    /// `State<'_, TerminalManager>`，多个并发命令（比如历史面板在搜、同时
+    /// 另一个会话在写新命令）都会调到它，`&mut` 会把两者串行化。
+    ///
+    /// 打开失败**不缓存失败结果**（`left` 保持 `None`）：磁盘临时不可用、
+    /// 目录权限刚被修好这类情况应当允许后续调用重试。若把 `Err` 也当成
+    /// 「已初始化」，用户就得重启应用才能恢复历史功能。
+    pub fn history(&self) -> Result<std::sync::MutexGuard<'_, Option<history::History>>, String> {
+        let mut guard = self.history.lock().unwrap_or_else(|e| e.into_inner());
+        if guard.is_none() {
+            *guard = Some(history::History::new(&self.root)?);
+        }
+        Ok(guard)
+    }
+
+    pub fn root(&self) -> &PathBuf {
+        &self.root
+    }
+
+    /// 把一条命令历史入队（由后台 writer 攒批落库）。
+    ///
+    /// 通道不可用（writer 尚未启动或已退出）时退回同步写：
+    /// 「writer 死了历史就静默丢失」比「热路径偶尔慢一次」更糟。
+    pub fn queue_history(&self, mut entry: history::HistoryEntry) {
+        {
+            let guard = self.history_tx.lock().unwrap_or_else(|e| e.into_inner());
+            if let Some(tx) = guard.as_ref() {
+                match tx.send(entry) {
+                    Ok(()) => return,
+                    // writer 已退出：SendError 里带着原值，取回走同步兜底
+                    Err(e) => entry = e.0,
+                }
+            }
+        }
+        // 通道已断：同步兜底
+        if let Ok(guard) = self.history() {
+            if let Some(h) = guard.as_ref() {
+                if let Err(e) = h.record(
+                    &entry.command,
+                    &entry.cwd,
+                    &entry.host_id,
+                    &entry.host_name,
+                    entry.ssh,
+                    entry.exit_code,
+                ) {
+                    crate::logger::log_error(
+                        "terminal",
+                        &format!("写入命令历史失败（不影响会话）: {e}"),
+                    );
+                }
+                if let Err(e) = h.prune(0) {
+                    crate::logger::log_error("terminal", &format!("淘汰历史容量失败: {e}"));
+                }
+            }
+        }
+    }
+
+    /// 查 shell / 主机的显示名（供历史落库）。
+    ///
+    /// 此前 `record_command` 用 `settings()`（整份深拷贝，含全部主机、Shell、
+    /// 快捷键表）只为拿一个名字，而它在输出热路径上。这里改为持锁只读出
+    /// 需要的字段。
+    pub fn display_name(&self, target_id: &str, ssh: bool) -> String {
+        let guard = self.lock_settings();
+        let Some(s) = guard.as_ref() else {
+            return target_id.to_string();
+        };
+        if ssh {
+            s.hosts
+                .iter()
+                .find(|h| h.id == target_id)
+                .map(|h| h.name.clone())
+                .unwrap_or_else(|| target_id.to_string())
+        } else {
+            s.shells
+                .iter()
+                .find(|x| x.id == target_id)
+                .map(|x| x.name.clone())
+                .unwrap_or_else(|| target_id.to_string())
+        }
+    }
+
+    pub fn settings_path(&self) -> PathBuf {
+        self.root.join("settings.json")
+    }
+
+    /// 密钥文件存放目录。
+    pub fn keys_dir(&self) -> PathBuf {
+        self.root.join("keys")
+    }
+
+    /// cwd hook 脚本目录（Git Bash 的 `--init-file` 需要一个真实文件）。
+    pub fn hooks_dir(&self) -> PathBuf {
+        self.root.join("hooks")
+    }
+
+    /// 会话日志目录（`{app_data_dir}/terminal/logs/`）。
+    ///
+    /// 目录由 `audit::toggle` 按需创建：日志是可选能力，
+    /// 不为它预付一次磁盘 IO。
+    pub fn logs_dir(&self) -> PathBuf {
+        self.root.join("logs")
+    }
+
+    /// 读取设置（带缓存）。
+    ///
+    /// 首次调用会从磁盘读取并执行 `heal()`；若 `heal` 报告变更则立即落盘，
+    /// 避免「老配置每次启动都要自愈一遍」。
+    pub fn settings(&self) -> TerminalSettings {
+        let mut guard = self.lock_settings();
+        if let Some(s) = guard.as_ref() {
+            return s.clone();
+        }
+        let mut s = self.load_settings_from_disk();
+        if s.heal() {
+            if let Err(e) = self.write_settings_file(&s) {
+                crate::logger::log_error("terminal", &format!("自愈后保存设置失败: {e}"));
+            }
+        }
+        *guard = Some(s.clone());
+        s
+    }
+
+    /// 写入设置（覆盖缓存 + 落盘）。
+    pub fn save_settings(&self, mut next: TerminalSettings) -> Result<(), String> {
+        // 保存前自愈一次：前端可能提交了越界值（滚动缓冲、字体大小等）
+        next.heal();
+        self.write_settings_file(&next)?;
+        *self.lock_settings() = Some(next);
+        Ok(())
+    }
+
+    /// 局部修改设置：读 → 改 → 写。避免前端为了改一个字段而回传整份设置
+    /// （回传整份会带来「前端旧快照覆盖后端新值」的竞态）。
+    pub fn update_settings<F>(&self, f: F) -> Result<TerminalSettings, String>
+    where
+        F: FnOnce(&mut TerminalSettings),
+    {
+        let mut s = self.settings();
+        f(&mut s);
+        self.save_settings(s.clone())?;
+        Ok(s)
+    }
+
+    /// 从磁盘读取。文件不存在或解析失败时返回默认值——
+    /// 配置文件损坏不该让整个模块不可用（用户至少还能新建会话）。
+    fn load_settings_from_disk(&self) -> TerminalSettings {
+        let path = self.settings_path();
+        match std::fs::read_to_string(&path) {
+            Ok(raw) => match serde_json::from_str::<TerminalSettings>(&raw) {
+                Ok(s) => s,
+                Err(e) => {
+                    // 备份损坏文件再退回默认：直接覆盖会让用户丢失可手工修复的内容
+                    let bak = path.with_extension("json.broken");
+                    let _ = std::fs::rename(&path, &bak);
+                    crate::logger::log_error(
+                        "terminal",
+                        &format!(
+                            "设置解析失败（已备份至 {}）: {e}",
+                            bak.display()
+                        ),
+                    );
+                    TerminalSettings::default()
+                }
+            },
+            Err(_) => TerminalSettings::default(),
+        }
+    }
+
+    fn write_settings_file(&self, s: &TerminalSettings) -> Result<(), String> {
+        let path = self.settings_path();
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| format!("创建配置目录失败: {e}"))?;
+        }
+        let json = serde_json::to_string_pretty(s).map_err(|e| format!("序列化设置失败: {e}"))?;
+        // 先写临时文件再 rename：避免写入中途崩溃留下半截 JSON
+        let tmp = path.with_extension("json.tmp");
+        std::fs::write(&tmp, json).map_err(|e| format!("写入设置失败: {e}"))?;
+        std::fs::rename(&tmp, &path).map_err(|e| format!("保存设置失败: {e}"))
+    }
+
+    /// 统一的锁获取：中毒时取回内部值。
+    ///
+    /// 设置结构本身没有跨字段不变量（每个字段独立），因此「中毒」不代表数据
+    /// 已损坏，直接 panic 反而会把一次无关的线程崩溃放大成整个模块不可用。
+    fn lock_settings(&self) -> MutexGuard<'_, Option<TerminalSettings>> {
+        self.settings.lock().unwrap_or_else(|e| e.into_inner())
+    }
+
+    /// 刷新 Shell 探测结果并写回设置。
+    ///
+    /// 返回完整的 Shell 列表（含用户自定义项）。用户在设置页点「重新探测」时调用。
+    pub fn refresh_shells(&self) -> Result<Vec<settings::ShellProfile>, String> {
+        let current = self.settings();
+        let merged = shell::detect_and_merge(&current.shells);
+        let result = merged.clone();
+        self.update_settings(|s| {
+            s.shells = merged;
+        })?;
+        Ok(result)
+    }
+
+    /// 应用退出清理：关闭所有会话。
+    ///
+    /// **不等待**。ConPTY 的 `ClosePseudoConsole` 会阻塞到所有句柄关闭，
+    /// 退出路径上等待会卡死（参照 `MonitorKernel` 的教训——那里用了独立线程
+    /// + `recv_timeout(3s)` 防挂起）。会话侧已把关闭动作放进后台线程，
+    /// 进程终止时 OS 回收剩余资源。
+    pub fn cleanup_on_exit(&self) {
+        let n = self.sessions.len();
+        if n > 0 {
+            crate::logger::log_info("terminal", &format!("退出：关闭 {n} 个会话"));
+        }
+        // 先关 SFTP 通道：它们与 shell 共用同一条 TCP 连接，若先关连接，
+        // SFTP 侧的 close 报文会写到已关闭的 socket 上（在日志里留下一串噪音）。
+        let ids: Vec<String> = self.sessions.list().into_iter().map(|s| s.id).collect();
+        for id in ids {
+            self.sftp.close(&id);
+        }
+        // 丢弃历史 writer 的入队端：writer 会把通道里剩余的记录写完后自然退出
+        // （不 join —— 退出路径上不做任何等待，见本函数头部注释）
+        *self.history_tx.lock().unwrap_or_else(|e| e.into_inner()) = None;
+        self.sessions.close_all();
+    }
+
+    /// 在应用启动时初始化：预创建 hooks 目录、刷新 Shell 探测、按需注册全局快捷键。
+    ///
+    /// **不发任何网络请求**（沿用 translate 模块的姿态）：SSH 连接只在用户
+    /// 主动打开会话时建立。
+    pub fn init_on_launch(&self, app: &AppHandle) {
+        // 首次运行或探测结果为空时做一次 Shell 探测
+        let s = self.settings();
+        if s.shells.is_empty() {
+            if let Err(e) = self.refresh_shells() {
+                crate::logger::log_error("terminal", &format!("Shell 探测失败: {e}"));
+            }
+        } else {
+            // 已有配置也要重新探测：用户可能升级/卸载了 PowerShell 7。
+            // 失败不阻断启动。
+            if let Err(e) = self.refresh_shells() {
+                crate::logger::log_warn("terminal", &format!("Shell 重探测失败（沿用旧配置）: {e}"));
+            }
+        }
+
+        // 清理上次运行遗留的 hook 脚本（内容每次都重新生成，不会丢信息）
+        let hooks = self.hooks_dir();
+        if let Ok(entries) = std::fs::read_dir(&hooks) {
+            for e in entries.flatten() {
+                if e.path().extension().map_or(false, |x| x == "sh") {
+                    let _ = std::fs::remove_file(e.path());
+                }
+            }
+        }
+
+        // 启动命令历史后台 writer（见 `history_tx` 字段的说明）
+        *self.history_tx.lock().unwrap_or_else(|e| e.into_inner()) =
+            Some(history::spawn_writer(app.clone()));
+
+        let _ = app; // 全局快捷键由前端 store 在模块启用时注册（与截图模块同一范式）
+    }
+}
+
+/// 从 Tauri State 取 TerminalManager。
+pub fn manager(app: &AppHandle) -> Result<tauri::State<'_, TerminalManager>, String> {
+    app.try_state::<TerminalManager>()
+        .ok_or_else(|| "终端模块未初始化".to_string())
+}
+
+/// 发射 SFTP 传输进度事件。
+///
+/// 转发到 [`events::emit_transfer`]，在 `terminal` 根上再导出一层是为了让命令层
+/// 写 `crate::terminal::emit_transfer(...)` 与 `emit_state` 保持同一路径风格。
+pub fn emit_transfer(app: &AppHandle, payload: &ssh::sftp::TransferProgress) {
+    events::emit_transfer(app, payload);
+}
+
+/// 发射会话状态事件。
+///
+/// # 为什么需要这个统一入口
+///
+/// 两个后端（ConPTY / SSH）在**六处**要更新状态：连接中、已认证、已建立、
+/// 降级、关闭、失败。若每处各自 `emit(TERMINAL_STATE, session.info())`，
+/// 就会出现「某处忘了 emit，前端状态点停在旧值」这类难查的不一致。
+/// 集中到一处后，「改状态」与「广播状态」永远成对发生。
+///
+/// `final_state` 参数是**显式传入**而非从 `info()` 读取的：调用方常常是在
+/// 刚写入状态、但 `info()` 还持有旧值的时间窗内调用（各自持有不同 Mutex），
+/// 传参能避免这个竞态。
+pub fn emit_state(
+    app: &AppHandle,
+    state: &session::LocalSessionState,
+    final_state: session::SessionState,
+    error: Option<String>,
+) {
+    if let Some(err) = error.as_ref() {
+        *state.error.lock().unwrap_or_else(|e| e.into_inner()) = Some(err.clone());
+    }
+    let mut info = session::local_info(state, session::SessionKind::Local);
+    info.state = final_state;
+    let _ = app.emit(crate::constants::events::TERMINAL_STATE, info);
+}

src-tauri/src/terminal/pty/conpty.rs

@@ -0,0 +1,746 @@
+//! ConPTY 绑定与本地会话实现。
+//!
+//! 直接绑定 `windows-sys` 的 `CreatePseudoConsole` 系列 API（而非引入
+//! `portable-pty` 之类的封装）。理由：本项目已有大量原生 Win32 调用
+//! （`win32_util.rs` / `screenshot/wgc_capture.rs` / `translate/capture/uia_capture.rs`），
+//! 这条路径熟悉；而 ConPTY 的三个坑（见下）无论加不加封装都要踩，多一层只增加定位难度。
+//!
+//! # ConPTY 的三个坑（全部已在实现中处理）
+//!
+//! 1. **`ClosePseudoConsole` 会阻塞**，直到所有引用该 PTY 的句柄被关闭。若在读线程
+//!    仍挂起于 `ReadFile` 时调用，就会永久卡住。处理：先 `CancelIoEx` 取消挂起的读，
+//!    再在**独立线程**里调用 `ClosePseudoConsole`，调用方不等待（见 [`ConPtySession::kill`]）。
+//!
+//! 2. **`ResizePseudoConsole` 有早期竞态**：进程刚创建、还没开始读 stdout 时调用，
+//!    尺寸可能被吞掉（表现为 TUI 程序启动后按 80×24 而不是实际尺寸绘制，vim/htop 花屏）。
+//!    处理：首帧输出到达前，resize 请求只入队不执行；首帧到达后再应用队列中的最新值
+//!    （见 [`PtyInner::pending_size`]）。
+//!
+//! 3. **进程退出 ≠ PTY 关闭**：子进程退出后，管道里可能还有未读完的输出（如最后一行
+//!    提示符、错误信息）。必须等 `ReadFile` 返回 0 或 `ERROR_BROKEN_PIPE` 才算真正结束，
+//!    否则会丢掉尾部输出——这正是很多自制终端「退出时少一行」的原因。
+//!
+//! # 线程模型
+//!
+//! 每个会话起 **两个** 后台线程：
+//! - 输出读线程：循环 `ReadFile`，把数据推入聚合缓冲，按 8~16ms 窗口发批次事件。
+//! - 退出等待线程：`WaitForSingleObject` 等子进程句柄，拿退出码，等读线程自然结束
+//!   （即坑 3）后把状态置为 `Closed` 并发事件。
+//!
+//! 写操作不单独起线程：`WriteFile` 在 ConPTY 上通常不阻塞（有内部缓冲），
+//! 由命令层直接同步调用。若未来证实大块粘贴会阻塞，再改成写队列。
+
+use std::io::{ErrorKind, Read, Write};
+use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use tauri::{AppHandle, Emitter};
+use windows_sys::Win32::Foundation::{CloseHandle, HANDLE, INVALID_HANDLE_VALUE};
+use windows_sys::Win32::System::Console::{
+    ClosePseudoConsole, CreatePseudoConsole, ResizePseudoConsole, COORD, HPCON,
+};
+use windows_sys::Win32::System::Threading::{
+    CreateProcessW, GetExitCodeProcess, TerminateProcess, WaitForSingleObject,
+    CREATE_UNICODE_ENVIRONMENT, EXTENDED_STARTUPINFO_PRESENT, PROCESS_INFORMATION,
+    STARTUPINFOEXW,
+};
+
+use super::super::session::{
+    local_info, LocalSessionState, Session, SessionId, SessionInfo, SessionKind, SessionState,
+};
+
+/// 输出聚合窗口。
+///
+/// 8ms 是权衡值：`cat` 大文件时每秒可产生数万次 `ReadFile` 返回，逐条 emit 会压垮
+/// WebView；但窗口太长（如 50ms）会让交互式输入出现可感知的延迟。8ms 约等于
+/// 一帧（120Hz），人眼无法分辨，同时能把数千次读合并成一次事件。
+const AGGREGATE_WINDOW: Duration = Duration::from_millis(8);
+
+/// 单次读缓冲区大小。64KB 与 ConPTY 内部缓冲匹配，避免多次往返。
+const READ_BUF_SIZE: usize = 64 * 1024;
+
+/// 聚合缓冲上限：防止「疯狂输出且前端卡住」时内存无限增长。
+/// 超出后丢弃**最旧**的数据（终端语义：用户更关心最新的输出）。
+const MAX_PENDING_BYTES: usize = 4 * 1024 * 1024;
+
+/// 会话终止时附加到输出的提示（由 Rust 侧统一给出，避免前端各写一套）。
+const EXIT_HINT: &str = "\r\n";
+
+// ===== 共享状态 =====
+
+struct PtyInner {
+    /// PTY 句柄。`Mutex` 保护是因为 resize 需要并发访问，而 ClosePseudoConsole
+    /// 会把它置为 None（表示已关闭，后续调用应静默忽略）。
+    hpc: Mutex<Option<HPCON>>,
+    /// 写入端（我们 → 伪控制台输入）。`Option` 以便 kill 后释放。
+    writer: Mutex<Option<std::fs::File>>,
+    /// 子进程句柄，用于退出等待与强制终止。
+    process: Mutex<Option<OwnedHandle>>,
+    /// 是否已收到首帧输出（ConPTY resize 竞态的处理依据，见模块注释坑 2）。
+    first_output_seen: AtomicBool,
+    /// 首帧之前缓存的尺寸请求。
+    pending_size: Mutex<Option<(u16, u16)>>,
+    /// 是否已关闭（幂等保护）。
+    closed: AtomicBool,
+}
+
+/// 本地 ConPTY 会话。
+pub struct ConPtySession {
+    pub state: Arc<LocalSessionState>,
+    inner: Arc<PtyInner>,
+    /// 事件发射器。持有 `AppHandle` 而非 `Window`：会话可以「提升」为独立窗口
+    /// （见 `terminal_detach_session`），事件应发给所有窗口而不是绑定的那一个。
+    app: AppHandle,
+    /// 输出批次序号（每会话独立计数，前端按会话校验连续性）。
+    seq: AtomicU64,
+}
+
+impl ConPtySession {
+    /// 启动一个本地 Shell 会话。
+    ///
+    /// `command_line` 必须是**完整的命令行**（含可执行文件路径）。Windows 的
+    /// `CreateProcessW` 在传入 `lpApplicationName = NULL` 时会自行解析命令行首段
+    /// 作为可执行文件，因此需要调用方保证路径带引号（见 [`super::super::shell::build_command_line`]）。
+    pub fn spawn(
+        app: AppHandle,
+        id: SessionId,
+        shell_id: String,
+        shell_name: String,
+        command_line: String,
+        cwd: Option<String>,
+        env: Vec<(String, String)>,
+        cols: u16,
+        rows: u16,
+    ) -> Result<Self, String> {
+        let state = Arc::new(LocalSessionState::new(id.clone(), shell_id, shell_name));
+        *state.size.lock().unwrap_or_else(|e| e.into_inner()) = (cols, rows);
+
+        // ===== 1. 创建一对匿名管道 =====
+        // ConPTY 需要「输入管道」（我们写、PTY 读）与「输出管道」（PTY 写、我们读）。
+        let (input_read, input_write) = create_pipe()?;
+        let (output_read, output_write) = create_pipe()?;
+
+        // ===== 2. 创建伪控制台 =====
+        let size = COORD {
+            X: cols as i16,
+            Y: rows as i16,
+        };
+        let mut hpc: HPCON = 0;
+        // SAFETY: 传入的两个句柄是本函数刚创建的、有效的管道端；
+        // size 已按 COORD 的 i16 范围做了钳制（见 clamp_dim）。
+        let hr = unsafe {
+            CreatePseudoConsole(size, input_read.as_raw_handle() as HANDLE, output_write.as_raw_handle() as HANDLE, 0, &mut hpc)
+        };
+        if hr < 0 {
+            return Err(format!("CreatePseudoConsole 失败（HRESULT: 0x{hr:08X}）"));
+        }
+
+        // 创建后立即关掉我们持有的这两端：
+        // - input_read：PTY 已持有自己的副本，我们只保留写端
+        // - output_write：同理，我们只保留读端
+        // 若不关闭，读端永远等不到 EOF（因为写端仍被本进程持有），
+        // 表现为「会话关闭后读线程不退出」，进而导致 ClosePseudoConsole 卡死（坑 1）。
+        drop(input_read);
+        drop(output_write);
+
+        // ===== 3. 组装 STARTUPINFOEX 并把 PTY 传给子进程 =====
+        let mut si: STARTUPINFOEXW = unsafe { std::mem::zeroed() };
+        si.StartupInfo.cb = std::mem::size_of::<STARTUPINFOEXW>() as u32;
+        // 必须设置这两个标志：
+        // - EXTENDED_STARTUPINFO_PRESENT：让系统读 attribute list 里的 HPCON
+        // - CREATE_UNICODE_ENVIRONMENT：环境块是 UTF-16
+        let mut pi: PROCESS_INFORMATION = unsafe { std::mem::zeroed() };
+
+        // 把 HPCON 放进进程属性列表。这一步用 ATTRIBUTE 常量的原始值即可，
+        // 不必引入 PROCTHREAD_ATTRIBUTE 类型（windows-sys 未导出便捷构造器）。
+        const PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE: usize = 0x0002_0016;
+        let mut attr_size: usize = 0;
+        unsafe {
+            // 第一次调用取所需大小
+            InitializeProcThreadAttributeList(std::ptr::null_mut(), 1, 0, &mut attr_size);
+        }
+        let mut attr_buf = vec![0u8; attr_size];
+        let attr_list = attr_buf.as_mut_ptr() as *mut _;
+        // SAFETY: attr_buf 按 API 报告的大小分配；attr_size 已由上一次调用写入。
+        let ok = unsafe { InitializeProcThreadAttributeList(attr_list, 1, 0, &mut attr_size) };
+        if ok == 0 {
+            unsafe { ClosePseudoConsole(hpc) };
+            return Err(format!(
+                "InitializeProcThreadAttributeList 失败: {}",
+                std::io::Error::last_os_error()
+            ));
+        }
+        // SAFETY: attr_list 已初始化且声明可容纳 1 个属性；hpc 是有效的 HPCON。
+        //
+        // 注意 windows-sys 0.52 里 `HPCON = isize`（0.59+ 才是 `*mut c_void`）。
+        // `isize as *const c_void` 是不允许的直接转型（E0641），
+        // 必须先转成 `usize` 再转指针——两步都是明确的大小的整数/指针转换。
+        let hpc_ptr = hpc as usize as *const std::ffi::c_void;
+        let ok = unsafe {
+            UpdateProcThreadAttribute(
+                attr_list,
+                0,
+                PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
+                hpc_ptr,
+                std::mem::size_of::<HPCON>(),
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+            )
+        };
+        if ok == 0 {
+            let e = std::io::Error::last_os_error();
+            unsafe {
+                DeleteProcThreadAttributeList(attr_list);
+                ClosePseudoConsole(hpc);
+            }
+            return Err(format!("UpdateProcThreadAttribute 失败: {e}"));
+        }
+        si.lpAttributeList = attr_list;
+
+        // ===== 4. 组装环境块与命令行 =====
+        let env_block = build_env_block(&env)?;
+        let mut cmdline: Vec<u16> = command_line.encode_utf16().chain(std::iter::once(0)).collect();
+        let cwd_wide: Option<Vec<u16>> = cwd
+            .as_ref()
+            .filter(|s| !s.trim().is_empty())
+            .map(|s| s.encode_utf16().chain(std::iter::once(0)).collect());
+
+        // ===== 5. 创建进程 =====
+        // SAFETY: 所有指针都指向本函数栈/堆上的有效数据，且在调用期间存活；
+        // cmdline 是可变的（CreateProcessW 可能原地修改它，这是 API 约定）。
+        let created = unsafe {
+            CreateProcessW(
+                std::ptr::null(),                                  // 让系统从命令行解析可执行文件
+                cmdline.as_mut_ptr(),                              // 可写缓冲
+                std::ptr::null(),                                  // 默认进程安全属性
+                std::ptr::null(),                                  // 默认线程安全属性
+                0,                                                 // 不继承句柄（PTY 走属性列表传递）
+                EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT,
+                env_block.as_ptr() as *const std::ffi::c_void,     // 环境块
+                cwd_wide.as_ref().map_or(std::ptr::null(), |s| s.as_ptr()),
+                &si.StartupInfo,
+                &mut pi,
+            )
+        };
+
+        // 无论成功与否，属性列表都可以释放了（系统已复制所需信息）
+        unsafe {
+            DeleteProcThreadAttributeList(attr_list);
+        }
+
+        if created == 0 {
+            let e = std::io::Error::last_os_error();
+            unsafe { ClosePseudoConsole(hpc) };
+            return Err(format!("创建进程失败: {e}"));
+        }
+
+        // 主线程句柄用不到，立即关闭（进程句柄保留，用于等待退出）
+        unsafe { CloseHandle(pi.hThread) };
+
+        // ===== 6. 组装会话对象 =====
+        // `create_pipe` 已直接返回 `File`（在内部完成裸句柄 → `File` 的转换），
+        // 此处不再做二次转换——早前那版把 `File` 当句柄再转一次，
+        // 会触发 `expected isize, found File` 的类型错误。
+        let writer = input_write;
+        let reader = output_read;
+        let process = unsafe { OwnedHandle::from_raw_handle(pi.hProcess as *mut _) };
+
+        let inner = Arc::new(PtyInner {
+            hpc: Mutex::new(Some(hpc)),
+            writer: Mutex::new(Some(writer)),
+            process: Mutex::new(Some(process)),
+            first_output_seen: AtomicBool::new(false),
+            pending_size: Mutex::new(None),
+            closed: AtomicBool::new(false),
+        });
+
+        let session = Self {
+            state: state.clone(),
+            inner: inner.clone(),
+            app: app.clone(),
+            seq: AtomicU64::new(0),
+        };
+
+        session.set_state(SessionState::Established, None);
+
+        // ===== 7. 启动读线程与退出等待线程 =====
+        spawn_reader(app.clone(), state.clone(), inner.clone(), reader);
+        spawn_waiter(app, state.clone(), inner, session.seq_counter());
+
+        Ok(session)
+    }
+
+    /// 输出序号计数器（每会话独立；前端按会话分别校验连续性）。
+    fn seq_counter(&self) -> Arc<AtomicU64> {
+        // 这里刻意返回一个独立计数器：`ConPtySession` 自身可能被 move 进
+        // 注册表，而读线程需要在 move 之前就拿到它。两者通过 Arc 共享。
+        Arc::new(AtomicU64::new(self.seq.load(Ordering::Relaxed)))
+    }
+}
+
+/// 管道创建：返回 (读端, 写端) 两个 `File`。
+fn create_pipe() -> Result<(std::fs::File, std::fs::File), String> {
+    use std::os::windows::io::FromRawHandle;
+    use windows_sys::Win32::System::Pipes::CreatePipe;
+
+    let mut read: HANDLE = INVALID_HANDLE_VALUE;
+    let mut write: HANDLE = INVALID_HANDLE_VALUE;
+    // SAFETY: 两个 out 参数都指向本函数栈上的有效 HANDLE 变量；
+    // 安全属性传 null 表示句柄不可继承（我们不需要子进程继承管道本身）。
+    let ok = unsafe { CreatePipe(&mut read, &mut write, std::ptr::null(), 0) };
+    if ok == 0 {
+        return Err(format!(
+            "CreatePipe 失败: {}",
+            std::io::Error::last_os_error()
+        ));
+    }
+    // SAFETY: CreatePipe 成功返回后，read/write 都是有效的、由我们独占的句柄。
+    unsafe {
+        Ok((
+            std::fs::File::from_raw_handle(read as *mut _),
+            std::fs::File::from_raw_handle(write as *mut _),
+        ))
+    }
+}
+
+/// 构造 UTF-16 环境块（`KEY=VALUE\0...\0\0`）。
+///
+/// 从 `std::env::vars()` 出发做增量修改，而不是从空环境开始：Windows 上进程
+/// 需要 `SystemRoot` / `PATH` / `USERPROFILE` 等继承变量才能正常工作。
+/// 值为空串表示**删除**该变量（前端用「清空值」表达删除意图，比另设开关直观）。
+fn build_env_block(overrides: &[(String, String)]) -> Result<Vec<u16>, String> {
+    let mut map: std::collections::BTreeMap<String, String> = std::env::vars().collect();
+    // 未设置会影响 shell 提示符与编码；显式补齐（用户 override 可覆盖）
+    map.entry("TERM".to_string()).or_insert_with(|| "xterm-256color".to_string());
+    for (k, v) in overrides {
+        if v.is_empty() {
+            map.remove(k);
+        } else {
+            map.insert(k.clone(), v.clone());
+        }
+    }
+
+    let mut block = Vec::with_capacity(4096);
+    for (k, v) in map {
+        // 环境块不允许 key 含 '='（Windows 用它分隔键值）
+        if k.contains('=') || k.is_empty() {
+            continue;
+        }
+        block.extend(format!("{k}={v}").encode_utf16());
+        block.push(0);
+    }
+    block.push(0); // 双 null 结尾
+    Ok(block)
+}
+
+/// 输出读线程：读 → 聚合 → 发批次事件。
+///
+/// 三种结束条件（都发 `terminal-exit`，但来源不同）：
+/// 1. `ReadFile` 返回 0（EOF）—— 正常结束
+/// 2. `ERROR_BROKEN_PIPE` / `ERROR_OPERATION_ABORTED` —— PTY 被关闭（kill 路径）
+/// 3. 其他 IO 错误 —— 异常，上报 error
+fn spawn_reader(
+    app: AppHandle,
+    state: Arc<LocalSessionState>,
+    inner: Arc<PtyInner>,
+    mut reader: std::fs::File,
+) {
+    std::thread::spawn(move || {
+        let mut buf = vec![0u8; READ_BUF_SIZE];
+        let mut pending: Vec<u8> = Vec::with_capacity(READ_BUF_SIZE);
+        let mut last_flush = Instant::now();
+        // OSC 序列扫描的拼接缓冲：序列可能被切在两批数据之间（见 shell::parse_control_sequences）
+        let mut osc_tail: Vec<u8> = Vec::new();
+        // 命令历史累积器（见 session::CommandAccumulator）。
+        // 由本读线程独占持有 —— 只在读线程里被访问，不需要共享。
+        let sim = crate::terminal::session::CommandAccumulator::new();
+        // 上一批发送的序号，用于退出时把 batch 序号一并回传（前端据此判断有无丢包）
+        let mut last_seq: u64 = 0;
+
+        loop {
+            match reader.read(&mut buf) {
+                Ok(0) => break, // EOF：坑 3 的正解，子进程退出后管道仍可能有残余数据
+                Ok(n) => {
+                    pending.extend_from_slice(&buf[..n]);
+
+                    // 首帧到达：应用之前排队的尺寸（坑 2）
+                    if !inner.first_output_seen.swap(true, Ordering::SeqCst) {
+                        if let Some((cols, rows)) = inner
+                            .pending_size
+                            .lock()
+                            .unwrap_or_else(|e| e.into_inner())
+                            .take()
+                        {
+                            apply_resize(&inner, cols, rows);
+                        }
+                    }
+
+                    // cwd / 标题 / 命令边界跟踪：在**原始字节**上解析，且解析结果不从前端输出里剔除。
+                    //
+                    // 为什么保留 OSC 7 原文发给前端：xterm 会自行忽略它，而保留原文让
+                    // 「会话输出日志」可以原样重放（P2 的审计功能）。剔除反而会引入
+                    // 一份「两份流不一致」的隐患。
+                    crate::terminal::session::scan_control_sequences(
+                        &app,
+                        &state,
+                        &mut osc_tail,
+                        &buf[..n],
+                        &sim,
+                    );
+
+                    // 聚合窗口到了就发一批
+                    if last_flush.elapsed() >= AGGREGATE_WINDOW {
+                        last_seq = flush_output(&app, &state, &mut pending).unwrap_or(last_seq);
+                        last_flush = Instant::now();
+                    } else if pending.len() > MAX_PENDING_BYTES {
+                        // 前端卡住导致积压：丢弃最旧的一半，保留最新输出
+                        let drop_len = pending.len() - MAX_PENDING_BYTES / 2;
+                        pending.drain(..drop_len);
+                        crate::logger::log_warn(
+                            "terminal",
+                            &format!(
+                                "会话 {} 输出积压超限，已丢弃 {} 字节最旧数据",
+                                state.id, drop_len
+                            ),
+                        );
+                    }
+                }
+                Err(e) => {
+                    // BROKEN_PIPE / OPERATION_ABORTED 是 kill 路径的正常表现，不算错误
+                    if e.kind() != ErrorKind::BrokenPipe && e.raw_os_error() != Some(995) {
+                        crate::logger::log_error(
+                            "terminal",
+                            &format!("会话 {} 读取失败: {e}", state.id),
+                        );
+                    }
+                    break;
+                }
+            }
+
+            // 有未发出的剩余数据时，退化为「尽快发出」：
+            // 交互式场景下提示符必须立刻可见，不能等满一个窗口
+            if !pending.is_empty() && last_flush.elapsed() >= AGGREGATE_WINDOW {
+                last_seq = flush_output(&app, &state, &mut pending).unwrap_or(last_seq);
+                last_flush = Instant::now();
+            }
+        }
+
+        // 读线程结束前把残留数据全部发出（否则最后一行提示符会丢）
+        if let Some(s) = flush_output(&app, &state, &mut pending) {
+            last_seq = s;
+        }
+
+        // 读线程结束即代表 PTY 侧已无更多数据，此时可以安全关闭 PTY（坑 1 的正解）
+        close_pty_background(&inner);
+
+        // 更新状态并发状态事件：若已被 waiter 置为 Closed 则保持 Closed 不变
+        let final_state = {
+            let mut st = state.state.lock().unwrap_or_else(|e| e.into_inner());
+            if *st != SessionState::Closed && *st != SessionState::Failed {
+                *st = SessionState::Closed;
+            }
+            *st
+        };
+        let _ = last_seq;
+        crate::terminal::emit_state(&app, &state, final_state, None);
+        let _ = app.emit(
+            crate::terminal::events::TERMINAL_EXIT,
+            crate::terminal::events::ExitPayload {
+                session_id: state.id.clone(),
+                exit_code: *state.exit_code.lock().unwrap_or_else(|e| e.into_inner()),
+                reason: Some("eof".to_string()),
+            },
+        );
+    });
+}
+
+// OSC 7（cwd）/ OSC 0,2（标题）/ OSC 133（命令边界）的扫描与落库
+// 全部委托给 `session::scan_control_sequences`。
+//
+// 这里此前有一份与本文件同源的实现，SSH 后端另有一份几乎相同的拷贝。
+// P1 加命令历史时把两份合一了 —— 否则「OSC 133 解析 + 落库」要在两处各写一遍，
+// 任何一处漏掉都表现为「只有本地会话有历史」这类按后端分支的诡异 bug。
+// 具体理由与实现见 `session.rs` 中该函数的长注释。
+
+/// 退出等待线程：等子进程结束 → 拿退出码 → 等读线程收尾。
+fn spawn_waiter(
+    app: AppHandle,
+    state: Arc<LocalSessionState>,
+    inner: Arc<PtyInner>,
+    _seq: Arc<AtomicU64>,
+) {
+    std::thread::spawn(move || {
+        // 取出进程句柄（不 take，kill 也要用）
+        let handle = {
+            let g = inner.process.lock().unwrap_or_else(|e| e.into_inner());
+            g.as_ref().map(|h| h.as_raw_handle() as HANDLE)
+        };
+        let Some(h) = handle else { return };
+
+        // SAFETY: h 是本会话持有的有效进程句柄；无限等待直到进程退出。
+        let _ = unsafe { WaitForSingleObject(h, u32::MAX) };
+
+        let mut code: u32 = 0;
+        // SAFETY: h 有效且进程已退出，GetExitCodeProcess 会写入 code。
+        let ok = unsafe { GetExitCodeProcess(h, &mut code) };
+        if ok != 0 {
+            *state.exit_code.lock().unwrap_or_else(|e| e.into_inner()) = Some(code as i32);
+        }
+
+        // 注意：这里**不**立刻置 Closed。进程退出后管道里可能还有尾部输出，
+        // 要等读线程把残余数据发完（坑 3）。读线程结束时会把状态置为 Closed。
+        // 但若进程是被 kill 且读线程已退出，这里的 emit 就成了唯一通知。
+        let already_closed = {
+            let st = state.state.lock().unwrap_or_else(|e| e.into_inner());
+            *st == SessionState::Closed
+        };
+        if !already_closed {
+            // 给读线程一点时间收尾（正常会在 8ms 内完成）
+            std::thread::sleep(Duration::from_millis(50));
+            let st_closed = {
+                let st = state.state.lock().unwrap_or_else(|e| e.into_inner());
+                *st == SessionState::Closed
+            };
+            if !st_closed {
+                *state.state.lock().unwrap_or_else(|e| e.into_inner()) = SessionState::Closed;
+                close_pty_background(&inner);
+                let _ = app.emit(
+                    crate::terminal::events::TERMINAL_EXIT,
+                    crate::terminal::events::ExitPayload {
+                        session_id: state.id.clone(),
+                        exit_code: *state.exit_code.lock().unwrap_or_else(|e| e.into_inner()),
+                        reason: Some("process-exit".to_string()),
+                    },
+                );
+            }
+        }
+    });
+}
+
+/// 把聚合缓冲发成一批事件。返回本次批次序号（缓冲为空时返回 `None`）。
+fn flush_output(app: &AppHandle, state: &LocalSessionState, pending: &mut Vec<u8>) -> Option<u64> {
+    if pending.is_empty() {
+        return None;
+    }
+    // 会话日志（audit）在 clear 之前写：保证日志与前端所见完全一致
+    crate::terminal::audit::write(&state.id, pending);
+    use base64::Engine;
+    let data = base64::engine::general_purpose::STANDARD.encode(&pending);
+    pending.clear();
+
+    let seq = SEQ.fetch_add(1, Ordering::Relaxed) + 1;
+    let _ = app.emit(
+        crate::terminal::events::TERMINAL_OUTPUT,
+        crate::terminal::events::OutputPayload {
+            session_id: state.id.clone(),
+            data,
+            seq,
+        },
+    );
+    Some(seq)
+}
+
+/// 全局输出批次序号。
+///
+/// 用全局计数器而非每会话计数器：前端校验连续性只需一个单调序列，
+/// 且跨会话的绝对顺序在排查问题时更有价值（能看出「哪个会话先输出」）。
+static SEQ: AtomicU64 = AtomicU64::new(0);
+
+/// 取下一个全局输出批次序号。
+///
+/// 对 SSH 后端开放（见 `ssh::flush_output`）：两种后端共用同一序列，
+/// 前端只需一套连续性校验逻辑。
+pub fn next_global_seq() -> u64 {
+    SEQ.fetch_add(1, Ordering::Relaxed) + 1
+}
+
+/// 应用尺寸变更（真正调用 ResizePseudoConsole）。
+fn apply_resize(inner: &PtyInner, cols: u16, rows: u16) {
+    let g = inner.hpc.lock().unwrap_or_else(|e| e.into_inner());
+    let Some(hpc) = *g else { return };
+    let size = COORD {
+        X: clamp_dim(cols) as i16,
+        Y: clamp_dim(rows) as i16,
+    };
+    // SAFETY: hpc 是有效的伪控制台句柄（未关闭），size 已钳制到 i16 范围。
+    let hr = unsafe { ResizePseudoConsole(hpc, size) };
+    if hr < 0 {
+        crate::logger::log_warn("terminal", &format!("ResizePseudoConsole 失败（HRESULT 0x{hr:08X}）"));
+    }
+}
+
+/// 把维度钳制到 COORD 的 i16 正数范围。
+///
+/// 为什么需要：`cols`/`rows` 来自前端 xterm 的测量结果，极端布局（超宽显示器 +
+/// 极窄侧栏）下可能算出 0 或超出 32767，直接转 i16 会得到负数，ConPTY 会拒绝或
+/// 产生诡异绘制。这里统一兜底到合理区间。
+fn clamp_dim(v: u16) -> u16 {
+    v.clamp(1, 1000)
+}
+
+/// 在后台线程关闭 PTY（坑 1：`ClosePseudoConsole` 可能阻塞）。
+///
+/// 调用方不等待。先置标志位保证幂等——读线程与退出等待线程都可能走到这里。
+fn close_pty_background(inner: &Arc<PtyInner>) {
+    if inner.closed.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    let inner = inner.clone();
+    std::thread::spawn(move || {
+        // 先释放写端：否则 PTY 侧仍认为有输入来源，其内部缓冲不会排空
+        {
+            let mut w = inner.writer.lock().unwrap_or_else(|e| e.into_inner());
+            *w = None;
+        }
+        let hpc = {
+            let mut g = inner.hpc.lock().unwrap_or_else(|e| e.into_inner());
+            g.take()
+        };
+        if let Some(hpc) = hpc {
+            // SAFETY: hpc 由本会话创建且尚未关闭（take 保证了唯一性）。
+            // 这个调用可能阻塞到所有句柄关闭，因此放在独立线程。
+            unsafe { ClosePseudoConsole(hpc) };
+        }
+    });
+}
+
+// ===== Session trait 实现 =====
+
+impl Session for ConPtySession {
+    fn id(&self) -> &str {
+        &self.state.id
+    }
+
+    fn kind(&self) -> SessionKind {
+        SessionKind::Local
+    }
+
+    fn write(&self, data: &[u8]) -> Result<(), String> {
+        let mut g = self.inner.writer.lock().unwrap_or_else(|e| e.into_inner());
+        let Some(w) = g.as_mut() else {
+            return Err("会话已关闭，无法写入".to_string());
+        };
+        w.write_all(data).map_err(|e| format!("写入失败: {e}"))?;
+        w.flush().map_err(|e| format!("刷新失败: {e}"))
+    }
+
+    fn resize(&self, cols: u16, rows: u16) -> Result<(), String> {
+        *self.state.size.lock().unwrap_or_else(|e| e.into_inner()) = (cols, rows);
+
+        // 坑 2：首帧之前只入队。ConPTY 在进程尚未开始读 stdout 时对 resize
+        // 的处理不可靠（尺寸可能被吞掉），表现为 vim/htop 按 80×24 绘制而花屏。
+        if !self.inner.first_output_seen.load(Ordering::SeqCst) {
+            *self
+                .inner
+                .pending_size
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()) = Some((cols, rows));
+            return Ok(());
+        }
+
+        apply_resize(&self.inner, cols, rows);
+        Ok(())
+    }
+
+    fn kill(&self) -> Result<(), String> {
+        // 幂等：重复 kill 不报错
+        if self.inner.closed.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
+        // 1. 先终止进程（若有）
+        if let Some(h) = self
+            .inner
+            .process
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .as_ref()
+            .map(|h| h.as_raw_handle() as HANDLE)
+        {
+            // SAFETY: h 是本会话持有的有效进程句柄。
+            // 退出码 1 表示「被终止」，与正常退出 0 区分开，便于前端展示。
+            unsafe { TerminateProcess(h, 1) };
+        }
+
+        // 2. 关 PTY（后台线程，不阻塞调用方）
+        close_pty_background(&self.inner);
+
+        // 3. 状态置为 Closed 并发事件
+        *self.state.state.lock().unwrap_or_else(|e| e.into_inner()) = SessionState::Closed;
+        let _ = self.app.emit(
+            crate::terminal::events::TERMINAL_EXIT,
+            crate::terminal::events::ExitPayload {
+                session_id: self.state.id.clone(),
+                exit_code: Some(1),
+                reason: Some("killed".to_string()),
+            },
+        );
+        let _ = EXIT_HINT; // 提示文本由前端拼接，此处保留常量以备审计日志使用
+        Ok(())
+    }
+
+    fn info(&self) -> SessionInfo {
+        local_info(&self.state, SessionKind::Local)
+    }
+
+    fn set_state(&self, state: SessionState, error: Option<String>) {
+        *self.state.state.lock().unwrap_or_else(|e| e.into_inner()) = state;
+        if let Some(e) = error {
+            *self.state.error.lock().unwrap_or_else(|e| e.into_inner()) = Some(e);
+        }
+        let _ = self
+            .app
+            .emit(crate::terminal::events::TERMINAL_STATE, self.info());
+    }
+
+    fn set_title(&self, title: &str) {
+        *self.state.title.lock().unwrap_or_else(|e| e.into_inner()) = title.to_string();
+    }
+
+    fn set_detached(&self, detached: bool) {
+        self.state.detached.store(detached, Ordering::Relaxed);
+    }
+
+    /// 本地会话的编码切换语义与 SSH 不同：**只影响输出的字节→文本解释**，
+    /// 不影响输入（Windows 控制台走 UTF-16 转换，`WriteFile` 收到的一直是
+    /// UTF-8，前端不必按目标代码页重编码）。因此这里不做输入侧处理。
+    fn set_encoding(&self, encoding: &str) -> bool {
+        self.state.set_encoding(encoding)
+    }
+
+    fn emit_state(&self) {
+        let _ = self
+            .app
+            .emit(crate::terminal::events::TERMINAL_STATE, self.info());
+    }
+}
+
+// ===== windows-sys 中未随 feature 导出的 API 声明 =====
+//
+// `InitializeProcThreadAttributeList` / `UpdateProcThreadAttribute` /
+// `DeleteProcThreadAttributeList` 属于 `Win32_System_Threading`，但 windows-sys
+// 0.52 未把它们纳入已启用的 feature 面。用 extern "system" 直接声明，
+// 避免为了三个函数额外开启一个大 feature（会显著增加编译时间）。
+unsafe extern "system" {
+    fn InitializeProcThreadAttributeList(
+        lp_attribute_list: *mut std::ffi::c_void,
+        dw_attribute_count: u32,
+        dw_flags: u32,
+        lp_size: *mut usize,
+    ) -> i32;
+
+    fn UpdateProcThreadAttribute(
+        lp_attribute_list: *mut std::ffi::c_void,
+        dw_flags: u32,
+        attribute: usize,
+        lp_value: *const std::ffi::c_void,
+        cb_size: usize,
+        lp_previous_value: *mut std::ffi::c_void,
+        lp_return_size: *mut usize,
+    ) -> i32;
+
+    fn DeleteProcThreadAttributeList(lp_attribute_list: *mut std::ffi::c_void);
+}
+

src-tauri/src/terminal/pty/mod.rs

@@ -0,0 +1,6 @@
+//! 终端进程后端。
+//!
+//! `conpty` 是本地 Shell 的实现（Windows ConPTY）。未来若需要支持非 Windows
+//! 平台，在此目录下新增 `unix_pty` 即可，上层只依赖 [`super::session::Session`]。
+
+pub mod conpty;

src-tauri/src/terminal/session.rs

@@ -0,0 +1,629 @@
+//! 会话抽象与注册表。
+//!
+//! ## 为什么不用 `crate::process_manager::ProcessManager`
+//!
+//! `ProcessManager` 是为「单例常驻守护进程」设计的（mihomo 内核）：一个模块 ID
+//! 对应一个进程，进程崩溃即按策略重启，配置在模块 `index.ts` 里静态声明。
+//! 终端要的是完全不同的语义——
+//!
+//! - **N 个会话并存**，每个会话生命周期独立（开一个标签 = 多一个会话）；
+//! - 需要**双向流式 I/O**（写 stdin、读 stdout），而不只是「启动/停止/看状态」；
+//! - 崩溃**不应重启**（重启一个 shell 只是给用户一个空提示符，毫无意义），
+//!   而应把退出码报给前端做展示；
+//! - 会话可能因为「网络断开」而进入 `degraded` 而不是 `stopped`。
+//!
+//! 把这四条塞进 `ProcessManager` 会撑坏它的抽象，因此终端模块自带一套。
+//!
+//! ## `Session` trait 的价值
+//!
+//! 本地（ConPTY）与远程（SSH）两种后端在「I/O 形态」上高度一致：都是一个字节流，
+//! 都要支持 write / resize / kill / 输出订阅。抽成 trait 后，上层的命令层
+//! （`terminal_write` / `terminal_resize` / …）与多会话管理逻辑**只需写一遍**。
+//!
+//! 两处刻意的不对称（值得记下，避免后来者以为是疏漏）：
+//! - `resize`：ConPTY 需要显式调用 `ResizePseudoConsole`；SSH 是发
+//!   `window-change` 请求。两者都要，故都在 trait 上。
+//! - `exit_code`：本地拿得到真实退出码；SSH 会话通道关闭时通常拿不到，
+//!   统一返回 `None`，由前端展示为「连接已关闭」。
+
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+
+use dashmap::DashMap;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+use super::pty::conpty::ConPtySession;
+
+/// 会话标识。
+pub type SessionId = String;
+
+/// 会话状态机。
+///
+/// `degraded` 专为 SSH 保留：TCP 断了但会话对象还在（可以尝试重连），
+/// 与 `closed`（已终结，需重开）是两回事。本地会话不会进入此态。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum SessionState {
+    /// 已创建，尚未开始握手/启动
+    Idle,
+    /// 正在连接（SSH 握手 / 本地启动进程）
+    Connecting,
+    /// 正在认证（仅 SSH）
+    Authenticating,
+    /// 已建立，可交互
+    Established,
+    /// 连接降级（SSH 断线，可尝试重连）
+    Degraded,
+    /// 已关闭（进程退出或用户主动关闭）
+    Closed,
+    /// 异常（启动失败、握手失败、致命错误）
+    Failed,
+}
+
+/// 会话类型（决定前端展示哪些能力）。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum SessionKind {
+    Local,
+    Ssh,
+}
+
+/// 会话元信息（回传前端；**不含任何 I/O 句柄**）。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionInfo {
+    pub id: SessionId,
+    pub kind: SessionKind,
+    /// 标题（本地为 Shell 名，SSH 为 用户@主机）
+    pub title: String,
+    pub state: SessionState,
+    /// 终端当前列数
+    pub cols: u16,
+    /// 终端当前行数
+    pub rows: u16,
+    /// 当前工作目录（由 OSC 7 hook 上报；未知为空串）
+    pub cwd: String,
+    /// 会话创建时间（Unix 毫秒）
+    pub created_at: u64,
+    /// 进程退出码（本地可拿到；SSH 通常为 None）
+    pub exit_code: Option<i32>,
+    /// 失败原因（state 为 Failed 时非空）
+    pub error: Option<String>,
+    /// 远端标识（本地为 shell id，SSH 为 host id）
+    pub target_id: String,
+    /// 是否由独立窗口承载（决定了关闭窗口时销毁还是保留会话）
+    pub detached: bool,
+    /// 会话的字符编码（规范名，如 `gbk` / `utf-8`）。
+    ///
+    /// 回传前端的原因：**终端画面的字节→文本转换在前端做**。xterm 的
+    /// `write` 接受 `Uint8Array`，解码策略由前端按这个字段决定。若放在 Rust 侧
+    /// 转换，前端就失去了「用户临时切编码重看历史内容」的能力——
+    /// 而重看历史恰恰是老服务器场景下最常用的操作。
+    pub encoding: String,
+    /// 是否正在记录会话日志（`audit` 模块）。前端据此显示工具栏开关状态。
+    pub logging: bool,
+}
+
+/// 会话抽象：本地 ConPTY 与 SSH 两种后端都实现它。
+///
+/// 所有方法都要求 `&self`（配合内部可变性）而不是 `&mut self`：会话句柄需要被
+/// 多个来源同时访问（输出读线程、命令层、退出监听），用 `&mut` 会把它们串行化。
+pub trait Session: Send + Sync {
+    fn id(&self) -> &str;
+    fn kind(&self) -> SessionKind;
+
+    /// 写入数据（前端键入的字符、粘贴内容）。
+    fn write(&self, data: &[u8]) -> Result<(), String>;
+
+    /// 通知终端尺寸变化。
+    ///
+    /// 实现方**必须容忍早期调用**：ConPTY 在进程刚开始输出时 resize 有竞态，
+    /// 需要排队到首帧之后再应用（详见 `pty::conpty`）。
+    fn resize(&self, cols: u16, rows: u16) -> Result<(), String>;
+
+    /// 终止会话。幂等：对已关闭的会话调用不应报错。
+    fn kill(&self) -> Result<(), String>;
+
+    /// 快照当前元信息。
+    fn info(&self) -> SessionInfo;
+
+    /// 更新状态（供内部线程在握手/退出时调用）。
+    fn set_state(&self, state: SessionState, error: Option<String>);
+
+    /// 更新标题。
+    fn set_title(&self, title: &str);
+
+    /// 标记是否由独立窗口承载。
+    fn set_detached(&self, detached: bool);
+
+    /// 切换字符编码。返回 `false` 表示编码名不被支持。
+    ///
+    /// # 为什么放进 trait 而不是走 `as_ssh()` 下转换
+    ///
+    /// 本地 ConPTY 会话也需要它 —— 用户的 Windows 控制台若是 936 代码页，
+    /// 本地会话同样会乱码，只是默认值不同。放进 trait 后命令层不必先判断
+    /// 会话类型再分派，两条后端路径只有一处实现点。
+    fn set_encoding(&self, encoding: &str) -> bool;
+
+    /// 广播当前会话快照到前端（`TERMINAL_STATE` 事件）。
+    ///
+    /// 用于「元信息变了但状态没变」的场景（改编码、改标题），此时
+    /// 既有的状态机路径不会触发广播，需要显式一次。
+    fn emit_state(&self);
+
+    /// 向下转换成 SSH 会话（仅 SFTP 面板需要）。
+    ///
+    /// # 为什么用「返回 `Option<&SshSession>`」而不是 `Any` 向下转换
+    ///
+    /// `Any::downcast_ref` 要求 trait 对象是 `'static` 且需要引入 `std::any`，
+    /// 更关键的是**编译期一无所知**：调用方写错目标类型要到运行期才炸。
+    /// 这里给出一个具名方法，`SshSession` 的返回 `Some(self)`、其余返回 `None`，
+    /// 类型由签名保证，调用点的 `ok_or_else` 也就有了明确的中文错误提示。
+    ///
+    /// 默认实现返回 `None`（本地会话不需要覆写）。
+    fn as_ssh(&self) -> Option<&super::ssh::SshSession> {
+        None
+    }
+}
+
+/// 会话注册表。
+///
+/// 用 `DashMap` 而不是 `Mutex<HashMap>`：会话的读操作极其频繁（每次输出批次都要
+/// 查表找会话），而写操作少（创建/销毁）。分片锁能让多个会话的 I/O 线程互不等待。
+///
+/// 注意 `Arc<dyn Session>`：注册表持有一份，各 I/O 线程各持一份，生命周期由
+/// 引用计数管理。**不使用 `Weak`**——会话的存活由用户显式关闭决定，不该因为
+/// 某个线程退出而被回收。
+pub struct SessionRegistry {
+    sessions: DashMap<SessionId, Arc<dyn Session>>,
+    /// 会话 id 发生器
+    next_id: AtomicU64,
+}
+
+impl SessionRegistry {
+    pub fn new() -> Self {
+        Self {
+            sessions: DashMap::new(),
+            next_id: AtomicU64::new(1),
+        }
+    }
+
+    /// 生成下一个会话 id。
+    ///
+    /// 形如 `s1` / `s2`：短、可读、便于日志检索。不用 UUID 的理由是这个 id 会
+    /// 出现在窗口 label（`terminal-window-s1`）与日志里，UUID 会让两者都难读。
+    /// 会话 id 只在本次进程生命周期内有效，重启后不保证不重复，因此无需全局唯一性。
+    pub fn next_session_id(&self) -> SessionId {
+        let n = self.next_id.fetch_add(1, Ordering::Relaxed);
+        format!("s{n}")
+    }
+
+    pub fn insert(&self, session: Arc<dyn Session>) {
+        self.sessions.insert(session.id().to_string(), session);
+    }
+
+    pub fn get(&self, id: &str) -> Option<Arc<dyn Session>> {
+        self.sessions.get(id).map(|e| e.value().clone())
+    }
+
+    /// 移除会话（**不调用 kill**，由调用方决定是否先终止）。
+    pub fn remove(&self, id: &str) -> Option<Arc<dyn Session>> {
+        self.sessions.remove(id).map(|(_, v)| v)
+    }
+
+    pub fn list(&self) -> Vec<SessionInfo> {
+        let mut list: Vec<SessionInfo> = self.sessions.iter().map(|e| e.value().info()).collect();
+        // 按创建时间排序，保证前端标签顺序稳定（DashMap 的迭代顺序不确定）
+        list.sort_by_key(|s| s.created_at);
+        list
+    }
+
+    pub fn len(&self) -> usize {
+        self.sessions.len()
+    }
+
+    /// 关闭并移除所有会话（应用退出时调用）。
+    ///
+    /// 逐个 `kill` 后清表。**不做等待**：退出路径上不能阻塞（ConPTY 的
+    /// `ClosePseudoConsole` 会阻塞到所有句柄关闭，见 `pty::conpty`）。
+    /// 进程终止时 OS 会回收残留资源，这里是「尽力而为」。
+    pub fn close_all(&self) {
+        let ids: Vec<String> = self.sessions.iter().map(|e| e.key().clone()).collect();
+        for id in ids {
+            if let Some(s) = self.get(&id) {
+                if let Err(e) = s.kill() {
+                    crate::logger::log_warn(
+                        "terminal",
+                        &format!("关闭会话 {id} 失败（退出路径，忽略）: {e}"),
+                    );
+                }
+            }
+            // 会话日志收尾（flush + 移除条目；与 close 命令路径保持一致）
+            crate::terminal::audit::cleanup(&id);
+            self.remove(&id);
+        }
+    }
+}
+
+impl Default for SessionRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// 为一个新会话分配终端默认尺寸。
+///
+/// 80×24 是 VT 规范的经典默认值。前端挂载 xterm 后会立刻上报真实尺寸，
+/// 这里的值只在「创建 → 首帧」之间短暂生效。
+pub const DEFAULT_COLS: u16 = 80;
+pub const DEFAULT_ROWS: u16 = 24;
+
+/// 本地会话的共享状态（供 `ConPtySession` 与命令层共用）。
+///
+/// 独立成一个结构而不是塞进 `ConPtySession`，是因为状态字段的读写来自
+/// 多个线程（命令层、读线程、退出监听线程），集中放置便于审计加锁范围。
+pub struct LocalSessionState {
+    pub id: SessionId,
+    pub target_id: String,
+    /// 会话类型（本地 ConPTY / SSH）。
+    ///
+    /// # 为什么存在这里而不是只由会话对象自己知道
+    ///
+    /// `scan_control_sequences` 是**自由函数**（ConPTY 与 SSH 两个后端共用），
+    /// 它只拿到 `LocalSessionState` 而拿不到会话对象。命令历史落库需要区分
+    /// 「target_id 是 shell id 还是主机 id」才能查对显示名 ——
+    /// 没有这个字段就只能靠 `target_id` 的形式去猜，那是不可靠的。
+    pub kind: SessionKind,
+    pub title: std::sync::Mutex<String>,
+    pub state: std::sync::Mutex<SessionState>,
+    pub error: std::sync::Mutex<Option<String>>,
+    pub cwd: std::sync::Mutex<String>,
+    pub size: std::sync::Mutex<(u16, u16)>,
+    pub created_at: u64,
+    pub exit_code: std::sync::Mutex<Option<i32>>,
+    pub detached: std::sync::atomic::AtomicBool,
+    /// 会话的字符编码（`encoding::normalize` 之后的规范名，如 `gbk` / `utf-8`）。
+    ///
+    /// 放在这里而不是让读线程从 `SshConnectParams` 持有：编码在会话存续期间
+    /// **可能被用户改**（连上后发现是 GBK，在状态栏切一下），此时需要立即生效。
+    /// 用 `Mutex<String>` 而非 `Arc<str>` 就是为了支持这个运行时变更。
+    pub encoding: std::sync::Mutex<String>,
+}
+
+impl LocalSessionState {
+    pub fn new(id: SessionId, target_id: String, title: String) -> Self {
+        Self::with_encoding(id, target_id, title, SessionKind::Local, "utf-8")
+    }
+
+    /// 带编码与类型构造。
+    ///
+    /// `kind` 由**创建方**传入而不是从 `target_id` 推断：本地会话的 target_id 是
+    /// shell id、SSH 会话的是主机 id，两者都是任意字符串，形式上看不出区别。
+    /// 让调用方（`ConPtySession::spawn` / `SshSession::spawn`）显式声明是唯一可靠的来源。
+    pub fn with_encoding(
+        id: SessionId,
+        target_id: String,
+        title: String,
+        kind: SessionKind,
+        encoding: &str,
+    ) -> Self {
+        Self {
+            id,
+            target_id,
+            kind,
+            title: std::sync::Mutex::new(title),
+            state: std::sync::Mutex::new(SessionState::Idle),
+            error: std::sync::Mutex::new(None),
+            cwd: std::sync::Mutex::new(String::new()),
+            size: std::sync::Mutex::new((DEFAULT_COLS, DEFAULT_ROWS)),
+            created_at: now_millis(),
+            exit_code: std::sync::Mutex::new(None),
+            detached: std::sync::atomic::AtomicBool::new(false),
+            encoding: std::sync::Mutex::new(crate::terminal::encoding::normalize(encoding)),
+        }
+    }
+
+    /// 是否为 SSH 会话（供命令历史等需要区分来源的场景）。
+    pub fn is_ssh(&self) -> bool {
+        matches!(self.kind, SessionKind::Ssh)
+    }
+
+    /// 当前编码（供读线程与命令层读取）。
+    pub fn encoding(&self) -> String {
+        self.encoding
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .clone()
+    }
+
+    /// 切换编码。返回 `false` 表示编码名不被支持（调用方应回滚 UI）。
+    pub fn set_encoding(&self, encoding: &str) -> bool {
+        let norm = crate::terminal::encoding::normalize(encoding);
+        if !crate::terminal::encoding::is_supported(&norm) {
+            return false;
+        }
+        *self.encoding.lock().unwrap_or_else(|e| e.into_inner()) = norm;
+        true
+    }
+}
+
+/// 当前 Unix 毫秒时间戳。
+pub fn now_millis() -> u64 {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis() as u64)
+        .unwrap_or(0)
+}
+
+// ===== 控制序列扫描（ConPTY / SSH 共用） =====
+
+/// `carry` 缓冲上限。正常 OSC 序列只有几十字节，超过即视为畸形数据。
+///
+/// 没有上限时，一段缺终止符的畸形输出（比如二进制文件被 `cat` 出来）
+/// 会让 `carry` 无限增长，最终吃满内存。
+const MAX_OSC_CARRY: usize = 8 * 1024;
+
+/// 扫描输出批次里的控制序列，把结果落到会话状态、广播事件、并在命令边界处落库历史。
+///
+/// # 为什么两个后端共用这一份（此前 ConPTY 与 SSH 各有一份几乎相同的拷贝）
+///
+/// 两份拷贝的差异只有一处：SSH 需要按会话编码二次解码 OSC 载荷
+/// （GBK 服务器上的标题与 cwd 会乱码）。其余（carry 拼接、上限防御、
+/// cwd 变更判定、只上报变化量）**完全一致**。
+///
+/// P1 新增命令历史时这个问题变成硬约束：若继续维持两份拷贝，
+/// 「OSC 133 解析 + 落库」就要在两处各写一遍 —— 任何一处漏掉都表现为
+/// 「只有本地会话有历史」或「只有 SSH 有历史」这类**按后端分支的诡异 bug**，
+/// 而且因为两条路径平时都各自能用，极难在测试中发现。
+///
+/// 编码与类型都从 `state` 上取（`state.encoding()` / `state.kind` /
+/// `state.is_ssh()`），所以这个函数不需要任何按后端分派的参数。
+///
+/// # 关于 `emit_state` 的差异
+///
+/// 标题变化时要广播 `TERMINAL_STATE`，而 ConPTY 走 `terminal::emit_state`
+/// （带显式 `final_state`）、SSH 走 `local_info(.., Ssh)`。统一为
+/// `local_info(state, state.kind)` + 保持当前 state 不变即可 ——
+/// 两条路径的原意都是「状态没变，只是标题变了」，用 `state.kind` 恰好等价。
+pub fn scan_control_sequences(
+    app: &tauri::AppHandle,
+    state: &LocalSessionState,
+    carry: &mut Vec<u8>,
+    chunk: &[u8],
+    sim: &CommandAccumulator,
+) {
+    use tauri::Emitter as _;
+
+    carry.extend_from_slice(chunk);
+    let parsed = crate::terminal::shell::parse_control_sequences(carry);
+    if parsed.consumed > 0 {
+        carry.drain(..parsed.consumed);
+    }
+    // 防御：畸形数据（没有终止符的超长序列）会让 carry 无限增长
+    if carry.len() > MAX_OSC_CARRY {
+        carry.clear();
+    }
+
+    // 编码转换：OSC 载荷与终端画面**共用同一套字节**，因此也必须用会话编码解码。
+    // 不转的话，GBK 服务器上 `echo -e "\e]0;测试\a"` 这种标题会变成乱码。
+    // 注意只在会话编码不是 UTF-8 时才有实际效果 —— `parse_control_sequences`
+    // 内部已按 UTF-8 有损解码过一轮，这一步是在其基础上的「纠正」。
+    let enc = state.encoding();
+    let recode = |v: Vec<String>| -> Vec<String> {
+        if enc == "utf-8" {
+            return v;
+        }
+        v.into_iter()
+            .map(|s| crate::terminal::encoding::decode(s.as_bytes(), &enc))
+            .collect()
+    };
+    let cwds = recode(parsed.cwds);
+    let titles = recode(parsed.titles);
+
+    if let Some(cwd) = cwds.last() {
+        let changed = {
+            let mut cur = state.cwd.lock().unwrap_or_else(|e| e.into_inner());
+            if *cur == *cwd {
+                false
+            } else {
+                *cur = cwd.clone();
+                true
+            }
+        };
+        if changed {
+            let _ = app.emit(
+                crate::terminal::events::TERMINAL_CWD,
+                crate::terminal::events::CwdPayload {
+                    session_id: state.id.clone(),
+                    cwd: cwd.clone(),
+                },
+            );
+        }
+    }
+
+    if let Some(title) = titles.last() {
+        let changed = {
+            let mut cur = state.title.lock().unwrap_or_else(|e| e.into_inner());
+            if *cur == *title {
+                false
+            } else {
+                *cur = title.clone();
+                true
+            }
+        };
+        if changed {
+            let _ = app.emit(
+                crate::terminal::events::TERMINAL_STATE,
+                local_info(state, state.kind),
+            );
+        }
+    }
+
+    // 命令边界：累积到 D 才落库（见 `CommandAccumulator` 的说明）
+    sim.absorb(app, state, &parsed.marks);
+}
+
+/// 跨批次累积「当前正在执行的命令」，在 OSC 133 的 `D` 标记处落库。
+///
+/// # 为什么需要累积而不是收到 D 就存
+///
+/// 协议里命令文本（`1337;Cmd=`）与结束标记（`133;D`）是**两个独立序列**，
+/// 顺序由 shell hook 决定，且可能被切在不同批次里。若收到 D 就立刻用
+/// 「当前已知的命令」落库，遇到「D 先到、Cmd 后到」的顺序会存下**上一条**命令 ——
+/// 错位一条，且只在特定时序下复现，是最难查的一类 bug。
+///
+/// 因此：Cmd 到达时先暂存，D 到达时用暂存的文本落库并清空。
+/// 若 D 到达时没有暂存文本（例如 hook 未被注入的老会话），则跳过 ——
+/// 记一条空命令进历史毫无意义。
+///
+/// # 为什么锁粒度是「整段」
+///
+/// 一个批次里可能有多组 Cmd/D（`ls; pwd` 在极快执行时被一次性读取）。
+/// 逐条加锁会让「暂存 → 落库 → 清空」三步之间可能被另一批次的同三步插入，
+/// 产生交叉覆盖。锁住整段即可，临界区里只有内存操作与一次 SQLite 写入。
+///
+/// # 挂载位置
+///
+/// 由调用方（两个后端的读线程）持有，与会话同生命周期。不放进
+/// `LocalSessionState`：那个结构是**状态**（可被任意线程读），
+/// 而这个是**读线程的私有工作变量**，混在一起会让「谁在改它」变得不清晰。
+pub struct CommandAccumulator {
+    inner: std::sync::Mutex<Option<String>>,
+}
+
+impl CommandAccumulator {
+    pub fn new() -> Self {
+        Self {
+            inner: std::sync::Mutex::new(None),
+        }
+    }
+
+    fn absorb(
+        &self,
+        app: &tauri::AppHandle,
+        state: &LocalSessionState,
+        marks: &[crate::terminal::shell::CommandMark],
+    ) {
+        use crate::terminal::shell::CommandMark;
+        if marks.is_empty() {
+            return;
+        }
+
+        let mut pending = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+        for mark in marks {
+            match mark {
+                CommandMark::Command(cmd) => {
+                    // 覆盖而非追加：`history 1` 总是给最新一条，
+                    // 同一批里出现两次 Cmd 时后者才是当前命令
+                    *pending = Some(cmd.clone());
+                }
+                CommandMark::End(code) => {
+                    let Some(cmd) = pending.take() else {
+                        continue;
+                    };
+                    if cmd.trim().is_empty() {
+                        continue;
+                    }
+                    // 记录失败**不影响终端**：历史是辅助功能，
+                    // 磁盘满 / 库损坏都不该让用户的命令执行流程中断。
+                    if let Err(e) = record_command(app, state, &cmd, *code) {
+                        crate::logger::log_error(
+                            "terminal",
+                            &format!("写入命令历史失败（不影响会话）: {e}"),
+                        );
+                    }
+                }
+                CommandMark::Start => {}
+            }
+        }
+    }
+}
+
+impl Default for CommandAccumulator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// 把一条命令送进历史库。
+///
+/// 从 `AppHandle` 反查 `TerminalManager`：本函数由读线程调用，那里只有
+/// `AppHandle` 与会话状态，没有 manager 引用。走 Tauri 的 state 查询
+/// 是这里唯一可行的方式（也是项目里 `manager(&app)` 的既有范式）。
+///
+/// # 落库在后台 writer
+///
+/// 本函数位于**输出热路径**（OSC 133 的 D 标记到达时读线程正在转发输出），
+/// 因此只做两次轻量读（显示名持锁读小字段、cwd 克隆）+ 一次 `mpsc::send`。
+/// SQLite 写入与 prune 由 [`crate::terminal::history::spawn_writer`] 的
+/// writer 线程攒批完成（通道断开时 manager 内部有同步兜底）。
+fn record_command(
+    app: &tauri::AppHandle,
+    state: &LocalSessionState,
+    command: &str,
+    exit_code: Option<i32>,
+) -> Result<(), String> {
+    use tauri::Manager as _;
+    let Some(mgr) = app.try_state::<crate::terminal::TerminalManager>() else {
+        return Ok(()); // 应用正在退出，manager 已释放 —— 静默跳过
+    };
+
+    // 解析显示名。本地会话的 target_id 是 shell id，SSH 会话是主机 id，
+    // 两者对用户是不同含义，所以分开查。
+    //
+    // 显示名**随记录一起存**（而不是查询时再联表）：主机被删除后，
+    // 若只有 id，历史列表里那一列会变成一串无意义的 hash。
+    let name = mgr.display_name(&state.target_id, state.is_ssh());
+    let cwd = state.cwd.lock().unwrap_or_else(|e| e.into_inner()).clone();
+
+    mgr.queue_history(crate::terminal::history::HistoryEntry {
+        command: command.to_string(),
+        cwd,
+        host_id: state.target_id.clone(),
+        host_name: name,
+        ssh: state.is_ssh(),
+        exit_code,
+    });
+    Ok(())
+}
+
+/// 由本地会话状态组装 `SessionInfo`。
+pub fn local_info(state: &LocalSessionState, kind: SessionKind) -> SessionInfo {
+    let (cols, rows) = *state.size.lock().unwrap_or_else(|e| e.into_inner());
+    SessionInfo {
+        id: state.id.clone(),
+        kind,
+        title: state
+            .title
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .clone(),
+        state: *state.state.lock().unwrap_or_else(|e| e.into_inner()),
+        cols,
+        rows,
+        cwd: state.cwd.lock().unwrap_or_else(|e| e.into_inner()).clone(),
+        created_at: state.created_at,
+        exit_code: *state.exit_code.lock().unwrap_or_else(|e| e.into_inner()),
+        error: state
+            .error
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .clone(),
+        target_id: state.target_id.clone(),
+        detached: state.detached.load(Ordering::Relaxed),
+        encoding: state.encoding(),
+        logging: crate::terminal::audit::is_logging(&state.id),
+    }
+}
+
+/// 供 `ConPtySession` 引用的类型别名，避免上层直接依赖 `pty` 模块。
+pub type BoxedSession = Arc<dyn Session>;
+
+/// 类型占位：确保 `ConPtySession` 在编译期满足 `Session` 契约。
+/// 若 `ConPtySession` 漏实现某个方法，这里会直接编译失败（比等到使用处才报错更早）。
+#[allow(dead_code)]
+fn _assert_conpty_is_session(s: ConPtySession) -> BoxedSession {
+    Arc::new(s)
+}

src-tauri/src/terminal/settings.rs

@@ -0,0 +1,928 @@
+//! 终端模块设置的数据模型与默认值。
+//!
+//! 持久化位置：`{app_data_dir}/terminal/settings.json`（与 translate / music 同一范式）。
+//! 容器级 `#[serde(default)]`：新增字段对旧配置文件是**向后兼容**的——缺字段取默认值
+//! 而不是让整份设置反序列化失败，避免用户因为一次升级丢掉全部配置。
+//!
+//! 安全姿态（与 `crate::secrets` 的约定一致）：**本结构里不允许出现任何明文凭据**。
+//! SSH 密码、私钥 passphrase 一律进系统凭据管理器，本结构只保存它们的引用 id 与
+//! 派生展示字段（如 `hasPassphrase`，由命令层回填，不落盘）。
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+// ===== 本地 Shell =====
+
+/// 本地 Shell 配置。
+///
+/// 探测到的 Shell 与用户自定义的 Shell 用同一结构表达：`detected` 为 true 表示
+/// 由 [`super::shell::detect_shells`] 自动发现，前端只允许改启动参数而不可改路径
+/// （路径已被验证存在，改错会让会话起不来）。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct ShellProfile {
+    /// 唯一标识（同时是新建会话时的 shellKey）
+    pub id: String,
+    /// 展示名称，如 "PowerShell 7"
+    pub name: String,
+    /// 可执行文件绝对路径
+    pub path: String,
+    /// 启动参数
+    pub args: Vec<String>,
+    /// 启动时的工作目录（空串表示用用户主目录）
+    pub cwd: String,
+    /// 环境变量覆盖（键值对；值为空串表示删除该变量）
+    pub env: Vec<EnvVar>,
+    /// Shell 类型："powershell" | "cmd" | "bash" | "wsl"
+    ///
+    /// 决定三件事：cwd 跟踪 hook 的注入方式、清屏命令、以及 OSC 7 的解析口径。
+    pub kind: String,
+    /// 是否由自动探测得到（true 时前端不可编辑 path）
+    pub detected: bool,
+    /// 是否在新建会话菜单中显示
+    pub enabled: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct EnvVar {
+    pub key: String,
+    pub value: String,
+}
+
+/// 手写 `Default` 而不是 derive：`detected` 与 `enabled` 的默认值必须是
+/// `true` / `true`（derive 会给 `false`），而 `#[serde(default)]` 在容器级
+/// 要求每个字段类型都实现 `Default`。两者不一致会导致「反序列化出来的
+/// Shell 默认禁用」这种隐性 bug。
+impl Default for ShellProfile {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            name: String::new(),
+            path: String::new(),
+            args: Vec::new(),
+            cwd: String::new(),
+            env: Vec::new(),
+            kind: "bash".to_string(),
+            detected: true,
+            enabled: true,
+        }
+    }
+}
+
+/// 容器级 `#[serde(default)]` 要求字段类型实现 `Default`。
+/// `EnvVar` 的「空值」语义就是空键空值，用 derive 的默认即可。
+impl Default for EnvVar {
+    fn default() -> Self {
+        Self {
+            key: String::new(),
+            value: String::new(),
+        }
+    }
+}
+
+impl ShellProfile {
+    pub fn new(id: &str, name: &str, path: &str, kind: &str) -> Self {
+        Self {
+            id: id.to_string(),
+            name: name.to_string(),
+            path: path.to_string(),
+            args: Vec::new(),
+            cwd: String::new(),
+            env: Vec::new(),
+            kind: kind.to_string(),
+            detected: true,
+            enabled: true,
+        }
+    }
+}
+
+// ===== SSH 主机 =====
+
+/// SSH 主机条目。
+///
+/// `id` 是凭据键名的一部分（`terminal-ssh-password-{id}`），**创建后不应修改**：
+/// 改了会让已存进凭据管理器的密码读不到。前端在编辑态需禁用该字段。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct SshHost {
+    pub id: String,
+    /// 展示别名（列表主标题）
+    pub name: String,
+    pub host: String,
+    pub port: u16,
+    pub username: String,
+    /// 认证方式："key"（公钥，默认）| "password" | "agent"（P1）| "keyboard"（P1）
+    pub auth_method: String,
+    /// 公钥认证使用的密钥 id（指向 [`super::keys`] 的密钥库）
+    pub key_id: String,
+    /// 分组名（侧栏按此分组）
+    pub group: String,
+    /// 备注
+    pub note: String,
+    /// 标签色（前端用于状态点/分组标识）
+    pub color: String,
+    /// 是否收藏（置顶显示）
+    pub favorited: bool,
+    /// 连接超时（毫秒）
+    pub connect_timeout_ms: u64,
+    /// keep-alive 间隔（秒，0 表示关闭）
+    pub keepalive_secs: u64,
+    /// 启动目录（空串表示登录后进入默认目录）
+    pub remote_cwd: String,
+    /// 登录后自动执行的命令
+    pub startup_command: String,
+    /// 是否走代理模块（mihomo）。默认关闭：内网主机不该被绕进代理。
+    pub use_proxy: bool,
+    /// 跳板机链（ProxyJump）：按连接顺序排列的主机 id。
+    ///
+    /// 每一项引用**本主机列表里的另一台主机**（复用它的地址、账号与凭据），
+    /// 连接方向为 `本机 → jump_ids[0] → jump_ids[1] → … → 本主机`。
+    /// 空 = 直连。约束（命令层校验）：不能引用自己、不能有环、
+    /// 链长上限 5、每一跳的认证方式必须是 key/password。
+    ///
+    /// 用 id 引用而不是内联一份地址+凭据的理由：跳板机自己的密码/密钥
+    /// 存在凭据管理器里，按 id 复用可以避免同一台跳板机在多处配置里
+    /// 留下多份凭据副本（改密码时漏改一处就是连接事故）。
+    pub jump_ids: Vec<String>,
+    /// 终端的字符编码（"utf-8" 默认 | "gbk" 等）。老服务器常见 GBK，中文环境刚需。
+    pub encoding: String,
+}
+
+impl Default for SshHost {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            name: String::new(),
+            host: String::new(),
+            port: 22,
+            username: String::new(),
+            auth_method: "key".to_string(),
+            key_id: String::new(),
+            group: String::new(),
+            note: String::new(),
+            color: String::new(),
+            favorited: false,
+            connect_timeout_ms: 15_000,
+            keepalive_secs: 30,
+            remote_cwd: String::new(),
+            startup_command: String::new(),
+            use_proxy: false,
+            jump_ids: Vec::new(),
+            encoding: "utf-8".to_string(),
+        }
+    }
+}
+
+// ===== 外观 =====
+
+/// 终端外观设置。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct AppearanceSettings {
+    /// 配色主题 id（内置若干，见前端 terminalThemes.ts）
+    pub theme: String,
+    /// 是否跟随应用亮暗主题（开启时 `theme` 只作为亮/暗的取色基准）
+    pub follow_app_theme: bool,
+    /// 字体族（逗号分隔的 CSS font-family）
+    pub font_family: String,
+    pub font_size: u32,
+    /// 行高倍数
+    pub line_height: f64,
+    /// 字母间距
+    pub letter_spacing: f64,
+    /// 光标样式："block" | "bar" | "underline"
+    pub cursor_style: String,
+    /// 光标是否闪烁
+    pub cursor_blink: bool,
+    /// 滚动缓冲区行数。上限 200000：再高会显著吃内存且滚动查找变慢。
+    pub scrollback: u32,
+    /// 背景不透明度百分比（100 = 不透明）
+    pub opacity: u32,
+    /// 是否启用 GPU 渲染（addon-webgl）。极少数显卡驱动下有花屏问题，故给开关。
+    pub gpu_rendering: bool,
+}
+
+impl Default for AppearanceSettings {
+    fn default() -> Self {
+        Self {
+            theme: "thing-dark".to_string(),
+            follow_app_theme: true,
+            font_family: "Cascadia Mono, Consolas, Microsoft YaHei Mono, monospace".to_string(),
+            font_size: 14,
+            line_height: 1.2,
+            letter_spacing: 0.0,
+            cursor_style: "block".to_string(),
+            cursor_blink: true,
+            scrollback: 10_000,
+            opacity: 100,
+            gpu_rendering: true,
+        }
+    }
+}
+
+// ===== 快捷键 =====
+
+/// 一条终端内快捷键绑定。
+///
+/// 只覆盖**终端内**（第二层）快捷键：全局快捷键（第一层）由 `crate::shortcut` 统一
+/// 注册并做应用内冲突检测，不走这里；shell 原生快捷键（第三层）不做拦截。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct ShortcutBinding {
+    /// 动作标识，见前端 `terminalActions.ts`（如 "copy" / "newTab"）
+    pub action: String,
+    /// 键位字符串，格式与 `crate::shortcut::parse_shortcut` 一致（如 "Ctrl+Shift+C"）
+    pub keys: String,
+    /// 是否启用（关掉后该动作无快捷键，但仍可从菜单触发）
+    pub enabled: bool,
+}
+
+impl Default for ShortcutBinding {
+    fn default() -> Self {
+        Self {
+            action: String::new(),
+            keys: String::new(),
+            enabled: true,
+        }
+    }
+}
+
+// ===== 终端内选中行为 =====
+
+/// 终端内选中行为。
+///
+/// # 为什么叫 `TerminalSelectionSettings` 而不是 `SelectionSettings`
+///
+/// 与 `translate::settings::SelectionSettings` 撞名。`tauri-specta` 的类型注册表
+/// **全局按类型名索引**，重名会让 `export_bindings()` panic
+/// （`Detected multiple types with the same name`）。
+/// specta 2.0.0-rc.25 的 derive 路径无法重命名导出类型
+/// （详见 `history::TerminalHistoryPage` 的注释），只能改 Rust 标识符本身。
+///
+/// 注意：这是**第二个**独立引入的 `SelectionSettings`。新增跨模块共享名之前，
+/// 先确认没有同名 `Type` 已存在 —— 否则会在**运行时启动阶段**才炸，
+/// 而不是编译期（见 `TERMINAL_MODULE_PLAN.md` 坑 27）。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct TerminalSelectionSettings {
+    /// 选中即复制（受 Linux/macOS 习惯影响的用户会开；默认关，避免误触）
+    pub copy_on_select: bool,
+    /// 中键粘贴（X11 习惯；Windows 下默认关）
+    pub middle_click_paste: bool,
+    /// 右键行为："menu"（默认，弹菜单）| "paste"（直接粘贴）| "select-word"
+    pub right_click: String,
+    /// 复制时是否去掉尾部空行
+    pub trim_trailing_newline: bool,
+}
+
+impl Default for TerminalSelectionSettings {
+    fn default() -> Self {
+        Self {
+            copy_on_select: false,
+            middle_click_paste: false,
+            right_click: "menu".to_string(),
+            trim_trailing_newline: true,
+        }
+    }
+}
+
+// ===== 布局 =====
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct LayoutSettings {
+    /// 关闭标签页时若会话仍有活跃进程，是否二次确认
+    pub confirm_close_running: bool,
+    /// 新建标签页时是否继承当前会话的工作目录
+    pub inherit_cwd: bool,
+    /// 侧栏默认是否展开
+    pub sidebar_open: bool,
+    /// 侧栏宽度（像素）
+    pub sidebar_width: u32,
+    /// 是否显示底部状态栏
+    pub show_status_bar: bool,
+    /// 分屏上限（1 = 不分屏，2 = 2×1，4 = 2×2）。
+    /// 上限刻意封在 4：分屏 × 标签 × 会话的组合复杂度会爆炸。
+    pub max_panes: u32,
+}
+
+impl Default for LayoutSettings {
+    fn default() -> Self {
+        Self {
+            confirm_close_running: true,
+            inherit_cwd: true,
+            sidebar_open: true,
+            sidebar_width: 220,
+            show_status_bar: true,
+            max_panes: 4,
+        }
+    }
+}
+
+// ===== 命令片段 =====
+
+/// 一条命令片段。
+///
+/// # 为什么 `command` 里允许变量占位符
+///
+/// 常用命令的差异往往只在少数字段（路径、主机名、分支名）。若每条变体都要
+/// 单独存一条，片段库会迅速退化成「一堆几乎一样的条目」，反而找不到东西。
+/// 因此支持 `${name}` 形式占位符，执行前弹出表单逐个填写。
+///
+/// 占位符语法刻意用 `${name}` 而不是 `{name}`：shell 自身大量使用 `{}`
+/// （`${VAR}`、`awk '{print}'`、brace expansion），单花括号会与用户的正常
+/// 命令冲突，导致片段存进去就「被替换掉了」。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct CommandSnippet {
+    pub id: String,
+    /// 展示名称（列表主标题）
+    pub name: String,
+    /// 命令内容（可含 `${name}` 占位符）
+    pub command: String,
+    /// 说明（列表副标题，讲清这条命令做什么、有什么前提）
+    pub description: String,
+    /// 分组名（空串归入「未分组」）
+    pub group: String,
+    /// 占位符的默认值：name → 默认值。未列出的占位符默认空串。
+    pub defaults: std::collections::BTreeMap<String, String>,
+    /// 适用的 shell kind（空数组表示所有 shell 都适用）。
+    /// 例：`Get-ChildItem` 只对 powershell 有意义，不该出现在 cmd 的列表里。
+    pub shell_kinds: Vec<String>,
+    /// 仅对 SSH 会话显示（如 `sudo systemctl restart` 类远端操作）
+    pub ssh_only: bool,
+    /// 是否需要二次确认（危险命令，如 `rm -rf`）
+    pub confirm: bool,
+    /// 是否在片段面板中置顶
+    pub pinned: bool,
+    /// 创建时间（Unix 毫秒，用于列表排序）
+    pub created_at: u64,
+}
+
+impl Default for CommandSnippet {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            name: String::new(),
+            command: String::new(),
+            description: String::new(),
+            group: String::new(),
+            defaults: std::collections::BTreeMap::new(),
+            shell_kinds: Vec::new(),
+            ssh_only: false,
+            confirm: false,
+            pinned: false,
+            created_at: 0,
+        }
+    }
+}
+
+/// 从命令文本中提取 `${name}` 占位符名（去重、保持出现顺序）。
+///
+/// 放在 Rust 侧而不是前端：占位符是**命令语义的一部分**，执行前的替换、
+/// 校验与「哪些占位符还没填」的判断必须用同一套解析，
+/// 两边各写一遍迟早会在边界情况（`$${x}`、`${a}${b}` 相邻）上分叉。
+pub fn snippet_placeholders(command: &str) -> Vec<String> {
+    let bytes = command.as_bytes();
+    let mut out: Vec<String> = Vec::new();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        // 找 `${`
+        if bytes[i] == b'$' && i + 1 < bytes.len() && bytes[i + 1] == b'{' {
+            // `$${x}` 是字面量 `${x}`（转义），跳过
+            let escaped = i > 0 && bytes[i - 1] == b'$';
+            if !escaped {
+                if let Some(end) = command[i + 2..].find('}') {
+                    let name = &command[i + 2..i + 2 + end];
+                    // 占位符名限定为标识符形态，避免把 `${VAR:-default}` 这类
+                    // shell 参数展开语法误当成占位符
+                    if !name.is_empty()
+                        && name
+                            .chars()
+                            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
+                        && !out.iter().any(|x| x == name)
+                    {
+                        out.push(name.to_string());
+                    }
+                    i = i + 2 + end + 1;
+                    continue;
+                }
+            }
+        }
+        i += 1;
+    }
+    out
+}
+
+/// 用给定值替换命令里的占位符。
+///
+/// 未提供的占位符**保持原样**（不替换成空串）：静默替换成空串会让
+/// `rm -rf ${dir}` 变成 `rm -rf ` —— 一个参数缺失的命令可能比一个
+/// 显式报错的命令危险得多。调用方应先校验所有占位符都有值。
+pub fn snippet_render(command: &str, values: &std::collections::BTreeMap<String, String>) -> String {
+    let mut out = String::with_capacity(command.len());
+    let bytes = command.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        if bytes[i] == b'$' && i + 1 < bytes.len() && bytes[i + 1] == b'{' {
+            let escaped = i > 0 && bytes[i - 1] == b'$';
+            if !escaped {
+                if let Some(end) = command[i + 2..].find('}') {
+                    let name = &command[i + 2..i + 2 + end];
+                    if !name.is_empty()
+                        && name
+                            .chars()
+                            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
+                    {
+                        match values.get(name) {
+                            Some(v) => out.push_str(v),
+                            None => out.push_str(&command[i..i + 2 + end + 1]),
+                        }
+                        i = i + 2 + end + 1;
+                        continue;
+                    }
+                }
+            }
+        }
+        // 逐字符拷贝，注意 UTF-8 多字节边界：这里直接按字节推进会让
+        // 中文字符被切断。故用 chars().next() 取整字符的长度。
+        let ch = command[i..].chars().next().unwrap_or(' ');
+        out.push(ch);
+        i += ch.len_utf8();
+    }
+    out
+}
+
+// ===== 密钥存储（仅元数据）=====
+
+/// 密钥库的单个条目（元数据，**不含私钥内容**）。
+///
+/// 私钥本体存放在 `{app_data_dir}/terminal/keys/` 的独立文件里（可能是几 KB，
+/// 塞进 Windows 凭据管理器不可靠——单条有大小上限），passphrase 才进凭据管理器。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct KeyMeta {
+    pub id: String,
+    /// 展示名称
+    pub name: String,
+    /// 算法："ed25519" | "rsa" | "ecdsa"
+    pub algorithm: String,
+    /// 位数 / 曲线（RSA 2048/3072/4096；ECDSA P-256/P-384/P-521；ed25519 固定空串）
+    pub bits: u32,
+    /// 公钥指纹（SHA256，OpenSSH 展示格式 `SHA256:xxxx`）
+    pub fingerprint: String,
+    /// 公钥内容（`ssh-ed25519 AAAA... comment`），用于一键复制
+    pub public_key: String,
+    /// 注释
+    pub comment: String,
+    /// 私钥文件名（`keys/` 目录下，相对名）
+    pub file_name: String,
+    /// 创建时间（RFC3339）
+    pub created_at: String,
+    /// 是否由 ssh-agent 托管（P1）
+    pub in_agent: bool,
+}
+
+impl Default for KeyMeta {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            name: String::new(),
+            algorithm: "ed25519".to_string(),
+            bits: 0,
+            fingerprint: String::new(),
+            public_key: String::new(),
+            comment: String::new(),
+            file_name: String::new(),
+            created_at: String::new(),
+            in_agent: false,
+        }
+    }
+}
+
+// ===== 安全 =====
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct SecuritySettings {
+    /// 主机密钥策略："ask"（默认，首次连接必须显式确认指纹）。
+    ///
+    /// **不提供 "auto-accept" 选项**：TOFU 静默接受是 MITM 的入口，
+    /// 属于代码层不该给用户的开关。
+    pub host_key_policy: String,
+    /// 指纹变更时是否阻断（**默认 true**）。关掉会让中间人攻击无声通过，
+    /// 因此前端需以红色风险提示呈现该开关。
+    pub block_on_fingerprint_change: bool,
+    /// 是否记录连接审计日志（P2，默认关；开启后输入输出落盘，含脱敏）
+    pub audit_log: bool,
+}
+
+impl Default for SecuritySettings {
+    fn default() -> Self {
+        Self {
+            host_key_policy: "ask".to_string(),
+            block_on_fingerprint_change: true,
+            audit_log: false,
+        }
+    }
+}
+
+// ===== 根结构 =====
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct TerminalSettings {
+    /// 结构版本号（用于后续迁移判断）
+    pub version: u32,
+    /// 本地 Shell 配置（探测结果 + 用户自定义，合并存放）
+    pub shells: Vec<ShellProfile>,
+    /// SSH 主机条目
+    pub hosts: Vec<SshHost>,
+    /// 密钥元数据
+    pub keys: Vec<KeyMeta>,
+    pub appearance: AppearanceSettings,
+    pub layout: LayoutSettings,
+    pub shortcuts: Vec<ShortcutBinding>,
+    pub selection: TerminalSelectionSettings,
+    pub security: SecuritySettings,
+    /// 「关闭标签页时确认」等行为的白名单：某些会话可豁免确认
+    pub close_confirm_exempt: Vec<String>,
+    /// 上次使用的 Shell id（新建会话时的默认选中项）
+    pub last_shell_id: String,
+    /// 命令片段库
+    pub snippets: Vec<CommandSnippet>,
+    /// 会话模板（一键拉起一组会话 + 布局）
+    pub templates: Vec<SessionTemplate>,
+}
+
+impl Default for TerminalSettings {
+    fn default() -> Self {
+        Self {
+            version: 2,
+            shells: Vec::new(),
+            hosts: Vec::new(),
+            keys: Vec::new(),
+            appearance: AppearanceSettings::default(),
+            layout: LayoutSettings::default(),
+            shortcuts: default_shortcuts(),
+            selection: TerminalSelectionSettings::default(),
+            security: SecuritySettings::default(),
+            close_confirm_exempt: Vec::new(),
+            last_shell_id: String::new(),
+            snippets: Vec::new(),
+            templates: Vec::new(),
+        }
+    }
+}
+
+/// 会话模板：一键拉起一组会话并排成布局。
+///
+/// 拉起语义：`entries[0]` 作为主面板，其余依次以分屏面板加入
+/// （受 `layout.maxPanes` 上限约束，超过 4 个的条目被忽略——
+/// WebGL 上下文上限决定了可见面板不可能超过 4，见 useSessionStream 说明）。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct SessionTemplate {
+    pub id: String,
+    pub name: String,
+    /// 创建时间（Unix 毫秒；模板列表按此排序）
+    pub created_at: u64,
+    pub entries: Vec<TemplateEntry>,
+}
+
+impl Default for SessionTemplate {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            name: String::new(),
+            created_at: 0,
+            entries: Vec::new(),
+        }
+    }
+}
+
+/// 模板中的一个会话条目。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct TemplateEntry {
+    /// `"local"`（shell）| `"ssh"`（主机）
+    pub kind: String,
+    /// 本地 = shell id；SSH = host id。拉起时实时解析——
+    /// 模板只存引用，不快照账号密码（那些在凭据管理器里按 id 存取）。
+    pub target_id: String,
+    /// 保存时的展示名快照（仅用于模板列表显示；target 失效时前端据此标注）
+    pub label: String,
+}
+
+impl Default for TemplateEntry {
+    fn default() -> Self {
+        Self {
+            kind: "local".to_string(),
+            target_id: String::new(),
+            label: String::new(),
+        }
+    }
+}
+
+/// 默认终端内快捷键。
+///
+/// 键位选择依据（Windows Terminal 惯例 + 与项目既有全局快捷键避让）：
+/// - 复制粘贴用 `Ctrl+Shift+C/V` 而**不是** `Ctrl+C/V`：`Ctrl+C` 在终端里必须是
+///   SIGINT，任何对它做复制映射的设计都会破坏 `^C` 中断，这是不可接受的。
+/// - 新建/关闭标签用 `Ctrl+Shift+T/W`，与浏览器习惯一致。
+/// - 跳转标签用 `Alt+1..9`：`Ctrl+数字` 已被翻译模块的 `Ctrl+2`（翻译面板）占用，
+///   而 `Alt+数字` 在终端里通常不产生控制字符，冲突面最小。
+pub fn default_shortcuts() -> Vec<ShortcutBinding> {
+    let pairs: &[(&str, &str)] = &[
+        ("copy", "Ctrl+Shift+C"),
+        ("paste", "Ctrl+Shift+V"),
+        ("newTab", "Ctrl+Shift+T"),
+        ("closeTab", "Ctrl+Shift+W"),
+        ("nextTab", "Ctrl+Tab"),
+        ("prevTab", "Ctrl+Shift+Tab"),
+        ("splitRight", "Ctrl+Shift+D"),
+        ("splitDown", "Ctrl+Shift+E"),
+        ("closePane", "Ctrl+Shift+Q"),
+        ("search", "Ctrl+Shift+F"),
+        ("clear", "Ctrl+Shift+K"),
+        ("fontIncrease", "Ctrl+="),
+        ("fontDecrease", "Ctrl+-"),
+        ("fontReset", "Ctrl+0"),
+        ("toggleSftp", "Ctrl+Shift+P"),
+        ("snippets", "Ctrl+Shift+S"),
+        // 历史用 H（History）。不与 `Ctrl+Shift+H`（替换）冲突 ——
+        // 终端里没有「替换」这个动作。
+        ("history", "Ctrl+Shift+H"),
+        ("renameTab", "F2"),
+        ("sessionSwitcher", "Ctrl+Shift+O"),
+    ];
+    pairs
+        .iter()
+        .map(|(action, keys)| ShortcutBinding {
+            action: action.to_string(),
+            keys: keys.to_string(),
+            enabled: true,
+        })
+        .collect()
+}
+
+impl TerminalSettings {
+    /// 按 id 找主机。
+    pub fn host(&self, id: &str) -> Option<&SshHost> {
+        self.hosts.iter().find(|h| h.id == id)
+    }
+
+    /// 按 id 找 Shell。
+    pub fn shell(&self, id: &str) -> Option<&ShellProfile> {
+        self.shells.iter().find(|s| s.id == id)
+    }
+
+    /// 自愈：修复失效引用、补齐缺失的默认值、推进结构版本。
+    ///
+    /// 沿用 translate 模块确立的 `heal()` 约定：老配置缺字段取默认值，
+    /// 失效引用自动回落，返回是否发生变更（由调用方决定是否落盘）。
+    pub fn heal(&mut self) -> bool {
+        let mut changed = false;
+
+        // 快捷键表：补齐新增动作、剔除已废弃动作。用户改过的键位保留。
+        let defaults = default_shortcuts();
+        for d in &defaults {
+            if !self.shortcuts.iter().any(|s| s.action == d.action) {
+                self.shortcuts.push(d.clone());
+                changed = true;
+            }
+        }
+        let before = self.shortcuts.len();
+        // 只保留默认表里存在的 action，避免版本升级后残留无人消费的绑定
+        self.shortcuts
+            .retain(|s| defaults.iter().any(|d| d.action == s.action));
+        if self.shortcuts.len() != before {
+            changed = true;
+        }
+
+        // 主机的 key_id 指向已删除的密钥 → 清空并退回密码认证的提示由前端给，
+        // 这里只做数据层清理（不回退 auth_method，避免静默改变用户的认证选择）
+        let key_ids: Vec<String> = self.keys.iter().map(|k| k.id.clone()).collect();
+        for host in &mut self.hosts {
+            if !host.key_id.is_empty() && !key_ids.contains(&host.key_id) {
+                host.key_id.clear();
+                changed = true;
+            }
+        }
+
+        // 主机字段兜底：端口非法、用户名缺失等由前端表单保证，这里只防越界
+        for host in &mut self.hosts {
+            if host.port == 0 {
+                host.port = 22;
+                changed = true;
+            }
+            if host.connect_timeout_ms < 1000 {
+                host.connect_timeout_ms = 15_000;
+                changed = true;
+            }
+            if host.encoding.trim().is_empty() {
+                host.encoding = "utf-8".to_string();
+                changed = true;
+            }
+        }
+
+        // 外观：滚动缓冲与字体大小越界会直接导致渲染异常
+        if self.appearance.scrollback < 100 {
+            self.appearance.scrollback = 10_000;
+            changed = true;
+        }
+        if self.appearance.scrollback > 200_000 {
+            self.appearance.scrollback = 200_000;
+            changed = true;
+        }
+        if self.appearance.font_size < 8 || self.appearance.font_size > 40 {
+            self.appearance.font_size = 14;
+            changed = true;
+        }
+
+        // 布局：分屏上限封顶 4
+        if self.layout.max_panes == 0 || self.layout.max_panes > 4 {
+            self.layout.max_panes = 4;
+            changed = true;
+        }
+
+        // last_shell_id 指向已删除的 Shell → 清空，由前端选第一个可用
+        if !self.last_shell_id.is_empty() && self.shell(&self.last_shell_id).is_none() {
+            self.last_shell_id.clear();
+            changed = true;
+        }
+
+        if self.version < 1 {
+            self.version = 1;
+            changed = true;
+        }
+
+        // v2：引入命令片段库。给**空库**塞一批起步片段 ——
+        // 一个空片段面板对着用户等于没有这个功能，而「自己写第一条」的门槛
+        // 比「改一条现成的」高得多。只在空库时注入，用户删光后不会被重塞。
+        if self.version < 2 {
+            if self.snippets.is_empty() {
+                self.snippets = default_snippets();
+            }
+            self.version = 2;
+            changed = true;
+        }
+
+        changed
+    }
+}
+
+/// 起步命令片段。
+///
+/// 选取标准：**跨平台通用、参数化后确有复用价值、且不容易打错**的东西。
+/// 刻意不放 `ls`/`cd` 这类过短命令 —— 它们手打比在列表里找更快，
+/// 放进片段库只会稀释信噪比。
+pub fn default_snippets() -> Vec<CommandSnippet> {
+    fn mk(
+        id: &str,
+        name: &str,
+        command: &str,
+        description: &str,
+        group: &str,
+        placeholders: &[(&str, &str)],
+        ssh_only: bool,
+        confirm: bool,
+    ) -> CommandSnippet {
+        CommandSnippet {
+            id: id.to_string(),
+            name: name.to_string(),
+            command: command.to_string(),
+            description: description.to_string(),
+            group: group.to_string(),
+            defaults: placeholders
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect(),
+            shell_kinds: Vec::new(),
+            ssh_only,
+            confirm,
+            pinned: false,
+            created_at: 0,
+        }
+    }
+
+    vec![
+        mk(
+            "snip-find-large",
+            "查找大文件",
+            "find ${dir} -type f -size +${size} -exec ls -lh {} \\;",
+            "列出指定目录下大于指定体积的文件。size 用 100M / 1G 这类写法。",
+            "文件",
+            &[("dir", "/"), ("size", "100M")],
+            false,
+            false,
+        ),
+        mk(
+            "snip-grep-recursive",
+            "递归搜索内容",
+            "grep -rn --include=${pattern} '${keyword}' ${dir}",
+            "在指定目录下按文件名模式递归搜索关键字。",
+            "文件",
+            &[("pattern", "*.log"), ("keyword", ""), ("dir", ".")],
+            false,
+            false,
+        ),
+        mk(
+            "snip-tar-extract",
+            "解压 tar.gz",
+            "tar -xzvf ${file} -C ${target}",
+            "解压到指定目录。target 留空则解到当前目录。",
+            "文件",
+            &[("file", ""), ("target", ".")],
+            false,
+            false,
+        ),
+        mk(
+            "snip-df",
+            "磁盘占用概览",
+            "df -h | sort -k5 -hr | head -20",
+            "按使用率倒序列出挂载点。排查「磁盘满了」的第一步。",
+            "诊断",
+            &[],
+            false,
+            false,
+        ),
+        mk(
+            "snip-port-owner",
+            "查端口占用",
+            "ss -tlnp | grep ${port}",
+            "查看监听指定端口的进程。老系统若无 ss，改用 netstat -tlnp。",
+            "诊断",
+            &[("port", "8080")],
+            false,
+            false,
+        ),
+        mk(
+            "snip-top-cpu",
+            "CPU 占用前 10",
+            "ps aux --sort=-%cpu | head -11",
+            "按 CPU 占用倒序列出进程（含表头共 11 行）。",
+            "诊断",
+            &[],
+            false,
+            false,
+        ),
+        mk(
+            "snip-tail-follow",
+            "跟踪日志",
+            "tail -f ${file}",
+            "实时跟随文件新增内容。Ctrl+C 退出。",
+            "运维",
+            &[("file", "")],
+            false,
+            false,
+        ),
+        mk(
+            "snip-systemd-status",
+            "服务状态",
+            "systemctl status ${service} --no-pager",
+            "查看 systemd 服务状态。--no-pager 让输出直接落到终端而不是进 less。",
+            "运维",
+            &[("service", "")],
+            true,
+            false,
+        ),
+        mk(
+            "snip-perm-fix",
+            "递归修正属主",
+            "chown -R ${owner}:${group} ${dir}",
+            "递归修改目录属主与属组。",
+            "运维",
+            &[("owner", ""), ("group", ""), ("dir", "")],
+            true,
+            true,
+        ),
+        mk(
+            "snip-ssh-tunnel",
+            "建立 SSH 隧道",
+            "ssh -N -L ${localPort}:${remoteHost}:${remotePort} ${user}@${jumpHost}",
+            "本地端口转发。localPort 是你要在本机访问的端口。",
+            "网络",
+            &[
+                ("localPort", "8080"),
+                ("remoteHost", "127.0.0.1"),
+                ("remotePort", "80"),
+                ("user", ""),
+                ("jumpHost", ""),
+            ],
+            false,
+            false,
+        ),
+        mk(
+            "snip-ssh-keygen",
+            "生成 SSH 密钥",
+            "ssh-keygen -t ed25519 -C \"${comment}\" -f ~/.ssh/${name}",
+            "生成 ed25519 密钥对。ed25519 比 RSA 短且更快，现代环境首选。",
+            "网络",
+            &[("comment", ""), ("name", "id_ed25519")],
+            false,
+            false,
+        ),
+    ]
+}

src-tauri/src/terminal/shell.rs

@@ -0,0 +1,687 @@
+//! 本地 Shell 探测、命令行组装与 cwd 跟踪 hook 注入。
+//!
+//! # cwd 为什么需要 hook
+//!
+//! ConPTY 拿不到子 shell 的真实工作目录：`GetCurrentDirectory` 返回的是**我们
+//! 自己进程**的目录，不是子进程的；`NtQueryInformationProcess` 读 PEB 虽然可行，
+//! 但需要每帧轮询且对已提权进程无权访问。业界通行做法是让 shell 在每次提示符
+//! 绘制时输出 **OSC 7** 转义序列（`ESC ] 7 ; file://host/path BEL`），
+//! Windows Terminal / VS Code Terminal 都走这条路。
+//!
+//! 这是「SFTP 跟随终端目录」的前置能力，因此 P0 就做进去，而不是等到 P1 再补。
+
+use std::path::{Path, PathBuf};
+
+use super::settings::{EnvVar, ShellProfile};
+
+/// 探测结果：合并「自动发现的 Shell」与「用户已有的自定义配置」。
+///
+/// 合并策略：**以自动探测为权威源修正路径**（用户机器上升级了 PowerShell 7，
+/// 路径可能变化），但保留用户设置的名字、参数、环境变量。已不存在且非用户自定义
+/// 的条目直接丢弃（`pwsh.exe` 卸载后不该留一个点不动的菜单项）。
+pub fn detect_and_merge(existing: &[ShellProfile]) -> Vec<ShellProfile> {
+    let detected = detect_shells();
+    let mut result: Vec<ShellProfile> = Vec::with_capacity(detected.len() + 2);
+
+    for mut d in detected {
+        if let Some(old) = existing.iter().find(|s| s.id == d.id) {
+            // 保留用户的个性化字段，路径以探测结果为准
+            d.name = if old.name.trim().is_empty() {
+                d.name.clone()
+            } else {
+                old.name.clone()
+            };
+            d.args = old.args.clone();
+            d.cwd = old.cwd.clone();
+            d.env = old.env.clone();
+            d.enabled = old.enabled;
+            d.detected = true;
+            // 用户在自定义条目上填过的路径若仍存在，尊重用户选择
+            if !old.path.trim().is_empty() && Path::new(&old.path).exists() && !old.detected {
+                d.path = old.path.clone();
+                d.detected = false;
+            }
+        }
+        result.push(d);
+    }
+
+    // 追加用户手工新增的、当前探测不到的条目（prune 逻辑在前端确认删除后执行）
+    for old in existing {
+        if old.detected {
+            continue; // 自动探测项已在上面的循环里处理（含丢弃已失效的）
+        }
+        if result.iter().any(|s| s.id == old.id) {
+            continue;
+        }
+        result.push(old.clone());
+    }
+
+    result
+}
+
+/// 自动探测本机可用的 Shell。
+///
+/// 顺序即菜单顺序，也是新建会话时的默认选中顺序（按现代性与功能排序）。
+pub fn detect_shells() -> Vec<ShellProfile> {
+    let mut list = Vec::new();
+
+    // PowerShell 7+（优先：跨平台、默认 UTF-8、语法现代）
+    if let Some(p) = find_in_path(&["pwsh.exe"]) {
+        list.push(ShellProfile::new("pwsh", "PowerShell 7", &p, "powershell"));
+    }
+    // Windows PowerShell（系统必带，作保底）
+    if let Some(p) = find_windows_powershell() {
+        list.push(ShellProfile::new(
+            "powershell",
+            "Windows PowerShell",
+            &p,
+            "powershell",
+        ));
+    }
+    // cmd
+    if let Some(p) = find_in_path(&["cmd.exe"]).or_else(find_cmd_fallback) {
+        list.push(ShellProfile::new("cmd", "命令提示符", &p, "cmd"));
+    }
+    // Git Bash（从 git 的安装目录反推，比扫 PATH 可靠）
+    if let Some(p) = find_git_bash() {
+        list.push(ShellProfile::new("gitbash", "Git Bash", &p, "bash"));
+    }
+    // WSL 发行版：每个发行版一个条目
+    for distro in list_wsl_distros() {
+        let id = format!("wsl-{}", sanitize_id(&distro));
+        let name = format!("WSL · {distro}");
+        let mut profile = ShellProfile::new(&id, &name, "wsl.exe", "wsl");
+        profile.args = vec!["-d".to_string(), distro];
+        list.push(profile);
+    }
+
+    list
+}
+
+/// 在 PATH 中查找可执行文件。
+fn find_in_path(names: &[&str]) -> Option<String> {
+    let path = std::env::var_os("PATH")?;
+    for dir in std::env::split_paths(&path) {
+        for name in names {
+            let candidate = dir.join(name);
+            if candidate.is_file() {
+                return Some(candidate.to_string_lossy().to_string());
+            }
+        }
+    }
+    None
+}
+
+/// 定位 Windows PowerShell。
+///
+/// 优先用 `%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe`（权威路径），
+/// 而不是查 PATH——PATH 里可能有同名伪装程序。
+fn find_windows_powershell() -> Option<String> {
+    let root = std::env::var_os("SystemRoot")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from(r"C:\Windows"));
+    let p = root
+        .join("System32")
+        .join("WindowsPowerShell")
+        .join("v1.0")
+        .join("powershell.exe");
+    if p.is_file() {
+        return Some(p.to_string_lossy().to_string());
+    }
+    find_in_path(&["powershell.exe"])
+}
+
+fn find_cmd_fallback() -> Option<String> {
+    let root = std::env::var_os("SystemRoot")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from(r"C:\Windows"));
+    let p = root.join("System32").join("cmd.exe");
+    if p.is_file() {
+        return Some(p.to_string_lossy().to_string());
+    }
+    find_in_path(&["cmd.exe"])
+}
+
+/// 定位 Git Bash。
+///
+/// 先查 PATH 上的 `bash.exe`（Git 安装时通常会把 `Git\bin` 或 `Git\usr\bin` 加进去），
+/// 但更要紧的是排除掉 WSL 的 `bash.exe`（`System32\bash.exe`）——它不是 Git Bash，
+/// 混用会导致用户点「Git Bash」却进了 WSL。
+fn find_git_bash() -> Option<String> {
+    let candidates = [
+        r"C:\Program Files\Git\bin\bash.exe",
+        r"C:\Program Files (x86)\Git\bin\bash.exe",
+    ];
+    for c in candidates {
+        if Path::new(c).is_file() {
+            return Some(c.to_string());
+        }
+    }
+    // 从 HOME 下的常见位置反推（scoop / 便携版）
+    if let Some(home) = dirs::home_dir() {
+        for rel in [r"scoop\apps\git\current\bin\bash.exe", r"AppData\Local\Programs\Git\bin\bash.exe"] {
+            let p = home.join(rel);
+            if p.is_file() {
+                return Some(p.to_string_lossy().to_string());
+            }
+        }
+    }
+    // 最后才查 PATH，且必须排除 System32（那是 WSL 的 bash）
+    find_in_path(&["bash.exe"]).filter(|p| {
+        let lower = p.to_lowercase();
+        !lower.contains("system32") && !lower.contains("windowsapps")
+    })
+}
+
+/// 枚举 WSL 发行版。
+///
+/// `wsl.exe -l -q` 输出 UTF-16LE（Windows 上部分 wsl.exe 版本如此），
+/// 先按 UTF-16 解，失败再按 UTF-8 解。输出每行一个发行版名。
+fn list_wsl_distros() -> Vec<String> {
+    let out = match std::process::Command::new("wsl.exe")
+        .args(["-l", "-q"])
+        .creation_flags_no_window()
+        .output()
+    {
+        Ok(o) if o.status.success() => o.stdout,
+        _ => return Vec::new(),
+    };
+
+    let text = decode_wsl_output(&out);
+    text.lines()
+        .map(|l| l.trim().trim_matches('\0').to_string())
+        // 过滤空行与提示行（"适用于 Linux 的 Windows 子系统..." 之类）
+        .filter(|l| !l.is_empty() && !l.contains(' ') )
+        .collect()
+}
+
+/// WSL 输出可能是 UTF-16LE 或 UTF-8，试两种。
+fn decode_wsl_output(bytes: &[u8]) -> String {
+    // UTF-16LE 的特征：ASCII 字符之间夹 0x00，且长度为偶数
+    let looks_utf16 = bytes.len() >= 4 && bytes.len() % 2 == 0 && bytes.iter().skip(1).step_by(2).filter(|&&b| b == 0).count() > bytes.len() / 4;
+    if looks_utf16 {
+        let units: Vec<u16> = bytes
+            .chunks_exact(2)
+            .map(|c| u16::from_le_bytes([c[0], c[1]]))
+            .collect();
+        String::from_utf16_lossy(&units)
+    } else {
+        String::from_utf8_lossy(bytes).to_string()
+    }
+}
+
+/// 把发行版名转成可用作 id 的字符串。
+fn sanitize_id(s: &str) -> String {
+    s.chars()
+        .map(|c| if c.is_ascii_alphanumeric() { c.to_ascii_lowercase() } else { '-' })
+        .collect()
+}
+
+/// 组装完整的命令行字符串。
+///
+/// Windows 的 `CreateProcessW` 在 `lpApplicationName = NULL` 时会自行解析命令行首段，
+/// 因此**路径含空格必须加引号**（`C:\Program Files\...` 不加引号会被切成
+/// `C:\Program` + 参数）。这里统一处理。
+pub fn build_command_line(profile: &ShellProfile) -> String {
+    let mut s = quote_if_needed(&profile.path);
+    for a in &profile.args {
+        s.push(' ');
+        s.push_str(&quote_if_needed(a));
+    }
+    // 启动后自动执行的命令：拼在参数之后，由 shell 自己解析
+    if !profile.cwd.is_empty() {
+        // cwd 由 CreateProcessW 的 lpCurrentDirectory 处理，不在这里拼
+    }
+    s
+}
+
+/// 需要时加引号。
+fn quote_if_needed(s: &str) -> String {
+    if s.contains(' ') && !s.starts_with('"') {
+        format!("\"{s}\"")
+    } else {
+        s.to_string()
+    }
+}
+
+/// 把 [`ShellProfile::env`] 转成 `CreateProcessW` 需要的键值对。
+pub fn env_pairs(env: &[EnvVar]) -> Vec<(String, String)> {
+    env.iter()
+        .filter(|e| !e.key.trim().is_empty())
+        .map(|e| (e.key.clone(), e.value.clone()))
+        .collect()
+}
+
+/// 为指定 Shell 生成 cwd 跟踪 hook 的注入参数。
+///
+/// 返回值是**额外的启动参数**，需要由调用方拼到命令行里。返回空表示该 Shell
+/// 无法通过参数注入（如 cmd），此时退化为不跟踪 cwd。
+///
+/// # 各 Shell 的注入方式与理由
+///
+/// - **PowerShell / pwsh**：`-NoExit -EncodedCommand <base64>`。脚本重定义 `prompt` 函数，
+///   在原有提示符前输出 OSC 7。用 `-NoExit` 是因为 `-Command` 默认会在脚本结束后
+///   退出 shell，而我们只要它执行一段初始化。**不覆盖用户已有的 profile**：
+///   `-Command` 在 profile 加载之后执行，属于叠加而非替换。
+///   用 `-EncodedCommand` 而不是 `-Command`：脚本里含**双引号**（`Write-Host "..."`），
+///   而 `CreateProcessW` 的命令行是单一字符串，引号必须按 MSVCRT 规则转义；
+///   直接拼 `-Command "script"` 时脚本内的 `"` 会提前终结外层引号，
+///   PowerShell 收到的是引号被剥掉的残缺脚本 → `Unexpected token '$('` 解析错误。
+///   `-EncodedCommand` 接收 base64（UTF-16LE），纯字母数字，与引号解析彻底无关。
+/// - **Git Bash**：`--init-file <文件>`。需要落一个临时脚本文件，因为 bash 的
+///   `--init-file` 只接受文件路径。脚本里用 `PROMPT_COMMAND` 输出 OSC 7。
+/// - **cmd**：无可靠注入点（`PROMPT` 环境变量不支持转义序列输出 ESC）。
+///   不跟踪，`cwd` 字段保持为空——这是能力边界，如实呈现而不糊弄。
+/// - **WSL**：与 bash 同理，但需要写到 WSL 内部路径，成本高。P0 不跟踪。
+pub fn cwd_hook_args(profile: &ShellProfile, hook_dir: &Path) -> (Vec<String>, Option<PathBuf>) {
+    match profile.kind.as_str() {
+        "powershell" => {
+            let script = powershell_prompt_hook();
+            (
+                vec![
+                    "-NoExit".to_string(),
+                    "-EncodedCommand".to_string(),
+                    encode_powershell_command(&script),
+                ],
+                None,
+            )
+        }
+        "bash" => {
+            let file = hook_dir.join("gitbash-cwd-hook.sh");
+            let content = bash_prompt_hook();
+            if std::fs::write(&file, content).is_err() {
+                return (Vec::new(), None);
+            }
+            (
+                vec!["--init-file".to_string(), file.to_string_lossy().to_string()],
+                Some(file),
+            )
+        }
+        // cmd / wsl：没有可靠注入点，不跟踪 cwd
+        _ => (Vec::new(), None),
+    }
+}
+
+/// 把脚本编码成 PowerShell `-EncodedCommand` 接受的 base64（UTF-16LE）。
+///
+/// PowerShell（5.1 与 7+）按 UTF-16LE 解码该参数；编码后不含空格与引号，
+/// 经过 [`build_command_line`] 的引用规则时不会被改写。
+fn encode_powershell_command(script: &str) -> String {
+    use base64::engine::general_purpose::STANDARD as B64;
+    use base64::Engine as _;
+
+    let utf16le: Vec<u8> = script
+        .encode_utf16()
+        .flat_map(u16::to_le_bytes)
+        .collect();
+    B64.encode(utf16le)
+}
+
+/// PowerShell 提示符 hook。
+///
+/// 关键点：
+/// - 用 `$ExecutionContext.SessionState.Path.CurrentLocation` 取当前路径
+/// - `file://` 后的主机名用 `$env:COMPUTERNAME`（本地会话无实际意义，但保持格式合法）
+/// - 路径里的反斜杠要转成 `/`，且 `file://` 三段式后不能有多余斜杠
+///   （否则部分解析器会把盘符吃掉）
+/// - 结尾用 BEL（`` `a ``）而不是 ST：BEL 兼容性最好，Windows Terminal 也用它
+///
+/// 注意 `$PWD` 在 PowerShell 里是 `PathInfo` 对象而非字符串，直接插值会得到
+/// `Microsoft.PowerShell.Core\FileSystem::C:\...` 这种非预期内容，因此用
+/// `ProviderPath` 显式取字符串路径。
+///
+/// # OSC 133 命令边界（命令历史的来源）
+///
+/// PowerShell 的提示符函数在「上一条命令执行完、即将显示新提示符」这个时刻被调用，
+/// 因此这里输出的是 **D（上一条结束）** 而不是 C（即将开始）。
+///
+/// 退出码取自 `$LASTEXITCODE`（原生命令）或 `$?`（cmdlet），两者语义不同：
+/// cmdlet 成功时 `$LASTEXITCODE` 可能保留着**更早那条原生命令**的值。
+/// 因此优先 `$LASTEXITCODE`（仅当其在本轮被设置过），否则用 `$?` 折算 0/1。
+/// 无法拿到 `$?` 的历史值 —— 它会被提示符函数自身的第一条语句覆盖，
+/// 所以这个取值必须在函数体**最开头**完成。
+fn powershell_prompt_hook() -> String {
+    [
+        "$__thingOrigPrompt = $function:prompt;",
+        "function global:prompt {",
+        // 必须最先取：后面任何一条语句都会刷新 $?
+        "  $__ok = $?;",
+        "  $__code = $LASTEXITCODE;",
+        "  if ($null -eq $__code) { $__code = if ($__ok) { 0 } else { 1 } }",
+        "  Write-Host -NoNewline \"$([char]27)]133;D;$__code$([char]7)\";",
+        "  $__p = $ExecutionContext.SessionState.Path.CurrentLocation;",
+        "  $__loc = $__p.ProviderPath;",
+        "  if ($__loc) {",
+        "    $__u = $__loc -replace '\\\\','/';",
+        "    if ($__u -notmatch '^/') { $__u = '/' + $__u }",
+        "    Write-Host -NoNewline \"$([char]27)]7;file://$env:COMPUTERNAME$__u$([char]7)\";",
+        "  }",
+        "  if ($__thingOrigPrompt) { & $__thingOrigPrompt } else { 'PS ' + (Get-Location) + '> ' }",
+        "}",
+    ]
+    .join(" ")
+}
+
+/// Git Bash 提示符 hook。
+///
+/// 用 `PROMPT_COMMAND` 而不是重定义 `PS1`：`PROMPT_COMMAND` 在每次绘制提示符前
+/// 执行，且不干扰用户自己设置的 `PS1`（重定义 PS1 会覆盖用户的样式）。
+///
+/// # 命令历史的来源（OSC 133 + 1337）
+///
+/// bash 没有「命令执行完」的钩子，但 `PROMPT_COMMAND` 恰好在同一时刻运行，
+/// 且此时 `$?` 仍是上一条命令的退出码（任何语句都会覆盖它，所以先存后读）。
+///
+/// 命令文本取自 `history 1`：它返回 `  123  <命令>`（前导空格 + 序号 + 空格）。
+/// 用 `history 1` 而不是 `BASH_COMMAND` 或 `$1`：
+/// - `BASH_COMMAND` 在 `PROMPT_COMMAND` 里指向的是 `PROMPT_COMMAND` 自身
+/// - `history 1` 给的是 **shell 最终执行的那条**，别名已展开、Tab 补全已生效
+///
+/// # 为什么 `history 1` 要去掉序号而不是按空格切
+///
+/// 序号与命令之间是**两个空格**分隔，但命令本身可能以空格开头
+/// （用户刻意用前导空格隐藏命令）。用 `sed 's/^ *[0-9]* *//'` 会连用户的
+/// 前导空格一起吃掉，导致「刻意隐藏的命令」变成普通命令被记进我们的历史 ——
+/// 这正好违背用户意图。因此用「剥掉前导空白 + 数字 + 一个空格」的精确匹配，
+/// 保留命令本身的任何前导空格... 但这样又与我们「前导空格不入库」的规则冲突。
+///
+/// 结论：**保留 shell 的原样输出交给 Rust 侧判断** —— hook 只管如实上报，
+/// 「前导空格要不要记」是策略，由 `History::record` 统一决定（那里也是
+/// `HISTCONTROL=ignorespace` 的落点）。hook 里做策略判断会散落成两处规则。
+fn bash_prompt_hook() -> String {
+    [
+        "# Thing 终端：shell integration hook（由终端模块注入，可安全删除）",
+        "# 输出 OSC 7（cwd）与 OSC 133/1337（命令边界与命令文本），",
+        "# 供文件管理器、cwd 继承与命令历史使用",
+        "__thing_osc7() {",
+        "  local __code=$?",
+        "  printf '\\033]133;D;%s\\007' \"$__code\"",
+        // 取最后一条历史：`history 1` 返回 `  123  <命令>`
+        // （前导空格 + 序号 + 两个空格 + 命令本体）。
+        //
+        // 用 `read -r` 拆而不是参数展开剥前缀：`${x#"$y"}` 这种嵌套引号在
+        // Rust 字符串字面量里要转义到难以阅读，而且 `history` 的输出里
+        // 命令本体可能**含空格**，参数展开必须保留剩余全部内容。
+        // `read -r _ _ __cmd` 的语义恰好是「跳过前两段空白分隔的字段，
+        // 其余原样（含内部空格）收进 __cmd」—— 正是所需，且引号最少。
+        "  local __cmd=''",
+        "  read -r _ _ __cmd <<< \"$(HISTTIMEFORMAT= builtin history 1)\"",
+        "  printf '\\033]1337;Cmd=%s\\007' \"$__cmd\"",
+        "  printf '\\033]7;file://%s%s\\007' \"${HOSTNAME:-localhost}\" \"$PWD\"",
+        "}",
+        "if [[ -n \"$PROMPT_COMMAND\" ]]; then",
+        "  PROMPT_COMMAND=\"__thing_osc7; $PROMPT_COMMAND\"",
+        "else",
+        "  PROMPT_COMMAND=\"__thing_osc7\"",
+        "fi",
+        "",
+    ]
+    .join("\n")
+}
+
+/// 清屏命令（按 Shell 类型区分）。
+pub fn clear_command(kind: &str) -> &'static str {
+    match kind {
+        "cmd" => "cls\r",
+        "powershell" => "Clear-Host\r",
+        // bash / wsl：`clear` 是 ANSI 序列，也可直接发 \x1bc 复位
+        _ => "clear\r",
+    }
+}
+
+use std::os::windows::process::CommandExt;
+
+/// `Command::creation_flags` 的糖：隐藏控制台窗口。
+trait NoWindow {
+    fn creation_flags_no_window(&mut self) -> &mut Self;
+}
+
+impl NoWindow for std::process::Command {
+    fn creation_flags_no_window(&mut self) -> &mut Self {
+        // CREATE_NO_WINDOW = 0x08000000，避免探测 wsl 时闪一个黑框
+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+        self.creation_flags(CREATE_NO_WINDOW)
+    }
+}
+
+/// 解析终端输出流中的 OSC 7（cwd）、OSC 0/2（标题）与 OSC 133（命令边界）序列。
+///
+/// 输入是原始字节流的一个片段，可能**不完整**（序列被切在中间）。因此本函数
+/// 采用「窗口扫描 + 保留尾部」策略：
+/// - 完整解析到的序列被消费掉
+/// - 未闭合的序列从起始 ESC 开始保留到缓冲区末尾，等下一批数据拼接
+///
+/// 返回 [`ParsedSequences`]，而不是继续扩元组 —— 再加一类序列就要变成 4 元组，
+/// 调用点会退化成一串 `let (_, _, x, _) = ...`，加字段时无从判断哪里该改。
+pub fn parse_control_sequences(data: &[u8]) -> ParsedSequences {
+    let mut out = ParsedSequences {
+        consumed: data.len(),
+        cwds: Vec::new(),
+        titles: Vec::new(),
+        marks: Vec::new(),
+    };
+    let mut i = 0usize;
+    // 最后一个「未消费但可能是序列开头」的位置
+    let mut safe_end = data.len();
+
+    while i < data.len() {
+        if data[i] != 0x1b {
+            i += 1;
+            continue;
+        }
+        // ESC ] ... 起点
+        if i + 1 >= data.len() {
+            safe_end = i;
+            break;
+        }
+        if data[i + 1] != b']' {
+            i += 1;
+            continue;
+        }
+        // 找终止符：BEL(0x07) 或 ST(ESC \)
+        let start = i + 2;
+        let mut j = start;
+        let mut terminated = false;
+        while j < data.len() {
+            if data[j] == 0x07 {
+                terminated = true;
+                break;
+            }
+            if data[j] == 0x1b && j + 1 < data.len() && data[j + 1] == b'\\' {
+                terminated = true;
+                break;
+            }
+            j += 1;
+        }
+        if !terminated {
+            // 序列被切断了，从 ESC 位置保留到末尾
+            safe_end = i;
+            break;
+        }
+
+        let body_end = j;
+        let payload = String::from_utf8_lossy(&data[start..body_end]).to_string();
+        // 消费的长度：ESC ] body 终止符(BEL 1 字节 / ST 2 字节)
+        let consumed_end = if data[body_end] == 0x07 { body_end + 1 } else { body_end + 2 };
+        i = consumed_end;
+
+        if let Some(rest) = payload.strip_prefix("7;") {
+            if let Some(cwd) = parse_osc7(rest) {
+                out.cwds.push(cwd);
+            }
+        } else if let Some(rest) = payload.strip_prefix("0;").or_else(|| payload.strip_prefix("2;")) {
+            if !rest.trim().is_empty() {
+                out.titles.push(rest.to_string());
+            }
+        } else if payload.starts_with("133;") {
+            if let Some(mark) = parse_osc133(&payload) {
+                out.marks.push(mark);
+            }
+        }
+    }
+
+    // 消费掉完整解析过的部分，保留尾部残留
+    let consumed = if safe_end < data.len() && i <= safe_end {
+        safe_end.max(i)
+    } else {
+        i.min(data.len())
+    };
+    out.consumed = consumed;
+    out
+}
+
+/// OSC 133 命令边界标记（shell integration 协议）。
+///
+/// # 为什么需要它才能记录命令历史
+///
+/// 终端应用要记录「用户执行了什么命令」，直觉做法是「把用户在键盘上敲的字符
+/// 攒起来，遇到回车就存」。这条路**必然出错**：
+/// - 退格、方向键、`Ctrl+U` 都会改写已敲内容，前端拿到的是一串 `\x7f` 与 `\x1b[D`
+/// - Tab 补全的结果是由 shell 生成的，前端根本不知道补全成了什么
+/// - 别名（`ll` → `ls -al`）、历史展开（`!!`）同理
+///
+/// OSC 133 由 **shell 自己**在提示符处输出，因此上述问题全部不存在 ——
+/// 它报告的是 shell 最终真正执行的那条命令。
+///
+/// # 协议形态
+///
+/// - `OSC 133 ; A` — 提示符开始（准备接收输入）
+/// - `OSC 133 ; B` — 输入区开始
+/// - `OSC 133 ; C` — 命令开始执行
+/// - `OSC 133 ; D ; <exit_code>` — 命令结束，可选携带退出码
+/// - `OSC 133 ; D` — 命令结束，无退出码
+///
+/// 本模块只关心 `D`：它标志着「上一条命令执行完毕」，此刻可以上报。
+///
+/// # 关于「命令文本从哪来」
+///
+/// OSC 133 的 `C` 标记**不携带命令文本**（协议本身只管边界，不管内容）。
+/// 要拿到文本，标准做法是 shell hook 里额外输出一个自定义序列
+/// （如 `OSC 633 ; E ; <cmd>`，VS Code 用这个）。这里沿用同一思路，
+/// 用 `OSC 1337 ; Cmd=<cmd>`（见 `shell_integration_script`）。
+///
+/// 把「命令文本」与「边界」分开传输，是因为前者需要 shell 侧配合转义
+/// （命令里可能含 `\a`、`\x1b`），而边界只要一个字符，两者可靠性诉求不同 ——
+/// 混在一个序列里会让「命令含 BEL 字符」直接破坏边界解析。
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CommandMark {
+    /// 命令开始执行（`C`）
+    Start,
+    /// 命令结束（`D`），携带退出码（若有）
+    End(Option<i32>),
+    /// 即将执行的命令文本（自定义序列，见上）
+    Command(String),
+}
+
+/// 解析 OSC 133 / 1337 的载荷（**不含** `OSC ` 前缀）。
+fn parse_osc133(payload: &str) -> Option<CommandMark> {
+    // 自定义序列必须**先**判断：`1337;Cmd=...` 与 `133;...` 共享 `133` 前缀，
+    // 若先走 `strip_prefix("133;")`，`1337;` 因第 4 字符是 `7` 而非 `;` 而失配，
+    // 结果是「命令文本永远收不到，且不报错」—— 静默失效最难查。
+    if let Some(cmd) = payload.strip_prefix("1337;Cmd=") {
+        return Some(CommandMark::Command(cmd.to_string()));
+    }
+
+    let rest = payload.strip_prefix("133;")?;
+
+    match rest.chars().next()? {
+        'C' => Some(CommandMark::Start),
+        'D' => {
+            // `D` / `D;0` / `D;1` —— 分号后的部分是退出码
+            let code = rest
+                .strip_prefix("D;")
+                .and_then(|s| s.trim().split(';').next())
+                .filter(|s| !s.is_empty())
+                .and_then(|s| s.parse::<i32>().ok());
+            Some(CommandMark::End(code))
+        }
+        // A / B 与历史记录无关（提示符与输入区起止），显式忽略而非报错：
+        // 它们由同一个 hook 输出，忽略掉比让调用方遍历时到处判类型更省事。
+        _ => None,
+    }
+}
+
+/// `parse_control_sequences` 的结果。
+#[derive(Debug, Clone, Default)]
+pub struct ParsedSequences {
+    /// 已完整解析、可从缓冲区丢弃的字节数
+    pub consumed: usize,
+    /// OSC 7 上报的 cwd（按出现顺序）
+    pub cwds: Vec<String>,
+    /// OSC 0/2 上报的标题
+    pub titles: Vec<String>,
+    /// OSC 133 命令边界标记（按出现顺序）
+    pub marks: Vec<CommandMark>,
+}
+
+/// 从 OSC 7 的载荷解析出本地路径。
+///
+/// 载荷形如 `file://HOST/C:/Users/foo` 或 `file:///home/user`。
+/// Windows 上要处理 `file://HOST/C:/...` → `C:\...` 的还原：
+/// 去掉开头的 `/`，把 `/` 换回 `\`，并把 `C:` 前面的多余斜杠去掉。
+fn parse_osc7(payload: &str) -> Option<String> {
+    let rest = payload.strip_prefix("file://").unwrap_or(payload);
+    // 跳过主机名（第一个 '/' 之前的部分）
+    let path_part = match rest.find('/') {
+        Some(idx) => &rest[idx..],
+        None => rest,
+    };
+    if path_part.is_empty() {
+        return None;
+    }
+    let decoded = percent_decode(path_part);
+    // Windows 盘符形态：/C:/Users → C:\Users
+    let normalized = if decoded.len() >= 3
+        && decoded.starts_with('/')
+        && decoded.as_bytes()[2] == b':'
+    {
+        decoded[1..].replace('/', "\\")
+    } else {
+        decoded.replace('/', "\\")
+    };
+    Some(normalized)
+}
+
+/// 极简百分号解码（OSC 7 里的路径可能含 `%20` 等）。
+fn percent_decode(s: &str) -> String {
+    let bytes = s.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'%' && i + 2 < bytes.len() {
+            let hex = std::str::from_utf8(&bytes[i + 1..i + 3]).ok();
+            if let Some(v) = hex.and_then(|h| u8::from_str_radix(h, 16).ok()) {
+                out.push(v);
+                i += 3;
+                continue;
+            }
+        }
+        out.push(bytes[i]);
+        i += 1;
+    }
+    String::from_utf8_lossy(&out).to_string()
+}
+
+/// 默认工作目录：优先用户主目录，其次当前目录。
+pub fn default_cwd() -> String {
+    dirs::home_dir()
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_else(|| ".".to_string())
+}
+
+/// 校验用户给定的工作目录是否可用（不存在则退回默认，不报错阻断会话创建）。
+pub fn resolve_cwd(requested: &str) -> Option<String> {
+    let r = requested.trim();
+    if r.is_empty() {
+        return Some(default_cwd());
+    }
+    if Path::new(r).is_dir() {
+        Some(r.to_string())
+    } else {
+        crate::logger::log_warn(
+            "terminal",
+            &format!("工作目录 {r} 不存在，退回默认目录"),
+        );
+        Some(default_cwd())
+    }
+}

src-tauri/src/terminal/ssh/forward.rs

@@ -0,0 +1,475 @@
+//! 端口转发引擎（P2）：`-L` 本地转发与 `-R` 远程转发。
+//!
+//! # 两个方向的管线
+//!
+//! **-L（本地转发）**：本机开 `TcpListener`，每来一条连接就在 SSH 会话上开一条
+//! `direct-tcpip` 通道指向目标，然后 `copy_bidirectional` 对拷：
+//!
+//! ```text
+//! 本地应用 ──TCP──▶ TcpListener ──▶ direct-tcpip 通道 ──▶ 服务器 ──▶ target_host:port
+//! ```
+//!
+//! **-R（远程转发）**：通过 `handle.tcpip_forward()` 请求**服务器**监听；
+//! 服务器侧来连接时，russh 在 Handler 的
+//! `server_channel_open_forwarded_tcpip` 回调里把通道交给我们，由我们连到目标：
+//!
+//! ```text
+//! 远端访问者 ──▶ 服务器:bind_port ──forwarded-tcpip 通道──▶ 本机 ──TCP──▶ target_host:port
+//! ```
+//!
+//! # 生命周期与所有权
+//!
+//! 转发规则挂在**会话**上（不持久化）：会话关闭 = 全部转发消失，
+//! 这与 ssh 客户端的直觉一致（连接断开转发即失效）。
+//! `-L` 的监听任务句柄存进注册表，remove 时 `abort()` 释放端口；
+//! `-R` 无本地任务（通道由 Handler 回调驱动），remove 时发 `cancel_tcpip_forward`。
+//!
+//! # 安全默认
+//!
+//! russh 对 `forwarded-tcpip` 通道的默认处理是**全部接受**——意味着只要服务器
+//! 愿意，任何一条 forwarded 通道都会被接受并挂起等数据。本模块的 Handler
+//! 覆写为**白名单匹配**：只有注册过的 `-R` 规则（按监听端口）才放行，其余拒绝。
+//!
+//! # 已知取舍
+//!
+//! - `-D`（SOCKS5 动态转发）不在本模块：需要实现 SOCKS5 握手协议，独立成项再做；
+//! - 转发规则不持久化：每次连接后按需添加。若后续要「主机级自动转发」，
+//!   在主机配置里存模板并在会话 Established 后逐条调 `add_local`/`add_remote` 即可。
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock};
+
+use serde::Serialize;
+use specta::Type;
+
+use super::{Channel, Msg, SshInner};
+use super::super::session::now_millis;
+
+/// 转发规则视图（发往前端）。
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ForwardView {
+    pub id: String,
+    /// `"local"`（-L）| `"remote"`（-R）
+    pub kind: String,
+    /// -L：本机监听地址；-R：**服务器端**监听地址
+    pub bind_host: String,
+    pub bind_port: u16,
+    /// -L：从**服务器**视角要连接的目标；-R：从**服务器**视角连接的目标
+    pub target_host: String,
+    pub target_port: u16,
+    /// `"active"` | `"error"`
+    pub status: String,
+    /// 人类可读状态（实际监听地址 / 错误原因）
+    pub detail: String,
+}
+
+/// 注册表条目。
+pub(crate) struct ForwardEntry {
+    pub rule: ForwardView,
+    /// `-L` 的监听循环任务（remove 时 abort 以释放端口）；`-R` 为 None。
+    pub task: Option<tauri::async_runtime::JoinHandle<()>>,
+}
+
+/// 会话 → (转发 id → 条目)。
+///
+/// 全局静态表的理由与 `PENDING_HOST_KEYS` 相同：转发管道任务的 spawn 点
+/// 分散在命令层与 Handler 回调里，拿不到统一的会话对象引用。
+/// 键直接用 `String`（`SessionId` 是它的别名，此处不依赖别名语义）。
+static REGISTRY: OnceLock<Mutex<HashMap<String, HashMap<String, ForwardEntry>>>> =
+    OnceLock::new();
+
+fn registry() -> &'static Mutex<HashMap<String, HashMap<String, ForwardEntry>>> {
+    REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+fn next_id() -> String {
+    format!("fw{}", now_millis())
+}
+
+/// 列出某会话的全部转发规则。
+pub fn list_for_session(session_id: &str) -> Vec<ForwardView> {
+    registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .get(session_id)
+        .map(|m| m.values().map(|e| e.rule.clone()).collect())
+        .unwrap_or_default()
+}
+
+/// Handler 回调用：按监听端口做**全局**匹配 `-R` 规则。
+///
+/// # 为什么是全局而不是按会话
+///
+/// P2 连接复用之后，入站的 forwarded-tcpip 通道总是从**连接级** Handler
+/// 回调进来，而该 Handler 的 session_id 属于**第一个**建立连接的会话；
+/// 第二个会话添加的 -R 规则若只查自己的 session_id 就永远匹配不上。
+/// 端口的全局唯一性在 `add_remote` 时已强制（重复绑定端口被拒绝），
+/// 因此这里按端口全局查找是安全的。
+///
+/// 返回 `(规则所属会话 id, 目标主机, 目标端口)`；无匹配 = 服务器来了一条
+/// 没有对应规则的转发连接，调用方应拒绝。
+pub(crate) fn match_remote_rule(connected_port: u32) -> Option<(String, String, u16)> {
+    let reg = registry().lock().unwrap_or_else(|e| e.into_inner());
+    for entries in reg.values() {
+        for e in entries.values() {
+            if e.rule.kind == "remote"
+                && e.rule.status == "active"
+                && e.rule.bind_port as u32 == connected_port
+            {
+                return Some((
+                    e.rule.id.clone(),
+                    e.rule.target_host.clone(),
+                    e.rule.target_port,
+                ));
+            }
+        }
+    }
+    None
+}
+
+/// 检查远程监听端口是否已被（任何会话的）规则占用。
+///
+/// 共享连接下两个会话各自 -R 同一端口会让路由产生歧义，必须在添加时拒绝。
+pub(crate) fn remote_port_taken(bind_port: u16) -> bool {
+    let reg = registry().lock().unwrap_or_else(|e| e.into_inner());
+    reg.values().any(|entries| {
+        entries.values().any(|e| {
+            e.rule.kind == "remote" && e.rule.status == "active" && e.rule.bind_port == bind_port
+        })
+    })
+}
+
+/// 标记规则出错（如 `-L` 监听套接字意外失效）。
+fn mark_error(session_id: &str, forward_id: &str, detail: String) {
+    if let Some(e) = registry()
+        .lock()
+        .unwrap_or_else(|x| x.into_inner())
+        .get_mut(session_id)
+        .and_then(|m| m.get_mut(forward_id))
+    {
+        e.rule.status = "error".to_string();
+        e.rule.detail = detail;
+    }
+}
+
+/// 添加 `-L` 本地转发。
+///
+/// 先 `bind` 再 spawn：端口被占用时**立刻**报错返回（fail-fast），
+/// 而不是存了一条永远没有流量的死规则。
+pub async fn add_local(
+    session_id: &str,
+    inner: std::sync::Arc<SshInner>,
+    bind_host: &str,
+    bind_port: u16,
+    target_host: &str,
+    target_port: u16,
+) -> Result<ForwardView, String> {
+    let listener = tokio::net::TcpListener::bind((bind_host, bind_port))
+        .await
+        .map_err(|e| {
+            format!(
+                "监听 {bind_host}:{bind_port} 失败: {e}。常见原因：端口已被其他程序占用。"
+            )
+        })?;
+    let actual = listener
+        .local_addr()
+        .map(|a| a.to_string())
+        .unwrap_or_else(|_| format!("{bind_host}:{bind_port}"));
+
+    let view = ForwardView {
+        id: next_id(),
+        kind: "local".to_string(),
+        bind_host: bind_host.to_string(),
+        bind_port,
+        target_host: target_host.to_string(),
+        target_port,
+        status: "active".to_string(),
+        detail: format!("本机监听 {actual}"),
+    };
+
+    let sid = session_id.to_string();
+    let target = target_host.to_string();
+    let fw_id = view.id.clone();
+    let task = tauri::async_runtime::spawn(async move {
+        local_accept_loop(&sid, &fw_id, listener, inner, &target, target_port).await;
+    });
+
+    registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .entry(session_id.to_string())
+        .or_default()
+        .insert(
+            view.id.clone(),
+            ForwardEntry {
+                rule: view.clone(),
+                task: Some(task),
+            },
+        );
+    Ok(view)
+}
+
+/// `-L` 的接受循环：每条连接开一条独立 `direct-tcpip` 通道。
+///
+/// 通道开启用 sftp 同款的 `spawn_blocking + block_on` 模式借出
+/// `Mutex` 里的 `Handle`（不可克隆、不能跨 `.await` 持锁）——
+/// 每条连接只占用阻塞线程一个 RTT，数据对拷是纯异步的。
+async fn local_accept_loop(
+    session_id: &str,
+    forward_id: &str,
+    listener: tokio::net::TcpListener,
+    inner: std::sync::Arc<SshInner>,
+    target_host: &str,
+    target_port: u16,
+) {
+    loop {
+        let accepted = listener.accept().await;
+        let (tcp, peer) = match accepted {
+            Ok(v) => v,
+            Err(e) => {
+                // 监听套接字级错误（极少见，如句柄耗尽）：标记错误并退出循环，
+                // 端口随即释放，前端列表里能看到 status 变为 error
+                mark_error(
+                    session_id,
+                    forward_id,
+                    format!("监听异常，转发已停止: {e}"),
+                );
+                return;
+            }
+        };
+
+        let inner = inner.clone();
+        let target = target_host.to_string();
+        let peer_ip = peer.ip().to_string();
+        let peer_port = peer.port();
+        let target_port_u32 = target_port as u32;
+        tauri::async_runtime::spawn(async move {
+            match open_direct_tcpip(&inner, &target, target_port_u32, &peer_ip, peer_port).await {
+                Ok(channel) => {
+                    // 通道转成流后与本地 TCP 对拷；任一侧关闭即结束
+                    let mut ch = channel.into_stream();
+                    let mut tcp = tcp;
+                    if let Err(e) = tokio::io::copy_bidirectional(&mut ch, &mut tcp).await {
+                        crate::logger::log_warn(
+                            "terminal",
+                            &format!("转发数据管道中断（{peer}）: {e}"),
+                        );
+                    }
+                }
+                Err(e) => {
+                    // 开通道失败：直接 drop 本地 TCP，让发起方立刻看到连接被断开，
+                    // 而不是挂死等超时
+                    crate::logger::log_warn(
+                        "terminal",
+                        &format!("转发开通道失败（{peer} → {target}:{target_port_u32}）: {e}"),
+                    );
+                }
+            }
+        });
+    }
+}
+
+/// 在 SSH 会话上开一条 `direct-tcpip` 通道（sftp 同款的借锁模式）。
+async fn open_direct_tcpip(
+    inner: &std::sync::Arc<SshInner>,
+    host: &str,
+    port: u32,
+    originator_ip: &str,
+    originator_port: u16,
+) -> Result<Channel<Msg>, String> {
+    let inner = inner.clone();
+    let host = host.to_string();
+    let originator_ip = originator_ip.to_string();
+    tokio::task::spawn_blocking(move || {
+        let rt = tokio::runtime::Handle::current();
+        rt.block_on(async {
+            // 槽位为 tokio Mutex（P2 连接复用）：锁的获取也放进 block_on
+            let guard = inner.handle.lock().await;
+            let handle = guard
+                .as_ref()
+                .ok_or_else(|| "SSH 会话已断开，转发不可用".to_string())?;
+            handle
+                .channel_open_direct_tcpip(host, port, originator_ip, originator_port as u32)
+                .await
+                .map_err(|e| format!("打开转发通道失败: {e}"))
+        })
+    })
+    .await
+    .map_err(|e| format!("转发任务异常: {e}"))?
+}
+
+/// 添加 `-R` 远程转发。
+///
+/// 请求**服务器**在 `bind_host:bind_port` 监听；后续连接经
+/// `server_channel_open_forwarded_tcpip` 回调回到本机（见 Handler 覆写）。
+pub async fn add_remote(
+    session_id: &str,
+    inner: &std::sync::Arc<SshInner>,
+    bind_host: &str,
+    bind_port: u16,
+    target_host: &str,
+    target_port: u16,
+) -> Result<ForwardView, String> {
+    // 共享连接下监听端口是**全局**资源：另一个会话已用同一端口时，
+    // 入站路由无法区分归属，必须在添加时拒绝而不是静默错乱
+    if remote_port_taken(bind_port) {
+        return Err(format!(
+            "远程监听端口 {bind_port} 已被占用（可能是其他会话的远程转发）"
+        ));
+    }
+    request_remote_listen(inner, bind_host, bind_port).await?;
+
+    let view = ForwardView {
+        id: next_id(),
+        kind: "remote".to_string(),
+        bind_host: bind_host.to_string(),
+        bind_port,
+        target_host: target_host.to_string(),
+        target_port,
+        status: "active".to_string(),
+        detail: format!("服务器监听 {bind_host}:{bind_port}"),
+    };
+
+    registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .entry(session_id.to_string())
+        .or_default()
+        .insert(
+            view.id.clone(),
+            ForwardEntry {
+                rule: view.clone(),
+                task: None,
+            },
+        );
+    Ok(view)
+}
+
+/// 请求服务器开始监听（`tcpip_forward`）。
+async fn request_remote_listen(
+    inner: &std::sync::Arc<SshInner>,
+    bind_host: &str,
+    bind_port: u16,
+) -> Result<(), String> {
+    let inner = inner.clone();
+    let host = bind_host.to_string();
+    tokio::task::spawn_blocking(move || {
+        let rt = tokio::runtime::Handle::current();
+        rt.block_on(async {
+            // 槽位为 tokio Mutex（P2 连接复用）：锁的获取也放进 block_on
+            let guard = inner.handle.lock().await;
+            let handle = guard
+                .as_ref()
+                .ok_or_else(|| "SSH 会话已断开，无法建立远程转发".to_string())?;
+            // 返回值是服务器确认的绑定端口（u32）；我们只关心成败
+            handle
+                .tcpip_forward(&host, bind_port as u32)
+                .await
+                .map(|_| ())
+                .map_err(|e| {
+                    format!(
+                        "服务器拒绝在 {host}:{bind_port} 监听: {e}。\
+                         常见原因：端口已被占用、或服务器禁用了 TCP 转发（AllowTcpForwarding no）。"
+                    )
+                })
+        })
+    })
+    .await
+    .map_err(|e| format!("转发任务异常: {e}"))?
+}
+
+/// 删除一条转发。
+///
+/// `-L`：abort 监听任务（端口立即释放）；`-R`：向服务器发 `cancel_tcpip_forward`
+/// （服务器停止监听；已建立的连接自然消亡）。
+pub async fn remove(
+    inner: &std::sync::Arc<SshInner>,
+    session_id: &str,
+    forward_id: &str,
+) -> Result<(), String> {
+    let removed = registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .get_mut(session_id)
+        .and_then(|m| m.remove(forward_id));
+    let Some(entry) = removed else {
+        return Err(format!("转发规则 {forward_id} 不存在"));
+    };
+
+    if let Some(task) = entry.task {
+        task.abort(); // `-L`：监听循环停止，端口释放
+    } else if entry.rule.kind == "remote" {
+        // `-R`：取消服务器端监听。失败不阻断（会话断开时服务器也会清理），
+        // 但要记日志——否则「删了还在监听」的问题无从排查
+        let inner = inner.clone();
+        let host = entry.rule.bind_host.clone();
+        let port = entry.rule.bind_port;
+        let r = tokio::task::spawn_blocking(move || {
+            let rt = tokio::runtime::Handle::current();
+            rt.block_on(async {
+                let guard = inner.handle.lock().await;
+                let Some(handle) = guard.as_ref() else {
+                    return Ok(());
+                };
+                handle.cancel_tcpip_forward(&host, port as u32).await
+            })
+        })
+        .await
+        .map_err(|e| format!("转发任务异常: {e}"));
+        match r {
+            Ok(Ok(())) => {}
+            Ok(Err(e)) => crate::logger::log_warn(
+                "terminal",
+                &format!("取消远程转发 {}:{} 失败（会话断开时会自动清理）: {e}", entry.rule.bind_host, port),
+            ),
+            Err(e) => crate::logger::log_warn("terminal", &format!("取消远程转发任务异常: {e}")),
+        }
+    }
+    Ok(())
+}
+
+/// 会话关闭时的清理：abort 全部 `-L` 任务并清空条目。
+///
+/// `-R` 不需要显式 cancel：SSH 会话断开时服务器会停掉该会话的所有监听。
+pub fn cleanup_session(session_id: &str) {
+    if let Some(m) = registry()
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .remove(session_id)
+    {
+        for (_, entry) in m {
+            if let Some(task) = entry.task {
+                task.abort();
+            }
+        }
+    }
+}
+
+/// Handler 回调里的管道任务：`forwarded-tcpip` 通道 → 本机目标。
+///
+/// 供 `ssh/mod.rs` 的 `server_channel_open_forwarded_tcpip` 覆写调用。
+pub(crate) fn pipe_forwarded_channel(
+    channel: Channel<Msg>,
+    target_host: String,
+    target_port: u16,
+) {
+    tauri::async_runtime::spawn(async move {
+        match tokio::net::TcpStream::connect((target_host.as_str(), target_port)).await {
+            Ok(mut tcp) => {
+                let mut ch = channel.into_stream();
+                if let Err(e) = tokio::io::copy_bidirectional(&mut ch, &mut tcp).await {
+                    crate::logger::log_warn(
+                        "terminal",
+                        &format!("远程转发管道中断（{target_host}:{target_port}）: {e}"),
+                    );
+                }
+            }
+            Err(e) => {
+                crate::logger::log_warn(
+                    "terminal",
+                    &format!("远程转发目标 {target_host}:{target_port} 连接失败: {e}"),
+                );
+            }
+        }
+    });
+}

src-tauri/src/terminal/ssh/hostkey.rs

@@ -0,0 +1,405 @@
+//! 主机密钥库（known_hosts）与指纹校验。
+//!
+//! # 为什么自己实现而不是复用 `~/.ssh/known_hosts`
+//!
+//! 三个理由：
+//! 1. **写入冲突**：OpenSSH 的 `known_hosts` 是追加式文本文件，多进程并发写入
+//!    会互相破坏（这也是为什么 OpenSSH 自己做文件锁）。我们的应用与用户的
+//!    `ssh` 命令行会同时改它。
+//! 2. **无法表达「拒绝」**：用户在我们的 UI 上选了「不接受」时，OpenSSH 格式里
+//!    没有对应的记录形态（只能不写，等于下次又问）。
+//! 3. **需要附加信息**：我们要记「首次见到时间」「上次确认时间」「变更历史」
+//!    以便审计与提示，这些在 OpenSSH 格式里无处安放。
+//!
+//! 因此用自有 JSON 存储，同时**提供导入/导出到 OpenSSH 格式**的能力，
+//! 让用户的既有记录可以迁移，且不与命令行工具形成两套互不相知的信任库。
+//!
+//! # 安全姿态
+//!
+//! - 指纹变更**默认阻断**（不是警告）：TOFU 疲劳是 MITM 的主要入口，
+//!   把它做成一个需要主动点开的红色阻断界面，是这里唯一有效的防御。
+//! - 超时/未响应 = 拒绝（安全侧默认值）。
+//! - known_hosts 是**非机密**数据，明文 JSON 存储、可导出、可人工审阅。
+
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::sync::{Mutex, OnceLock};
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// 单条已知主机记录。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct KnownHost {
+    /// 主机地址（不含端口，端口单独存）
+    pub host: String,
+    pub port: u16,
+    /// 密钥算法（如 "ssh-ed25519" / "rsa-sha2-512" / "ssh-rsa"）
+    ///
+    /// 同一主机可能有多种算法的密钥（服务器同时提供 ed25519 与 rsa），
+    /// 因此按 (host, port, key_type) 三元组建索引，而不是 (host, port)。
+    pub key_type: String,
+    /// SHA256 指纹（OpenSSH 展示格式，如 `SHA256:Abc...`）
+    pub fingerprint: String,
+    /// 首次见到时间（RFC3339）
+    pub first_seen: String,
+    /// 最近一次确认时间（RFC3339）
+    pub last_confirmed: String,
+    /// 指纹变更历史（最新在前）。
+    ///
+    /// 保留历史的价值：用户点「接受新指纹」之后，回看历史能判断这到底是
+    /// 服务器重装（一次性变更）还是持续的中间人（每次都变）。
+    pub history: Vec<FingerprintChange>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", default)]
+pub struct FingerprintChange {
+    /// 被替换掉的旧指纹
+    pub old_fingerprint: String,
+    /// 变更发生时间
+    pub changed_at: String,
+    /// 用户是否接受了这次变更
+    pub accepted: bool,
+}
+
+impl Default for FingerprintChange {
+    fn default() -> Self {
+        Self {
+            old_fingerprint: String::new(),
+            changed_at: String::new(),
+            accepted: false,
+        }
+    }
+}
+
+impl Default for KnownHost {
+    fn default() -> Self {
+        Self {
+            host: String::new(),
+            port: 22,
+            key_type: String::new(),
+            fingerprint: String::new(),
+            first_seen: String::new(),
+            last_confirmed: String::new(),
+            history: Vec::new(),
+        }
+    }
+}
+
+/// 校验结论。
+#[derive(Debug, Clone)]
+pub enum Verdict {
+    /// 指纹与记录一致 → 可信，直接放行
+    Trusted,
+    /// 该主机对此算法**没有记录** → 首次连接，需用户确认
+    Unknown,
+    /// 有记录但指纹不同 → 高危，需用户显式确认
+    Changed { previous: String },
+}
+
+/// 主机密钥库（内存缓存 + 文件持久化）。
+struct Store {
+    path: PathBuf,
+    /// `(host, port, key_type)` → 记录
+    entries: BTreeMap<String, KnownHost>,
+    /// 是否需要落盘
+    dirty: bool,
+}
+
+static STORE: OnceLock<Mutex<Option<Store>>> = OnceLock::new();
+
+fn store_slot() -> &'static Mutex<Option<Store>> {
+    STORE.get_or_init(|| Mutex::new(None))
+}
+
+/// 初始化存储路径（应用启动时调用一次）。
+pub fn init(path: PathBuf) {
+    let mut slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    if slot.is_some() {
+        return;
+    }
+    let entries = match std::fs::read_to_string(&path) {
+        Ok(raw) => match serde_json::from_str::<Vec<KnownHost>>(&raw) {
+            Ok(list) => list
+                .into_iter()
+                .map(|h| (key_of(&h.host, h.port, &h.key_type), h))
+                .collect(),
+            Err(e) => {
+                crate::logger::log_error(
+                    "terminal",
+                    &format!("known_hosts 解析失败（将以空库启动）: {e}"),
+                );
+                BTreeMap::new()
+            }
+        },
+        Err(_) => BTreeMap::new(),
+    };
+    *slot = Some(Store {
+        path,
+        entries,
+        dirty: false,
+    });
+}
+
+fn key_of(host: &str, port: u16, key_type: &str) -> String {
+    format!("{host}:{port}:{key_type}")
+}
+
+/// 校验主机密钥。
+///
+/// 注意「同主机多算法」的处理：服务器同时提供 ed25519 与 rsa 时，我们按
+/// `key_type` 分别记录。若用户上次连的是 ed25519、这次服务器（因客户端算法
+/// 偏好变化）用了 rsa，**不应判为指纹变更**——那是不同算法的两把不同密钥，
+/// 属于正常情况。因此这里的比对严格限定在同一 key_type 内。
+pub fn verify(host: &str, port: u16, fingerprint: &str, key_type: &str) -> Verdict {
+    let slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(store) = slot.as_ref() else {
+        // 未初始化：保守起见按「未知」处理，要求用户确认
+        return Verdict::Unknown;
+    };
+
+    // 先查同算法记录
+    if let Some(rec) = store.entries.get(&key_of(host, port, key_type)) {
+        if fingerprints_equal(&rec.fingerprint, fingerprint) {
+            return Verdict::Trusted;
+        }
+        return Verdict::Changed {
+            previous: rec.fingerprint.clone(),
+        };
+    }
+
+    // 同算法无记录，但同主机其它算法有记录：说明这个主机我们见过，
+    // 只是这次协商出了不同算法。仍按「未知」处理（要求确认），
+    // 但这是正常现象，日志里降级为 info 而非 warn。
+    let has_other_algo = store
+        .entries
+        .keys()
+        .any(|k| k.starts_with(&format!("{host}:{port}:")));
+    if has_other_algo {
+        crate::logger::log_info(
+            "terminal",
+            &format!("主机 {host}:{port} 提供了新的密钥算法 {key_type}，需确认指纹"),
+        );
+    }
+
+    Verdict::Unknown
+}
+
+/// 指纹比较：忽略大小写与前缀差异。
+///
+/// SHA256 指纹在不同工具里可能表现为 `SHA256:AbC...` / `AbC...` / 末尾带 `=`，
+/// 这些差异不该被当作「指纹不同」（那会让用户看到惊悚的变更告警）。
+fn fingerprints_equal(a: &str, b: &str) -> bool {
+    let norm = |s: &str| {
+        s.trim()
+            .trim_start_matches("SHA256:")
+            .trim_start_matches("MD5:")
+            .trim_end_matches('=')
+            .replace(':', "")
+            .to_lowercase()
+    };
+    norm(a) == norm(b)
+}
+
+/// 接受并记录指纹（首次或变更后）。
+pub fn accept(host: &str, port: u16, fingerprint: &str, key_type: &str) -> Result<(), String> {
+    let mut slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(store) = slot.as_mut() else {
+        return Err("known_hosts 存储未初始化".to_string());
+    };
+
+    let k = key_of(host, port, key_type);
+    let now = chrono::Local::now().to_rfc3339();
+
+    match store.entries.get_mut(&k) {
+        Some(rec) => {
+            if !fingerprints_equal(&rec.fingerprint, fingerprint) {
+                // 记入变更历史（保留最近 20 条，避免无限增长）
+                rec.history.insert(
+                    0,
+                    FingerprintChange {
+                        old_fingerprint: rec.fingerprint.clone(),
+                        changed_at: now.clone(),
+                        accepted: true,
+                    },
+                );
+                rec.history.truncate(20);
+                rec.fingerprint = fingerprint.to_string();
+            }
+            rec.last_confirmed = now;
+        }
+        None => {
+            store.entries.insert(
+                k,
+                KnownHost {
+                    host: host.to_string(),
+                    port,
+                    key_type: key_type.to_string(),
+                    fingerprint: fingerprint.to_string(),
+                    first_seen: now.clone(),
+                    last_confirmed: now,
+                    history: Vec::new(),
+                },
+            );
+        }
+    }
+    store.dirty = true;
+    persist(store)
+}
+
+/// 记录一次「拒绝」（仅记历史，不改指纹）。
+///
+/// 价值：用户拒绝后，下次连接还会弹出提示。历史里留下「曾在某时刻拒绝过」，
+/// 便于事后审计——「谁在什么时候试图用新指纹冒充这台主机」。
+pub fn record_rejection(host: &str, port: u16, fingerprint: &str, key_type: &str) {
+    let mut slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(store) = slot.as_mut() else { return };
+    let k = key_of(host, port, key_type);
+    if let Some(rec) = store.entries.get_mut(&k) {
+        rec.history.insert(
+            0,
+            FingerprintChange {
+                old_fingerprint: fingerprint.to_string(),
+                changed_at: chrono::Local::now().to_rfc3339(),
+                accepted: false,
+            },
+        );
+        rec.history.truncate(20);
+        store.dirty = true;
+        let _ = persist(store);
+    }
+}
+
+/// 列出全部记录（含历史），供设置页展示。
+pub fn list() -> Vec<KnownHost> {
+    let slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    slot.as_ref()
+        .map(|s| s.entries.values().cloned().collect())
+        .unwrap_or_default()
+}
+
+/// 删除某条记录（用户清理失效主机时用）。
+pub fn forget(host: &str, port: u16, key_type: &str) -> Result<(), String> {
+    let mut slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(store) = slot.as_mut() else {
+        return Err("known_hosts 存储未初始化".to_string());
+    };
+    store.entries.remove(&key_of(host, port, key_type));
+    store.dirty = true;
+    persist(store)
+}
+
+/// 清空全部记录（危险操作，前端需二次确认）。
+pub fn clear() -> Result<(), String> {
+    let mut slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(store) = slot.as_mut() else {
+        return Err("known_hosts 存储未初始化".to_string());
+    };
+    store.entries.clear();
+    store.dirty = true;
+    persist(store)
+}
+
+/// 落盘（先写临时文件再 rename，避免半截 JSON）。
+fn persist(store: &Store) -> Result<(), String> {
+    let list: Vec<&KnownHost> = store.entries.values().collect();
+    let json =
+        serde_json::to_string_pretty(&list).map_err(|e| format!("序列化 known_hosts 失败: {e}"))?;
+    if let Some(parent) = store.path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {e}"))?;
+    }
+    let tmp = store.path.with_extension("json.tmp");
+    std::fs::write(&tmp, json).map_err(|e| format!("写入 known_hosts 失败: {e}"))?;
+    std::fs::rename(&tmp, &store.path).map_err(|e| format!("保存 known_hosts 失败: {e}"))
+}
+
+// ===== OpenSSH 格式互操作 =====
+
+/// 导出为 OpenSSH `known_hosts` 文本格式。
+///
+/// 用途：(a) 用户可把记录带进命令行 ssh；(b) 便于人工审阅。
+/// 输出是标准 `host:port keytype base64comment` 形态的 **hashed 形式**
+/// 还是明文形式？这里选 **明文**：用户要能读懂、能 diff，才有审阅价值。
+/// OpenSSH 本身也接受明文（`HashKnownHosts no`）。
+///
+/// 注意：我们只有指纹（SHA256 base64），没有完整公钥 blob，因此导出的
+/// 第二列写 `SHA256:...` 形式的注释，**不是**可直接被 ssh 使用的完整格式。
+/// 这一点必须在 UI 上说明，避免用户以为导出的文件能直接给 ssh 用。
+pub fn export_openssh_text() -> String {
+    let mut out = String::from(
+        "# 由 Thing 终端模块导出\n\
+         # 注意：本文件仅用于人工审阅与记录迁移，第二列是指纹而非公钥 blob，\n\
+         # 不能直接作为 OpenSSH 的 known_hosts 使用。\n",
+    );
+    for h in list() {
+        out.push_str(&format!(
+            "{}:{} {} {}\n",
+            h.host, h.port, h.key_type, h.fingerprint
+        ));
+    }
+    out
+}
+
+/// 从 OpenSSH `known_hosts` 文本导入指纹记录。
+///
+/// 支持的行形态（跳过注释与空行）：
+/// - `host:port keytype fingerprint`（本模块自己的导出格式）
+/// - `host keytype fingerprint`
+///
+/// 返回成功导入的条数。
+pub fn import_openssh_text(text: &str) -> Result<usize, String> {
+    let mut slot = store_slot().lock().unwrap_or_else(|e| e.into_inner());
+    let Some(store) = slot.as_mut() else {
+        return Err("known_hosts 存储未初始化".to_string());
+    };
+
+    let now = chrono::Local::now().to_rfc3339();
+    let mut count = 0usize;
+
+    for line in text.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() < 3 {
+            continue;
+        }
+        // 解析 host[:port]
+        let (host, port) = match parts[0].rsplit_once(':') {
+            Some((h, p)) => match p.parse::<u16>() {
+                Ok(port) => (h.to_string(), port),
+                Err(_) => (parts[0].to_string(), 22),
+            },
+            None => (parts[0].to_string(), 22),
+        };
+        let key_type = parts[1].to_string();
+        let fingerprint = parts[2].to_string();
+        // 只接受指纹形态（SHA256:...）——完整公钥 blob 需要另外的解析路径，
+        // 且我们无法从它反推指纹而不引入更多依赖
+        if !fingerprint.starts_with("SHA256:") && !fingerprint.starts_with("MD5:") {
+            continue;
+        }
+
+        let k = key_of(&host, port, &key_type);
+        store.entries.insert(
+            k,
+            KnownHost {
+                host,
+                port,
+                key_type,
+                fingerprint,
+                first_seen: now.clone(),
+                last_confirmed: now.clone(),
+                history: Vec::new(),
+            },
+        );
+        count += 1;
+    }
+
+    store.dirty = true;
+    persist(store)?;
+    Ok(count)
+}

src-tauri/src/terminal/ssh/pool.rs

@@ -0,0 +1,255 @@
+//! SSH 连接池（P2 连接复用）。
+//!
+//! # 语义
+//!
+//! 同一「身份」（用户名 + 主机 + 端口 + 认证材料指纹）的多个会话
+//! **共享同一条 SSH 连接**：第二个会话跳过 TCP / 握手 / 认证，直接在
+//! 既有连接上开新的会话通道。与 OpenSSH ControlMaster 的行为一致：
+//! - 打开：首个会话建立连接；
+//! - 共享：后续会话引用计数 +1；
+//! - 关闭：会话关闭只减引用并关闭**自己的 shell 通道**；
+//!   **最后一个引用释放时**才断开底层连接（含跳板机链）。
+//!
+//! # 为什么 Handle 必须经由池共享
+//!
+//! `russh::client::Handle` 不实现 `Clone`（内含 session actor 的接收端），
+//! 此前每个 `SshSession` 独占一个 Handle，无从复用。池条目持有
+//! `Arc<tokio::sync::Mutex<Option<Handle>>>` 槽位，会话间共享同一 Arc；
+//! tokio Mutex（而非 std）是为了允许**连接建立期间跨 `.await` 持锁**——
+//! 它天然串行化了「双击两个标签同时连同一主机」的竞态：后到者等待，
+//! 先到者成功后直接复用。
+//!
+//! # 跳板机链的归属
+//!
+//! 经跳板链建立的连接，其跳板 Handle 挂在**池条目**上而不是首建会话上：
+//! 否则首建会话关闭时会连带剪断仍在被其他会话使用的隧道。
+//! 最后一个引用释放时，跳板与目标连接一起断开。
+//!
+//! # 已知取舍
+//!
+//! - 共享连接的 keepalive / 加密参数取自**首个**建立它的会话；
+//! - 共享连接断开（网络故障）时，挂在上面的所有会话一起进入 Closed——
+//!   这与「它们本来就在同一条 TCP 上」的物理事实一致；
+//! - 远程转发（-R）的入站路由按端口做**全局**匹配（见 forward 模块），
+//!   因为入站通道总是从属连接级 Handler，而 Handler 的 session_id 属于首建会话。
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use russh::client::Handle;
+use russh::Disconnect;
+
+use super::SshHandler;
+
+/// 可克隆的池句柄（`TerminalManager` 持有一份，每个会话 clone 一份）。
+#[derive(Clone, Default)]
+pub struct ConnectionPool {
+    conns: Arc<Mutex<HashMap<String, PooledEntry>>>,
+}
+
+struct PooledEntry {
+    /// 共享槽位：`None` = 连接建立中（或失败）；`Some` = 已就绪。
+    slot: Arc<tokio::sync::Mutex<Option<Handle<SshHandler>>>>,
+    /// 仍在使用此连接的会话数
+    refcount: usize,
+    /// 连接是否已就绪（同步可查；`has_handle` 用）
+    ready: bool,
+    /// 跳板机链的连接（经跳板建立时非空；随条目共享，最后释放时断开）
+    hops: Vec<Handle<SshHandler>>,
+    /// 日志用描述
+    label: String,
+}
+
+impl ConnectionPool {
+    /// 取（或创建）某身份的连接槽位，引用计数 +1。
+    ///
+    /// 返回的 Arc 就是池条目里的槽位本身：会话把它存进 `SshInner.handle`，
+    /// 连接建立后写 `Some(handle)`，同键的其他会话即刻可见。
+    pub fn slot(&self, key: &str) -> Arc<tokio::sync::Mutex<Option<Handle<SshHandler>>>> {
+        let mut conns = self.conns.lock().unwrap_or_else(|e| e.into_inner());
+        let entry = conns.entry(key.to_string()).or_insert_with(|| PooledEntry {
+            slot: Arc::new(tokio::sync::Mutex::new(None)),
+            refcount: 0,
+            ready: false,
+            hops: Vec::new(),
+            label: String::new(),
+        });
+        entry.refcount += 1;
+        entry.slot.clone()
+    }
+
+    /// 设置日志用描述（连接建立成功后调用）。
+    pub fn set_label(&self, key: &str, label: &str) {
+        if let Some(e) = self
+            .conns
+            .lock()
+            .unwrap_or_else(|x| x.into_inner())
+            .get_mut(key)
+        {
+            e.label = label.to_string();
+        }
+    }
+
+    /// 标记连接已就绪（do_connect 写入 Handle 之后）。
+    pub fn mark_ready(&self, key: &str) {
+        if let Some(e) = self
+            .conns
+            .lock()
+            .unwrap_or_else(|x| x.into_inner())
+            .get_mut(key)
+        {
+            e.ready = true;
+        }
+    }
+
+    /// 把跳板机连接挂到池条目上（fresh 连接路径、有跳板时调用一次）。
+    pub fn attach_hops(&self, key: &str, hops: Vec<Handle<SshHandler>>) {
+        if let Some(e) = self
+            .conns
+            .lock()
+            .unwrap_or_else(|x| x.into_inner())
+            .get_mut(key)
+        {
+            e.hops = hops;
+        }
+    }
+
+    /// 连接是否已就绪（同步可查；替代原 `SshSession::has_handle` 的语义）。
+    pub fn is_ready(&self, key: &str) -> bool {
+        self.conns
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .get(key)
+            .is_some_and(|e| e.ready)
+    }
+
+    /// 释放一个会话的引用。
+    ///
+    /// 返回 `Some((槽位, 跳板连接))` 表示这是**最后一个**引用——调用方负责
+    /// 断开底层连接与跳板（异步任务里做，见 `kill`）。非最后引用返回 `None`，
+    /// 调用方只需关闭自己的 shell 通道。
+    pub fn release(
+        &self,
+        key: &str,
+    ) -> Option<(
+        Arc<tokio::sync::Mutex<Option<Handle<SshHandler>>>>,
+        Vec<Handle<SshHandler>>,
+    )> {
+        let mut conns = self.conns.lock().unwrap_or_else(|e| e.into_inner());
+        let Some(entry) = conns.get_mut(key) else {
+            return None;
+        };
+        entry.refcount = entry.refcount.saturating_sub(1);
+        if entry.refcount > 0 {
+            return None;
+        }
+        // 最后一个引用：移除条目并交出断开责任
+        let entry = conns.remove(key)?;
+        Some((entry.slot, entry.hops))
+    }
+}
+
+/// 连接池身份键：用户名 + 主机 + 端口 + 认证方式 + 认证材料指纹。
+///
+/// 认证材料（密码或私钥文本）取短哈希入键——同一主机配置两份不同密钥/密码时
+/// 不应共享连接（那等于用 A 的身份看了 B 的会话）。
+pub fn pool_key_of(
+    username: &str,
+    host: &str,
+    port: u16,
+    auth_method: &str,
+    auth_material: Option<&str>,
+) -> String {
+    let marker = match auth_material {
+        Some(m) => short_hash(m),
+        None => "none".to_string(),
+    };
+    format!("{username}|{host}:{port}|{auth_method}|{marker}")
+}
+
+/// 材料指纹：SHA-256 前 8 字节的十六进制（16 字符）。
+fn short_hash(material: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let digest = Sha256::digest(material.as_bytes());
+    digest[..8].iter().map(|b| format!("{b:02x}")).collect()
+}
+
+/// 断开一个 Handle（kill 与最后引用释放共用的收尾动作）。
+pub async fn disconnect(handle: Handle<SshHandler>) {
+    let _ = handle
+        .disconnect(Disconnect::ByApplication, "closed by user", "")
+        .await;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 条目级语义测试：不涉及真实 Handle（槽位保持 None 即可）。
+    #[test]
+    fn acquire_increments_and_release_removes_on_last() {
+        let pool = ConnectionPool::default();
+        let s1 = pool.slot("k");
+        let s2 = pool.slot("k");
+        // 同键两次 acquire 返回同一个 Arc（这才是「共享」）
+        assert!(Arc::ptr_eq(&s1, &s2));
+        assert!(pool.release("k").is_none(), "还有 1 个引用，不应触发拆除");
+        let (slot, hops) = pool.release("k").expect("最后一个引用应触发拆除");
+        assert!(Arc::ptr_eq(&slot, &s1));
+        assert!(hops.is_empty());
+        // 移除后再次 acquire 得到全新条目
+        let s3 = pool.slot("k");
+        assert!(!Arc::ptr_eq(&s3, &s1));
+        pool.release("k");
+    }
+
+    #[test]
+    fn independent_keys_are_independent() {
+        let pool = ConnectionPool::default();
+        let a = pool.slot("a");
+        let b = pool.slot("b");
+        assert!(!Arc::ptr_eq(&a, &b));
+        assert!(pool.release("a").is_some());
+        assert!(pool.release("b").is_some());
+    }
+
+    #[test]
+    fn ready_flag_and_hops_follow_entry_lifecycle() {
+        let pool = ConnectionPool::default();
+        assert!(!pool.is_ready("k"));
+        pool.slot("k");
+        pool.slot("k"); // 两个会话共享
+        pool.mark_ready("k");
+        assert!(pool.is_ready("k"));
+        pool.attach_hops("k", Vec::new());
+        // 释放一个引用后条目仍在（另一个会话还在用），ready 保持
+        assert!(pool.release("k").is_none());
+        assert!(pool.is_ready("k"));
+        // 最后一个引用释放后条目消失
+        assert!(pool.release("k").is_some());
+        assert!(!pool.is_ready("k"));
+    }
+
+    #[test]
+    fn over_release_is_safe() {
+        let pool = ConnectionPool::default();
+        assert!(pool.release("ghost").is_none());
+        pool.slot("k");
+        pool.release("k");
+        // 多余的 release 不应 panic（saturating 语义）
+        let _ = pool.release("k");
+    }
+
+    #[test]
+    fn pool_key_distinguishes_identity() {
+        let k1 = pool_key_of("ops", "srv", 22, "key", Some("keytext"));
+        let k2 = pool_key_of("ops", "srv", 22, "key", Some("other-key"));
+        let k3 = pool_key_of("ops", "srv", 22, "key", Some("keytext"));
+        let k4 = pool_key_of("root", "srv", 22, "key", Some("keytext"));
+        assert_ne!(k1, k2, "不同认证材料不应共享连接");
+        assert_eq!(k1, k3, "相同身份应命中同一池条目");
+        assert_ne!(k1, k4, "不同用户不应共享连接");
+        // 无认证材料（理论上不出现）也不与他人混淆
+        let k5 = pool_key_of("ops", "srv", 22, "password", None);
+        assert_ne!(k1, k5);
+    }
+}

src-tauri/src/terminal/ssh/sftp.rs

@@ -0,0 +1,663 @@
+//! SFTP 文件管理：复用 SSH 会话连接的双栏文件传输。
+//!
+//! # 为什么 SFTP 挂在会话上而不是独立连接
+//!
+//! 一台主机开两个 SSH 连接（一个 shell、一个 SFTP）有三个实际代价：
+//! 1. **认证两次**——公钥还好，密码/2FA 场景下用户要输两遍；
+//! 2. **服务端 `MaxStartups` / `MaxSessions` 限制**——内网跳板机经常卡这条；
+//! 3. 两条连接的主机密钥都要各自校验，known_hosts 里同一台机器两份记录。
+//!
+//! SSH 协议本身就为此设计了 **subsystem channel**：在已认证的连接上开新通道，
+//! `request_subsystem(true, "sftp")` 即可。因此 SFTP 面板只对**活跃的 SSH 会话**
+//! 开放——本地 ConPTY 会话没有这条路径（本地文件用系统的资源管理器更合适）。
+//!
+//! # 一个 SFTP 客户端只能串行用一条通道
+//!
+//! `SftpSession` 内部是「请求 → 等响应」的请求/响应模型，**并发调用会因为
+//! 响应乱序而错配**。russh-sftp 内部做了请求 id 匹配，因此 `&SftpSession` 上
+//! 并发 `.await` 是安全的；但同一时刻大量并发（如递归上传 1000 个文件全并发）
+//! 会把服务端的窗口打满并触发限流。
+//!
+//! 因此上传/下载走**受控并发**：由 `SftpHandle::semaphore` 限制在 4 路。
+//!
+//! # 断点续传
+//!
+//! 用 `OpenFlags::WRITE | CREATE` 打开已存在的文件，再 `seek` 到本地已有的
+//! 大小继续写。服务端不支持 `append` 语义时（部分紫光的 sftp-server），
+//! 退化为「整文件重传」——由 `resume_supported` 探测决定。
+
+use std::sync::Arc;
+
+use dashmap::DashMap;
+use russh::client::Handle;
+use russh_sftp::client::SftpSession;
+use russh_sftp::protocol::OpenFlags;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
+use tokio::sync::{Mutex, Semaphore};
+
+use super::{SshHandler, SshSession};
+
+/// 受控并发的上限。
+///
+/// 为什么是 4：单个 SFTP 通道的吞吐已接近链路带宽（有 32KB 报文窗口），
+/// 再高的并发只是把服务端的 inflight 队列堆长，收益递减而内存占用线性增长。
+/// 4 路足以让「大量小文件」这条慢路径（每文件一次 round-trip）提速约 3 倍。
+const MAX_CONCURRENT_TRANSFERS: usize = 4;
+
+/// 单次传输的分块大小。
+///
+/// 32KB 是 SFTP 协议默认的最大读报文（部分服务端放宽到 256KB，但 32KB
+/// 是所有实现的**安全下界**）。取 32KB 而非更大：大块在丢包链路上重传代价高，
+/// 而 32KB 已足够跑满千兆内网。
+const CHUNK_SIZE: usize = 32 * 1024;
+
+// ===== 数据模型 =====
+
+/// 一个远端目录项（回传前端渲染）。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct RemoteEntry {
+    pub name: String,
+    /// 完整路径（服务端形态，`/` 分隔）
+    pub path: String,
+    /// "file" | "dir" | "symlink" | "other"
+    pub kind: String,
+    pub size: u64,
+    /// 修改时间（Unix 毫秒；服务端未提供时为 None）
+    pub modified_at: Option<u64>,
+    /// 权限位的八进制展示（如 "755"）；无权限信息时为空串
+    pub permissions: String,
+    /// 符号链接的目标（仅 kind == "symlink" 时非空）
+    pub link_target: String,
+}
+
+/// 目录列举结果。
+///
+/// 单独包一层而不是直接返回 `Vec`：前端需要 `cwd` 来确认「服务端实际解析到
+/// 的目录」——符号链接目录下 `pwd` 与用户点的路径可能不同，这个字段让面包屑
+/// 可以显示真实位置而不是用户以为的位置。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct RemoteDir {
+    /// 服务端规范化之后的目录（`canonicalize` 结果）
+    pub cwd: String,
+    pub entries: Vec<RemoteEntry>,
+}
+
+/// 传输进度事件负载。
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct TransferProgress {
+    /// 传输任务 id（前端据此更新对应行的进度条）
+    pub id: String,
+    pub session_id: String,
+    /// "upload" | "download"
+    pub direction: String,
+    /// 源路径（展示用）
+    pub source: String,
+    /// 目标路径（展示用）
+    pub target: String,
+    /// 已传输字节
+    pub transferred: u64,
+    /// 总字节（未知时为 0）
+    pub total: u64,
+    /// "running" | "done" | "failed" | "canceled"
+    pub state: String,
+    /// 失败原因
+    pub error: Option<String>,
+}
+
+// ===== 会话级 SFTP 句柄 =====
+
+/// 一个会话的 SFTP 通道。
+///
+/// `SftpSession` 本身不是 `Sync` 的友好类型，且我们要在其上做「先查目录再写文件」
+/// 这类多步操作，故用 `Mutex` 串行化**结构性操作**（建目录、删文件）；
+/// 大数据传输则只借用不可变引用（`&SftpSession` 的分块读写在 russh-sftp 内部
+/// 有请求 id 匹配，可安全并发）。
+pub struct SftpHandle {
+    /// 打开面板的会话 id。
+    ///
+    /// 当前只有注册表的 key 用到会话 id，结构体内这份冗余字段暂无读者；
+    /// 保留它是为了 P2 的「跨会话传输」与日志定位（错误信息里需要会话上下文）。
+    #[allow(dead_code)]
+    pub session_id: String,
+    /// 串行闸门：保证「建目录 → 上传」这类有先后依赖的操作不会被乱序执行。
+    ///
+    /// P0 的传输命令都是单步操作，尚无读者；P2 的组合操作（模板上传、
+    /// 递归同步）落地时启用。
+    #[allow(dead_code)]
+    pub gate: Mutex<()>,
+    pub sftp: SftpSession,
+    /// 并发闸门：限制同时在跑的大数据传输数量
+    pub semaphore: Semaphore,
+    /// 远端当前目录的缓存（`cwd` 跟随用；避免每次都 round-trip 取）
+    pub last_dir: Mutex<String>,
+}
+
+/// 所有活跃会话的 SFTP 通道表。
+///
+/// 与 `SessionRegistry` 同样的理由用 `DashMap`：查表极频繁（每个传输分块都要
+/// 找 handle），而插入/删除只在打开/关闭面板时发生。
+#[derive(Default)]
+pub struct SftpRegistry {
+    handles: DashMap<String, Arc<SftpHandle>>,
+}
+
+impl SftpRegistry {
+    pub fn new() -> Self {
+        Self {
+            handles: DashMap::new(),
+        }
+    }
+
+    pub fn get(&self, session_id: &str) -> Option<Arc<SftpHandle>> {
+        self.handles.get(session_id).map(|e| e.value().clone())
+    }
+
+    pub fn insert(&self, session_id: String, handle: Arc<SftpHandle>) {
+        self.handles.insert(session_id, handle);
+    }
+
+    pub fn remove(&self, session_id: &str) -> Option<Arc<SftpHandle>> {
+        self.handles.remove(session_id).map(|(_, v)| v)
+    }
+
+    pub fn has(&self, session_id: &str) -> bool {
+        self.handles.contains_key(session_id)
+    }
+
+    /// 关闭某会话的 SFTP 通道（会话关闭时调用）。
+    pub fn close(&self, session_id: &str) {
+        self.handles.remove(session_id);
+    }
+}
+
+/// 在已有 SSH 会话上打开 SFTP subsystem。
+///
+/// # 前置条件
+///
+/// 会话必须已 `Established` 且持有可用的 `Handle`。若会话是本地 ConPTY
+/// 或 SSH 尚未认证完成，这里会返回可读的错误而不是 panic。
+///
+/// # 为什么用 `spawn_blocking` 而不是直接 await
+///
+/// `Handle` 不实现 `Clone`，因此开通道必须**持有 `MutexGuard` 跨 await**。
+/// 而 `std::sync::MutexGuard` 不是 `Send`，这让整个 future 也不是 `Send`，
+/// 无法交给 `tauri::async_runtime::spawn`（Tauri 命令要求 `Send`）。
+///
+/// 解法：把「持锁 + 开通道」这一小段放进 `spawn_blocking`。它内部是
+/// **阻塞的 tokio runtime block_on**，锁与 await 都限制在那个线程里，
+/// 对外只返回值（`Channel` 是 `Send`）。代价是占一个线程约握手 RTT 的时间，
+/// 而这只在用户点「打开文件管理器」时发生一次。
+pub async fn open_subsystem(session: &SshSession) -> Result<Arc<SftpHandle>, String> {
+    // 先在外部确认会话可用（避免为一个必然失败的请求去占线程）
+    if !session.has_handle() {
+        return Err("SSH 会话尚未建立连接，无法打开文件管理器".to_string());
+    }
+
+    let channel = {
+        let inner = session.inner_shared();
+        // 把「加锁 → 开通道 → 请求 subsystem」整段移出 async 上下文。
+        // 槽位是 tokio Mutex（P2 连接复用），锁 `.await` 放进 block_on 里。
+        tokio::task::spawn_blocking(move || {
+            let rt = tokio::runtime::Handle::current();
+            rt.block_on(async {
+                let guard = inner.handle.lock().await;
+                let handle = guard
+                    .as_ref()
+                    .ok_or_else(|| "SSH 会话连接已断开，无法打开文件管理器".to_string())?;
+
+                let channel = handle
+                    .channel_open_session()
+                    .await
+                    .map_err(|e| format!("打开 SFTP 通道失败: {e}"))?;
+                channel
+                    .request_subsystem(true, "sftp")
+                    .await
+                    .map_err(|e| format!("请求 sftp 子系统失败（服务端可能未启用 SFTP）: {e}"))?;
+                Ok::<_, String>(channel)
+            })
+        })
+        .await
+        .map_err(|e| format!("打开 SFTP 通道的任务异常退出: {e}"))?
+    }?;
+
+    let sftp = SftpSession::new(channel.into_stream())
+        .await
+        .map_err(|e| format!("初始化 SFTP 会话失败（可能是版本协商不兼容）: {e}"))?;
+
+    // 初始目录：优先用户配置的 remote_cwd，否则用登录目录。
+    // `canonicalize(".")` 而不是直接用 "."：服务端的 SFTP 起点（chroot 场景下
+    // 是 `/`，普通场景下是 home）只有服务端知道，取回真实值前端才好画面包屑。
+    let initial = match sftp.canonicalize(".").await {
+        Ok(p) if !p.trim().is_empty() => p,
+        _ => ".".to_string(),
+    };
+
+    Ok(Arc::new(SftpHandle {
+        session_id: session.state.id.clone(),
+        gate: Mutex::new(()),
+        sftp,
+        semaphore: Semaphore::new(MAX_CONCURRENT_TRANSFERS),
+        last_dir: Mutex::new(initial),
+    }))
+}
+
+// ===== 目录操作 =====
+
+/// 列举远端目录。
+///
+/// 排序在服务端做而不是让前端排：SFTP 的 `read_dir` 返回顺序是服务端的
+/// 目录项物理顺序（通常是插入序），逐次调用结果不稳定；在这里排一次
+/// 保证「刷新」不会让列表跳动。
+pub async fn list_dir(handle: &SftpHandle, path: &str) -> Result<RemoteDir, String> {
+    // `read_dir` 返回 `ReadDir`（一个可迭代的句柄），**必须显式 collect**：
+    // 它的迭代会持续向服务端发 READDIR 报文直到服务端返回 EOF，
+    // 不 collect 的话句柄被丢弃时可能留下未读完的报文，污染后续请求的响应队列。
+    let iter = handle
+        .sftp
+        .read_dir(path)
+        .await
+        .map_err(|e| format!("读取目录 {path} 失败: {e}"))?;
+
+    let mut list: Vec<RemoteEntry> = Vec::new();
+    for e in iter {
+        let name = e.file_name();
+        // `.` 与 `..` 由前端用面包屑表达，不混进列表（混进去会让「全选」误伤父目录）
+        if name == "." || name == ".." {
+            continue;
+        }
+        let meta = e.metadata();
+        // `file_type()` 来自协议 attrs；`metadata()` 里**没有** `is_file()`
+        // ——`FileAttributes` 只提供 `is_dir()` / `is_symlink()` / `file_type()`。
+        // 因此「是不是普通文件」的判定必须落到 `file_type()` 上（`is_file()` 是
+        // `FileType` 的方法，不是 attrs 的）。
+        let ft = e.file_type();
+        let is_symlink = ft.is_symlink() || meta.is_symlink();
+        let kind = if is_symlink {
+            "symlink"
+        } else if ft.is_dir() || meta.is_dir() {
+            "dir"
+        } else if ft.is_file() {
+            "file"
+        } else {
+            "other"
+        };
+        // `mtime` 是 Unix 秒（SFTP v3 的 attrs 无亚秒精度），统一乘 1000 成毫秒。
+        // 服务端未提供时保持 None，前端显示为「—」而不是伪造的 1970 年。
+        let mtime = meta.mtime.map(|s| (s as u64) * 1000);
+        let perms = meta
+            .permissions
+            .map(|p| format!("{:o}", p & 0o7777))
+            .unwrap_or_default();
+
+        list.push(RemoteEntry {
+            name: name.clone(),
+            path: join_remote(path, &name),
+            kind: kind.to_string(),
+            size: meta.size.unwrap_or(0),
+            modified_at: mtime,
+            permissions: perms,
+            // `read_dir` 不带 link target，符号链接的目标要单独 `read_link`。
+            // 这里不逐条调用：一个含 200 个符号链接的目录会变成 200 次 round-trip。
+            // 前端在用户点击/悬停时再单独请求（见 `read_link` 命令）。
+            link_target: String::new(),
+        });
+    }
+
+    // 目录优先，其次按名称（用不区分大小写的比较，符合 Windows 用户直觉）
+    list.sort_by(|a, b| {
+        let a_dir = a.kind == "dir";
+        let b_dir = b.kind == "dir";
+        b_dir
+            .cmp(&a_dir)
+            .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+    });
+
+    let cwd = handle
+        .sftp
+        .canonicalize(path)
+        .await
+        .unwrap_or_else(|_| path.to_string());
+    *handle.last_dir.lock().await = cwd.clone();
+
+    Ok(RemoteDir {
+        cwd,
+        entries: list,
+    })
+}
+
+/// 拼接远端路径（POSIX 语义，注意不要产生 `//`）。
+pub fn join_remote(base: &str, name: &str) -> String {
+    if base.is_empty() || base == "." {
+        return name.to_string();
+    }
+    if name.starts_with('/') {
+        return name.to_string();
+    }
+    if base.ends_with('/') {
+        format!("{base}{name}")
+    } else {
+        format!("{base}/{name}")
+    }
+}
+
+/// 取远端路径的父目录（用于「上一级」与面包屑）。
+pub fn parent_remote(path: &str) -> String {
+    let trimmed = path.trim_end_matches('/');
+    // 根目录的父目录还是自己，避免前端无限上溯
+    if trimmed.is_empty() {
+        return "/".to_string();
+    }
+    match trimmed.rfind('/') {
+        Some(0) => "/".to_string(),
+        Some(i) => trimmed[..i].to_string(),
+        // 相对路径（服务端未 canonicalize 时）：退化为当前目录
+        None => ".".to_string(),
+    }
+}
+
+/// 读符号链接的目标。
+pub async fn read_link(handle: &SftpHandle, path: &str) -> Result<String, String> {
+    handle
+        .sftp
+        .read_link(path)
+        .await
+        .map_err(|e| format!("读取链接目标失败: {e}"))
+}
+
+/// 创建目录（递归）。
+pub async fn create_dir_all(handle: &SftpHandle, path: &str) -> Result<(), String> {
+    // 逐级创建：SFTP 的 `create_dir` 不递归（与 `mkdir` 不同，没有 `-p`），
+    // 而 `create_dir_all` 在 russh-sftp 里不存在，只能自己走。
+    let mut cur = String::new();
+    for seg in path.trim_start_matches('/').split('/') {
+        if seg.is_empty() {
+            continue;
+        }
+        cur = if cur.is_empty() {
+            if path.starts_with('/') {
+                format!("/{seg}")
+            } else {
+                seg.to_string()
+            }
+        } else {
+            format!("{cur}/{seg}")
+        };
+        // 已存在是正常情况（多级创建的中途层级），忽略错误继续
+        let _ = handle.sftp.create_dir(&cur).await;
+    }
+    Ok(())
+}
+
+/// 删除远端文件。
+pub async fn remove_file(handle: &SftpHandle, path: &str) -> Result<(), String> {
+    handle
+        .sftp
+        .remove_file(path)
+        .await
+        .map_err(|e| format!("删除文件失败: {e}"))
+}
+
+/// 递归删除远端目录。
+///
+/// 手写递归而不是 `remove_dir_all`：后者在部分服务端实现上对符号链接的处理
+/// 不一致（有的会跟随链接删掉目标内容，这是**数据事故**）。这里显式判断
+/// `symlink_metadata`，遇到符号链接只删链接本身。
+pub async fn remove_dir_all(handle: &SftpHandle, path: &str) -> Result<u64, String> {
+    let mut removed: u64 = 0;
+    let iter = handle
+        .sftp
+        .read_dir(path)
+        .await
+        .map_err(|e| format!("读取目录 {path} 失败: {e}"))?;
+
+    let mut sub_dirs: Vec<String> = Vec::new();
+    let mut files: Vec<String> = Vec::new();
+    for e in iter {
+        let name = e.file_name();
+        if name == "." || name == ".." {
+            continue;
+        }
+        let full = join_remote(path, &name);
+        let ft = e.file_type();
+        let meta = e.metadata();
+        // 符号链接**先于** is_dir 判断：SFTP 的 attrs 对链接常会报告目标类型，
+        // 若先判 is_dir 会把链接当目录递归进去（删掉链接目标的真内容）。
+        if ft.is_symlink() || meta.is_symlink() {
+            files.push(full);
+        } else if ft.is_dir() || meta.is_dir() {
+            sub_dirs.push(full);
+        } else {
+            files.push(full);
+        }
+    }
+
+    // 先删文件再删子目录：先把当前层的文件清掉，收敛更快（失败时更容易定位）
+    for f in files {
+        handle
+            .sftp
+            .remove_file(&f)
+            .await
+            .map_err(|e| format!("删除 {f} 失败: {e}"))?;
+        removed += 1;
+    }
+    for d in sub_dirs {
+        removed += Box::pin(remove_dir_all(handle, &d)).await?;
+    }
+
+    handle
+        .sftp
+        .remove_dir(path)
+        .await
+        .map_err(|e| format!("删除目录 {path} 失败: {e}"))?;
+    Ok(removed + 1)
+}
+
+/// 重命名 / 移动。
+pub async fn rename(handle: &SftpHandle, from: &str, to: &str) -> Result<(), String> {
+    handle
+        .sftp
+        .rename(from, to)
+        .await
+        .map_err(|e| format!("重命名失败: {e}"))
+}
+
+// ===== 上传 / 下载 =====
+
+/// 上传本地文件到远端。
+///
+/// # 断点续传
+///
+/// 打开远端文件时**不加 `TRUNCATE`**，先 `metadata` 取已存在的大小，
+/// 再 `seek` 到该位置继续写。若远端已有文件比本地大（本地被截断过），
+/// 则退回整文件重传——继续写会得到一个「前长后短」的损坏文件。
+pub async fn upload_file(
+    handle: &SftpHandle,
+    local: &str,
+    remote: &str,
+    on_progress: impl Fn(u64, u64),
+) -> Result<u64, String> {
+    let _permit = handle
+        .semaphore
+        .acquire()
+        .await
+        .map_err(|e| format!("获取传输许可失败: {e}"))?;
+
+    let total = tokio::fs::metadata(local)
+        .await
+        .map_err(|e| format!("读取本地文件 {local} 失败: {e}"))?
+        .len();
+
+    // 远端已有大小（用于续传判断）
+    let existing = handle
+        .sftp
+        .metadata(remote)
+        .await
+        .ok()
+        .and_then(|m| m.size)
+        .unwrap_or(0);
+
+    let resume_from = if existing > 0 && existing < total {
+        existing
+    } else {
+        0
+    };
+
+    let flags = if resume_from > 0 {
+        OpenFlags::WRITE
+    } else {
+        OpenFlags::WRITE | OpenFlags::CREATE | OpenFlags::TRUNCATE
+    };
+
+    let mut remote_file = handle
+        .sftp
+        .open_with_flags(remote, flags)
+        .await
+        .map_err(|e| format!("打开远端文件 {remote} 失败: {e}"))?;
+
+    let mut local_file = tokio::fs::File::open(local)
+        .await
+        .map_err(|e| format!("打开本地文件 {local} 失败: {e}"))?;
+
+    if resume_from > 0 {
+        local_file
+            .seek(std::io::SeekFrom::Start(resume_from))
+            .await
+            .map_err(|e| format!("定位本地文件失败: {e}"))?;
+        remote_file
+            .seek(std::io::SeekFrom::Start(resume_from))
+            .await
+            .map_err(|e| format!("定位远端文件失败: {e}"))?;
+    }
+
+    let mut buf = vec![0u8; CHUNK_SIZE];
+    let mut sent = resume_from;
+    on_progress(sent, total);
+
+    loop {
+        let n = local_file
+            .read(&mut buf)
+            .await
+            .map_err(|e| format!("读取本地文件失败: {e}"))?;
+        if n == 0 {
+            break;
+        }
+        remote_file
+            .write_all(&buf[..n])
+            .await
+            .map_err(|e| format!("写入远端失败: {e}"))?;
+        sent += n as u64;
+        on_progress(sent, total);
+    }
+
+    // `shutdown` 会把 SFTP 的 close 报文发出去；不调用的话服务端可能迟迟不落盘
+    // （尤其写的是网络文件系统上的文件）。
+    remote_file
+        .shutdown()
+        .await
+        .map_err(|e| format!("关闭远端文件失败（数据可能未完整落盘）: {e}"))?;
+
+    Ok(sent)
+}
+
+/// 从远端下载文件到本地。
+///
+/// 断点续传逻辑与上传对称：本地已有一部分则从该偏移继续。
+pub async fn download_file(
+    handle: &SftpHandle,
+    remote: &str,
+    local: &str,
+    on_progress: impl Fn(u64, u64),
+) -> Result<u64, String> {
+    let _permit = handle
+        .semaphore
+        .acquire()
+        .await
+        .map_err(|e| format!("获取传输许可失败: {e}"))?;
+
+    let total = handle
+        .sftp
+        .metadata(remote)
+        .await
+        .ok()
+        .and_then(|m| m.size)
+        .unwrap_or(0);
+
+    let existing = tokio::fs::metadata(local)
+        .await
+        .map(|m| m.len())
+        .unwrap_or(0);
+
+    let resume_from = if existing > 0 && total > 0 && existing < total {
+        existing
+    } else {
+        0
+    };
+
+    let mut remote_file = handle
+        .sftp
+        .open(remote)
+        .await
+        .map_err(|e| format!("打开远端文件 {remote} 失败: {e}"))?;
+
+    // 确保父目录存在（下载到新目录时很常见）
+    if let Some(parent) = std::path::Path::new(local).parent() {
+        let _ = tokio::fs::create_dir_all(parent).await;
+    }
+
+    let mut local_file = tokio::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(resume_from == 0)
+        .open(local)
+        .await
+        .map_err(|e| format!("创建本地文件 {local} 失败: {e}"))?;
+
+    if resume_from > 0 {
+        remote_file
+            .seek(std::io::SeekFrom::Start(resume_from))
+            .await
+            .map_err(|e| format!("定位远端文件失败: {e}"))?;
+        local_file
+            .seek(std::io::SeekFrom::Start(resume_from))
+            .await
+            .map_err(|e| format!("定位本地文件失败: {e}"))?;
+    }
+
+    let mut buf = vec![0u8; CHUNK_SIZE];
+    let mut got = resume_from;
+    on_progress(got, total);
+
+    loop {
+        let n = remote_file
+            .read(&mut buf)
+            .await
+            .map_err(|e| format!("读取远端失败: {e}"))?;
+        if n == 0 {
+            break;
+        }
+        local_file
+            .write_all(&buf[..n])
+            .await
+            .map_err(|e| format!("写入本地文件失败: {e}"))?;
+        got += n as u64;
+        on_progress(got, total);
+    }
+
+    local_file
+        .flush()
+        .await
+        .map_err(|e| format!("刷新本地文件失败: {e}"))?;
+
+    Ok(got)
+}
+
+/// 类型占位：确保 `SshHandler` 与 `Handle<SshHandler>` 的关联在编译期成立。
+#[allow(dead_code)]
+fn _assert_handle_type(h: &Handle<SshHandler>) -> &Handle<SshHandler> {
+    h
+}

src-tauri/src/terminal/window.rs

@@ -0,0 +1,147 @@
+//! 终端窗口管理。
+//!
+//! # 设计取舍：一个会话一个窗口，而非一个窗口多个会话
+//!
+//! 有两条路可走：
+//!
+//! | 方案 | 优势 | 代价 |
+//! |---|---|---|
+//! | 一个独立窗口承载全部会话（把主窗口的终端 UI 整体搬出去） | 实现简单，复用全部前端组件 | 无法「只把一个会话拖出来」；两处 UI 状态要同步 |
+//! | **一个会话一个窗口** | 符合「拖出标签成窗」的直觉；窗口粒度与会话粒度一致，状态无歧义 | 每窗口一个 WebView，内存开销更大 |
+//!
+//! 选后者。理由：终端的核心使用场景就是「同时盯几台机器的输出」，把其中一个
+//! 会话丢到第二块屏幕是所有终端工具的刚需；而窗口粒度与会话粒度一致，意味着
+//! 「关闭窗口」= 「关闭会话」，没有隐藏状态，心智负担最小。
+//!
+//! 内存开销通过限制窗口数量（[`MAX_DETACHED_WINDOWS`]）来控制。
+//!
+//! # 会话与窗口的关系
+//!
+//! 会话**不随窗口创建而创建**。用户点「在新窗口打开」时，会话已经在主窗口里
+//! 跑着（进程在 Rust 侧），窗口只是**另一个 attach 到这个会话的视图**。
+//! 这带来两个后果：
+//! 1. 主窗口关闭（隐藏到托盘）不影响终端窗口 —— 会话在 Rust 侧，与窗口无关。
+//! 2. 同一个会话可以同时显示在主窗口与独立窗口（输出事件是广播的）。
+//!    这是刻意的：用户可以在主窗口把某个会话放进分屏、同时另开一个窗口放大看。
+
+use tauri::{AppHandle, Manager, WebviewUrl, WebviewWindowBuilder};
+
+use super::session::SessionId;
+use crate::constants::windows as W;
+
+/// 同时存在的独立终端窗口上限。
+///
+/// 8 是个经验值：每个终端窗口都是一个独立 WebView（各自约 40~80MB），
+/// 再多会明显吃内存；而「同时盯 8 个终端」已覆盖绝大多数实际需求。
+/// 超出时明确报错而不是静默失败——用户需要知道是上限拦住了他。
+pub const MAX_DETACHED_WINDOWS: usize = 8;
+
+/// 计算会话对应的窗口 label。
+pub fn label_for(session_id: &str) -> String {
+    format!("{}-{}", W::TERMINAL_WINDOW, session_id)
+}
+
+/// 当前有多少个终端独立窗口。
+pub fn count_windows(app: &AppHandle) -> usize {
+    app.webview_windows()
+        .keys()
+        .filter(|k| k.starts_with(&format!("{}-", W::TERMINAL_WINDOW)))
+        .count()
+}
+
+/// 打开（或聚焦）某会话的独立窗口。
+///
+/// 幂等：窗口已存在时只做 `show` + `set_focus`，不重建 WebView。
+/// 重建会丢失 xterm 的滚动缓冲（虽然内容可从会话快照恢复，但没必要多此一举）。
+pub fn open_for_session(
+    app: &AppHandle,
+    session_id: &SessionId,
+    title: &str,
+) -> Result<(), String> {
+    let label = label_for(session_id);
+
+    if let Some(win) = app.get_webview_window(&label) {
+        win.show().map_err(|e| format!("显示窗口失败: {e}"))?;
+        win.set_focus().map_err(|e| format!("聚焦窗口失败: {e}"))?;
+        return Ok(());
+    }
+
+    let n = count_windows(app);
+    if n >= MAX_DETACHED_WINDOWS {
+        return Err(format!(
+            "已达独立终端窗口上限（{MAX_DETACHED_WINDOWS} 个）。\
+             请先关闭一些窗口，或改为在主窗口内使用标签页。"
+        ));
+    }
+
+    // 窗口尺寸：终端是「宽而扁」的，给一个偏宽的默认值，接近常见终端习惯
+    let win = WebviewWindowBuilder::new(
+        app,
+        &label,
+        // 路由到前端的 terminal 独立窗口入口（main.ts 中按 hash 分派）
+        WebviewUrl::App(format!("index.html#terminal-window/{session_id}").into()),
+    )
+    .title(format!("终端 · {title}"))
+    .inner_size(1000.0, 620.0)
+    .min_inner_size(420.0, 240.0)
+    .resizable(true)
+    // 无系统边框：窗口内自绘标题栏（TerminalWindow.vue），系统标题栏会与之叠加
+    .decorations(false)
+    // 无边框窗口默认没有投影，加上以保持与系统窗口一致的层次感
+    .shadow(true)
+    .center()
+    .build()
+    .map_err(|e| format!("创建终端窗口失败: {e}"))?;
+
+    // 关闭窗口时：**只关窗口，不关会话**。
+    //
+    // 这是刻意的语义选择。若「关窗即关会话」，用户移动窗口时误点关闭就会
+    // 丢掉一个正在跑长任务的 SSH 连接；而保留会话的代价只是列表里多一个标签。
+    // 需要在窗口里显式提供「关闭会话」按钮，让两个动作分离。
+    let app_handle = app.clone();
+    let sid = session_id.clone();
+    win.on_window_event(move |event| {
+        if let tauri::WindowEvent::Destroyed = event {
+            // 把会话标记回「未分离」状态，前端的标签列表据此恢复显示
+            if let Ok(state) = super::manager(&app_handle) {
+                if let Some(s) = state.sessions.get(&sid) {
+                    s.set_detached(false);
+                }
+            }
+        }
+    });
+
+    Ok(())
+}
+
+/// 关闭某会话的独立窗口（会话本身保留）。
+pub fn close_for_session(app: &AppHandle, session_id: &SessionId) -> Result<(), String> {
+    let label = label_for(session_id);
+    if let Some(win) = app.get_webview_window(&label) {
+        win.close().map_err(|e| format!("关闭窗口失败: {e}"))?;
+    }
+    Ok(())
+}
+
+/// 把会话的 `detached` 标记与窗口状态对齐。
+///
+/// 应用启动后（或窗口被外部关闭后）可能存在不一致：标记说已分离但窗口不在。
+/// 由命令层在查询会话列表前调用一次，保证前端拿到的状态是准确的。
+///
+/// 返回**是否有任何标记被修正**：调用方（`terminal_list_sessions`）据此决定
+/// 是否需要再取一次列表——无变更时直接复用第一次的结果，省掉一次全表遍历。
+pub fn reconcile_flags(app: &AppHandle, sessions: &[(SessionId, bool)]) -> bool {
+    let mut changed = false;
+    for (id, marked) in sessions {
+        let exists = app.get_webview_window(&label_for(id)).is_some();
+        if *marked != exists {
+            if let Ok(state) = super::manager(app) {
+                if let Some(s) = state.sessions.get(id) {
+                    s.set_detached(exists);
+                    changed = true;
+                }
+            }
+        }
+    }
+    changed
+}

src-tauri/src/translate/capture/clipboard_capture.rs

@@ -0,0 +1,500 @@
+//! 取词：智能路径（UIA 直读）优先，兼容路径（模拟 Ctrl+C）兜底。
+//!
+//! 整个流程在**调用方的阻塞线程**上执行（最长约 1s）。**严禁在主线程调用**：
+//! 全局快捷键回调与 UI 线程都不该被这段等待卡住。命令层用 `spawn_blocking` 包装，
+//! 快捷键回调自行 `std::thread::spawn`。
+
+use std::time::{Duration, Instant};
+
+use serde::Serialize;
+use specta::Type;
+use tauri::{AppHandle, Manager};
+
+use crate::clipboard::reader::{read_clipboard, write_dib, write_files, write_text, ClipData};
+use crate::clipboard::ClipboardManager;
+use crate::translate::engines::{ErrorKind, TranslateError};
+use windows_sys::Win32::Foundation::CloseHandle;
+use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber;
+use windows_sys::Win32::System::Threading::{
+    OpenProcess, QueryFullProcessImageNameW, PROCESS_QUERY_LIMITED_INFORMATION,
+};
+use windows_sys::Win32::UI::Input::KeyboardAndMouse::{
+    GetAsyncKeyState, SendInput, INPUT, INPUT_KEYBOARD, KEYBDINPUT, KEYEVENTF_KEYUP, VK_CONTROL,
+};
+use windows_sys::Win32::UI::WindowsAndMessaging::{
+    GetForegroundWindow, GetWindowThreadProcessId,
+};
+
+/// 模拟按键后等待剪贴板更新的上限。
+///
+/// 300ms 偏短：浏览器、Electron 应用、带插件的编辑器在复制前还要走一遍自己的
+/// 命令分发，慢一点的直接超时。放宽到 600ms 后失败率明显下降，而用户感知的
+/// 「按下到弹出」延迟仍在可接受范围（取词是主动行为，不是输入反馈）。
+const PASTE_WAIT: Duration = Duration::from_millis(600);
+/// 轮询间隔
+const POLL_INTERVAL: Duration = Duration::from_millis(10);
+/// 等用户自然松开修饰键的时间（见 [`neutralise_modifiers`]）
+const MOD_RELEASE_WAIT: Duration = Duration::from_millis(400);
+
+const VK_C: u16 = 0x43;
+const VK_V: u16 = 0x56;
+const VK_INSERT: u16 = 0x2D;
+const VK_MENU: u16 = 0x12; // Alt
+const VK_SHIFT: u16 = 0x10;
+const VK_LWIN: u16 = 0x5B;
+const VK_RWIN: u16 = 0x5C;
+
+/// 会「污染」Ctrl+C 的修饰键：按下时目标应用看到的是 Alt+Ctrl+C 之类，
+/// 没有任何应用把它当复制。Alt 与 Shift 会被强制松开（见 [`neutralise_modifiers`]）。
+const BLOCKING_MODIFIERS: [u16; 2] = [VK_MENU, VK_SHIFT];
+/// 参与「等自然松开」但不强制合成的键：合成 Win 抬起会触发开始菜单，代价太大。
+const WAIT_ONLY_MODIFIERS: [u16; 2] = [VK_LWIN, VK_RWIN];
+
+/// 取词参数（来自设置）
+#[derive(Debug, Clone)]
+pub struct CaptureRequest {
+    /// 文本字符数上限，超出直接拒绝而不是发一个巨大的请求
+    pub max_chars: usize,
+    /// 取词后是否还原剪贴板
+    pub restore_clipboard: bool,
+    /// 跳过取词的进程名黑名单（终端类）
+    pub blacklist: Vec<String>,
+    /// 取词方式："smart"（UIA 直读优先，失败退回模拟按键）| "compat"（只用模拟按键）
+    pub mode: String,
+}
+
+/// 取词结果
+#[derive(Debug, Clone, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CaptureOutcome {
+    pub text: String,
+    /// 取词来源："clipboard"（模拟 Ctrl+C）
+    pub source: String,
+    /// 取词时的前台窗口句柄（P3 回填替换选区时要用，事后无法补齐）
+    pub source_hwnd: i64,
+    /// 前台窗口所属进程名（用于提示与黑名单判定）
+    pub source_process: String,
+    /// 剪贴板是否被成功还原。false 有两种情况：备份时剪贴板是**不支持的格式**
+    /// （如仅含 HTML/RTF，无法原样写回），或还原本身失败——此时选区文本会留在剪贴板上。
+    pub restored_clipboard: bool,
+}
+
+/// 执行一次取词。**阻塞**，见模块头注释。
+///
+/// 并发互斥：连按快捷键（以为没反应再按一次是常见操作）会让两套
+/// 「备份 → Ctrl+C → 轮询 → 还原」并发执行，互相覆盖剪贴板状态。
+/// 在途时后来者直接放弃，静默返回。
+pub fn capture_selection(
+    app: &AppHandle,
+    req: &CaptureRequest,
+) -> Result<CaptureOutcome, TranslateError> {
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    static IN_FLIGHT: AtomicBool = AtomicBool::new(false);
+    if IN_FLIGHT.swap(true, Ordering::SeqCst) {
+        return Err(TranslateError::new(
+            ErrorKind::Empty,
+            "上一次取词仍在进行中",
+        ));
+    }
+    let result = capture_selection_inner(app, req);
+    IN_FLIGHT.store(false, Ordering::SeqCst);
+    result
+}
+
+fn capture_selection_inner(
+    app: &AppHandle,
+    req: &CaptureRequest,
+) -> Result<CaptureOutcome, TranslateError> {
+    let (hwnd, process) = foreground_window_process();
+    let process_name = process.clone().unwrap_or_default();
+
+    if !process_name.is_empty()
+        && req
+            .blacklist
+            .iter()
+            .any(|b| b.trim().eq_ignore_ascii_case(&process_name))
+    {
+        return Err(TranslateError::unsupported(format!(
+            "「{process_name}」中 Ctrl+C 是中断信号，无法用于取词。\
+             请选中文字后复制，再用「翻译剪贴板」快捷键。"
+        )));
+    }
+
+    // ===== 智能路径：UIA 直读（不动键盘、不碰剪贴板）=====
+    // 命中即返回：既避免了修饰键残留 / 提权窗口 / 剪贴板占用这三类兼容路径问题，
+    // 也快得多（一次跨进程 COM 调用 vs 一次 600ms 的剪贴板等待）。
+    if req.mode.trim() != "compat" {
+        if let Some(text) = uia_selection() {
+            crate::logger::log_info(
+                "translate",
+                &format!(
+                    "取词：UIA 直读命中（{} 字符），前台进程 {:?}",
+                    text.chars().count(),
+                    process_name
+                ),
+            );
+            return finish_text(req, text, hwnd, &process_name, true);
+        }
+    }
+
+    // 屏蔽窗口覆盖「Ctrl+C 覆盖剪贴板 → 读走 → 还原」的全过程。
+    // 守卫析构时自动解除，提前 return 也不会漏。
+    let suppress = app.try_state::<ClipboardManager>().map(|m| m.suppress());
+    let _guard = suppress.as_ref().map(|s| s.burst());
+
+    let backup = read_clipboard();
+    let before = clipboard_seq();
+
+    // 关键：先让修饰键回到「都没按」的状态，再发 Ctrl+C。
+    // 全局快捷键是在**按下**的瞬间触发的，此刻 Alt 必然还被物理按住；
+    // 直接补发 Ctrl+C，目标应用收到的是 Alt+Ctrl+C —— 复制不会发生，
+    // 于是必然走到下面的「取词超时」。这是兼容路径取不到词最主要的原因。
+    let forced = neutralise_modifiers();
+
+    send_ctrl_c();
+    let mut updated = wait_clipboard_change(before, PASTE_WAIT);
+    // 重试一次：部分应用首次按键被自身的输入法/菜单状态吃掉，第二次才真正复制。
+    // 复制是幂等的，多按一次没有副作用，比直接判定失败划算。
+    if !updated {
+        send_ctrl_c();
+        updated = wait_clipboard_change(before, PASTE_WAIT / 2);
+    }
+    // Ctrl+Insert 兜底：个别应用对合成的 Ctrl+C 不响应，但认经典的复制和弦
+    // （控制台/部分老程序对 Ctrl+Insert 的处理路径也与 Ctrl+C 不同）。
+    // 无选区时该组合键无副作用，与「复制是幂等的」同理。
+    if !updated {
+        crate::logger::log_info(
+            "translate",
+            &format!("取词：Ctrl+C 未更新剪贴板（前台进程 {process_name:?}），改试 Ctrl+Insert"),
+        );
+        send_ctrl_insert();
+        updated = wait_clipboard_change(before, PASTE_WAIT / 2);
+    }
+    let clip = if updated { read_clipboard() } else { None };
+    // 键盘状态尽早复原：越早把 Alt 按回去，越不容易让目标应用进入菜单栏模式
+    restore_modifiers(&forced);
+
+    if !updated {
+        return Err(TranslateError::new(
+            ErrorKind::Empty,
+            "取词失败：模拟 Ctrl+C 后剪贴板没有更新。\
+             常见原因是目标窗口以管理员权限运行（系统会丢弃来自普通权限程序的模拟按键），\
+             或该应用不支持复制选区。可改用「翻译剪贴板」：先复制，再按对应快捷键。"
+                .to_string(),
+        ));
+    }
+
+    // 剪贴板已被目标应用覆盖为选区内容。**先还原再做一切判定**：
+    // 还原必须覆盖所有后续路径（非文本 / 空文本 / 超限 / 成功），
+    // 否则「取词失败」的代价是用户剪贴板被悄悄换掉，与 restore_clipboard 设置矛盾。
+    let restored = if req.restore_clipboard {
+        restore_clipboard(backup)
+    } else {
+        false
+    };
+    // 还原本身也改了剪贴板。虽然还在屏蔽窗口内，但窗口解除后监听可能才轮到这一次变化，
+    // 于是额外精确记账一次，把边界情况的漏网也堵上。
+    if restored {
+        if let Some(s) = suppress.as_ref() {
+            s.mark_seq(clipboard_seq());
+        }
+    }
+
+    let text = match clip {
+        Some(ClipData::Text(t)) => t,
+        Some(_) => {
+            return Err(TranslateError::new(
+                ErrorKind::Empty,
+                "取到的内容不是文本（选区可能是图片或文件）",
+            ))
+        }
+        None => {
+            return Err(TranslateError::new(
+                ErrorKind::Empty,
+                "未获取到选中文本：目标窗口可能不允许复制，或当前没有选中任何文字",
+            ))
+        }
+    };
+
+    finish_text(
+        req,
+        text,
+        hwnd,
+        &process_name,
+        // UIA 路径：剪贴板从头到尾没被碰过
+        restored,
+    )
+}
+
+/// 取到文本后的公共收尾：裁剪 → 空判定 → 字数上限 → 组装结果。
+///
+/// 两条取词路径（UIA 直读 / 模拟 Ctrl+C）都必须过这套校验，否则「字数上限」
+/// 只对其中一条生效——那正是配置里写「上限」却仍被绕过的原因。
+fn finish_text(
+    req: &CaptureRequest,
+    text: String,
+    hwnd: i64,
+    process_name: &str,
+    clip_intact: bool,
+) -> Result<CaptureOutcome, TranslateError> {
+    let trimmed = text.trim();
+    if trimmed.is_empty() {
+        return Err(TranslateError::new(
+            ErrorKind::Empty,
+            "未获取到选中文本（取到的内容为空）",
+        ));
+    }
+    let char_count = trimmed.chars().count();
+    if req.max_chars > 0 && char_count > req.max_chars {
+        return Err(TranslateError::unsupported(format!(
+            "选中内容 {char_count} 字符，超过取词上限（{}）。\
+             请在「翻译 → 设置 → 划词翻译」中调高上限，或改用主面板翻译。",
+            req.max_chars
+        )));
+    }
+
+    Ok(CaptureOutcome {
+        text: trimmed.to_string(),
+        source: "selection".to_string(),
+        source_hwnd: hwnd,
+        source_process: process_name.to_string(),
+        restored_clipboard: clip_intact,
+    })
+}
+
+fn clipboard_seq() -> u32 {
+    unsafe { GetClipboardSequenceNumber() }
+}
+
+/// UIA 直读选区（智能路径）。`windows` crate 只在 Windows 目标上参与构建，
+/// 因此非 Windows 目标这里直接返回 None（等价于「读不到」→ 走兼容路径）。
+#[cfg(windows)]
+fn uia_selection() -> Option<String> {
+    super::uia_capture::read_selection()
+}
+
+#[cfg(not(windows))]
+fn uia_selection() -> Option<String> {
+    None
+}
+
+/// 等剪贴板序号变化（即目标应用完成了复制）。
+fn wait_clipboard_change(before: u32, timeout: Duration) -> bool {
+    let deadline = Instant::now() + timeout;
+    while Instant::now() < deadline {
+        if clipboard_seq() != before {
+            return true;
+        }
+        std::thread::sleep(POLL_INTERVAL);
+    }
+    false
+}
+
+fn key_down(vk: u16) -> bool {
+    (unsafe { GetAsyncKeyState(vk as i32) } as u16 & 0x8000) != 0
+}
+
+/// 发送单个按键事件（`up` 为真表示抬起）。
+fn send_key(vk: u16, up: bool) {
+    let mut input: INPUT = unsafe { std::mem::zeroed() };
+    input.r#type = INPUT_KEYBOARD;
+    input.Anonymous.ki = KEYBDINPUT {
+        wVk: vk,
+        wScan: 0,
+        dwFlags: if up { KEYEVENTF_KEYUP } else { 0 },
+        time: 0,
+        dwExtraInfo: 0,
+    };
+    unsafe {
+        SendInput(1, &input, std::mem::size_of::<INPUT>() as i32);
+    }
+}
+
+/// 让修饰键回到「都没按」的状态，返回被**强制**松开的键（调用方负责按回去）。
+///
+/// 两步走，顺序很重要：
+/// 1. **先等用户自然松开**。全局快捷键在按键**按下**的瞬间触发，此刻 Alt 一定还按着；
+///    绝大多数情况用户几十毫秒内就松手了，等一下既解决了问题，又完全不用合成按键
+///    （合成 Alt 抬起有让目标应用进入菜单栏模式的风险）。
+/// 2. 超时仍未松开（长按、卡键）才合成抬起事件。只处理 Alt/Shift：合成 Win 抬起
+///    会触发开始菜单，代价远大于收益——Win 参与的组合键本就罕见。
+fn neutralise_modifiers() -> Vec<u16> {
+    let deadline = Instant::now() + MOD_RELEASE_WAIT;
+    let all: Vec<u16> = BLOCKING_MODIFIERS
+        .iter()
+        .chain(WAIT_ONLY_MODIFIERS.iter())
+        .copied()
+        .collect();
+    while Instant::now() < deadline {
+        if !all.iter().copied().any(key_down) {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(8));
+    }
+
+    let mut forced = Vec::new();
+    for vk in BLOCKING_MODIFIERS {
+        if key_down(vk) {
+            send_key(vk, true);
+            forced.push(vk);
+        }
+    }
+    if !forced.is_empty() {
+        // 给目标应用一点时间处理抬起事件，避免紧接着的 Ctrl+C 被合并成 Alt+Ctrl+C
+        std::thread::sleep(Duration::from_millis(10));
+    }
+    forced
+}
+
+/// 把 [`neutralise_modifiers`] 强制松开的键按回去，让用户自己松手时状态一致。
+///
+/// **只还原仍然物理按住的键**：用户可能在等待期间就松手了，此时再合成一个 keydown
+/// 会把 Alt 留在「按下」状态——他下一次敲任意键都会变成 Alt+某键，比不还原糟糕得多。
+fn restore_modifiers(keys: &[u16]) {
+    for vk in keys {
+        if key_down(*vk) {
+            send_key(*vk, false);
+        }
+    }
+}
+
+/// 把备份内容原样写回。仅支持文本 / 图片 / 文件三种格式——其余格式（HTML/RTF 等）
+/// 在备份阶段就读不出来，因此无法还原，返回 false 而不是假装成功。
+fn restore_clipboard(backup: Option<ClipData>) -> bool {
+    match backup {
+        Some(ClipData::Text(t)) => write_text(&t),
+        Some(ClipData::Image { dib, .. }) => write_dib(&dib),
+        Some(ClipData::Files(files)) => write_files(&files),
+        None => false,
+    }
+}
+
+/// 模拟 Ctrl+V（译文回填替换选区用）。
+///
+/// 与 [`send_ctrl_c`] 相同的修饰键处理：若用户仍按着 Ctrl，只补发 V 键，
+/// 避免把用户的修饰键一并释放。
+pub fn send_ctrl_v() {
+    let ctrl_held = (unsafe { GetAsyncKeyState(VK_CONTROL as i32) } as u16 & 0x8000) != 0;
+
+    let mut inputs: Vec<INPUT> = Vec::with_capacity(4);
+    let mut push = |vk: u16, up: bool| {
+        let mut input: INPUT = unsafe { std::mem::zeroed() };
+        input.r#type = INPUT_KEYBOARD;
+        input.Anonymous.ki = KEYBDINPUT {
+            wVk: vk,
+            wScan: 0,
+            dwFlags: if up { KEYEVENTF_KEYUP } else { 0 },
+            time: 0,
+            dwExtraInfo: 0,
+        };
+        inputs.push(input);
+    };
+
+    // 取词悬浮窗是非激活的，前台窗口仍是原应用：Ctrl+V 会落在原选区上
+    let own_ctrl = !ctrl_held;
+    if own_ctrl {
+        push(VK_CONTROL, false);
+    }
+    push(VK_V, false);
+    push(VK_V, true);
+    if own_ctrl {
+        push(VK_CONTROL, true);
+    }
+
+    unsafe {
+        SendInput(
+            inputs.len() as u32,
+            inputs.as_ptr(),
+            std::mem::size_of::<INPUT>() as i32,
+        );
+    }
+}
+
+/// 取前台窗口句柄与所属进程名。
+fn foreground_window_process() -> (i64, Option<String>) {
+    unsafe {
+        let hwnd = GetForegroundWindow();
+        if hwnd == 0 {
+            return (0, None);
+        }
+        let mut pid: u32 = 0;
+        GetWindowThreadProcessId(hwnd, &mut pid);
+        let hwnd_i64 = hwnd as i64;
+        if pid == 0 {
+            return (hwnd_i64, None);
+        }
+        let handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
+        if handle == 0 {
+            // 目标进程权限更高时连句柄都拿不到——这本身就是一个有效信号，
+            // 但不必在这里下结论，让后续「取词超时」去提示
+            return (hwnd_i64, None);
+        }
+        let mut buf = [0u16; 512];
+        let mut size = buf.len() as u32;
+        let ok = QueryFullProcessImageNameW(handle, 0, buf.as_mut_ptr(), &mut size);
+        CloseHandle(handle);
+        if ok == 0 {
+            return (hwnd_i64, None);
+        }
+        let path = String::from_utf16_lossy(&buf[..size as usize]);
+        let name = path
+            .rsplit(['\\', '/'])
+            .next()
+            .unwrap_or(path.as_str())
+            .to_string();
+        (hwnd_i64, if name.is_empty() { None } else { Some(name) })
+    }
+}
+
+/// 模拟「Ctrl + 某键」。
+///
+/// 关键细节：若用户此刻**正按着 Ctrl**（例如取词快捷键本身带 Ctrl），
+/// 我们发出的 Ctrl 抬起会把用户的修饰键一并释放，造成「按一次快捷键后
+/// Ctrl 行为异常」。因此先探测 Ctrl 的物理状态，只补发缺失的那一段。
+fn send_ctrl_chord(vk: u16) {
+    // 高位为 1 表示当前处于按下状态
+    let ctrl_held = (unsafe { GetAsyncKeyState(VK_CONTROL as i32) } as u16 & 0x8000) != 0;
+
+    let mut inputs: Vec<INPUT> = Vec::with_capacity(4);
+    let mut push = |vk: u16, up: bool| {
+        let mut input: INPUT = unsafe { std::mem::zeroed() };
+        input.r#type = INPUT_KEYBOARD;
+        input.Anonymous.ki = KEYBDINPUT {
+            wVk: vk,
+            wScan: 0,
+            dwFlags: if up { KEYEVENTF_KEYUP } else { 0 },
+            time: 0,
+            dwExtraInfo: 0,
+        };
+        inputs.push(input);
+    };
+
+    let own_ctrl = !ctrl_held;
+    if own_ctrl {
+        push(VK_CONTROL, false);
+    }
+    push(vk, false);
+    push(vk, true);
+    if own_ctrl {
+        push(VK_CONTROL, true);
+    }
+
+    unsafe {
+        SendInput(
+            inputs.len() as u32,
+            inputs.as_ptr(),
+            std::mem::size_of::<INPUT>() as i32,
+        );
+    }
+}
+
+/// 模拟 Ctrl+C。
+fn send_ctrl_c() {
+    send_ctrl_chord(VK_C);
+}
+
+/// 模拟 Ctrl+Insert：部分应用对合成的 Ctrl+C 不响应，但认这条经典复制和弦。
+fn send_ctrl_insert() {
+    send_ctrl_chord(VK_INSERT);
+}

src-tauri/src/translate/capture/mod.rs

@@ -0,0 +1,28 @@
+//! 取词：把「用户选中的文本」弄到手。
+//!
+//! 两条路径，由 `selection.mode` 决定（默认 `"smart"`）：
+//! - **UIA 直读**（[`uia_capture`]）：向目标进程的自动化提供者要当前选区。
+//!   不模拟按键、不碰剪贴板，因此不受修饰键残留、UIPI、剪贴板占用影响。读不到就
+//!   返回 None，自动退回下一条路径。
+//! - **兼容路径**（[`clipboard_capture`]）：备份剪贴板 → 模拟 Ctrl+C → 读走 → 还原。
+//!   覆盖最广（几乎所有支持复制的宿主都行），代价是短暂占用剪贴板。
+//!
+//! 调用方不该关心用了哪条路径，只看 [`clipboard_capture::CaptureOutcome::source`] 即可。
+//!
+//! 四条必须显式处理的现实约束（都是踩过才知道的）：
+//! 0. **修饰键残留**：全局快捷键在按键**按下**瞬间触发，此时 Alt 仍被物理按住，
+//!    补发的 Ctrl+C 在目标应用看来是 `Alt+Ctrl+C` —— 没有任何应用把它当复制。
+//!    这是「按了快捷键却取不到词」最主要的原因，见
+//!    [`clipboard_capture`] 里的 `neutralise_modifiers`。
+//! 1. **剪贴板必须被屏蔽**：整个取词过程会动三次剪贴板，而监听线程是 250ms 轮询，
+//!    按序列号逐个记账存在竞态。见 [`crate::clipboard::suppress`]。
+//! 2. **终端类应用不能取词**：Ctrl+C 在那里是中断信号。走进程黑名单，给出可行的替代做法。
+//! 3. **提权窗口取不到词**：目标进程以管理员权限运行时，非提权进程的 `SendInput`
+//!    会被 UIPI 直接丢弃（不报错、无反馈）。因此必须区分「超时」与「剪贴板变了但没有文本」，
+//!    否则用户只会看到一句含糊的失败。
+
+pub mod clipboard_capture;
+#[cfg(windows)]
+pub mod uia_capture;
+
+pub use clipboard_capture::{capture_selection, send_ctrl_v, CaptureRequest};

src-tauri/src/translate/capture/uia_capture.rs

@@ -0,0 +1,174 @@
+//! UIA 直读取词：不模拟任何按键，直接从焦点元素读出选区文本。
+//!
+//! 为什么需要它 —— 模拟 Ctrl+C 这条兼容路径有三个绕不过去的现实问题：
+//! 1. **修饰键残留**。全局快捷键在**按键按下**的瞬间触发，此时 Alt 仍被物理按住，
+//!    我们补发的 Ctrl+C 在目标应用看来是 `Alt+Ctrl+C` —— 没有任何应用把它当「复制」，
+//!    于是必然走到「取词超时」。这正是「试了好几个程序都取不到」的主因。
+//! 2. **提权窗口**。UIPI 会静默丢弃来自低完整性级别进程的模拟按键。
+//! 3. **剪贴板占用**。取词期间用户的剪贴板被临时换掉，任何并发的复制都会丢。
+//!
+//! UIA 三条全避开：它只是「问」目标进程的自动化提供者要当前选区，不改键盘状态、
+//! 不碰剪贴板。浏览器（Chromium / Firefox）、Office、多数 Qt / Win32 编辑控件都提供
+//! TextPattern；读不到就返回 `None`，由调用方退回兼容路径。
+//!
+//! 两条工程约束：
+//! - **必须在独立线程上执行并带超时**。UIA 是跨进程 COM 调用，目标进程无响应时
+//!   `GetFocusedElement` 会一直挂着（既不返回也不报错）。没有超时就会漏线程、
+//!   并且让「取词」这个动作永久卡住。
+//! - **只能尽力而为**。这里不返回 `Result`：UIA 读不到是正常的（很多程序没有
+//!   TextPattern），调用方只需按「有 / 没有」分支，不需要错误文案。
+
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::mpsc as std_mpsc;
+use std::time::Duration;
+
+use windows::Win32::System::Com::{
+    CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_SERVER, COINIT_MULTITHREADED,
+};
+use windows::Win32::UI::Accessibility::{
+    CUIAutomation, IUIAutomation, IUIAutomationElement, IUIAutomationTextPattern,
+    IUIAutomationTextRangeArray, UIA_TextPatternId,
+};
+
+/// 单次 UIA 读取的超时上限。
+///
+/// 700ms 的依据：本地跨进程 COM 往返正常在 10ms 量级；给到 700ms 足以覆盖目标进程
+/// 偶发忙碌，又不会让用户感到「按了没反应」。再长就该交给兼容路径去兜底了。
+const UIA_TIMEOUT: Duration = Duration::from_millis(700);
+
+/// 沿焦点元素向上找 TextPattern 的最大层数。
+///
+/// 浏览器里焦点常落在一个深层节点（甚至是 body），而 TextPattern 挂在更上层的
+/// 文档节点上；但要限制层数——一路上溯到桌面根节点既慢又可能读到整页文本。
+const MAX_ANCESTORS: usize = 4;
+
+/// 连续超时次数上限。达到后本次进程内暂停尝试 UIA。
+///
+/// 超时意味着目标进程（或 UIA 服务）无响应。每次取词都起一个注定挂住的线程
+/// 会持续泄漏，因此给它一个熔断。熔断带 60s 衰减（见 [`read_selection`]）：
+/// 只针对当下无响应的目标，不该让一次抖动永久禁用 UIA。
+static TIMEOUTS: AtomicU32 = AtomicU32::new(0);
+const TIMEOUT_LIMIT: u32 = 3;
+/// 最近一次 UIA 超时的系统时间（毫秒），配合 TIMEOUTS 做衰减复位
+static LAST_TIMEOUT_MS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+/// 熔断衰减窗口：距上次超时超过该时长即清零计数，重新给 UIA 机会
+const TIMEOUT_DECAY_MS: u64 = 60_000;
+
+fn system_millis() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis() as u64)
+        .unwrap_or(0)
+}
+
+/// 尝试用 UIA 直读当前选区文本。读不到返回 `None`。
+pub fn read_selection() -> Option<String> {
+    // 熔断 + 衰减：达到上限后跳过 UIA，但 60s 内未再超时就清零重新启用。
+    // 没有衰减的话，一次抖动（目标进程短暂忙碌）就会让 UIA 在整个进程生命周期里失效，
+    // 之后所有取词都退到模拟按键路径——症状正是「换个程序也取不到」。
+    if TIMEOUTS.load(Ordering::SeqCst) >= TIMEOUT_LIMIT {
+        let last = LAST_TIMEOUT_MS.load(Ordering::SeqCst);
+        let now = system_millis();
+        if last != 0 && now.saturating_sub(last) < TIMEOUT_DECAY_MS {
+            return None;
+        }
+        TIMEOUTS.store(0, Ordering::SeqCst);
+    }
+
+    let (tx, rx) = std_mpsc::channel();
+    std::thread::spawn(move || {
+        let result = read_selection_blocking();
+        let _ = tx.send(result);
+    });
+
+    match rx.recv_timeout(UIA_TIMEOUT) {
+        Ok(Some(text)) => {
+            // 命中即清零熔断计数：超时针对的是「当下的目标」，成功说明 UIA 服务正常
+            TIMEOUTS.store(0, Ordering::SeqCst);
+            Some(text)
+        }
+        // 读不到（没有 TextPattern / 无选区）：正常情况，交给兼容路径
+        Ok(None) => None,
+        Err(_) => {
+            LAST_TIMEOUT_MS.store(system_millis(), Ordering::SeqCst);
+            let n = TIMEOUTS.fetch_add(1, Ordering::SeqCst) + 1;
+            crate::logger::log_warn(
+                "translate",
+                &format!("UIA 取词超时（第 {n} 次），本次改用模拟 Ctrl+C 兜底"),
+            );
+            None
+        }
+    }
+}
+
+/// 真正的读取逻辑。**阻塞**，且必须在独立线程上调用（见模块头注释）。
+fn read_selection_blocking() -> Option<String> {
+    unsafe {
+        let hr = CoInitializeEx(None, COINIT_MULTITHREADED);
+        // 只在本次调用确实初始化了 COM 时才配平 Uninitialize
+        let uninit = hr.is_ok();
+        let result = read_selection_inner();
+        if uninit {
+            CoUninitialize();
+        }
+        result
+    }
+}
+
+fn read_selection_inner() -> Option<String> {
+    unsafe {
+        let automation: IUIAutomation = CoCreateInstance(&CUIAutomation, None, CLSCTX_SERVER).ok()?;
+        let walker = automation.ControlViewWalker().ok()?;
+        let mut element: Option<IUIAutomationElement> = automation.GetFocusedElement().ok();
+
+        let mut depth = 0;
+        while let Some(el) = element {
+            if let Some(text) = selection_text_of(&el) {
+                let trimmed = text.trim();
+                if !trimmed.is_empty() {
+                    return Some(trimmed.to_string());
+                }
+            }
+            if depth >= MAX_ANCESTORS {
+                break;
+            }
+            depth += 1;
+            element = walker.GetParentElement(&el).ok();
+        }
+        None
+    }
+}
+
+/// 取某个元素上「当前选区」的文本。元素不支持 TextPattern 或没有选区 → None。
+fn selection_text_of(element: &IUIAutomationElement) -> Option<String> {
+    unsafe {
+        let pattern = element
+            .GetCurrentPatternAs::<IUIAutomationTextPattern>(UIA_TextPatternId)
+            .ok()?;
+        let ranges: IUIAutomationTextRangeArray = pattern.GetSelection().ok()?;
+        join_ranges(&ranges)
+    }
+}
+
+/// 把多个选区区间拼成一段文本（`-1` 表示不限长度，取区间全部内容）。
+fn join_ranges(ranges: &IUIAutomationTextRangeArray) -> Option<String> {
+    unsafe {
+        let count = ranges.Length().ok()?;
+        if count <= 0 {
+            return None;
+        }
+        let mut parts: Vec<String> = Vec::new();
+        for i in 0..count {
+            let range = ranges.GetElement(i).ok()?;
+            let text = range.GetText(-1).ok()?.to_string();
+            if !text.trim().is_empty() {
+                parts.push(text);
+            }
+        }
+        if parts.is_empty() {
+            None
+        } else {
+            Some(parts.join("\n"))
+        }
+    }
+}

src-tauri/src/translate/engines/ai.rs

@@ -0,0 +1,661 @@
+//! OpenAI 兼容引擎。
+//!
+//! 一套代码覆盖 DeepSeek / OpenAI / 通义（DashScope 兼容模式）/ Kimi / 智谱 /
+//! 本地 Ollama / LM Studio / one-api 等中转服务——它们都提供
+//! `POST {baseUrl}/chat/completions` 且请求响应结构一致，因此差异只在配置项里。
+//!
+//! 翻译场景刻意**不开思考模式**：不写 `thinking` / `reasoning_effort`，换低延迟与低费用。
+//! 若用户确实需要，可通过 `extra_body`（JSON 文本）自行透传。
+
+use std::time::{Duration, Instant};
+
+use serde::Deserialize;
+use serde_json::json;
+
+use super::{
+    apply_common_params, build_user_content, render_template, EngineRequest, ErrorKind, TokenUsage,
+    TranslateEngine, TranslateError, TranslateMode, TranslateResult,
+};
+use crate::translate::settings::{PromptTemplates, TranslateEngineConfig};
+
+/// 自检与连通性测试使用的探测文本
+const PROBE_TEXT: &str = "Hello, world.";
+
+pub struct AiEngine {
+    cfg: TranslateEngineConfig,
+    templates: PromptTemplates,
+    client: reqwest::Client,
+}
+
+impl AiEngine {
+    pub fn new(
+        cfg: TranslateEngineConfig,
+        templates: PromptTemplates,
+        client: reqwest::Client,
+    ) -> Self {
+        Self {
+            cfg,
+            templates,
+            client,
+        }
+    }
+
+    /// API 根地址。容错处理：用户常把完整端点（`.../chat/completions`）直接粘进来，
+    /// 若不在末尾剥掉，就会拼出 `.../chat/completions/chat/completions`，
+    /// 而这类错误在上游表现为 404，排查成本远高于此处一行判断。
+    fn api_root(cfg: &TranslateEngineConfig) -> Result<String, TranslateError> {
+        let raw = cfg.base_url.trim();
+        if raw.is_empty() {
+            return Err(TranslateError::config(format!(
+                "引擎「{}」尚未配置 Base URL",
+                cfg.name
+            )));
+        }
+        if !(raw.starts_with("http://") || raw.starts_with("https://")) {
+            return Err(TranslateError::config(format!(
+                "Base URL 需以 http:// 或 https:// 开头，当前为「{raw}」"
+            )));
+        }
+        let mut root = raw.trim_end_matches('/').to_string();
+        for suffix in ["/chat/completions", "/completions", "/models"] {
+            if let Some(stripped) = root.strip_suffix(suffix) {
+                root = stripped.trim_end_matches('/').to_string();
+                break;
+            }
+        }
+        Ok(root)
+    }
+
+    fn chat_endpoint(cfg: &TranslateEngineConfig) -> Result<String, TranslateError> {
+        Ok(format!("{}/chat/completions", Self::api_root(cfg)?))
+    }
+
+    fn models_endpoint(cfg: &TranslateEngineConfig) -> Result<String, TranslateError> {
+        Ok(format!("{}/models", Self::api_root(cfg)?))
+    }
+
+    /// 密钥只从系统凭据管理器读，不进配置文件、不经前端。
+    fn api_key(cfg: &TranslateEngineConfig) -> String {
+        crate::translate::engine_api_key(&cfg.id)
+    }
+
+    fn require_key(cfg: &TranslateEngineConfig) -> Result<String, TranslateError> {
+        let key = Self::api_key(cfg);
+        if key.trim().is_empty() {
+            return Err(TranslateError::auth(format!(
+                "引擎「{}」尚未配置 API Key，请在翻译设置中填写",
+                cfg.name
+            )));
+        }
+        Ok(key)
+    }
+
+    fn require_model(cfg: &TranslateEngineConfig) -> Result<String, TranslateError> {
+        let model = cfg.model.trim();
+        if model.is_empty() {
+            return Err(TranslateError::config(format!(
+                "引擎「{}」尚未选择模型，可在设置中拉取模型列表后选择",
+                cfg.name
+            )));
+        }
+        Ok(model.to_string())
+    }
+
+    /// 有效 system prompt：实例级自定义提示词优先，否则用模式对应的全局模板。
+    fn system_prompt(&self, req: &EngineRequest) -> String {
+        if !self.cfg.system_prompt.trim().is_empty() {
+            return render_template(&self.cfg.system_prompt, req);
+        }
+        render_template(self.templates.for_mode(req.mode), req)
+    }
+
+    /// 流式收尾。空内容不直接判死：**自动改用同步接口重试一次**。
+    ///
+    /// 上游偶发「流正常结束但 content 为空」（安全拦截、思维链吃满 max_tokens、
+    /// 中转服务抖动都会导致）。用户视角这与请求失败无异，但同步接口往往能正常
+    /// 返回——与其抛错让人手动重试，不如在这里自愈一次。重试失败才把错误交给上层。
+    async fn finish_stream_with_fallback(
+        &self,
+        tx: &tokio::sync::mpsc::Sender<super::StreamEvent>,
+        request_id: String,
+        content: String,
+        req: &EngineRequest,
+        started: Instant,
+        finish_reason: Option<String>,
+    ) -> Result<(), TranslateError> {
+        if content.trim().is_empty() {
+            if tx.is_closed() {
+                // 调用方已放弃（停止 / 新请求顶替），不再花一次 API 调用
+                return Ok(());
+            }
+            crate::logger::log_warn(
+                "translate",
+                &format!(
+                    "「{}」流式返回为空（finish_reason={:?}），自动改用同步接口重试",
+                    self.cfg.name, finish_reason
+                ),
+            );
+            // 同步路径的错误更具体（认证/额度/响应解析都能区分），直接透传
+            let result = self.translate(req).await?;
+            let _ = tx.send(super::StreamEvent::Done { request_id, result }).await;
+            return Ok(());
+        }
+        finish_stream(
+            tx,
+            request_id,
+            content,
+            req,
+            &self.cfg,
+            started.elapsed().as_millis() as u64,
+        )
+        .await
+    }
+}
+
+#[async_trait::async_trait]
+impl TranslateEngine for AiEngine {
+    fn config(&self) -> &TranslateEngineConfig {
+        &self.cfg
+    }
+
+    async fn translate(&self, req: &EngineRequest) -> Result<TranslateResult, TranslateError> {
+        if req.text.trim().is_empty() {
+            return Err(TranslateError::empty());
+        }
+        let key = Self::require_key(&self.cfg)?;
+        let model = Self::require_model(&self.cfg)?;
+        let endpoint = Self::chat_endpoint(&self.cfg)?;
+
+        let mut body = serde_json::Map::new();
+        body.insert("model".to_string(), json!(model));
+        body.insert("stream".to_string(), json!(false));
+        body.insert(
+            "messages".to_string(),
+            json!([
+                { "role": "system", "content": self.system_prompt(req) },
+                { "role": "user", "content": build_user_content(req, self.cfg.supports_vision) },
+            ]),
+        );
+        apply_common_params(&mut body, &self.cfg);
+
+        let started = Instant::now();
+        let resp = self
+            .client
+            .post(&endpoint)
+            .bearer_auth(&key)
+            .timeout(Duration::from_millis(self.cfg.timeout_ms.max(1000)))
+            .json(&serde_json::Value::Object(body))
+            .send()
+            .await
+            .map_err(|e| classify_reqwest(e, &self.cfg.name))?;
+
+        let status = resp.status();
+        let raw = resp
+            .text()
+            .await
+            .map_err(|e| TranslateError::network(format!("读取「{}」响应失败: {e}", self.cfg.name)))?;
+
+        if !status.is_success() {
+            return Err(classify_http(status.as_u16(), &raw, &self.cfg.name, &model));
+        }
+
+        let parsed: ChatResponse = serde_json::from_str(&raw).map_err(|e| {
+            TranslateError::parse(format!("「{}」响应不是预期的 JSON: {e}", self.cfg.name))
+                .with_detail(&raw)
+        })?;
+
+        if let Some(err) = parsed.error {
+            let msg = err
+                .message
+                .filter(|m| !m.trim().is_empty())
+                .unwrap_or_else(|| "上游返回了错误对象".to_string());
+            return Err(
+                TranslateError::new(ErrorKind::Unknown, format!("「{}」返回错误：{msg}", self.cfg.name))
+                    .with_detail(&raw),
+            );
+        }
+
+        let text = parsed
+            .choices
+            .into_iter()
+            .next()
+            .and_then(|c| c.message.content)
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .ok_or_else(TranslateError::empty)?;
+
+        let latency_ms = started.elapsed().as_millis() as u64;
+        let usage = parsed.usage.map(|u| {
+            let total = if u.total_tokens > 0 {
+                u.total_tokens
+            } else {
+                u.prompt_tokens + u.completion_tokens
+            };
+            TokenUsage {
+                prompt_tokens: u.prompt_tokens,
+                completion_tokens: u.completion_tokens,
+                total_tokens: total,
+            }
+        });
+
+        Ok(TranslateResult {
+            text,
+            // AI 引擎不做语言检测：显式指定了源语言时回显，auto 时留空由前端展示「自动」
+            detected: if req.from.trim().is_empty() || req.from == "auto" {
+                None
+            } else {
+                Some(req.from.clone())
+            },
+            engine_id: self.cfg.id.clone(),
+            engine_name: self.cfg.name.clone(),
+            latency_ms,
+            usage,
+        })
+    }
+
+    /// 流式翻译（SSE）。增量经通道下发，`data: [DONE]` 或流结束时发 Done。
+    ///
+    /// 错误处理约定：**本方法不发送 `StreamEvent::Error`**——任何失败都通过 `Err` 返回，
+    /// 由命令层统一转成错误事件，避免前端收到两条错误。通道关闭（调用方已放弃，
+    /// 例如用户点了停止）时安静返回 `Ok(())`，不当作失败。
+    async fn translate_stream(
+        &self,
+        req: &EngineRequest,
+        request_id: String,
+        tx: tokio::sync::mpsc::Sender<super::StreamEvent>,
+    ) -> Result<(), TranslateError> {
+        if req.text.trim().is_empty() && req.image_png.is_none() {
+            return Err(TranslateError::empty());
+        }
+        let key = Self::require_key(&self.cfg)?;
+        let model = Self::require_model(&self.cfg)?;
+        let endpoint = Self::chat_endpoint(&self.cfg)?;
+
+        let mut body = serde_json::Map::new();
+        body.insert("model".to_string(), json!(model));
+        body.insert("stream".to_string(), json!(true));
+        body.insert(
+            "messages".to_string(),
+            json!([
+                { "role": "system", "content": self.system_prompt(req) },
+                { "role": "user", "content": build_user_content(req, self.cfg.supports_vision) },
+            ]),
+        );
+        apply_common_params(&mut body, &self.cfg);
+
+        let started = Instant::now();
+        let resp = self
+            .client
+            .post(&endpoint)
+            .bearer_auth(&key)
+            .timeout(Duration::from_millis(self.cfg.timeout_ms.max(1000)))
+            .json(&serde_json::Value::Object(body))
+            .send()
+            .await
+            .map_err(|e| classify_reqwest(e, &self.cfg.name))?;
+
+        let status = resp.status();
+        if !status.is_success() {
+            let raw = resp.text().await.unwrap_or_default();
+            return Err(classify_http(status.as_u16(), &raw, &self.cfg.name, &model));
+        }
+
+        // SSE 逐行解析：字节块可能把一行劈成两半，必须先攒缓冲再按 \n 切
+        use futures_util::StreamExt;
+        let mut stream = resp.bytes_stream();
+        let mut buffer: Vec<u8> = Vec::new();
+        let mut content = String::new();
+        let mut finish_reason: Option<String> = None;
+
+        while let Some(item) = stream.next().await {
+            let bytes =
+                item.map_err(|e| TranslateError::network(format!("读取流失败: {e}")))?;
+            buffer.extend_from_slice(&bytes);
+            while let Some(pos) = buffer.iter().position(|&b| b == b'\n') {
+                let line_bytes: Vec<u8> = buffer.drain(..=pos).collect();
+                let line = String::from_utf8_lossy(&line_bytes[..line_bytes.len() - 1]);
+                let Some(payload) = line.trim().strip_prefix("data:") else {
+                    continue;
+                };
+                let payload = payload.trim();
+                if payload.is_empty() {
+                    continue;
+                }
+                if payload == "[DONE]" {
+                    return self
+                        .finish_stream_with_fallback(
+                            &tx,
+                            request_id,
+                            content,
+                            req,
+                            started,
+                            finish_reason,
+                        )
+                        .await;
+                }
+                let Ok(value) = serde_json::from_str::<serde_json::Value>(payload) else {
+                    continue;
+                };
+                // 上游在流中携带错误对象时终止
+                if let Some(message) = value
+                    .pointer("/error/message")
+                    .and_then(|m| m.as_str())
+                    .filter(|m| !m.trim().is_empty())
+                {
+                    return Err(TranslateError::new(
+                        ErrorKind::Unknown,
+                        format!("「{}」流中返回错误：{message}", self.cfg.name),
+                    ));
+                }
+                if let Some(fr) = value
+                    .pointer("/choices/0/finish_reason")
+                    .and_then(|v| v.as_str())
+                {
+                    finish_reason = Some(fr.to_string());
+                }
+                let Some(delta) = value
+                    .pointer("/choices/0/delta/content")
+                    .and_then(|c| c.as_str())
+                    .filter(|d| !d.is_empty())
+                else {
+                    continue;
+                };
+                content.push_str(delta);
+                if tx
+                    .send(super::StreamEvent::Chunk {
+                        request_id: request_id.clone(),
+                        delta: delta.to_string(),
+                    })
+                    .await
+                    .is_err()
+                {
+                    // 通道已关 = 调用方放弃（停止 / 新请求顶替），安静退出
+                    return Ok(());
+                }
+            }
+        }
+
+        // 流结束但没收到 [DONE]：部分上游异常断流。已有内容仍视为成功，
+        // 否则用户会看着已译出一半的结果被告知失败。
+        self.finish_stream_with_fallback(
+            &tx,
+            request_id,
+            content,
+            req,
+            started,
+            finish_reason,
+        )
+        .await
+    }
+
+    async fn list_models(&self) -> Result<Vec<String>, TranslateError> {
+        let key = Self::require_key(&self.cfg)?;
+        let endpoint = Self::models_endpoint(&self.cfg)?;
+        let resp = self
+            .client
+            .get(&endpoint)
+            .bearer_auth(&key)
+            .timeout(Duration::from_millis(self.cfg.timeout_ms.clamp(3_000, 15_000)))
+            .send()
+            .await
+            .map_err(|e| classify_reqwest(e, &self.cfg.name))?;
+
+        let status = resp.status();
+        let raw = resp
+            .text()
+            .await
+            .map_err(|e| TranslateError::network(format!("读取「{}」模型列表失败: {e}", self.cfg.name)))?;
+
+        if !status.is_success() {
+            return Err(classify_http(
+                status.as_u16(),
+                &raw,
+                &self.cfg.name,
+                self.cfg.model.as_str(),
+            ));
+        }
+
+        let parsed: ModelsResponse = serde_json::from_str(&raw).map_err(|e| {
+            TranslateError::parse(format!("「{}」的模型列表无法解析: {e}", self.cfg.name))
+                .with_detail(&raw)
+        })?;
+
+        let mut ids: Vec<String> = parsed
+            .data
+            .into_iter()
+            .map(|m| m.id)
+            .filter(|id| !id.trim().is_empty())
+            .collect();
+        ids.sort();
+        ids.dedup();
+        Ok(ids)
+    }
+
+    async fn test(&self) -> Result<String, TranslateError> {
+        let req = EngineRequest {
+            text: PROBE_TEXT.to_string(),
+            from: "en".to_string(),
+            to: "zh-Hans".to_string(),
+            to_label: "简体中文".to_string(),
+            from_label: "英语".to_string(),
+            mode: TranslateMode::Translate,
+            image_png: None,
+            via: "preview".to_string(),
+        };
+        let started = Instant::now();
+        let result = self.translate(&req).await?;
+        let total = started.elapsed().as_millis() as u64;
+        Ok(format!(
+            "连通正常 · 模型 {} · {}ms · 回显「{}」",
+            self.cfg.model, total, result.text
+        ))
+    }
+}
+
+/// 收尾：把累积内容封装成结果下发。空内容按「上游没产出」处理。
+async fn finish_stream(
+    tx: &tokio::sync::mpsc::Sender<super::StreamEvent>,
+    request_id: String,
+    content: String,
+    req: &EngineRequest,
+    cfg: &TranslateEngineConfig,
+    latency_ms: u64,
+) -> Result<(), TranslateError> {
+    let text = content.trim().to_string();
+    if text.is_empty() {
+        return Err(TranslateError::new(
+            ErrorKind::Empty,
+            format!("「{}」未返回任何译文（流提前结束）", cfg.name),
+        ));
+    }
+    let _ = tx
+        .send(super::StreamEvent::Done {
+            request_id,
+            result: TranslateResult {
+                text,
+                detected: if req.from.trim().is_empty() || req.from == "auto" {
+                    None
+                } else {
+                    Some(req.from.clone())
+                },
+                engine_id: cfg.id.clone(),
+                engine_name: cfg.name.clone(),
+                latency_ms,
+                // 流式路径不索取 usage：stream_options 是各家扩展，兼容性不一
+                usage: None,
+            },
+        })
+        .await;
+    Ok(())
+}
+
+/// 网络层错误分类。
+fn classify_reqwest(e: reqwest::Error, engine: &str) -> TranslateError {
+    if e.is_timeout() {
+        return TranslateError::timeout(format!(
+            "请求「{engine}」超时，可在引擎设置中调大超时时间，或检查网络"
+        ));
+    }
+    if e.is_connect() {
+        return TranslateError::network(format!(
+            "无法连接「{engine}」：{e}（若该服务在境外，请检查网络或开启代理）"
+        ));
+    }
+    TranslateError::network(format!("请求「{engine}」失败：{e}"))
+}
+
+/// HTTP 状态码分类。把「Key 不对」「模型名不对」「被限流」分开，
+/// 是因为这三者在前端的处置动作完全不同。
+fn classify_http(status: u16, body: &str, engine: &str, model: &str) -> TranslateError {
+    let snippet = body.trim();
+    let lower = snippet.to_lowercase();
+    let err = match status {
+        401 | 403 => TranslateError::auth(format!(
+            "「{engine}」认证失败（HTTP {status}），请检查 API Key 是否正确、是否有该模型的权限"
+        )),
+        402 => TranslateError::auth(format!("「{engine}」余额不足或未开通计费（HTTP 402）")),
+        429 => TranslateError::rate_limit(format!(
+            "「{engine}」请求过于频繁（HTTP 429），请稍后重试或降低频率"
+        )),
+        400 | 404 | 422 => {
+            if lower.contains("model") {
+                TranslateError::config(format!(
+                    "「{engine}」不识别模型「{model}」（HTTP {status}）：上游模型名可能已变更，\
+                     请在设置中拉取模型列表后重新选择"
+                ))
+            } else {
+                TranslateError::new(
+                    ErrorKind::Config,
+                    format!("「{engine}」拒绝了该请求（HTTP {status}）"),
+                )
+            }
+        }
+        408 | 504 => TranslateError::timeout(format!("「{engine}」上游超时（HTTP {status}）")),
+        s if (500..600).contains(&s) => {
+            TranslateError::network(format!("「{engine}」服务端错误（HTTP {status}），可稍后重试"))
+        }
+        s => TranslateError::new(ErrorKind::Unknown, format!("「{engine}」返回 HTTP {s}")),
+    };
+    err.with_detail(snippet)
+}
+
+// ===== 响应结构（宽松解析：缺字段不报错，由业务层判断内容是否可用） =====
+
+#[derive(Debug, Deserialize)]
+struct ChatResponse {
+    #[serde(default)]
+    choices: Vec<ChatChoice>,
+    #[serde(default)]
+    usage: Option<ChatUsage>,
+    #[serde(default)]
+    error: Option<ApiErrorBody>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ChatChoice {
+    #[serde(default)]
+    message: ChatMessage,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct ChatMessage {
+    /// 部分实现会返回 null（例如只产出思维链时），故用 Option 而非 String
+    #[serde(default)]
+    content: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ChatUsage {
+    #[serde(default)]
+    prompt_tokens: u32,
+    #[serde(default)]
+    completion_tokens: u32,
+    #[serde(default)]
+    total_tokens: u32,
+}
+
+#[derive(Debug, Deserialize)]
+struct ApiErrorBody {
+    #[serde(default)]
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ModelsResponse {
+    #[serde(default)]
+    data: Vec<ModelEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ModelEntry {
+    #[serde(default)]
+    id: String,
+}
+
+/// 通用（非翻译语义）的对话补全入口：供终端 AI 助手等模块复用引擎配置。
+///
+/// 与翻译路径共享端点归一（剥 `/chat/completions` 后缀）、密钥存取
+/// （凭据管理器）、`apply_common_params`（temperature / max_tokens / extra_body）
+/// 与响应解析，但 **消息由调用方全量给定**——这里不含任何翻译提示词语义。
+///
+/// 刻意做成关联函数而不是 `AiEngine` 的实例方法：调用方（终端助手）只持有
+/// `TranslateEngineConfig`，为它构造 `AiEngine` 还要 PromptTemplates 与 client，
+/// 属于无谓的耦合。
+pub async fn chat_once(
+    cfg: &TranslateEngineConfig,
+    messages: Vec<(&str, String)>,
+) -> Result<String, String> {
+    let key = AiEngine::require_key(cfg).map_err(|e| e.to_string())?;
+    let model = AiEngine::require_model(cfg).map_err(|e| e.to_string())?;
+    let endpoint = AiEngine::chat_endpoint(cfg).map_err(|e| e.to_string())?;
+
+    let mut body = serde_json::Map::new();
+    body.insert("model".to_string(), json!(model));
+    body.insert("stream".to_string(), json!(false));
+    body.insert(
+        "messages".to_string(),
+        json!(messages
+            .into_iter()
+            .map(|(role, content)| json!({ "role": role, "content": content }))
+            .collect::<Vec<_>>()),
+    );
+    apply_common_params(&mut body, cfg);
+
+    let client = reqwest::Client::new();
+    let resp = client
+        .post(&endpoint)
+        .bearer_auth(&key)
+        .timeout(Duration::from_millis(cfg.timeout_ms.max(1000)))
+        .json(&serde_json::Value::Object(body))
+        .send()
+        .await
+        .map_err(|e| classify_reqwest(e, &cfg.name).to_string())?;
+
+    let status = resp.status();
+    let raw = resp
+        .text()
+        .await
+        .map_err(|e| format!("读取「{}」响应失败: {e}", cfg.name))?;
+    if !status.is_success() {
+        return Err(classify_http(status.as_u16(), &raw, &cfg.name, &model).to_string());
+    }
+
+    let parsed: ChatResponse = serde_json::from_str(&raw)
+        .map_err(|e| format!("「{}」响应不是预期的 JSON: {e}", cfg.name))?;
+    if let Some(err) = parsed.error {
+        let msg = err
+            .message
+            .filter(|m| !m.trim().is_empty())
+            .unwrap_or_else(|| "上游返回了错误对象".to_string());
+        return Err(format!("「{}」返回错误：{msg}", cfg.name));
+    }
+
+    parsed
+        .choices
+        .into_iter()
+        .next()
+        .and_then(|c| c.message.content)
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .ok_or_else(|| format!("「{}」返回了空内容", cfg.name))
+}

src-tauri/src/translate/engines/deepl.rs

@@ -0,0 +1,255 @@
+//! DeepL 云厂商翻译源。
+//!
+//! 选它作云厂商第一家 purely 因为接入成本：`Authorization: DeepL-Auth-Key <key>`
+//! 一个头就完成鉴权，没有 MD5/TC3 那类签名流程。其它云厂商（百度/腾讯/阿里/有道）
+//! 签名各不相同，按需再加。
+//!
+//! 三个必须如实告知用户的限制：
+//! - **免费 Key 与付费 Key 的端点不同**（`api-free.deepl.com` / `api.deepl.com`）。
+//!   用错端点会返回 403，错误信息里必须把这个可能性讲出来，否则用户只会反复重输 Key。
+//! - **目标语言只有简体中文**（`ZH`）。DeepL 暂无繁体中文目标，本实现会把
+//!   `zh-Hant` 也映射到 `ZH`，译出的会是简体——不是 bug，是上游能力边界。
+//! - 无流式接口，走 trait 默认实现（同步完成后整体下发）。
+//!
+//! HTTP 形态：`POST {base}/translate`，body `{"text":["..."],"target_lang":"ZH"}`，
+//! `source_lang` 省略时由上游自动检测。
+
+use std::time::{Duration, Instant};
+
+use serde::Deserialize;
+
+use super::{
+    is_auto, provider_code, ErrorKind, TranslateEngine, TranslateError, TranslateResult,
+};
+use crate::translate::settings::TranslateEngineConfig;
+
+const PROBE_TEXT: &str = "Hello, world.";
+
+pub struct DeepLEngine {
+    cfg: TranslateEngineConfig,
+    client: reqwest::Client,
+}
+
+impl DeepLEngine {
+    pub fn new(cfg: TranslateEngineConfig, client: reqwest::Client) -> Self {
+        Self { cfg, client }
+    }
+
+    /// API 根地址（容错：剥掉误粘的 `/translate`，与 AI 引擎同一思路）
+    fn api_root(&self) -> Result<String, TranslateError> {
+        let raw = self.cfg.base_url.trim();
+        if raw.is_empty() {
+            return Err(TranslateError::config(format!(
+                "引擎「{}」尚未配置 Base URL（免费 Key 用 https://api-free.deepl.com/v2，\
+                 付费 Key 用 https://api.deepl.com/v2）",
+                self.cfg.name
+            )));
+        }
+        if !(raw.starts_with("http://") || raw.starts_with("https://")) {
+            return Err(TranslateError::config(format!(
+                "Base URL 需以 http:// 或 https:// 开头，当前为「{raw}」"
+            )));
+        }
+        let mut root = raw.trim_end_matches('/').to_string();
+        if let Some(stripped) = root.strip_suffix("/translate") {
+            root = stripped.trim_end_matches('/').to_string();
+        }
+        Ok(root)
+    }
+
+    fn require_key(&self) -> Result<String, TranslateError> {
+        let key = crate::translate::engine_api_key(&self.cfg.id);
+        if key.trim().is_empty() {
+            return Err(TranslateError::auth(format!(
+                "引擎「{}」尚未配置 DeepL Auth Key",
+                self.cfg.name
+            )));
+        }
+        Ok(key)
+    }
+
+    /// 目标语言码。DeepL 要求变体形式：英语必须是 EN-GB/EN-US，葡语必须是 PT-PT/PT-BR。
+    fn target_code(internal: &str) -> Result<String, TranslateError> {
+        let code = provider_code(internal);
+        let lower = code.to_lowercase();
+        let out = match lower.as_str() {
+            "zh" | "zh-cn" => "ZH".to_string(),
+            "zh-tw" | "zh-hant" => "ZH".to_string(),
+            "en" => "EN-US".to_string(),
+            "en-gb" => "EN-GB".to_string(),
+            "en-us" => "EN-US".to_string(),
+            "pt" => "PT-BR".to_string(),
+            "pt-pt" => "PT-PT".to_string(),
+            "pt-br" => "PT-BR".to_string(),
+            other => other.split('-').next().unwrap_or(other).to_uppercase(),
+        };
+        if out.trim().is_empty() {
+            return Err(TranslateError::config("未指定目标语言"));
+        }
+        Ok(out)
+    }
+
+    /// 源语言码。省略（auto）时不上送，由上游检测。
+    fn source_code(internal: &str) -> Option<String> {
+        if is_auto(internal) {
+            return None;
+        }
+        let code = provider_code(internal);
+        Some(code.split('-').next().unwrap_or(&code).to_uppercase())
+    }
+}
+
+#[async_trait::async_trait]
+impl TranslateEngine for DeepLEngine {
+    fn config(&self) -> &TranslateEngineConfig {
+        &self.cfg
+    }
+
+    async fn translate(
+        &self,
+        req: &super::EngineRequest,
+    ) -> Result<TranslateResult, TranslateError> {
+        let text = req.text.trim();
+        if text.is_empty() {
+            return Err(TranslateError::empty());
+        }
+        let key = self.require_key()?;
+        let target = Self::target_code(&req.to)?;
+        let root = self.api_root()?;
+
+        let mut body = serde_json::json!({ "text": [text], "target_lang": target });
+        if let Some(source) = Self::source_code(&req.from) {
+            body["source_lang"] = serde_json::json!(source);
+        }
+
+        let started = Instant::now();
+        let resp = self
+            .client
+            .post(format!("{root}/translate"))
+            .header("Authorization", format!("DeepL-Auth-Key {key}"))
+            .timeout(Duration::from_millis(self.cfg.timeout_ms.max(2_000)))
+            .json(&body)
+            .send()
+            .await
+            .map_err(|e| classify_reqwest(e, self.cfg.name.as_str()))?;
+
+        let status = resp.status();
+        let raw = resp.text().await.map_err(|e| {
+            TranslateError::network(format!("读取「{}」响应失败: {e}", self.cfg.name))
+        })?;
+        if !status.is_success() {
+            return Err(classify_http(status.as_u16(), &raw, self.cfg.name.as_str()));
+        }
+
+        let parsed: DeepLResponse = serde_json::from_str(&raw).map_err(|e| {
+            TranslateError::parse(format!("「{}」响应不是预期的 JSON: {e}", self.cfg.name))
+                .with_detail(&raw)
+        })?;
+
+        // DeepL 的翻译结果按 text 数组分段返回；单段请求时取第一段即可
+        let text_out = parsed
+            .translations
+            .first()
+            .and_then(|t| t.text.clone())
+            .map(|t| t.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .ok_or_else(|| {
+                TranslateError::new(
+                    ErrorKind::Empty,
+                    format!("「{}」未返回译文", self.cfg.name),
+                )
+                .with_detail(raw.trim())
+            })?;
+
+        let detected = parsed
+            .translations
+            .first()
+            .and_then(|t| t.detected_source_language.clone())
+            .filter(|s| !s.trim().is_empty())
+            // 上游返回大写（如 "EN"），统一转小写与内部语言码对齐
+            .map(|s| s.to_lowercase());
+
+        Ok(TranslateResult {
+            text: text_out,
+            detected,
+            engine_id: self.cfg.id.clone(),
+            engine_name: self.cfg.name.clone(),
+            latency_ms: started.elapsed().as_millis() as u64,
+            usage: None,
+        })
+    }
+
+    async fn list_models(&self) -> Result<Vec<String>, TranslateError> {
+        Ok(Vec::new())
+    }
+
+    async fn test(&self) -> Result<String, TranslateError> {
+        let req = super::EngineRequest {
+            text: PROBE_TEXT.to_string(),
+            from: "en".to_string(),
+            to: "zh-Hans".to_string(),
+            to_label: "简体中文".to_string(),
+            from_label: "英语".to_string(),
+            mode: super::TranslateMode::Translate,
+            image_png: None,
+            via: "preview".to_string(),
+        };
+        let started = Instant::now();
+        let result = self.translate(&req).await?;
+        Ok(format!(
+            "连通正常 · {}ms · 回显「{}」",
+            started.elapsed().as_millis(),
+            result.text
+        ))
+    }
+}
+
+fn classify_reqwest(e: reqwest::Error, engine: &str) -> TranslateError {
+    if e.is_timeout() {
+        return TranslateError::timeout(format!("请求「{engine}」超时，可调大超时时间"));
+    }
+    if e.is_connect() {
+        return TranslateError::network(format!("无法连接「{engine}」：{e}，请检查网络"));
+    }
+    TranslateError::network(format!("请求「{engine}」失败：{e}"))
+}
+
+fn classify_http(status: u16, body: &str, engine: &str) -> TranslateError {
+    let err = match status {
+        403 => TranslateError::auth(format!(
+            "「{engine}」认证失败（HTTP 403）：Key 无效，或免费 Key 用了付费端点（反之亦然）。\
+             免费 Key 应使用 https://api-free.deepl.com/v2"
+        )),
+        456 => TranslateError::rate_limit(format!(
+            "「{engine}」本月翻译额度已用尽（HTTP 456）"
+        )),
+        429 => TranslateError::rate_limit(format!(
+            "「{engine}」请求过于频繁（HTTP 429），请稍后重试"
+        )),
+        400 => TranslateError::config(format!(
+            "「{engine}」拒绝了该请求（HTTP 400）：目标语言或文本不合法"
+        )),
+        414 => TranslateError::unsupported(format!(
+            "文本过长，「{engine}」拒绝了该请求（HTTP 414）"
+        )),
+        s if (500..600).contains(&s) => {
+            TranslateError::network(format!("「{engine}」服务端错误（HTTP {status}），可稍后重试"))
+        }
+        s => TranslateError::new(ErrorKind::Unknown, format!("「{engine}」返回 HTTP {s}")),
+    };
+    err.with_detail(body.trim())
+}
+
+#[derive(Debug, Deserialize)]
+struct DeepLResponse {
+    #[serde(default)]
+    translations: Vec<DeepLTranslation>,
+}
+
+#[derive(Debug, Deserialize)]
+struct DeepLTranslation {
+    #[serde(default)]
+    text: Option<String>,
+    #[serde(rename = "detected_source_language", default)]
+    detected_source_language: Option<String>,
+}