4 Commits
Author SHA1 Message Date
zhongluofeng 7e65825d3e dsh模块、快捷键调整 2026-09-28 18:05:29 +08:00
LFeng ff1d5cd517 音乐控制/解密 2026-09-28 00:21:12 +08:00
zhongluofeng 9e6d73e191 调整 2026-09-25 18:23:56 +08:00
zhongluofeng 79bded1cd2 细节调整 2026-09-23 18:29:20 +08:00
154 changed files with 26686 additions and 1927 deletions

No files matched your search

+667
View File
@@ -0,0 +1,667 @@
# 音乐模块 · 本地音乐解密规划(Music Decrypt Plan)
> 状态:**P0 + P1a + P1c 已实施并完成真机端到端验证**(2026-09-27:网易云解密 + QQ音乐离线解密 + 文件夹批量 + musicex 在线取密钥,用真实 192kHz/24bit `.mflac` 样本跑通全链路;Rust 单测 204 项全库通过)
> 定位:音乐模块的「本地解密」子能力,不是独立模块——挂靠 `music` 模块新增「解密」页签,Rust 侧新增 `music/decrypt/` 子模块;`ncm` 与 `qmc` 均为纯 Rust 离线引擎,QQ 按「内嵌 ekey 离线 → musicex 在线取密钥」分层(Frida 降为 P2 兜底)
> 日期:2026-09-27(同日修订:QQ 分层重排、ncm 算法细节补全)
> 关联文档:`AI_DEV_GUIDE.md`(模块注册 / IPC 范式——注意 specta 绑定见 `lib.rs` 的 `export_bindings()`)、`MUSIC_REMOTE_PLAN.md`(规划文档范式)
> 参考项目与**许可分档**:
> - `taurusxin/ncmdump`(<https://github.com/taurusxin/ncmdump>,**MIT**)——§3.1 全部算法细节的对照物,**可逐行对照**。
> - `QQKWKG-TriMusicDecrypt`(QKKDecrypt,<https://github.com/Acooldog/QQKWKG-TriMusicDecrypt>,**GPLv3**)——只取平台矩阵与坑清单。
> - `ownlight6/qmc-decoder`(<https://github.com/ownlight6/qmc-decoder>,**GPLv3**)——只取 QMC/musicex/ekey 的**格式与协议知识**(<https://github.com/ownlight6/qmc-decoder/blob/main/MGG_DECRYPTION_FLOW.md>)。
> - GPLv3 两仓:**只读文档与行为,严禁抄代码**。
---
## 0. 结论先行
1. **范围收敛到两平台**(本轮显式指定):网易云 `.ncm` + QQ音乐 QMC 系列。酷狗/酷我明确出栈,不进任何分期。
2. **两条技术路线,全部纯 Rust,零新增运行时依赖**:
- ncm → **Rust 原生**(`aes 0.8` / `cbc 0.1` / `base64 0.22` 已在依赖;`ecb` crate 不在依赖树,ECB 手写 16 字节块循环,零新增 crate)。
- QQ → **Rust 原生三层路由**(详见 §3.2):① 尾部内嵌 ekey 的文件纯离线可解;② musicex 文件读本机凭据调 `GetEVkey` API;③ 前两层都不成立才用 Frida 注入兜底。
- **本节原有的「Frida 主链」判断已作废**:它把「需要客户端在跑」与「需要 Frida 注入」绑成了一件事。实际只有第③层需要注入,而前两层覆盖绝大多数真实文件。改分层后**不再需要便携 Python、不再需要 `pip install frida`、不再受杀软与 mangled 符号版本漂移影响**。
3. **UI 是音乐模块第 4 个页签「解密」**:`useModuleTabs` 加一项 + `DecryptPanel.vue` + 独立轻量 store,命令与事件挂进现有 music 命令族,完全照抄下载任务的「先回 taskId、进度走事件」范式。
4. **许可边界分三档**:`ncmdump` 是 MIT,**可逐行对照**;QKKDecrypt 与 `qmc-decoder` 是 GPLv3 + FFmpeg GPL,**只沉淀格式/协议知识与坑清单,实现逐行重写**。
5. **工作量**:P0(网易云 + 页签全链路)约 **2 个工作日**;P1a(QQ 离线 + API,纯 Rust)约 **2~3 个工作日**;P1b(Frida 兜底,按需)另计。
```mermaid
flowchart LR
subgraph FE["前端 · 解密页签"]
A["DecryptPanel.vue<br/>文件选择 / 任务列表 / 状态卡"]
S["decryptStore.ts<br/>任务状态 + 事件监听"]
end
subgraph R["Rust · music/decrypt/"]
C["commands.rs<br/>run / cancel"]
N["ncm.rs<br/>网易云离线引擎"]
Q["qq.rs<br/>QMC 三层路由(P1)"]
end
subgraph QQS["QQ 三层(P1)"]
L1["① 尾部内嵌 ekey<br/>纯离线"]
L2["② musicex → 本机凭据<br/>GetEVkey API"]
L3["③ Frida 兜底<br/>(P1b,按需)"]
end
O["savedir/decrypted/"]
A --> S --> C
C --> N --> O
C --> Q --> L1 --> O
Q --> L2 --> O
Q -.-> L3 -.-> O
Q -.->|"music-decrypt-event"| S
N -.-> S
```
---
## 1. 需求解构
| 用户原话 | 解构 | 落点 |
|---|---|---|
| 在音乐模块添加解密 Tabs | 音乐模块第 4 个页签 | §5.2 |
| 解密各平台的加密格式 | 收敛为 QQ音乐 + 网易云(本轮显式指定) | §3 |
| 最小路径实现 | 砍掉:转码、元数据回填、封面提取、拖拽、酷狗酷我、并发调优、历史持久化 | §7 P2 清单 |
| 可参考 QKKDecrypt | 对齐思路与坑,不搬 GPLv3 代码 | §3.3 |
---
## 2. 现状勘察(2026-09-27 从仓库实际读取)
### 2.1 已具备的基建(直接复用)
| 能力 | 现有实现 | 复用方式 |
|---|---|---|
| Tab 体系 | `useModuleTabs`(`MusicModule.vue:78`,alwaysVisible 模式,标题栏浮动切换器自动接管) | 加 `{ value: 'decrypt', label: '解密' }` 一项 |
| 任务 + 事件范式 | `music_download` / `music-download-event`(`commands.rs:187`、`constants.rs:107`) | 解密照抄:先回 taskId,进度推事件 |
| 便携 Python + pip 镜像 | `runtime.rs`(清华源 `PIP_INDEX_URL`,`mod.rs:77`) | QQ sidecar 的 frida 安装、Python 就绪检查 |
| 加密依赖 | `Cargo.toml` 已有 `aes = "0.8"`、`cbc = "0.1"`、`base64 = "0.22"` | ncm 的 AES-128-ECB 手写循环,零新增依赖 |
| specta 绑定 | `lib.rs export_bindings()` 两处 `collect_commands!` | 新命令两处同步登记(`lib.rs:300` 注释明确要求) |
| 文件选择对话框 | `@tauri-apps/plugin-dialog`(`MusicModule.vue:4` 已 import) | 页签内直接用,不加 Rust 命令 |
| 输出目录 | 默认 `savedir`(设置页「本地下载目录」) | 解密默认输出 `savedir/decrypted/` |
| 播放引擎 | symphonia(`Cargo.toml:115`) | 解出的 flac/mp3/ogg 可直接进曲库试听 |
### 2.2 关键缺口(需新增)
| 缺口 | 说明 |
|---|---|
| ncm 解密实现 | 纯算法,约 200 行 + 单测 |
| QQ 运行期 sidecar | Frida 注入 + `EncAndDesMediaFile` 调用序列,按参考思路重写 |
| 解密任务 store | 下载任务在 `musicStore`;解密需独立轻量 store(页签切换会卸载组件,监听器必须挂 store) |
| frida 依赖安装 | `pip install frida`(wheel 带原生扩展,走现有镜像),需一条安装命令 + 进度事件 |
---
## 3. 技术选型
### 3.1 网易云 `.ncm`:Rust 原生离线
**为什么不进 Python**:
- ncm 是纯文件级算法,不需要任何进程配合;塞进 Python 等于把 200 行算法绑上「必须先装运行时」的前置。
- 便携 Python 是按需安装(musicdl 才触发),解密不应被它卡住——Rust 路线开箱即用。
- Rust 侧可直接 `cargo test`,对照样本文件做回归。
**算法要点**(对照 MIT 协议的 `ncmdump`(`src/ncmcrypt.cpp`)逐条独立重写。下面每一条都是**会写错的地方**,不是梗概):
**① 容器结构**
```
0x00 magic 8B "CTENFDAM"(即 43 54 45 4E 46 44 41 4D)
0x08 2B 0x02 0x00 → 跳过
0x0A key_len 4B LE
0x0E key_data key_len B (XOR 0x64 → AES-128-ECB → 得 RC4 密钥盒种子)
... meta_len 4B LE
... meta_data meta_len B (XOR 0x63 → 去 22B 前缀 → base64 → AES-128-ECB → 去 6B 前缀 → JSON)
... 5B 跳过(CRC32 4B + 图片版本 1B)
... cover_len 4B LE
... img_len 4B LE
... img_data img_len B (内嵌封面:PNG 或 JPEG)
... 跳 cover_len - img_len
... audio 剩余全部 (改性 RC4)
```
**② 两个 XOR 常量不同**(原文档误合并成一个 `0x64`)
| 段 | XOR 常量 | 加密方式 | 解密后处理 |
|---|---|---|---|
| key 段 | `0x64` | AES-128-ECB | **跳过前 17 字节**(`neteasecloudmusic`),其余即 RC4 密钥盒种子 |
| meta 段 | `0x63` | AES-128-ECB(先 base64 解码) | 跳过前 6 字节(`music:`),其余为 JSON |
**③ AES-128-ECB 解密**:**key 段与 meta 段用两个不同的 16 字节密钥**——`sCoreKey` = ASCII `neteasecloudmusi`(即 17 字节前缀 `neteasecloudmusic\0` 的前 16 字节)、`sModifyKey` = ASCII `#14ljk_!\]&0U<'(`。**收尾不是"去前缀",而是 PKCS#7 风格 padding**:逐 16 字节块解密,最后一字节即 padding 长度(`> 16` 时视作 0),去掉 padding 后再手动跳前缀。
> 易错点:**「AES 密钥」与「要剥掉的前缀」是两个东西**。`neteasecloudmusic` 既是被剥的 17 字节前缀(含结尾 NUL),其前 16 字节又是 key 段的 AES 密钥;meta 段则两者都不同。混用不报错、只会全解错(实现里分别命名为 `CORE_KEY` / `CORE_AES_KEY` / `MODIFY_KEY`)。
**④ meta 段的两层前缀**:原始数据前 22 字节是字面量 `163 key(Don't modify):`,**先剥掉它**,再对余下部分 base64 解码,才喂给 AES。
**⑤ 音频段是「改性 RC4」**
- 密钥盒用参考实现的 KSA:`swap = keybox[i]`;`c = (swap + last_byte + key[key_offset]) & 0xff`,`key_offset` 触 keyLen 归零循环取 key,`keybox[i] = keybox[c]`、`keybox[c] = swap`、`last_byte = c`。**照抄即可,但注意 `last_byte` 在模 256 下是恒等变形(结果与标准 RC4 逐字节相同),它既不是"关键差异",也不能作为验证手段**——见 §6.25。
- 明文按 `0x8000` 字节一块循环,块内 `j = (i + 1) & 0xff`,`plain[i] = cipher[i] ^ keybox[(keybox[(keybox[j] + j) & 0xff] + keybox[j]) & 0xff]`。块之间不重置密钥盒、也不额外跳字节——`i` 是块内下标。
- **块边界必须由"读满一块"确定**(`read_full`),不能用 `Read::read` 的短读结果,否则相位错位、中途变噪声(§6.24)。
- **不存在"每 0x8000 字节后跳过 5 字节间隔"**(原文档此条有误)。`0x8000` 是块大小,`5` 是 §① 里跳过的 CRC32 + 图片版本。
**⑥ 输出扩展名由音频首帧魔数决定,不是 meta 的 `format` 字段**(原文档此条说反了):首个解密块以 `ID3`(`0x49 0x44 0x33`)开头 → `.mp3`,否则 → `.flac`。meta 的 `format` 只用于另一件事——**判断该不该回填标签/封面时的格式分支**。
**⑦ 顺手可得的元数据**:meta JSON 含 `musicName` / `artist`(二维数组,取每项第 0 个元素并用 `/` 连接)/ `album` / `bitrate` / `duration`,且封面字节已在上面的 `img_data` 里读出。**P0 已实现封面单独落盘**(`<歌名>.cover.png|jpg`,按魔数定扩展名);**写进音频标签**仍留 P2——那需要 `lofty` 且要按 mp3/flac/m4a 分派容器,属于「增强」而非「能播」。
**⑧ 失败处理**:魔数不符 / `key_len <= 0` / 块不足 16 字节 → 返回可读错误(`Err(String)`),**per-file 失败不 panic、不中断整批**。
### 3.2 QQ音乐:Rust 原生三层路由(**本节已重写**)
**原判断作废的理由**:原文把「需要 QQ 客户端在跑」与「需要 Frida 注入」绑成了一件事。二者其实独立——ekey(解密密钥)有三种存储形态,只有第三种才需要注入。前两层覆盖真实曲库的绝大多数文件,且都是纯 Rust。
**QMC 加密本体**(与 ncm 同构:字节流密码 + 可选密钥):
| 方案 | 密钥来源 | 适用 |
|---|---|---|
| QMC1 | 固定种子,**无需密钥** | 旧版 `.qmc0` / `.qmc3` / `.qmcflac` / `.qmcogg` |
| QMC2 | ekey(base64 + TC-TEA 加密),密钥 ≤300B 走 Map XOR,>300B 走改性 RC4 | `.mgg` / `.mflac` 全系 |
**ekey 的三种存储形态 → 三层路由**:
| 层 | 形态 | 需要客户端? | 实现方式 |
|---|---|---|---|
| **①** | **尾部内嵌 ekey**:QTag 格式(ekey + 歌曲 ID + `QTag` 魔术)或 V1 格式(文件末尾 4 字节为 key 长度,key 在其前) | ❌ 不需要 | **纯 Rust 离线**,从文件尾直接提取 |
| **②** | **musicex 尾部**(QQ 客户端 ≥ 19.57 / Win 22.x):尾部 192B 只存 song_id + media_mid + filename,**ekey 不落盘** | ✅ 需运行且已登录 | **纯 Rust**:读凭据 → 调 API 取 ekey |
| **③** | 客户端内部导出(方案原文所选) | ✅ | Python sidecar + Frida attach `QQMusicCommon.dll` |
**第②层的完整链路**(全部可在 Rust 内完成,`windows-sys` 只差一个 feature):
1. 尾部检测:读末 8 字节,为 `"musicex\0"` 即 musicex;再向前读 `footer_size + 8` 解析完整 footer(`0x00` song_id u32LE、`0x0C` media_mid UTF-16LE 60B、`0x48` filename UTF-16LE 68B、`0xC0` footer_size、`0xC8` magic)。
2. 取 `uin`:读 `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 的 `[Account] Uin`(明文 INI)。
3. 取 `authst`:**`authst` 在 Windows 上不落盘**,仅在运行中的 `QQMusic.exe` 进程内存里。用 `CreateToolhelp32Snapshot` + `Process32FirstW/NextW` 定位进程 → `OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ)` → `VirtualQueryEx` 遍历可读区(只需 `MEM_COMMIT`,跳过 `MEM_MAPPED`)→ `ReadProcessMemory` 按 1MB 分块 → 搜 `"authst":"` 取其后 Base64URL 串。实测约 0.5 秒。
4. 调 API:`POST https://u.y.qq.com/cgi-bin/musicu.fcg`,`req_1.module = "music.vkey.GetEVkey"`、`method = "CgiGetEVkey"`;`param.filename` **必须带 `.mgg`/`.mflac` 后缀**、`param.songtype` **必须为 1**(否则返回 `104005`)、`param.platform = "27"`(Windows)。响应取 `req_1.data.midurlinfo[0].ekey`。
> 三处易错点:`MEMORY_BASIC_INFORMATION` 在 Win10 1803+ 有 2 字节 `PartitionId` 插在 `AllocationProtect` 与 `RegionSize` 之间,**漏掉会导致 `state` 读成 `protect`、所有内存区被跳过**;`filename` 不带扩展名返回空 ekey;`authst` 有效期约 22.3 小时会过期。
**前置检查与降级出口**(UI 状态卡据此渲染):QQ 未运行或未登录 → 提示"请启动并登录 QQ 音乐后重试";层①②均失败的文件才落到③;Frida 不可用时报可读错误并给排除指引,**不自动拉起 QQ 客户端**。
**③(P1b,按需)的形态**若将来要做:`qq_decrypt.py` 走 `include_str!` 内置(与 `bridge.rs:17` 的 `BRIDGE_SCRIPT` 同范式),一次进程 attach 一批文件,stdout JSON-Lines 回报进度;导出符号是 mangled name(`?Open@EncAndDesMediaFile@@…`),**按子串 `EncAndDesMediaFile` 模糊匹配,严禁硬编码地址或 RVA**。
**输出扩展名**(不能按输入扩展名机械映射):`.qmc0`→`.mp3`、`.qmc3`→`.mp3`、`.qmc2`→`.ogg`、`.qmcogg`→`.ogg`、`.qmcflac`→`.flac`、`.mgg`/`.mgg0`/`.mgg1`/`.mggl`→`.ogg`、`.mflac`/`.mflac0`/`.mflach`→`.flac`(均以首帧魔数兜底校验)。**`.mmp4` 的产物容器(m4a 还是 mp4)尚未独立证实,实施 P1 时必须用真机样本确认后再定**。
### 3.3 许可边界(必须遵守,三档口径)
- **MIT(可逐行对照)**:`taurusxin/ncmdump`(网易云 ncm 算法本体)。可直接对照 `src/ncmcrypt.cpp` 实现,仅需保留版权声明。
- **GPLv3(只读文档与行为,严禁抄代码)**:`QQKWKG-TriMusicDecrypt`(+ FFmpeg GPL)、`ownlight6/qmc-decoder`。**整段搬代码 = 给本仓库引入 GPL 传染。** 允许的是:阅读其调用序列、常量、格式与协议说明后**独立重写**——本文档 §3.1 / §3.2 沉淀的正是这类非代码知识。
- **合规口径**(UI 底部放一行):仅处理用户本人拥有合法访问权限的本地文件,不用于批量分发或规避付费授权。
---
## 4. 接口契约
### 4.1 Tauri 命令
```rust
// 任务
music_decrypt_run(task_id, files?, folder?, root?, out_dir?, in_place?) -> Result<(), String>
music_decrypt_cancel(task_id: String) -> Result<bool, String>
// 预览与状态
music_decrypt_scan(folder: String, root: Option<String>) -> Result<ScanSummary, String>
music_decrypt_qq_status() -> Result<QqOnlineStatus, String> // 只读本机,不发网络请求
```
`QqOnlineStatus` 字段:`{ running, loggedIn, uin, ready, message, steps }`。
**`authst` 不下发到前端**——它只活在后端内存里用于调接口。
- **注册是 3 处,不是 2 处**(实测仓库现状):
1. `music/mod.rs` 的 `pub use commands::{...}` re-export(约 `mod.rs:48`);
2. `lib.rs` 的 `collect_commands![]`(`export_bindings()` 内,`lib.rs:205`);
3. `lib.rs` 的 `generate_handler![]`(`run()` 内,`lib.rs:348`)。
漏第 2 处 = 运行时能调但 `bindings.ts` 缺类型;漏第 1、3 处 = 编译失败或调用失败。
- 前端沿用本模块既有范式(`musicStore.ts` 全用原生 `invoke` + 手写类型,不用 `commands`),故解密 store 同样用 `invoke`。
### 4.2 事件 `music-decrypt-event`(登记进 `constants.rs` 音乐分组)
```typescript
type MusicDecryptEvent = // 注意:只有 tag 是 kebab-case,**字段名仍是 snake_case**
| { type: 'start'; task_id: string; total: number }
| { type: 'file'; task_id: string; index: number; name: string;
status: 'ok' | 'error' | 'unsupported';
message: string | null; // 失败原因,或成功时的备注(平台 / 密钥形态 / 元数据摘要)
output: string | null; // 主产物
cover: string | null } // 单独落盘的封面(网易云带内嵌封面时才有)
| { type: 'progress'; task_id: string; done: number; total: number;
bytes_done: number; bytes_total: number; name: string }
| { type: 'finished'; task_id: string; ok: number; failed: number; cancelled: number }
```
> **字段名是 snake_case 而非 camelCase**:`DecryptEvent` 上只有 `#[serde(tag = "type", rename_all = "kebab-case")]`
> 作用在 tag 上,变体字段名原样输出。前端 `decryptStore.ts` 的 `RawEvent` 必须照此声明
> ——两边不一致时不会编译报错,只会表现为「任务建好了但进度永不动」。
> Rust 侧有 `event_json_contract` 单测把形状钉死(§6.23)。
>
> 结果态没有 `already`:P0 不做「已解密过则跳过」(同一文件重解会产出 `_1` 后缀的新文件),
> 语义比"猜哪份产物属于哪次输入"更可预测。
> 原先的 `deps-install` 事件随 `music_decrypt_install_deps` 一起取消——三层路由后不再需要 `pip install frida`。
> 注意前端 `musicStore.ts:419` 是**硬编码事件名字符串**、并未引用前端常量表,故解密 store 同样硬编码,仅 Rust 侧登记常量。
### 4.3 文件识别(用户不选平台)
按扩展名路由,魔数校验兜底:
| 扩展名 | 路线 |
|---|---|
| `.ncm` | 网易云离线引擎(按内容魔数识别,不依赖后缀) |
| `.mgg` / `.mgg0` / `.mgg1` / `.mggl` / `.mflac` / `.mflac0` / `.mflach` / `.mmp4` / `.qmc0` / `.qmc2` / `.qmc3` / `.qmcflac` / `.qmcogg` | QQ 引擎(按尾部形态决定是否联网) |
| 其他 | 散选时保留为 `unsupported`;文件夹扫描时直接跳过 |
> 后缀矩阵原文档只列了 3 个,会**静默漏掉用户曲库里的常见文件**,故过滤列表与路由表**一次写全**。
> 实际判定以**内容**为准(§4.5),后缀只用于文件对话框的过滤器。
### 4.3.1 QQ 音乐:是否需要登录?
这是使用者最常问的一点,所以结论放在前面:
| 文件来源 | 扩展名 | 需要 QQ 音乐登录? |
|---|---|---|
| QQ 客户端 **≤ 19.51** 下载 | `.qmc0` `.qmc3` `.qmcflac` `.qmcogg` | **不需要** |
| QQ 客户端较旧版本下载(QTag / V1 尾部) | `.mgg` `.mflac` | **不需要** |
| QQ 客户端 **≥ 19.57** 下载(musicex 尾部) | `.mgg` `.mflac` `.mmp4` | **需要**:客户端运行 + 已登录 |
| 网易云(任何版本) | `.ncm` | **不需要** |
**为什么新版必须登录**:从 19.57 起,QQ 音乐不再把解密密钥(ekey)写进文件,
只在文件末尾留 192 字节元数据;客户端自己也是在播放/下载时拿本机登录态
(`uin` + `authst`)向服务器实时换取密钥。第三方要解开同一个文件,只能复刻这一步。
**这里的实现方式**:只读本机凭据(INI 里的 `uin` + 运行中 `QQMusic.exe` 内存里的 `authst`),
再调官方 `music.vkey.GetEVkey` 接口取密钥——**不注入进程、不改写文件、不做任何反检测**。
**操作步骤**(与 UI 状态卡里的文案一致):
1. 在电脑上启动 QQ 音乐客户端(Windows 版)。
2. 用它登录你的账号,并**保持客户端开着**(`authst` 只存在于运行期内存)。
3. 回到「解密」页点「重新检测」,状态变为「已就绪」即可解密 musicex 文件。
4. 若提示未取到登录令牌:先在客户端里**播放任意一首歌**触发一次网络请求,再重新检测。
5. 仍失败则试过**以管理员身份运行**本应用(读其他进程内存可能需要更高权限)。
6. 登录令牌约 **22.3 小时**过期;过期后重新检测即可,无需重装。
**UI 呈现**:状态卡显示三态(未运行 / 未登录 / 已就绪)+ QQ 号 + 「重新检测」按钮;
未就绪时折叠区里就是上面这 6 条步骤。上方那句"旧版文件与 `.ncm` 本来就不需要登录"
也会一并显示,避免用户误以为自己必须登录才能用这个功能。
### 4.4 输出路径规则
- **就地模式(`in_place = true`,文件夹批量的默认)**:产物与源文件**同目录同名**,
仅按格式改扩展名(`Pop/a.mflac` → `Pop/a.flac`)。符合"就地解出来"的直觉,
也天然不会与其他目录的同名文件冲突。此时 `out_dir` 不参与写盘。
- **指定输出目录(`in_place = false`)**:默认根目录 `savedir/decrypted/`,
并**按 `root` 还原相对目录结构**(`Pop/2026/b.ncm` → `out/Pop/2026/b.flac`)。
散选文件没有相对目录,平铺到根目录。
- **同名去重**:即使还原了目录结构,同一目录内仍可能撞名(如 `.mgg` 与 `.mgg1` 同基名)。
规则:优先用原名,已存在(磁盘上或本批内已占位)则追加 `_1` / `_2`…
- **输入输出相交保护**:非就地模式下,若某输入文件已位于输出目录内则剔除,
避免"解出来再解"无限膨胀;全被剔除时报错并提示可改用「就地解密」。
- 扩展名以**音频首帧魔数**决定(ncm 见 §3.1⑥,QMC 见 §3.2 末),不信任输入扩展名;
魔数认不出时才回退到输入后缀映射。
### 4.5 文件夹批量
命令参数的关系:
| 参数 | 含义 |
|---|---|
| `folder` | **文件夹批量入口**:Rust 侧递归扫描该目录 |
| `root` | 计算相对路径的基准(决定输出目录里还原哪几层) |
| `files` | 散选文件列表(`folder` 为空时使用) |
| `in_place` | 就地解密(默认 `true`,见 §4.4) |
| `music_decrypt_scan` | 只扫描不解密,返回 `{ total, ncm, qmc }` 供 UI 预览 |
**平台判定按内容,不按后缀**(`scan::route`):
1. 读 8 字节魔数,命中 `CTENFDAM` → 网易云;
2. 否则读尾部判 QMC 形态:后缀在 QMC 家族里 → QQ音乐;
3. 后缀不认识时,只有**明确**的尾部形态(QTag / V1 / musicex)才认领——
否则任何末尾凑巧不是 `QTag` 的文件都会被判成"QMC1",噪声太大。
理由:同一曲库里 `.ncm` / `.mflac` / `.qmcflac` / `.mgg` 混放是常态,且 QQ 还有
`.mgg0` / `.mflac0` 等变体,靠后缀枚举必然漏。代价是**认不出的文件会被跳过**,
所以扫描数可能少于用户预期——因此 UI 先调 `music_decrypt_scan` 显示
"找到 N 个 · 网易云 x · QQ音乐 y",让用户在开跑前就能判断是否符合预期。
---
## 5. 架构与模块设计
### 5.1 Rust 侧 `src-tauri/src/music/decrypt/`(已实施的实际结构)
```
decrypt/
mod.rs // 任务表(Mutex<HashMap<taskId, 取消标志>>)、工作线程 + 节流事件转发、事件契约
common.rs // 两引擎公共件:DecryptError、魔数定格式、同名去重、读满一块
ncm.rs // 网易云离线引擎(AES-ECB + RC4 变体 + meta/封面)
qmc.rs // QQ:QMC1 静态密钥 / QMC2 Map / QMC2 RC4 / tc_tea / 尾部形态 + 流密码
qq_footer.rs // musicex 尾部解析(纯,可单测)
qq_credentials.rs // 凭据:INI 解析(纯)+ 进程内存取 authst(平台胶水)
qq_memscan.rs // Windows 专用:ToolHelp 枚举进程 + VirtualQueryEx/ReadProcessMemory(只读)
qq_ekey.rs // GetEVkey 请求组装与响应解析(纯,可单测)
qq_online.rs // 编排:musicex → 凭据 → 取密钥 → 解密;probe_status()
scan.rs // 文件夹递归扫描 + 内容优先的平台路由
commands.rs // run / cancel / scan / qq_status(四条命令)
```
平台判定与密钥来源的**分工**:`scan.rs` 只决定"这文件归哪个引擎";
`qmc.rs` 决定"密钥从哪来"(内嵌 / 静态);只有尾部是 musicex 时,
调度层才把 `KeyRequired` 交给 `qq_online.rs` 转在线路径——这样离线路径保持零网络依赖。
`mod.rs` 挂到 `music/mod.rs` 的子模块列表;事件常量加进 `constants.rs` 音乐分组。
### 5.2 前端
```
src/modules/music/components/DecryptPanel.vue // 页签内容
src/stores/decryptStore.ts // 任务列表 + 事件监听(照 musicUploadStore 范式)
MusicModule.vue // tabs 加一项 + <TabsContent value="decrypt">
index.ts // searchItems 加「音乐解密」(tab: 'decrypt')
```
**P0 / P1a / P1c UI 形态**(已实施):
- 顶部操作行:**选择文件夹** | 选择文件(dialog 多选,按 §4.3 全后缀过滤)| **就地解密开关** | 取消 / 清空记录
- **QQ 音乐在线解密状态卡**:状态点(三态)+ 一句话状态 + QQ 号 + **重新检测** + 折叠的**操作步骤**;
未就绪时折叠区里就是 §4.3.1 那 6 条,并附一句"旧版文件与 `.ncm` 本来就不需要登录"
- 输出目录行:就地模式下置灰并显示"与源文件同目录"
- **文件夹扫描预览条**:显示"找到 N 个 · 网易云 x · QQ音乐 y" + 开始解密按钮
- 中部任务表:任务头(文件夹路径 / 进度条 / `bytes_done/bytes_total` / 打开产物目录)|
文件行(文件名 | 平台徽标 | 状态徽章 | 打开产物目录 | 打开封面 | 备注或失败原因)
- 空态用 `StateBlock variant="empty"`;进度条结构恒定(完成后保留满格,不整块消失)
- 底部一行合规说明
### 5.3 数据流
与下载链路同构:前端 → `music_decrypt_run` → Rust 建 taskId 即回 → 后台执行 → `music-decrypt-event` → `decryptStore` 更新 → 列表刷新。页签切换组件卸载不影响任务(监听在 store)。
---
## 6. 关键实现细节与已知的坑
**ncm**(编号对应 §3.1 的条目号)
1. `aes 0.8` 只有块原语、`ecb` crate 不在依赖树:ECB 手写 16 字节块循环(`cipher::BlockDecrypt::decrypt_block`)。**不要**为此引入 `ecb` crate。
2. **两段 XOR 常量不同**(`0x64` key / `0x63` meta)。照抄成同一个常量 = 必然失败。
3. **PKCS#7 风格 padding**:AES-ECB 收尾取最后一字节为 padding 长度(`> 16` 视作 0),不是“去前缀”。
4. **改性 RC4 KSA 的 `last_byte` 累加**(照抄参考实现即可,但别误解它):
式子 `c = (swap + last_byte + key[key_offset]) & 0xff` 在模 256 下**恰好化简为标准 RC4**,
实测两者密钥盒逐字节相同(256/256)。因此它**不是**"与标准 RC4 的关键差异",
也不能靠与标准 RC4 比对来验证实现——验证只能靠固定向量(见 §6.25)。
`key_offset` 触 keyLen 归零循环取 key 这一点照抄。
5. **音频块之间不跳字节**,`0x8000` 只是块大小;`i` 是块内下标。原文档的"每 0x8000 跳过 5 字节"是错的(那 5 字节在 §① 的头部里,且已单独处理)。**但块边界必须由"读满一块"确定**,不能用 `Read::read` 的短读结果(见 §6.24)。
6. **输出扩展名看音频首帧魔数**(`ID3` → `.mp3`,否则 `.flac`),不看 meta 的 `format`。
实现比这条更宽一点:还识别 `fLaC` / `OggS` / `RIFF..WAVE` / `ftyp` / `wvpk`,
给 P1 的 QQ 产物复用(ncmdump 的兜底同为 flac)。
7. meta 段是**两层前缀**:先剥 22 字节 `163 key(Don't modify):`,再 base64,再 AES,再剥 6 字节 `music:`。
8. **流式处理**:`0x8000` 块逐块读→解→写,禁止整文件读入内存(`.mmp4` 可能很大)。大文件下需按已处理字节数推 `progress`。
9. **单测不依赖真实样本**:真实 FLAC 最小样本进不了仓库。改为对**中间产物**断言——AES-ECB 往返、KSA 密钥盒已知值、padding 剥离、魔数→扩展名判定、以及"自造一个合法 ncm 容器(用同一套算法正向构造)再解回来"的往返测试。真机样本走手动自测。
10. 魔数/解析失败走 per-file `Err`,**不 panic、不中断整批**。
**QQ(P1)**
11. 第①层(QTag / V1)**完全离线**,不要因为"QQ 文件"就先去连客户端——先用尾部分支判形态再决定要不要读凭据。
12. 第②层的 `authst` **只在 `QQMusic.exe` 运行期内存里**,不落盘;`uin` 在 `QQMusicServiceConfig.ini` 可明文读。`MEMORY_BASIC_INFORMATION` 的 2 字节 `PartitionId`(Win10 1803+)**必须包含**,否则 `state` 会读成 `protect`、所有内存区被跳过。
13. API 三处必须:`filename` 带 `.mgg`/`.mflac` 后缀、`songtype = 1`、`module = music.vkey.GetEVkey`(不是 `GetVkey`)。否则 `104005` 或 ekey 为空。
14. `authst` 约 22.3 小时过期:失败文案要给"重新登录 QQ 音乐"的出口,而不是只报网络错误。
15. 第③层(Frida):必须**先启动 QQ 音乐**再 attach,`QQMusicCommon.dll` 打开主界面即加载;导出符号是 mangled name,**按子串 `EncAndDesMediaFile` 模糊匹配,严禁硬编码地址或 RVA**;被杀软拦截只给排除指引,**不做反检测动作**;批量时客户端 UI 可能短暂卡顿,属预期。
16. `path_sensitive_mflac` 变体(同名文件不同目录内容不同)P1 不处理:报错带全路径,遇到再迭代。
17. `.mmp4` 产物容器未证实,P1 先用真机样本确认再定(见 §3.2 末)。
**工程**
18. 新命令登记 **3 处**:`music/mod.rs` re-export、`lib.rs` 的 `collect_commands![]`、`lib.rs` 的 `generate_handler![]`(见 §4.1)。
19. `music-decrypt-event` 常量进 `constants.rs` 音乐分组;前端沿用硬编码字符串(与 `musicStore.ts:419` 一致)。
20. 解密 store 必须独立于组件生命周期:Tabs 非 active 会卸载内容,事件监听挂 store 不挂组件。
21. **输出同名去重 + 输入输出相交保护**(见 §4.4)——原文档缺失,不做会静默覆盖用户文件。
22. 三层路由后**不再需要便携 Python 与 frida**,`music_decrypt_install_deps` 命令取消;QQ 未登录的错误出口走状态卡提示。
**实施中新增确认的坑(2026-09-27 实测)**
23. **事件字段名是 snake_case**(不是 camelCase)。`#[serde(tag = ..., rename_all = "kebab-case")]`
只作用于 tag,变体字段名原样输出。前后端不一致时**不报错**,只表现为进度不动。
Rust 侧 `event_json_contract` 单测钉死 JSON 形状。
24. **音频块边界必须用"读满一块"而非 `Read::read` 的返回值**。`BufReader::read` 会短读,
块边界一漂移,解密式里的「块内偏移 `i`」就与加密侧错位,表现为**文件从中间某处起全是噪声**
(实测首个坏字节落在 32418,仍在第一大块内),前半段却完全正常,极难排查。
已加 `read_full()` 专门处理。
25. **`last_byte` 累加在模 256 下是恒等变形**:`c = swap + last_byte + key` 与标准 RC4 的
`j += s[i] + key` 结果**逐字节相同**(已实测 256/256 一致)。所以:
- 不能靠"与标准 RC4 比对"来验证密钥盒实现;
- 也**不要**以为它是"改性 RC4 的关键差异"而据此改写(本计划早期的 §6.4 表述即由此误导)。
真正的验证手段是**固定向量**(`key_box_matches_reference_vectors` /
`keystream_matches_reference_vector`)。
26. **`MODIFY_KEY` 是 16 字节而非 17**(`aes::Aes128` 的密钥长度就是 16);
`CORE_KEY` 的 17 字节是**解密后要剥掉的前缀**,与 AES 密钥不是同一个东西
(AES 密钥是它的前 16 字节)。两者混用不会编译报错,只会全解错。
27. **合成容器单测的 key 段必须带 `neteasecloudmusic` 前缀**——否则解密端剥前缀后拿到错种子。
这个坑一度被"单循环 KSA"的错误实现掩盖(两边同时错、往返仍然自洽)。
**P1a(QQ 离线)实施中新增确认的坑**
28. **QMC2 Map 密码的 `scramble` 必须用 `wrapping_shl/shr`**(对移位量取模),
不能写成 `u8::rotate_left/rotate_right`——后者会在内部再取一次模,结果**不同**。
被 Apache 参考实现的原向量抓到(若不比对向量,会产出"能跑但全错"的解密)。
29. **tc_tea 不是 TEA-ECB,而是 TEA 变体 + 自定义 CBC**:块与密钥字都是**大端**、
16 轮(非 32)、单轮是 `((v<<4)+k1) ^ (sum+v) ^ ((v>>5)+k2)`,
且明文前置 `1+pad+2` 字节头、尾部 7 字节 0 自校验。照 TEA-ECB 写会解出**部分可读的乱码**
(表现极具迷惑性:能看到明文碎片)。尾部 0 校验正是"密钥对不对"的权威判据。
30. **V1 尾部判定不能只看长度**:任意加密数据末尾都可能凑出 `0<n<=0x400`,
只按长度判会把普通 QMC1 文件误判成 V1 并砍掉一大截音频(实测 32871 字节 → 4096)。
必须追加"前面那一段像不像 base64 ekey"的校验。
31. **`sniff_tail` 的 `audio_len` 必须换算成绝对长度**:它只读了尾部 probe,
`detect_tail` 给出的是**相对 probe 起点**的偏移;QMC1(无尾部)必须回落到**整个文件大小**。
另外**不要在两个地方各写一遍尾部探测**——当初 `decrypt_file` 自己复制了一遍,
修了 `sniff_tail` 却没修它,症状是"探测结果对、实际产物只有 4KB"。
32. **QMC1 的掩码分支是 `pos > 0x7FFF`(严格大于)**,不是 `>=`;写成 `>=` 会在回绕点差一字节。
**P1c(musicex 在线)实施中新增确认的点**
33. **`MEMORY_BASIC_INFORMATION` 的 `PartitionId`(Win10 1803+)**:直接沿用
`windows-sys` 的结构体即可,但**自己手写 `#[repr(C)]` 时千万别漏**——漏了会让
`RegionSize`/`State`/`Protect` 全部读错偏移,`VirtualQueryEx` 返回的 `State`
读成 `Protect`(如 `0x04` 而非 `0x1000`),于是所有内存区被跳过、永远扫不到 token。
34. **`getEVkey` 的三个"必须"**:`filename` 带扩展名、`songtype=1`、
`module=music.vkey.GetEVkey`(不是 `GetVkey`)。任一写错都只是"拿不到 ekey",
不会报错——所以请求体用纯函数组装并单测锁死(`qq_ekey::build_evkey_request`)。
35. **`authst` 会过期(约 22.3 小时)**:失败文案必须给"重新登录 / 重新检测"的出口,
否则用户会以为是网络问题。响应里的 `expiration` 已带进产物备注。
36. **单元测试不要真的发网络请求**:本机一旦登录成功,测试就会去连 QQ 服务器,
导致测试变慢变脆。改为验证"请求体能正确构造"+"`#!Qk` 头守卫"+"尾部能被解析出
`media_mid`/`filename`"三段——真实响应留给真机端到端。
37. **musicex 音频段要校验 `#!Qk` 头**:尾部像 musicex 不代表内容真是 QMC2 密文;
没有这道守卫会把任意文件"解"成垃圾却报告成功。
**真机端到端验证后修正(2026-09-27)**
38. **`#!Qk` 不是 QMC2 密文的通用魔术**(推翻第 37 条的做法):真机 musicex 样本
(Avicii - Heaven,197MB `.mflac`)的密文头是 **`51 74 03 75`**,按"必须以 `#!Qk`
开头"写的守卫会把**完全合法的文件误拒**。
正确做法是**用解密结果判定密钥是否正确**:用取到的密钥解出前 16 字节,
看是否是已知音频魔术(`fLaC` / `OggS` / `ID3` / `ftyp`…)——密钥错时它是随机噪声,
几乎不可能凑巧命中;命中即说明密钥对、文件也对。
这也是"内容优先"原则的又一次应用:**不要用猜测的密文特征做判据,要用能验证的结果。**
39. **文档给的 musicex 字段偏移在真样本上是对的**:`0x0C` media_mid(60B UTF-16LE)、
`0x48` filename(68B UTF-16LE)、`0xC0` footer_size、`0xC8` magic 全部命中,
尾部实测 192 字节、padding 区有 13 个非零字节(所以不能假设 padding 全 0)。
40. **真机样本的规模提醒**:`.mflac` 可达 197MB / 192kHz / 24bit。
`qq_online` 目前把音频段整段读入内存再解密(探针与生产路径都是),
在这个量级下可用,但如果将来遇到多 G 的文件,应改成分块解密 + 流式写盘
(`qmc` 的流密码本身已支持任意偏移)。
---
## 7. 分阶段计划
### P0 — 网易云 + 解密页签全链路(约 2 天)**✅ 已实施(2026-09-27)**
- [x] `useModuleTabs` + `TabsContent` 接「解密」页签;`index.ts` 搜索条目
- [x] `decrypt/ncm.rs`:§3.1 全部要点 + 单测(**18 项通过**)
- [x] `decrypt/mod.rs` + `commands.rs`:run / cancel + 事件发射;**三处**登记;`constants.rs` 事件常量
- [x] `decryptStore.ts` + `DecryptPanel.vue`:选文件 → 批量任务 → 进度 → 打开输出目录
- [x] 输出同名去重 + 输入输出相交保护(§4.4)
- [x] 封面单独落盘(`<歌名>.cover.png|jpg`)——标签回填仍留 P2(`lofty` 需按容器分派)
- [ ] **自测:真实 `.ncm` 样本解出**(需人工用真机样本验证;仓库内样本有版权且体积大,故算法靠 §6.9 的中间产物单测 + 合成容器往返覆盖)
- **验收**:页签选 10 个 ncm 全部解出、失败有原因、切页签不丢任务、播放器直接可播
**已交付文件**:
| 文件 | 内容 |
|---|---|
| `src-tauri/src/music/decrypt/ncm.rs` | 网易云离线引擎(容器解析 / AES-ECB / 密钥盒 / 流式解密 / 魔数定格式 / 封面 / 同名去重)+ 单测 |
| `src-tauri/src/music/decrypt/mod.rs` | 任务表、工作线程 + 节流事件转发、`DecryptEvent` 契约(含 JSON 形状单测) |
| `src-tauri/src/music/decrypt/commands.rs` | `music_decrypt_run` / `music_decrypt_cancel` + 输出目录解析与相交保护 |
| `src/stores/decryptStore.ts` | 任务状态 + 事件监听(挂 store,不随组件卸载) |
| `src/modules/music/components/DecryptPanel.vue` | 页签 UI |
| `music/mod.rs` · `lib.rs` · `constants.rs` | 子模块挂载、`MusicManager.decrypt` 字段、三处命令登记、事件常量 |
### P1a — QQ 离线解密 + 文件夹批量(**✅ 已实施,纯 Rust,无 Python/frida**)
- [x] `decrypt/qmc.rs`:QMC1 静态密钥表 / QMC2 Map 密码 / QMC2 RC4 变体 / tc_tea(TEA 变体 + 自定义 CBC)
- [x] 第①层:QTag 与 V1 尾部 ekey 提取 → **离线解密**
- [x] `decrypt/scan.rs`:递归扫描 + 内容优先的平台路由 + 保留相对目录结构
- [x] **文件夹批量**:`folder` / `root` / `in_place` 三个参数 + `music_decrypt_scan` 预览命令
- [x] `decrypt/common.rs`:两引擎统一的错误类型、魔数定格式、同名去重、读满一块
- [x] 单测 **56 项**(模块合计 174 项全库通过),含参考实现的原始测试向量
- [ ] 第②层 musicex + `GetEVkey` API(**未实施**,见 P1c)
- [ ] 真实 `.mflac/.mgg/.qmcflac` 样本自测(需人工;仓库内不放版权样本)
**已交付文件(P1a 增量)**:
| 文件 | 内容 |
|---|---|
| `src-tauri/src/music/decrypt/qmc.rs` | QMC 全套离线算法 + 尾部形态判定 |
| `src-tauri/src/music/decrypt/scan.rs` | 文件夹递归扫描与平台路由 |
| `src-tauri/src/music/decrypt/common.rs` | 两引擎公共件 |
**算法来源(全部宽松许可,均有原始向量锁行为)**:
| 部分 | 来源 | 许可 |
|---|---|---|
| QMC1 静态密钥表 + 掩码规则 | `jixunmoe/qmc-decode` | MIT |
| QMC2 密钥派生 / Map / RC4 / 尾部形态 | `bczhc/qmc-dec`(`qmc2-crypto`) | Apache-2.0 |
| tc_tea | `tc_tea` crate | MIT/Apache-2.0 |
### P1b — Frida 兜底(按需,不计入本轮)
- [ ] `qq_decrypt.py`(`include_str!`):attach → `EncAndDesMediaFile` 调用序列 → 批量 → JSON-Lines 进度
- [ ] `decrypt/qq_frida.rs`:前置检查、spawn、逐行读转发事件
- **触发条件**:仅当 §3.2 的第③层文件在真实用户场景中被确认存在且前两层无法覆盖时才做
### P1c — musicex 联网取 ekey(**✅ 已实施**)
- [x] `qq_footer.rs`:musicex 尾部解析(song_id / media_mid / filename)
- [x] `qq_credentials.rs`:读 `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 的 `uin` + 扫进程内存取 `authst`
- [x] `qq_memscan.rs`(Windows):`CreateToolhelp32Snapshot` + `OpenProcess` + `VirtualQueryEx` + `ReadProcessMemory`(**只读**)
- [x] `qq_ekey.rs`:`GetEVkey` 请求组装与响应解析(`filename` 带扩展名 / `songtype=1` / `platform="27"`)
- [x] `qq_online.rs`:编排 + `probe_status()` 在线能力探测
- [x] `music_decrypt_qq_status` 命令 + UI 状态卡(含**逐步操作说明**)
- [x] `windows-sys` 增开 `Win32_System_Diagnostics_ToolHelp` 与 `..._Debug`
- [x] **本机实测**:`probe_status()` 返回 `running=true logged_in=true uin=1154027699 ready=true` —— 内存扫描确实取到了 `authst`
- [x] **端到端已用真机样本跑通**(2026-09-27,见下)
#### 真机端到端验证记录(首个 musicex 样本)
样本:`C:\Users\Administrator\Music\Heaven - Avicii_EM.mflac`(197,104,516 字节,
尾部 `musicex\0`,`song_id=233102682`,`media_mid=003iTvi44A6RMs`,
`filename=AIM0002ELI6a1wXJDo.mflac`)
| 环节 | 实测结果 |
|---|---|
| 尾部解析 | song_id / quality1=2 / quality2=11 / media_mid / filename 全部正确 |
| 凭据 | 返回 `running=true logged_in=true uin=1154027699 ready=true` |
| `GetEVkey` | **成功**,拿到 704 字符 ekey;`expiration=80400`(22.3 小时,与文档一致) |
| ekey → 密钥 | 解密出 **512 字节**原始密钥 → 命中 **RC4 变体**(>300 字节)分支 |
| 音频段 | 197,104,324 字节(= 文件大小 − 192 字节尾部,完全吻合) |
| 解密结果 | 首帧 `66 4c 61 43` = **`fLaC`** ✅ |
| 产物校验(`lofty`) | **277.261 秒 · 192000 Hz · 24 bit · 2 声道 · 5686 kbps** —— 192kHz/24bit Hi-Res 无损 |
**验证方式**:`examples/decrypt_musicex_probe.rs` 走真实链路(读内存凭据 → 真实
HTTP 请求 → 解密),再用 `examples/verify_audio.rs` 交给项目同款解析器确认产物合法。
两个 example 都保留,供后续 QQ 改协议时快速定位。
**这次验证推翻了一个错误假设**:样本的密文头是 `51 74 03 75`,**不是**文档里提到的
`#!Qk`。原先按"密文必须以 `#!Qk` 开头"写的守卫会把完全合法的文件误拒——已改为
**用解密结果判定**(解出的前 16 字节是否为已知音频魔术),见 §6.38。
**凭据可用性已知限制**:
| 维度 | 情况 |
|---|---|
| `uin` 来源 | INI 明文,稳定 |
| `authst` 来源 | 仅运行期内存;**QQ 音乐必须开着且已登录** |
| 有效期 | 约 22.3 小时(响应 `expiration` 字段,已带进产物备注) |
| 权限 | 读他人进程内存可能需管理员;失败文案已提示 |
| 是否注入 | **否**,纯只读——这是它与 Frida 兜底的本质区别 |
### P2 — 按需增强(不进本轮)
- **ID3 / FLAC / MP4 标签回填**(用 `lofty`,按容器分派;meta JSON 已在解密时解析出来)
- 解密完成 →「加入本地曲库」/ 上传飞牛(复用 `musicUploadStore`)
- 拖拽文件进页签、解密历史持久化
- 酷狗 / 酷我(除非再次明确要求)
- QQ 变体适配(path_sensitive_mflac)
> **变更**:原计划把「封面提取 / ID3 标签回填」一起从 P2 提前到 P0。**实际只提前了封面提取**——
> 封面字节在解析容器时顺手就读出来了,落盘是十几行,且不做就"能播但难用"。
> 标签回填仍留 P2:它需要 `lofty` 且要按 mp3/flac/m4a 分派容器,属于增强而非可用性门槛。
---
## 8. 风险与开放问题
| 风险 | 影响 | 对策 |
|---|---|---|
| QQ 改 musicex 尾部/API 协议 | 第②层失效 | 协议字段集中在 `qq_footer` / `qq_ekey` 两处;错误文案带原始响应码;关注 qmc-decoder issue |
| `authst` 提取被安全软件拦截 | 第②层失效 | **只读**内存、不注入;失败给"以管理员身份运行"出口 |
| **musicex 端到端** | ~~真实响应字段可能与文档不符~~ **已验证通过**(真机 197MB 样本,产物为合法 192kHz/24bit FLAC) | 保留 `examples/decrypt_musicex_probe.rs` + `verify_audio.rs`,QQ 改协议时可快速定位 |
| `authst` 过期(22.3h) | 第②层短期失效 | 错误文案给"重新登录/重新检测"出口;有效期带进产物备注 |
| QQ 版本升级改 mangled 导出符号 | 仅第③层(Frida)失效 | 子串模糊匹配;第③层不在实施范围,影响面已缩小 |
| 真实样本不足导致算法细节偏差 | 解出错文件 | **已用参考实现的原始测试向量交叉验证**(QMC1 掩码 / Map / RC4 / tc_tea / ekey 端到端) |
| GPLv3 边界被无意破坏 | 许可风险 | 三档口径见 §3.3;QMC 只取 MIT / Apache-2.0 两份来源的**代码与数据** |
| 网易云改 ncm 格式 | 个别文件失败 | per-file error 不中断整批 |
| 同名文件落盘互相覆盖 | **用户文件丢失** | §4.4 同名去重 + 相交保护 |
| 文件夹扫描漏文件(内容认不出) | 用户以为解完了 | UI 先出 `music_decrypt_scan` 预览数量 |
**开放问题**:
1. 解密输出默认就地(文件夹批量)或 `savedir/decrypted/`(散选);独立设置项留 P2。
2. QQ 未运行时是否自动拉起?**离线层与 `.ncm` 完全不需要客户端**;只有 musicex 需要,
当前选择"只提示、不自动拉"(客户端要登录,自动拉起也解决不了登录态)。
3. `.mmp4` 的产物容器(m4a / mp4)待真机样本确认——当前靠首帧 `ftyp` 魔数判定,认不出时按后缀落 `m4a`。
(`.mflac` 已实测确认:产物为 192kHz/24bit 的 `.flac`。)
4. ~~musicex 端到端未验证~~ **已解决**(2026-09-27,真机样本跑通,见 P1c 的验证记录)。
5. `.mflac0` / `.mgg1` 等变体按 QMC2 处理,但**未用真实样本验证**过其尾部形态与 `.mflac` / `.mgg` 一致。
6. 微信登录的 QQ 音乐 (`tmeLoginType=3`):实现上 `authst` 与 QQ 登录通用,
但 `login_type` 目前固定发 `1`(QQ 登录实测可用)——若真机发现微信登录取不到 ekey,需按凭据来源推断。
7. **大文件内存占用**:`qq_online` 目前整段读入内存解密;197MB 实测可用,
但 `.mflac` 可以更大。若遇到多 G 文件,应改流式(`qmc` 的流密码已支持任意偏移)。
---
## 附录 A:参考项目对照(只取思路)
### A.1 QKKDecrypt 实测结论(2026-09-27 深读 `main@938b22d`,来自其源码而非猜测)
**最重要的一条**:该项目 QQ 路径**完全不解析 QMC 加密格式**——它把原始加密文件整包交给 QQ 自己的 DLL 解密,因此不受 static/map cipher 变体影响。**代价是强依赖四项**:QQ 客户端运行 + `QQMusicCommon.dll` 已加载 + **管理员权限**(`cli.py::_require_admin()`,非管理员直接 `return 2` 并打印"已禁止继续使用")+ mangled 名/编译器版本不变。**这四项与它的"回退"一起,正是我们改走 §3.2 分层路由的原因。**
| QKKDecrypt 文件 | 可借鉴 | 不可借鉴 |
|---|---|---|
| `platforms/qq/adapter.py` | `SUPPORTED_SUFFIXES` 仅 `.mflac/.mgg/.mmp4`;前置检查项;ASCII 暂存 |
| `qq/runtime/qqmusic_decrypt.py` | `EncAndDesMediaFile` 的 3 组候选 mangled 名、NativeFunction 全 `thiscall` 签名、调用序(`Memory.alloc(0x28)` → ctor → `allocUtf16String` → `Open(..,1,0)` → `GetSize` → `Read` → dtor) | **硬编码**;整文件读入内存;未校验 `Open`/`Read` 返回值 |
| `qq/runtime/frida_decrypt_gateway.py` | 进程查找用**子串匹配** `"qqmusic"`;**每批次只 attach 一次**并缓存 session | 无 session 重连(QQ 中途重启即失效) |
| `qq/variant_adapter.py` | "路径敏感型 mflac"→**解密前先复制到纯 ASCII 路径**(`pick_safe_tmp_dir`:盘根 `_qqmusic_tmp` → 项目根 → `tempfile.gettempdir()`) | 只实装了这一个变体 |
| `qq/internal_direct.py` / `qq/export_fallback.py` | — | **存在但未接入主流程 = 死代码**,不可当作可用的回退能力承诺 |
| `platforms/netease/adapter.py` | 输出扩展白名单法 | **它没有自研 ncm 算法**——直接 `from ncmdump import NeteaseCloudMusicFile` 委托 PyPI 的 `ncmdump-py`;且 `predicted_extension()` 会**多解密一遍**(性能坑) |
| `Application/decrypt_service.py` | 事件粒度 = **逐文件 `index`/`total`**;`file_finished.result ∈ success/failed/already_decrypted` | 事件种类过多(20+) |
| `cover_art_service.py` | "本地同名图 → 缓存 → 联网"的 local-first 顺序 | **给网易云产物做封面兜底时查的是 QQ 音乐 API** |
| `THIRD_PARTY_LICENSES.md` | 合规口径与风险表述 | 内置 FFmpeg 为 `--enable-gpl --enable-version3` 构建 → 传染面比"仓库 GPLv3"更大 |
**对本文档的两处直接修正**:
1. **"输出扩展名看音频首帧魔数"得到双重印证**——QKKDecrypt 的最终扩展名同样**不取映射表**,而是 `detect_audio_container()` 从实际字节判定(`fLaC`/`OggS`/`RIFF..WAVE`/`ID3`/`0xFF 0xFB|0xF3|0xF2`/偏移 4 处 `ftyp`)。故 §3.2 的输出扩展名表仅作**声明/预期**用,实际以魔数为准。
2. **`.mgg` 解出后它强制归一为 `.m4a`**(`normalize_target_format` 把 `ogg→m4a`)。本项目**不跟**这个行为——`Cargo.toml:112` 已确认 symphonia 默认特性含 `ogg/vorbis`,直接落 `.ogg` 即可播,保持"所见即所得"(§3.1 原口径)。
3. QKKDecrypt 不支持 `.mflac0/.mgg1/.mflac1/.qmc*`——**我们的扩展面比它宽**(§4.3),但格式知识来源是 qmc-decoder 的**文档**(GPLv3,不抄代码)。
### A.2 借鉴到 P0 的一条设计(**最终未采用,附理由**)
QKKDecrypt 的 `file_finished.result` 含 `already_decrypted` 与 `stopped_by_user` 两个态。
**`stopped_by_user` 已采纳**(取消后 `finished.cancelled > 0`,任务落为"已取消")。
**`already_decrypted` 决定不做**:它要判断"某份已存在的产物是否就是本次输入的产物",
在扁平输出目录里只能靠文件名猜,猜错就静默跳过用户的文件——代价大于收益。
P0 改为**永不跳过**:目标名被占用就写 `<名>_1.<ext>`,宁可多一份产物也不丢工作。
(`ncm::unique_output` 同时处理"磁盘上已存在"与"本批次内已占用"两种情况。)
+303
View File
@@ -0,0 +1,303 @@
# 音乐模块 · 手机端连接与控制规划(Music Remote Plan)
> 状态:**规划中**(未开始实施)
> 定位:音乐模块的"手机互联"子能力,不是独立模块——挂靠 `music` 模块,Rust 侧新增 `music/remote/` 子系统
> 日期:2026-09-25
> 关联文档:`AI_DEV_GUIDE.md`(模块注册 / IPC 范式——注意其未涵盖 specta,绑定范例见 `lib.rs` 的 `export_bindings()`)、`TERMINAL_MODULE_PLAN.md`(规划文档范式)
> 对端文档:`F:\AtieProject\LFMusic\PLAN.md`(手机端 LFMusic 的功能与实现规划,协议以本文 §4(协议)/ §5(实现)为准)
---
## 0. 结论先行
四个关键判断,先摆在这里,后文展开论证:
1. **"获取电脑端正在播放的内容(不管是不是 Thing 播的)"必须走 GSMTC**(`GlobalSystemMediaTransportControlsSessionManager`),而不是扩展现有的 `smtc.rs`。`smtc.rs` 以"Thing → 系统"的元数据/进度上报为主(`ISystemMediaTransportControlsInterop::GetForWindow`),并经 `TypedEventHandler` 接收系统按钮回传(双向)——但它只管自己这条会话;要读到**系统里所有应用的媒体会话**(网易云、QQ 音乐、浏览器、Thing 自己……),唯一官方通道是 GSMTC 的全局会话管理器。两者方向相反、互不冲突,`smtc.rs` 原样保留。
2. **控制链路统一走 GSMTC 的 `Try*Async`,Thing 自己不特殊处理**。手机发的播放/暂停/切歌 → Thing 的 GSMTC 调用 → 系统把按钮事件派发给目标会话。Thing 自己因为已在 `smtc.rs` 注册了 SMTC 会话并有按钮事件回传链路(`music-smtc-button` → 前端执行),这条环路是现成的,**对 Thing 自身会话近乎零新增执行代码**(需补的是 cmd-ack 语义与派发时序定义,见 §4.2 / §5.2)。不要为 Thing 自建"直通 AudioEngine"的旁路——多一条路径就多一类不一致(P1 若延迟体感明显再优化)。
3. **局域网服务用 axum(已有依赖)新增 HTTP + WebSocket 双通道,发现用"电脑广播 beacon + 手动扫码"双保险**。axum 已在 `download_engine/server.rs` 和 `feiniu/proxy.rs` 两处落地,范式现成。发现协议不选 mDNS 做 P0 主路径:Android/iOS 的 mDNS 栈碎片化、路由器 AP 隔离下失效、iOS 后台受限;而电脑端周期性 UDP 广播 + 手机被动监听实现最简、权限最友好,配合二维码手动配对兜底已覆盖 99% 场景。mDNS 降级为 P1 增强。
4. **安全按"配对制"设计,不做裸奔**。首次连接用一次性配对码(Thing 弹窗展示,手机扫码/手输),换取长期设备 token;token 两侧持久化(Thing 侧入 keyring,手机侧入系统安全存储),后续连接 WS 握手鉴权,设置页可随时撤销设备。局域网明文 HTTP 在 P0 可接受(风险面:同网段已配对 token 泄露才会被利用),TLS 自签放 P2。
**工作量估算**:P0(系统会话捕获 + LAN 服务 + 发现配对 + 基础遥控)约 6~9 个工作日;P1(mDNS、多会话切换、系统音量、投播)约 5~8 个工作日;P2(TLS、队列投播完善)按需。
---
## 1. 需求解构
用户需求拆成可执行的规格:
| 用户原话 | 解构为 | 落点 |
|---|---|---|
| 「手机端 app 打开后自动连接局域网电脑上的 Thing」 | 电脑端局域网服务(HTTP+WS)+ 自动发现(UDP beacon)+ 配对与鉴权 | §3.2 / §3.3 / §3.4 |
| 「可以获取到电脑端正在播放的内容(不管是 Thing 自己播放的,或是其他应用播放的)」 | GSMTC 全局会话监视:当前活跃会话的元数据、进度、播放状态、封面 | §3.1 / §5.2 |
| 「显示例如歌曲名,歌手,专辑,封面,进度」 | `NowPlaying` 状态模型 + WS 增量推送 + 封面 HTTP 端点 | §4 / §5.2 |
| 「控制等等」 | 播放/暂停/上一首/下一首/seek/停止,走 GSMTC `Try*Async`;音量 P1 | §3.1 / §5.3 |
| (自然延伸,非本次明说) | 投播:手机选歌 → 电脑播放(Thing 曲库播放队列控制) | §7 P2 |
| 「打开后自动连接」的边界 | 首次需用户在电脑设置页点「连接手机」弹出配对码/二维码,5 分钟内完成一次配对;此后已配对设备才自动重连 | §3.4 / 对端文档 §5.1 |
---
## 2. 现状勘察(2026-09-25 从仓库实际读取)
### 2.1 已具备的基建(直接复用)
| 能力 | 现有实现 | 本功能可复用的部分 |
|---|---|---|
| 播放引擎 | `music/audio/engine.rs`:`AudioEngine`(symphonia + cpal/WASAPI 独立线程),`AudioState` 快照 + `music-audio-ended` / `music-audio-error` 事件 | Thing 自身播放状态的事实来源;封面/元数据兜底可直读播放队列 |
| SMTC 上报 | `music/smtc.rs`:`SmtcController`(GetForWindow 全字段上报 + 系统按钮事件 `music-smtc-button` 回传前端) | **零改动保留**;它让 Thing 拥有一条标准 SMTC 会话,GSMTC 控制才能作用到 Thing 自己 |
| HTTP 服务范式 | `download_engine/server.rs`、`feiniu/proxy.rs` 均为 axum + `tokio::net` | 新 LAN 服务照抄此范式(`axum::serve` + tokio) |
| WebSocket | `tokio-tungstenite 0.24` 已在依赖树 | 备选;WS 通道直接用 axum 的 `ws` feature 更统一 |
| 凭据存储 | `secrets.rs`(keyring + Windows 凭据管理器)、`music/secrets.rs` | 设备 token / 配对密钥持久化 |
| 类型绑定 | tauri-specta 自动生成 `src/lib/bindings.ts` | remote 命令与消息类型走 specta,前端零手写类型 |
| 设置持久化 | `MusicManager::load_settings / save_settings`(settings.json + 500ms 缓存) | remote 开关/端口等设置项追加到 `MusicSettings` |
| 日志 | `logger.rs` 统一日志 | remote 全链路日志 |
### 2.2 关键缺口(需新增)
| 缺口 | 现状 | 方案 |
|---|---|---|
| 系统媒体会话读取 | 无。`windows` crate 未开 `Media_Control` feature | 开启 feature,新增 `music/remote/glsmtc.rs`(见 §3.1) |
| 局域网服务 | axum 仅用于本机/代理场景,无对外 LAN 端点 | 新增 `music/remote/server.rs`,监听 `0.0.0.0` |
| 设备发现 | 无 | 新增 `music/remote/discovery.rs`(UDP beacon) |
| 配对与设备管理 | 无 | 新增 `music/remote/pairing.rs` |
| 二维码渲染 | 无 | 前端引入 `qrcode`/`qr-code-styling`(纯前端生成即可) |
---
## 3. 技术选型
### 3.1 系统媒体捕获:GSMTC
Windows 10 1809+ 的 `Windows.Media.Control` 命名空间是**唯一**能枚举/监视/控制系统全部 SMTC 会话的公开 API。凡是有标准系统集成(SMTC)的播放器——网易云、QQ 音乐、foobar2000、浏览器、以及 Thing 自己——都会出现在会话列表里。
Rust 侧路径:`windows` crate(当前 0.52)增加 `"Media_Control"` feature,类型位于 `windows::Media::Control`:
```rust
use windows::Media::Control::{
GlobalSystemMediaTransportControlsSessionManager,
GlobalSystemMediaTransportControlsSession,
};
```
核心 API 清单:
| API | 用途 |
|---|---|
| `SessionManager::RequestAsync()` | 取全局管理器单例(惰性初始化,失败则整个能力降级关闭) |
| `manager.GetSessions()` | 枚举所有会话——**同步**返回 `IVectorView`(0.52 投影无 Async 版本,计划原文 `GetSessionsAsync` 有误,以实测为准) |
| `manager.GetCurrentSession()` | 当前"活跃"会话(系统自动判定:最近操作的会话);**同步**,无会话时 ABI 返回 null → windows-rs 投影为 `Err(E_POINTER)`,按"无会话"分支处理。**实测修正:WinRT 没有 `SetCurrentSessionAsync`**——P1 多会话切换采用 Thing 侧"选中覆盖"(§7),不修改系统判定 |
| `session.SourceAppUserModelId` | 来源应用标识(用于显示"正在播放的应用",也作为会话 key) |
| `session.TryGetMediaPropertiesAsync()` | 元数据:Title / Artist / AlbumTitle / AlbumArtist / **Thumbnail** |
| `session.GetTimelineProperties()` | Position / EndTime / **LastUpdatedTime**(进度推算基准,见 §6.4) |
| `session.GetPlaybackInfo()` | PlaybackStatus / Controls(`IsPlayEnabled` 等能力位)/ PlaybackRate |
| `TryPlayAsync` / `TryPauseAsync` / `TryStopAsync` / `TrySkipNextAsync` / `TrySkipPreviousAsync` | 控制(即手机端全部按钮的实现) |
| `TryChangePlaybackPositionAsync(ticks)` | seek(仅当会话 `IsSeekEnabled`) |
| 事件:`CurrentSessionChanged` / `MediaPropertiesChanged` / `TimelinePropertiesChanged` / `PlaybackInfoChanged` / `SessionsChanged` | 状态变更推送源 |
**线程与套间**(沿用 `smtc.rs` 已验证的范式,但有一处关键差异):
- 初始化(`RequestAsync`)与事件订阅在**主线程**执行(`run_on_main_thread` 抛过去),与 `smtc.rs` 一致。
- **`Try*Async` 的 `.get()` 阻塞等待必须放专用工作线程**,不能在主线程 `.get()`——STA 上阻塞等待 WinRT async 有死锁风险,而 `smtc.rs` 那种"fire-and-forget 更新属性"不涉及等待所以没踩到。设计上:主线程只做"发起",等待统一丢给 `tokio::task::spawn_blocking` 或专用线程。
- 所有 GSMTC 对象是 agile 的,跨线程传引用安全(与 smtc.rs 注释同源结论)。
**失败策略**:与 `smtc.rs` 同哲学——GSMTC 任何一步失败只记日志,不影响播放;GSMTC 初始化失败时整个"远程查看/控制其他应用"能力降级为"仅 Thing 自身"(可从 `AudioEngine.state()` 兜底聚合,见 §5.2)。
### 3.2 局域网服务:axum HTTP + WebSocket
单端口(默认候选 **26124**,被占则 +1 重试至 26139,实际端口写进 beacon 与二维码):
| 端点 | 方法 | 用途 |
|---|---|---|
| `/ws` | GET(Upgrade) | 主通道:鉴权、状态推送(server→client)、控制指令(client→server) |
| `/api/state` | GET | REST 兜底快照(WS 不可用/调试用),Bearer token 鉴权 |
| `/cover/:hash` | GET | 封面字节流(内存缓存,`hash` 由状态推送携带,`?v=` 控制刷新),Bearer token(query 参数 `t=`,`<img>` 标签无法带 header);**访问日志不打印 query**,token 不落日志 |
| `/pair` | POST | 配对:`{ pairingCode, deviceName }` → `{ token, deviceId }` |
WS 承载双向消息(协议见 §4.2);HTTP 承载资源(封面)与低频操作。全部监听 `0.0.0.0`。
**防火墙注意**:首次监听 LAN 端口 Windows 会弹防火墙授权(专用网络勾选即可)。在设置页 remote 开关旁给出说明文案;不做 `netsh` 自动加规则(改系统防火墙属于越权行为,且需要管理员)。
### 3.3 设备发现:UDP beacon(P0 主)+ 扫码兜底(P0)+ mDNS(P1)
| 方案 | 机制 | 判断 |
|---|---|---|
| **UDP beacon(推荐 P0)** | 电脑每 3s 向 `255.255.255.255:26123` 与各网卡定向广播地址发 JSON 包:`{ "service": "thing-music", "deviceId", "name", "port", "protoVer" }`;手机监听 26123 被动收集 | 实现最简(一个 tokio interval + UdpSocket);手机端只需 bind 收包,**Android 免多播权限问题,iOS 不触发 multicast entitlement**(仍会触发本地网络权限弹窗,属正常) |
| 扫码/手输(P0 兜底) | Thing 设置页展示二维码:`thingmusic://connect?ip=…&port=…&code=…`;手机扫码或手输 IP+配对码 | AP 隔离下 beacon 不可达时的最后手段;同时它就是配对入口(见 §3.4) |
| mDNS(P1 增强) | `mdns-sd` crate 注册 `_thingmusic._tcp.local.`,手机 browse | 生态标准、后台发现友好;但依赖各端 mDNS 栈质量,放 P1 不阻塞 |
beacon 里**不含**任何敏感信息(无 token、无配对码),只描述"这里有一个 Thing 音乐服务"。手机端根据 deviceId 去重。
### 3.4 安全与配对
流程(对齐业界遥控 App 的标准做法):
1. 手机端发起配对:beacon 得到 ip:port 后 POST `/pair`,携带 6 位一次性配对码 + 设备名。
2. 配对码由 Thing 侧生成:用户在设置页点击「连接手机」→ 弹窗展示 6 位码 + 二维码(码内含 ip/port/code,扫码即完成 1、2 两步),有效期 5 分钟,一次性。
3. 校验通过 → 生成 32 字节随机 hex 设备 token,返回手机;Thing 侧持久化 `{deviceId, deviceName, token}` 到 keyring(复用 `secrets.rs` 范式),列表落 settings。
4. 后续连接:WS 握手首条消息 `hello { token }`(或 HTTP `Authorization: Bearer`),校验失败 3 次即拉黑该 IP 60s;`/pair` 的配对码校验执行同一限速(防 6 位码爆破,配对响应也只在成功时下发 token)。
5. 设置页设备列表:展示在线/离线、最后连接时间,可撤销(吊销 token)。
P2 增强:自签 TLS(`rcgen` 生成 + `rustls`,二维码里带证书指纹)。P0 明文 HTTP 的风险面评估:同局域网内明文嗅探只能看到 token 之后的媒体元数据;token 本身仅在配对响应中明文传输一次,可接受。
---
## 4. 状态模型与协议设计
### 4.1 `NowPlaying`(核心状态, specta 类型双端共享)
```typescript
interface NowPlaying {
sessionId: string // 会话 key(SourceAppUserModelId;Thing 自身 = "thing.self")
sourceApp: string // 来源应用显示名(AUMID 末段或注册表友好名)
isThing: boolean // 是否 Thing 自身播放(决定封面/元数据兜底来源)
title: string
artist: string
album: string
coverHash: string | null // 封面缓存键;封面从 /cover/:hash 拉
status: 'playing' | 'paused' | 'stopped'
durationSec: number
positionSec: number // 推送时刻的位置
positionUpdatedAtMs: number // 电脑时钟毫秒(源自 TimelineProperties.LastUpdatedTime,见 §6.4);仅供校准,手机端 elapsed 一律以本地收包时刻起算(见 §6.10)
playbackRate: number
canControl: { play: boolean; pause: boolean; next: boolean; prev: boolean; seek: boolean }
deviceId: string // 电脑标识(多电脑预留)
}
```
### 4.2 WS 消息(JSON,`type` 字段区分)
| 方向 | type | 载荷 | 时机 |
|---|---|---|---|
| c→s | `hello` | `{ token, deviceName, protoVer }` | 连接后首条;失败即断开 |
| s→c | `welcome` | `{ deviceId, deviceName, protoVer }` | 鉴权通过 |
| s→c | `state` | `NowPlaying`(全量) | 连接后、以及任何变更(见 §6.3 节流;**由 `cmd` 触发的变更立即推一帧,绕过节流**) |
| c→s | `cmd` | `{ id, action, args? }`,action ∈ `play / pause / toggle / next / prev / stop / seek(posSec)` | 用户操作 |
| s→c | `cmd-ack` | `{ id, ok, error? }` | 回执语义 = **"指令已被接受/派发"**(GSMTC 路径 = Try*Async 完成;前端兜底路径 = 事件已投递),不代表播放状态已切换;UI 轻提示,真实状态以随后的 `state` 为准 |
| c→s | `ping` / s→c `pong` | `{ ts }` | 30s 心跳,双向判活 |
版本策略:`protoVer` 从 1 起,不匹配时 `welcome` 带最新版本号,手机端提示升级。
---
## 5. 架构与模块设计
### 5.1 Rust 侧:`src-tauri/src/music/remote/`
```
src-tauri/src/music/remote/
├── mod.rs # RemoteManager:manage() 进 State;启动/停止服务与 beacon;开关状态
├── server.rs # axum app:路由 /ws /api/state /cover /pair;WS 会话表(fanout 广播)
├── glsmtc.rs # GsmtcMonitor:GSMTC 初始化、事件订阅 → 聚合 NowPlaying → 广播
├── discovery.rs # UdpBeacon:3s 周期广播(255.255.255.255 + 各网卡定向广播)
├── pairing.rs # 配对码生成/校验、设备 token 签发、设备表(keyring + settings)
└── proto.rs # NowPlaying / WS 消息类型(serde + specta,前端 bindings 自动生成)
```
数据流:
```
GSMTC 事件(主线程订阅)──→ GsmtcMonitor 聚合/节流 ──→ Server 广播到全部 WS 客户端
AudioEngine.state()(兜底聚合,isThing 时封面/元数据来源之一)┘
手机 cmd ──→ server.rs ──→ glsmtc.rs(spawn_blocking 调 Try*Async)──→ 系统派发给目标会话
└─ Thing 自身会话:SMTC 按钮 → smtc.rs 既有链路 → 前端 feiniuStore 执行(既有链路,约束见 §5.2)
```
`MusicManager` 增加 `remote: RemoteManager` 字段(或平级 manage,倾向后者,避免 MusicManager 继续膨胀);`lib.rs` 注册 `remote_*` 系列命令:
| 命令 | 用途 |
|---|---|
| `remote_get_config` / `remote_set_enabled` | 开关(MusicSettings 追加 `remote_enabled`、`remote_port`) |
| `remote_status` | 服务状态、端口、在线设备 |
| `remote_start_pairing` | 生成配对码 + 二维码 payload(前端渲染二维码) |
| `remote_cancel_pairing` | 取消 |
| `remote_list_devices` / `remote_revoke_device` | 设备管理 |
### 5.2 双来源聚合规则(GSMTC 为主,AudioEngine 兜底)
- GSMTC 可用:一切以 GSMTC 当前会话为准。Thing 自身播放时它就是一条普通会话(`SourceAppUserModelId` 识别后标 `isThing: true`)。
- GSMTC 无会话但 `AudioEngine` 在播放(GSMTC 初始化失败或会话丢失的兜底):从 `AudioEngine.state()` + 播放队列聚合出 `NowPlaying`(`isThing: true`);控制指令由 server 复用 `music-smtc-button` 事件(同名、同 payload)emit 给前端执行。**既有架构约束**:队列控制逻辑(toggle/next/prev/播放模式)在前端 `feiniuStore`,AudioEngine 本身只有 play/set_playing/seek/stop——兜底路径依赖 WebView 存活,WebView 未就绪时直接回 `cmd-ack { ok: false, error: "frontend-unavailable" }`。
- 两者都无:`status: 'stopped'`,手机端显示"电脑未在播放"。
### 5.3 前端侧
- `src/modules/music/components/settings/RemoteSettings.vue`:总开关、端口、设备列表(在线状态/撤销)、「连接手机」按钮 → 配对码 + 二维码(`qrcode` 库,5s 轮询 status 刷新倒计时/在线态)。
- 状态存放:P0 用 RemoteSettings **组件本地状态**(5s 轮询 `remote_status`),不扩 musicStore——当前无其他消费方;遥控 UI 出现共享需求时再入 store。
- `constants.rs`:`REMOTE_WS_*` 等消息类型常量(如需要);本功能的"事件"主要是 WS 而非 Tauri event,前端基本只走 invoke + bindings。
### 5.4 生命周期
- 随应用启动初始化(不随模块启用——music 默认启用且常驻),`remote_enabled = false` 时仅不启服务/beacon,GSMTC 监视可保持惰性。
- 应用退出:axum graceful shutdown、beacon 停发(`cleanup_on_exit` 挂钩,参照 `MusicManager::cleanup_on_exit` 范式)。
- 系统休眠/网络切换:WS 断开由心跳判活;beacon 无状态持续广播即可,无需额外处理。
---
## 6. 关键实现细节与已知的坑
1. **GSMTC 在非打包桌面应用可用**(unpackaged desktop app 明确支持,1809+)。不要被"WinRT 需要 package identity"的泛泛说法劝退——GSMTC 不在受限之列,开源社区大量此类工具可佐证。**2026-09-25 已实证**:`examples/gsmtc_probe.rs`(unpackaged 控制台进程)跑通,读到当前会话元数据/状态/时间轴,核心假设成立。
2. **封面(Thumbnail)是 `RandomAccessStreamReference`**:`OpenReadAsync()` → 按 `ContentType`(image/png|jpeg)读全量字节 → 以 `hash(sourceApp + title + album + 尺寸)` 为键存内存 LRU(上限 ~20 张)。推送里只带 `coverHash`,封面走 HTTP 拉取,避免 WS 帧被几百 KB 图片打爆。
3. **事件风暴节流**:`TimelinePropertiesChanged` 在部分播放器上高频触发(每次内部时钟更新都发)。聚合层统一节流:任何状态变更合并后**最快 1Hz** 推送 `state`;进度靠手机端 `positionSec + elapsed` 本地推算(`status=playing` 时每秒 +1,收到新 `state` 校准),不依赖高频推送。**例外**:由 `cmd` 触发的状态变更立即推一帧(绕过 1Hz 节流),避免按钮"没反应"的体感——节流仅约束进度等自然高频变更。
4. **进度推算基准用 `TimelineProperties.LastUpdatedTime`**,不要用"收到事件的本地时刻"——事件分发有延迟,`LastUpdatedTime` 是播放器侧的权威时间戳。(本条约束 **Thing 侧**把 GSMTC 事件组装成 `positionSec/positionUpdatedAtMs` 的动作;**手机侧** elapsed 的起算基准见 §6.10,两层不要混用。)
5. **会话 key 的稳定性**:GSMTC 无显式 sessionId,用 `SourceAppUserModelId` 作 key;同一应用双会话(极少见)时后者覆盖前者,P1 的多会话切换再处理。
6. **`Try*Async` 的返回值不可全信**:部分播放器对不可用操作静默成功,回执只做 UI 轻提示,真实状态以下一帧 `state` 为准(`canControl` 能力位已尽力过滤)。
7. **AUMID → 友好名**:`SourceAppUserModelId` 是 `PackageFamilyName!App` 或注册表 AUMID,显示名需查 `Get-StartApps` 等价逻辑(注册表 `HKCU\Software\Classes\AppUserModelId`);先显示末段兜底,友好名缓存 LRU。
8. **防火墙弹窗只出现一次**(每个 exe 路径 × 网络类型),开发期 `tauri dev` 与正式版 exe 路径不同会各弹一次,属预期。
9. **Windows 通知区域"媒体"浮层与 GSMTC 互不干扰**:`smtc.rs` 的上报会话照常工作;手机控制 Thing 自身时,系统面板同步可见,是 feature 不是 bug。
10. **进度推算的时钟基准分两层,不要混用**:Thing 侧组装 `positionSec/positionUpdatedAtMs` 用 `TimelineProperties.LastUpdatedTime`(§6.4);手机侧 `elapsed` **一律以本地收到该条 `state` 的时刻起算**,禁止拿 `positionUpdatedAtMs` 与手机本机时间直接做差——电脑时钟偏差(手动对时/休眠漂移可差数秒以上)会整体拖偏进度条。手机端检测到两端时钟偏差 >5s 时冻结推算、只显示基准值,等待下一条 `state` 校准。两端时钟正常时(NTP 同步)此方案残差 ≤ 推送延迟(LAN 上 <1s,且播放中 ~1Hz 校准)。
---
## 7. 分阶段计划
### P0:可用版本(目标:手机能看到并控制电脑当前播放)
- [x] `windows` crate 开 `Media_Control` feature;10 行探测 demo 验证 GSMTC 在本机可用 —— **2026-09-25 实测通过**(`examples/gsmtc_probe.rs`,unpackaged 控制台进程:读到 1 会话 + 元数据/状态/时间轴全通;注意 `GetSessions`/`GetCurrentSession` 是同步 API,见 §3.1)
- [x] `remote/proto.rs`:类型定义(serde,未进 specta——WS 对端是手机,Thing 前端不消费)+ 单测(序列化往返/时间换算/会话 key)——**2026-09-26 完成,8 单测全绿**
- [x] `remote/glsmtc.rs`:初始化、事件订阅、`NowPlaying` 聚合、封面 LRU、节流(1Hz + cmd Force 例外)——**完成**;订阅 P0 只挂 Manager 级两事件 + 500ms 节拍轮询(会话级事件需随会话订阅/退订,列入 P1)
- [x] `remote/server.rs`:axum 路由 + WS 会话表 + 广播 + 心跳判活 + Bearer/hello 鉴权(+ /pair 限速、封面 token 走 query)——**完成**
- [x] `remote/discovery.rs`:UDP beacon(GetAdaptersAddresses 各网卡定向广播)——**完成**
- [x] `remote/pairing.rs`:配对码 + token 签发 + 设备表(keyring `music-remote-token-*`)——**完成**(单测含限速)
- [x] 控制指令:play/pause/toggle/next/prev/stop/seek → `Try*Async`(spawn_blocking);**Thing 自身 seek 直通 AudioEngine**(SMTC 回环无 seek 通道)——**完成**
- [x] 命令注册(collect_commands + generate_handler 双处)+ `RemoteSettings.vue`(开关/配对二维码/设备列表;qrcode 库前端生成)——**完成**;改为组件本地状态,不扩 musicStore(当前无其他消费方,需要时再入 store)
- [x] `AudioEngine` 兜底聚合(+ `SmtcMetaCache` 回填标题/歌手/专辑)——**完成**
- [x] 运行时冒烟(2026-09-26):自启绑定 `0.0.0.0:26124` ✓、beacon 实收(`addrs=["192.168.110.40"]`、deviceId 落盘)✓、`/api/state` 401 ✓、`/pair` 错码 403 ✓、日志「GSMTC 已初始化(专用线程 MTA)」✓、运行时 bindings 导出含 remote 命令 ✓
- [x] 联调:**真机 E2E 完成(2026-09-26)**——LFMusic 真机客户端全流程实测:配对码 142919 → `/pair` 成功(192.168.110.27)→ WS hello 鉴权 → state 推送(封面/元数据/thing.self/能力位)→ 播放暂停上下首控制生效 → App 重启后自动重连。过程修复:手机端 deviceId 语义(存电脑 id 而非 Thing 分配的行 id)与对端显示名两处关联 bug
- [ ] P0 验收口径(联调时执行):遥控界面显示 GSMTC `GetCurrentSession` 判定的活跃会话("最近操作"语义,多会话切换只留 UI 入口);进度推算按 §6.10 时钟基准联调;`cmd` 后 1s 内看到状态变化
### P1:体验完善 —— **2026-09-26 除两项暂缓外全部完成**
- [ ] mDNS 发现(mdns-sd 注册 `_thingmusic._tcp`)——**暂缓**:beacon 在目标网络 100% 可用且扫码兜底已覆盖;双端 mDNS(含 Android MulticastLock/Kotlin 桥)成本高、当前无失效场景驱动,等 beacon 实际失效案例再做
- [x] 多会话列表与手动切换——**完成**:`sessions` WS 消息(watch 变化推送 + 连接首帧)+ `select` 动作(**WinRT 无 SetCurrentSession,实测修正**:Thing 侧选中覆盖,空 id = 跟随系统 current;选中会话消失自动回落);手机端 chips UI(高亮 `isCurrent`)+「跟随系统」
- [x] **会话级事件精细化订阅**——**完成**:`SessionSubs` 随目标会话换绑 `MediaPropertiesChanged`/`TimelinePropertiesChanged`/`PlaybackInfoChanged`(切换时先退订后订阅,线程退出统一清理);Manager 级两事件 + 500ms 节拍轮询保留为保底
- [x] 系统音量控制 + 手机端音量条——**完成**:`volume.rs`(MMDevice → `IAudioEndpointVolume`,每次现取 COM 对象避免 Send/Sync 争议);监视线程 500ms 轮询进 `NowPlaying.volume/muted`(指纹纳入、变化即推);`volume` 动作 0~1、**>0 自动解除静音**;手机端 🔊 音量条(松手发送)
- [x] Thing 直通控制路径评估——**评估结论:落地直通**:`isThing` 按钮类指令直接 emit `music-smtc-button`(跳过 GSMTC→系统→SMTC 回环,少一跳系统派发延迟);seek 本就直通 AudioEngine;非 Thing 会话仍走 GSMTC `Try*Async`。系统面板同步不受影响(面板状态由前端持续上报 smtc.rs)。**真机复测**:非 Thing 路径(QQMusic 播放恢复)通过;isThing 直通与 P0 事件链同码,待 Thing 下次自身播放时自然覆盖
- [x] AUMID 友好名缓存、封面本地持久化缓存——**完成**:`friendly_name`(`HKCU\Software\Classes\AppUserModelId\<aumid>\DisplayName` 查询 + 128 条缓存,查不到退回 AUMID 简化段;路径形 AUMID 跳过注册表);`CoverStore` 写透 `{app_data}/remote_covers`(内存+磁盘双层 LRU 各 20 张,冷启动可回源)。**真机复测**:友好名生效(QQMusic / Microsoft.ZuneMusic);持久化目录已创建,落盘写入待下次取到封面时自然验证(当前可见会话均无缩略图)
- [ ] 手机端通知栏/锁屏媒体控件联动(LFMusic 侧 native-audio / MediaSession,见对端文档)——**暂缓**:被 LFMusic M1(集成 `tauri-plugin-native-audio`)阻塞,M1 完成后按对端文档回填
### P2:增强(按需)
- [ ] 自签 TLS(rcgen + rustls,二维码带证书指纹)
- [ ] 投播:手机浏览 Thing 曲库 → 远程下发放进 Thing 播放队列(`/queue` 端点 + AudioEngine 队列 API 暴露)
- [ ] 歌词推送(Thing 已有 lyric 能力,同步到手机端滚动显示)
- [ ] 多电脑:beacon 天然支持,配对表按 deviceId 区分,UI 侧完善
---
## 8. 风险与开放问题
| 风险/问题 | 影响 | 对策 |
|---|---|---|
| GSMTC 某播放器不上报专辑/封面(上报方行为,非 bug) | 手机端显示缺字段 | UI 兜底占位;Thing 自身播放时从曲库元数据补全(lofty 已有) |
| 路由器 AP 隔离导致广播不可达 | 手机发现不了电脑 | 扫码/手输 IP 兜底(P0 已含);mDNS 同样受影响,不是银弹 |
| 防火墙/杀软拦截 LAN 监听 | 手机连不上 | 设置页说明 + 连接失败诊断提示(检测本机端口监听、提示放行) |
| 手机休眠断 WS | 状态不实时 | 心跳 + 重连退避(手机端职责,见对端文档);恢复前台即拉 `/api/state` 快照 |
| `TryChangePlaybackPositionAsync` 部分应用不支持 | seek 无效 | `canControl.seek` 能力位隐藏进度条拖动 |
| 多网段/VPN 虚拟网卡产生杂音 beacon | 发现列表脏数据 | beacon 携带本机各网卡地址,手机端按连通性优选;显示名可区分 |
**开放问题**(实施前确认):
1. 是否需要"电脑端显示已连接手机"的托盘/OSD 提示?(倾向 P1,托盘菜单加一行在线设备数即可)
2. 投播的队列控制 API 形态(P2 前与 LFMusic 端一起定)。
3. 遥控界面是否需要歌词显示?用户需求"显示音乐信息"是否含歌词——Thing 已有 lyric 能力,但"歌词推送"列在 P2,需两端确认是否提前。
4. 音量控制是否提前到 P0?用户"控制电脑端"可能隐含音量——当前计划在 P1(`IAudioEndpointVolume`)。
+190 -2
View File
@@ -1182,11 +1182,192 @@ security / shortcuts)后广播 `terminal-settings`(无负载;`save_setting
| 待真机确认(第四轮 · 死设置) | 关闭「关闭运行中的会话前确认」后关标签不再弹窗;开启「新会话继承当前目录」后新建本地标签落在当前 cwd(SSH 会话下不继承);「选中即复制」选中后剪贴板有内容、「中键粘贴」中键一次只粘一次;关掉「指纹变更时阻断连接」后换过密钥的主机直接连上且日志有 warn;关掉「记录安全事件」后日志不再出现主机密钥事件行;布局页不再有陈旧文案 |
| 待真机确认(第三轮) | 新建/更多菜单可点开、tooltip 正常;独立窗口拖拽/最小化/最大化/关闭;Ctrl+3 从其它应用按下能唤到前台并建出窗口;终端模块禁用后 Ctrl+3 不再占用;深色模式下开窗不再闪白;主窗口改终端配色/字号后独立窗口即时同步;应用切深浅时终端画布一起变 |
### 文件面板三处修复(2026-09-24 第五轮)
用户报三条:文件面板默认宽度太窄;本地栏选完目录不列文件、且路径不可编辑;
**SSH 会话的远端目录读不出来**(红字 `读取目录 \home\Atie 失败: No such file`)。
#### 一、远端目录为什么读不出来(根因在 OSC 7,不在 SFTP)
报错里的路径是 `\home\Atie` —— 反斜杠,而远端是 POSIX 系统。
追到 `shell.rs::parse_osc7`:它把 OSC 7 载荷里的路径**无条件**做了 `/` → `\`
的替换(只有「`^/[A-Za-z]:` 盘符形态」的分支多剥一个前导斜杠,**两个分支都在替换**)。
于是远端 bash 上报的 `/home/Atie` 被存成 `\home\Atie`,文件管理器拿这个字符串去
`read_dir`,服务端当然回 `No such file`。
`ssh/mod.rs` 里那句「远端路径是 POSIX 形态,`parse_osc7` 已按 `^/[A-Za-z]:` 区分,
无需特判」写的是**意图**,而代码只实现了盘符那半边 —— 注释是对的,实现是错的。
这类 bug 的恶果在于三层之隔(OSC 解析 → 会话状态 → SFTP),现象端完全看不出根因。
**修法**:只有盘符形态才动路径(`/C:/Users` → `C:\Users`),其余一律原样返回。
Git Bash / WSL 这类本地上报 POSIX 路径的 shell 同样受益(此前它们的 cwd 也被换成
`\c\Users\...`)。新增单测 `parse_osc7_kind_by_reporter` 锁住四种形态
(远端 POSIX / `file:///` 无主机 / Windows 盘符 / 百分号编码)。
#### 二、默认宽度 420 → 620
420px 是「本地栏只用来选目录」时代的取值:双栏各剩不到 200px,「名称」列连常见文件名
都显示不全。本地栏升级为完整文件管理器后,两栏要给按钮组(5 个图标 + 筛选框,约 250px)
和四列表格留位置,故默认 620px;左右按 **45% / 55%** 分(远端多一列「权限」)。
拖左边缘仍可调宽。
#### 三、本地栏升级为完整文件管理器
原设计(见本文件 §SFTP 与 `SftpPanel.vue` 头部注释)刻意让本地栏只做「定位与选取」,
浏览交给系统资源管理器。这条取舍在「先看看本地有什么、挑几个传上去」的场景下会撞出
断头路:对话框一次选完就没了,不能进目录翻找,也不能就地改名或删除。
现在两栏结构对称,差别只剩两点:本地删除**走回收站**、符号链接的类型由本地解析得到。
| 改动 | 位置 | 说明 |
|---|---|---|
| 新增 `local_fs` 模块(列举 / 建目录 / 重命名 / 删除) | `terminal/local_fs.rs` | 符号链接返回**目标**类型(`metadata()` 免费拿到),`kind` 与远端栏因此可共用同一套判断;`canonicalize` 的 `\\?\` 前缀统一剥掉(否则回传给 `ShellExecuteW`/对话框/上传源路径都不认) |
| 4 个命令走 `spawn_blocking` | `terminal/commands.rs` | 映射网络盘 / 休眠机械盘上 `read_dir` 会阻塞数秒,占住 tokio worker 会拖慢同期的终端输出 |
| 删除复用 quickpanel 的回收站实现 | `quickpanel::commands::delete_file_impl` 改 `pub(crate)` | 这类实现最怕的是「某一份漏掉回收站语义变成永久删除」,差异没人会比对 |
| **盘符根不可删**(硬守卫) | `local_fs::delete` | 面板「上一级」停在 `C:\` 时删除按钮仍可用;不加判断就是递归删驱动器级别的数据事故 |
| 前端:可编辑路径栏 + 主目录 / 系统对话框两个跳转入口 | `SftpPanel.vue` | 手输路径(回车跳转、ESC 回填)与对话框定位并存,深路径与已知路径各取所便 |
| 前端:列表**多选**(`Ctrl` 加减、`Shift` 取范围) | `SftpPanel.vue` | 上传是最高频动作;选中 5 个文件逐个点要 10 次操作 |
| 前端:上传改为「选中项里的文件」;下载到本地目录后刷新本地列表 | `SftpPanel.vue` | 目录递归上传/下载仍属 P2,与远端口径一致(选到目录时按钮禁用并给出原因) |
顺带统一两栏工具条的「重命名」图标(此前是一个文件图标,语义不对)。
#### 验证
| 检查 | 结果 |
|---|---|
| `vue-tsc --noEmit` | exit 0 |
| `eslint src`(改动文件) | exit 0 |
| `cargo check`(src-tauri) | exit 0 |
| `cargo test --lib` | 108 passed / 0 failed(含新增 3 条:OSC 7 形态、盘符根守卫、主目录列举) |
| 待真机确认 | SSH 会话打开文件面板,远端栏直接列出 `/home/<user>`(不再红字报错);本地栏默认落在用户主目录、可双击进目录、可手输路径跳转、可新建/重命名、删除进了回收站;选中多个文件点「上传」全部传完;拖宽面板后两栏列宽正常 |
### 文件管理器改版:从会话面板到独立页(2026-09-24 第六轮)
上一轮把面板默认宽度加到 620px 之后,反馈仍是「还是有些小」。根因不在宽度:
面板长在终端卡片右侧,**它的宽度只能从终端画布里抢**,而双栏文件管理器需要的是
一整页。因此改成模块级的一页,并顺手把「一次只服务一个会话」这个限制去掉。
#### 一、形态:终端卡片里的面板 → 模块「文件」页 + 独立窗口
| 项 | 旧 | 新 |
|---|---|---|
| 位置 | 终端卡片右侧的 `<aside>`(宽度 620,可拖) | 模块 Tabs 的「文件」页(终端 · **文件** · 主机 · 密钥 · 设置);另有单例独立窗口 |
| 分栏 | 本地 ↔ 当前会话(唯一组合) | 左右各 50%,**每栏各自选连接**(本地 / 任一已连接 SSH),组合为 本地↔ssh1、ssh1↔ssh2、ssh1↔ssh1(同机跨目录) |
| 无 SSH 时 | 面板不可打开(`canShowSftp`) | 左栏本地、右栏空态提示;连上主机后右栏自动补上第一个会话 |
| 路径行 | 本地显示只读文本、远端显示面包屑 | 统一**可编辑输入框**(回车跳转、ESC 还原)。取舍:远端丢了逐级点击,换来两栏同一心智模型(Explorer 地址栏)与「本地可编辑」这条诉求 |
| 传输 | 左栏「上传」+ 右栏「下载到本地目录」 | 每栏底部一个**方向式**按钮(箭头指向另一栏,文案随组合变化:上传到远端 / 下载到本地 / 中继到远端) |
| 「跟随 cd」 | 跟随终端页当前激活会话(面板绑会话) | 跟随**本栏所选会话**的 cwd(多栏各自独立) |
| 入口 | 控制栏「更多」菜单里的「显示/隐藏文件面板」 | 控制栏**外露**的文件图标:终端页 → 跳到「文件」页并预选当前会话;终端独立窗口 → 打开/唤出文件窗口。快捷键 `Ctrl+Shift+P` 的 action id 仍叫 `toggleSftp`(改名会让用户已有的绑定失效),行为已改为跳页 |
#### 二、SSH → SSH 传输:流式中继(新增后端能力)
双远端传输是这次改版带来的**新组合**,原有两条命令(`sftp_upload` 需本地源、
`sftp_download` 需本地目标)都不适用。三条路里选了**流式中继**:
| 方案 | 为什么不选 |
|---|---|
| 下载到本地临时目录再上传 | 本地磁盘要 ≥ 文件大小、链路走两遍、临时文件清理还要再定一套规则 |
| 只浏览不传 | 用户明确要 ssh1 ↔ ssh2 |
| **流式中继**(选中) | 从源会话读 32KB 块直接写进目标会话,本地只留一个缓冲;新增 `relay_file` + `terminal_sftp_relay` |
两处刻意的取舍:**只取目标侧的并发许可**(同时占源、目标两把信号量会在双向中继
并发时成环);**不做断点续传**(两端都不在本地,没有可信的进度锚点,目标一律
`TRUNCATE` 重写 —— 宁可重传也不能写出一半新一半旧的损坏文件)。
#### 三、独立文件窗口(单例)
`FileWindow.vue` + `terminal_file_window_open`,label 固定 `file-window`
(新增 `capabilities/file-window.json`)。与终端独立窗口的关系是**刻意的不对称**:
终端窗口的粒度是会话(一会话一窗口),文件窗口的粒度是「两台机器之间的关系」,
因此它不绑会话,也就**只能是单例** —— 开第二个只会显示同一份状态。
窗口由 Rust 隐藏创建,前端应用主题后再显示(与同模块其它窗口同一套)。
#### 四、SFTP 通道生命周期变了:按需打开、不再主动关
旧规则是「面板打开 → open,面板关闭 → close」。现在同一会话的通道可能被
**两个窗口**同时使用(文件页 + 文件窗口),谁先切走就 close 会让另一个窗口
直接报「尚未打开」。新规则:进入某栏的 ssh 来源时确保打开(幂等),
关闭只发生在**会话结束时**(Rust 随会话回收)。因此前端不再调用
`terminal_sftp_close` / `terminal_sftp_is_open`(两个命令保留在命令层)。
#### 五、代码落点
| 文件 | 变化 |
|---|---|
| `components/FilePane.vue`(新) | 单栏组件:本地与远端**合成一套代码**(差异只剩「调用哪条命令 / 路径怎么拼 / 删除是什么语义」),含连接选择器、多选、增删改 |
| `components/FileManager.vue`(新) | 双栏容器:连接组合 → 传输方向的编排、传输进度条、默认分栏与失效连接的收敛 |
| `FileWindow.vue`(新)+ `main.ts` | 独立窗口入口(`#file-window`) |
| `fileUtils.ts`(新) | 路径拼接(`joinLocal` / `joinRemote`)与展示工具。**单独抽出来**是因为它要被三处用,而拼错路径是静默错误(`C:\dir\/name` 只在服务端报 `No such file` 时才暴露) |
| `components/SftpPanel.vue` | **删除**(逻辑已并入 FilePane / FileManager) |
| `stores/terminalStore.ts` | 新增 `filePaneSources`(两栏连接,放 store 才能在 tab 切走再回来时保住)、`sftpRelay`、`openFileWindow`;删除 `sftpClose` / `sftpIsOpen` |
| `terminal/window.rs`、`ssh/sftp.rs` | `open_file_window`(单例幂等)、`relay_file`(流式中继) |
#### 验证
| 检查 | 结果 |
|---|---|
| `cargo check`(src-tauri) | exit 0(新增 capability 已被 tauri-build 收进 `capabilities.json`) |
| `cargo test --lib` | 108 passed / 0 failed |
| `vue-tsc --noEmit` | exit 0 |
| `eslint src`(改动文件) | exit 0 |
| 待真机确认 | 「文件」页左本地 / 右第一个 SSH;两栏可各自切到任一已连接会话(本地选项在另一栏已是本地时置灰);选中多文件后按方向按钮上传/下载/中继各跑通一次、进度条与完成提示正常;终端控制栏文件按钮跳页并预选当前会话;终端独立窗口的文件按钮打开/唤出文件窗口(第二次是唤出而非新建);Ctrl+Shift+P 同样可用 |
### 文件页布局返工:表格换固定列宽行(2026-09-24 第七轮)
第六轮上线后用户报五条,全部成立,其中一条是**布局缺陷而非审美问题**。
#### 一、名称列被压成 0 宽(真 bug)
截图里「名称」列头与所有文件名都不见了,大小/时间列被挤成 40px 宽、日期折成三行,
列表还多出一条横向滚动条。根因是列表用了 `<table>` + **auto 布局**:
- 表格的 auto 布局按内容**协商**列宽。名称单元格里是 `min-w-0` 的 flex + `truncate`
的文本,这个组合的最小内容宽度是 0,于是协商时名称列被让到 0;
- 大小/时间列的 `w-20` / `w-28` 只是**偏好**宽度,协商中被压到最小内容宽度
(`大小` 两个汉字换行、`2026-05-19` 在连字符处折行);
- 表格的 `w-full` 又要求它撑满容器,两侧要求互相矛盾,最终多出一条横向滚动条。
**改法**:列表不再用表格,改成**定宽 flex 行**(与项目 `DataListRow` 同一套手法):
| 列 | 规则 |
|---|---|
| 名称 | `flex-1 min-w-0` + `truncate` —— 唯一可伸缩的一列 |
| 大小 | `w-[72px] shrink-0` + `whitespace-nowrap tabular-nums` |
| 修改时间 | `w-[76px] shrink-0` + `whitespace-nowrap` |
| 权限(仅远端) | `w-11 shrink-0` + `whitespace-nowrap` |
定宽列没有任何协商空间,宽度不足时只会**挤名称列并截断**,其余列永不变形。
表头与数据行共用同一套列宽,且表头放在滚动区**外面**(不随内容滚动,
也不牵连 sticky 在 reka-ui viewport 里的定位问题)。
顺带把修改时间改成紧凑格式:本年内 `05-19 10:01`、其余 `2024-05-19`,
完整时间戳放悬停提示(`fmtEntryTime` / `fmtFullTime`)。原先一律 `YYYY-MM-DD HH:mm`
在 12px 下要 100px 宽,是定宽列被逼换行的直接原因。
#### 二、其余四条
| 反馈 | 处理 |
|---|---|
| 左右两栏应在一个窗口内、能拖中线改宽度 | 两张 `Card` + `gap-3`(读作「两个窗口并排」)改为**一张 `Card` 内两栏**,中间是命中区 5px、视觉 1px 的可拖分界线;宽度存**百分比**(`filePaneSplit`,存 store 以便切 tab 后仍生效),拖动逻辑挂在 document 上(鼠标划出 5px 命中区不会断) |
| 内部宽度远超容器 | 见上,横向溢出随表格一起消失 |
| 画面大了文字还是很小 | 列表 11px → **12px**、行高 → 32px;工具条/路径行/筛选框 11px → 12px、控件 h-6 → h-7;按钮与图标同步放大一档 |
| 滚动条用 ScrollArea | 列表滚动区改为 `ScrollArea`(项目统一的可视化滚动条)。**注意**:ScrollArea 只有竖向滚动条,横向溢出会被裁掉 —— 所以它同时是「内容必须自适应」的硬约束,与表格改定宽列是同一件事的两面 |
#### 验证
| 检查 | 结果 |
|---|---|
| `vue-tsc --noEmit` / `eslint` | exit 0 |
| 真实组件实测(临时页 = 真 `FileManager` + 真 Tailwind,`window.__TAURI_INTERNALS__.invoke` 喂假数据,视口 1267px) | 名称列 432.5px / 大小 72px / 修改时间 76px;超长文件名 `clientWidth 582 < scrollWidth 692` 且 `text-overflow: ellipsis`(截断生效);大小与时间列 `clientHeight == lineHeight == 16px` 单行;行高 32px、字号 12px;列表 `clientWidth === scrollWidth` → **无横向滚动条** |
| 分界线拖动(同一次实测) | 合成 mousedown/mousemove(+202px)/mouseup 后:左栏 620.5px → 822px(行容器 1241px,即 50% → 66%),右栏同步收窄;拖动后两栏仍 `scrollWidth === clientWidth`,列与截断表现不变 |
> 结论:本轮的布局缺陷已用**实测**(而非推理)确认修复。上一版之所以漏掉,正是因为只跑了类型检查与 lint —— 表格 auto 布局的问题只在真实渲染里才暴露。
## 附:P1 新增命令清单(供前端对接与后续维护)
| 命令 | 参数 | 返回 |
|---|---|---|
| `terminal_sftp_is_open` | `sessionId` | `bool` |
| `terminal_sftp_is_open` | `sessionId` | `bool`(前端已不用:通道按需打开、不主动关,见第六轮) |
| `terminal_sftp_open` | `sessionId` | `ActionOutcome`(幂等) |
| `terminal_sftp_close` | `sessionId` | `()` |
| `terminal_sftp_list` | `sessionId`, `path` | `RemoteDir` |
@@ -1196,10 +1377,16 @@ security / shortcuts)后广播 `terminal-settings`(无负载;`save_setting
| `terminal_sftp_delete` | `sessionId`, `path`, `isDir` | `ActionOutcome` |
| `terminal_sftp_rename` | `sessionId`, `from`, `to` | `()` |
| `terminal_sftp_upload` | `sessionId`, `localPath`, `remotePath` | `ActionOutcome` |
| `terminal_sftp_relay` | `fromSessionId`, `fromPath`, `toSessionId`, `toPath` | `ActionOutcome`(远端→远端流式中继,不经本地磁盘) |
| `terminal_sftp_download` | `sessionId`, `remotePath`, `localPath` | `ActionOutcome` |
| `terminal_file_window_open` | — | `ActionOutcome`(文件窗口,**单例**:已存在则 show + focus) |
| `terminal_session_cwd_value` | `sessionId` | `string` |
| `terminal_open_local_path` | `path` | `()` |
| `terminal_reveal_local_path` | `path` | `()` |
| `terminal_local_list` | `path`(空串 = 用户主目录) | `LocalDir`(`cwd` / `parent`(盘符根为 `null`)/ `entries`) |
| `terminal_local_mkdir` | `path` | `()`(递归创建) |
| `terminal_local_rename` | `from`, `to` | `()` |
| `terminal_local_delete` | `paths: string[]` | `ActionOutcome`(**移入回收站**;部分成功时 `ok=false` 且 message 带成功数,前端按 `ok` 分流提示级别) |
| `terminal_list_snippets` | — | `SnippetView[]` |
| `terminal_save_snippet` | `snippet` | `SnippetView[]` |
| `terminal_delete_snippet` | `snippetId` | `SnippetView[]` |
@@ -1207,7 +1394,8 @@ security / shortcuts)后广播 `terminal-settings`(无负载;`save_setting
| `terminal_run_snippet` | `sessionId`, `snippetId`, `values`, `submit` | `ActionOutcome` |
| `terminal_restore_default_snippets` | — | `SnippetView[]` |
**新增事件**:`terminal-transfer-progress`(负载 `TransferProgress`,200ms 节流)。
**新增事件**:`terminal-transfer-progress`(负载 `TransferProgress`,200ms 节流;
`direction` 取 `upload` / `download` / `relay`,中继事件的 `sessionId` 是**目标**会话)。
### 追加:P1 第四 / 第五批(字符编码 + 命令历史)
+44 -3
View File
@@ -62,8 +62,12 @@ shadcn 既有(值调整) → --background / --foreground / --primary / --c
--card: #FFFFFF; /* 卡片 / 面板 */
--popover: #FFFFFF; /* 浮层 */
--subtle: #F0F0F2; /* 次级填充:搜索框底、分段控件槽、代码块 */
--hover: #EBEBED; /* 幽灵控件 hover */
--hover: #EBEBED; /* 通用中性 hover:按钮、菜单项、数据表、导航 */
--active: #E4E4E7; /* 幽灵控件 active */
--row-hover: #EBF3FB; /* 内容行 hover(= primary 8% 混入 card,随主题色变) */
--row-selected: #D9E8F7; /* 内容行选中(= primary 15% 混入 card) */
--row-hover-veil: color-mix(in srgb, var(--primary) 16%, transparent); /* mica 弹窗行 hover */
--row-selected-veil: color-mix(in srgb, var(--primary) 30%, transparent); /* mica 弹窗行选中 */
/* ── 描边 ───────────────────────────── */
--border: #E4E4E7; /* 卡片外框、输入框 */
@@ -124,6 +128,9 @@ shadcn 既有(值调整) → --background / --foreground / --primary / --c
--subtle: #26262B;
--hover: #2C2C32;
--active: #33333A;
--row-hover: #1F2B3A; /* = primary 11% 混入 card(深色下用更高强度) */
--row-selected: #213E5C; /* = primary 26% 混入 card */
/* --row-*-veil 刻意不在此重写:半透明叠在壁纸上,深浅由 --primary 自动决定 */
--border: #2E2E34;
--border-strong: #3A3A42;
@@ -313,6 +320,11 @@ shadcn 既有(值调整) → --background / --foreground / --primary / --c
深色模式**单独派生一套**(深底上要提亮),不能复用浅色值。
行高亮这一族(`--row-hover` / `--row-selected` / `--row-hover-veil` / `--row-selected-veil`)
**不在这 7 个之内**:它们在 `style.css` 里写成 `color-mix(..., var(--primary) ...)`,
而 `--primary` 的行内覆盖是惰性求值的,所以换主题色时自动跟着变,
不需要进 `theme.ts` 的派生组,也不需要新增断言。
#### 关键技术点
1. **用 OKLCH 做派生,不要用 HSL。**
@@ -592,11 +604,40 @@ useModuleTabs('proxy', activeTab, tabs, { alwaysVisible: true })
| 主按钮 | `--primary-hover`(变深) | `--primary-active` |
| 次按钮 / 卡片 | `--hover`(中性加深) | `--active` |
| 幽灵按钮 / 图标按钮 | `--primary-soft` + `--primary-soft-text` | `--primary-soft` |
| 列表行 / 菜单项 | `--hover` | — |
| 选中行 / 选中 Tab | — | `--primary-soft` |
| 内容列表行 / 选项卡片 | `--row-hover`(主题色弱底) | — |
| mica / acrylic 弹窗内的行(快速面板、托盘菜单) | `--row-hover-veil`(半透明蒙层) | `--row-selected-veil`(按下/光标) |
| 菜单项 / 数据表行 / 导航 / 分段 / 折叠头 | `--hover` | — |
| 选中行 | — | `--row-selected` |
| 选中 Tab | — | `--primary-soft` |
**焦点环**全应用统一:`ring-2 ring-ring/40`。hover ≠ selected:hover 表达"可以点",selected 表达"已经选中",后者才用强调色。
**内容行 vs 通用中性(2026-09 修订)**
`--hover` 与行高亮的分工,不是"哪个好看",而是语义:
| | 用 `--hover`(中性) | 用行高亮(主题色) |
|---|---|---|
| 判断依据 | 控件本身可点,不承载数据对象 | 一行/一卡承载一个**对象**(歌曲、任务、主机、密钥、设备、剪贴项) |
| 典型 | 按钮、菜单项、代理连接表、侧栏、Tab、设置行 | 音乐列表/队列/歌单/搜索结果、任务列表、主机/密钥/shell 卡片、监控设备项、历史命令、剪贴板条目、快速面板与托盘菜单条目 |
**四种值的选择(2×2)**
先问两件事:**是不是"一行一个对象"** → 否则用 `--hover`;**这一行坐在什么底上** → 决定用哪一对:
| 行所在的面 | hover | 选中 |
|---|---|---|
| 不透明(卡片、面板、弹窗自带底色) | `--row-hover` 8% / 11% | `--row-selected` 15% / 26% |
| mica / acrylic 糊化层(行直接画在壁纸上,窗口无自身底色) | `--row-hover-veil` 16% | `--row-selected-veil` 30% |
五条硬约束:
1. **不能全局把 `--hover` 改成主题色**。次按钮 hover 会与幽灵按钮(`--primary-soft`)撞色,菜单项与数据表整片变蓝,按钮层级和"hover 中性"的既有观感一起塌。必须是新增 token 分开用。
2. **行选中不能用 `--primary-soft`**。`--primary-soft` ≈ primary 10% 混白,和 8% 的 `--row-hover` 只差 2 个色阶,悬停已选中项时看不出区别 —— 这就是 `--row-selected`(15%)存在的原因。`--primary-soft` 留给"选中 Tab / 幽灵按钮 hover"。
3. **透明面上的行必须用 veil 而不是不透明色**。不透明浅底在糊化层上会变成一块"贴上去的白块",并盖掉 mica 质感;半透明会与壁纸自然叠合(浅壁纸偏浅、深壁纸偏深),因此 veil 只在 `:root` 定义一次,不在 `.dark` 重写。veil 也明显更重(16% vs 8%)—— 不透明的 8% 放到壁纸上基本看不见;但也不能一路加重,20% 起就偏"罩住"了,16% / 30% 是实测的手感点。
4. **禁止在内容行上继续用 `--accent/40 ~ /60`**。半透明中性灰在白卡上只有 3% 明度差,等于 hover 无效——这是本次修订要清掉的存量问题。
5. **选中态必须显式盖过 hover**。二者的 CSS 特异性经常是平的或反过来:纯 CSS 里 `:hover`((0,2,0))高于单类((0,1,0)),要写 `.sel:hover` 同规则;Vue 里静态的 `hover:bg-row-hover` 不能和条件类的 `bg-row-selected` 并存,必须写成三元互斥(见 `SftpPanel.vue` 文件表格与 `TrackItem.vue`)。
**状态点**
```
+60
View File
@@ -24,6 +24,7 @@
"clsx": "^2.1.1",
"pinia": "^3.0.4",
"pinyin-pro": "^3.28.2",
"qrcode": "^1.5.4",
"reka-ui": "^2.10.1",
"tailwind-merge": "^3.6.0",
"tailwindcss": "^4.3.2",
@@ -34,6 +35,7 @@
"devDependencies": {
"@tauri-apps/cli": "^2",
"@types/node": "^26.1.1",
"@types/qrcode": "^1.5.6",
"@vitejs/plugin-vue": "^5.2.1",
"@vue/eslint-config-typescript": "^14.9.0",
"eslint": "^10.11.0",
@@ -296,6 +298,8 @@
"@types/node": ["@types/node@26.1.1", "https://registry.npmmirror.com/@types/node/-/node-26.1.1.tgz", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-nxAkRSVkN1Y0JC1W8ky/fTfkGsMmcrRsbx+3XoZE+rMOX71kLYTV7fLXpqud1GpbpP5TuffXFqfX7fH2GgZREw=="],
"@types/qrcode": ["@types/qrcode@1.5.6", "https://registry.npmmirror.com/@types/qrcode/-/qrcode-1.5.6.tgz", { "dependencies": { "@types/node": "*" } }, "sha512-te7NQcV2BOvdj2b1hCAHzAoMNuj65kNBMz0KBaxM6c3VGBOhU0dURQKOtH8CFNI/dsKkwlv32p26qYQTWoB5bw=="],
"@types/sortablejs": ["@types/sortablejs@1.15.9", "https://registry.npmmirror.com/@types/sortablejs/-/sortablejs-1.15.9.tgz", {}, "sha512-7HP+rZGE2p886PKV9c9OJzLBI6BBJu1O7lJGYnPyG3fS4/duUCcngkNCjsLwIMV+WMqANe3tt4irrXHSIe68OQ=="],
"@types/web-bluetooth": ["@types/web-bluetooth@0.0.21", "https://registry.npmmirror.com/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz", {}, "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA=="],
@@ -386,6 +390,10 @@
"alien-signals": ["alien-signals@1.0.13", "https://registry.npmmirror.com/alien-signals/-/alien-signals-1.0.13.tgz", {}, "sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg=="],
"ansi-regex": ["ansi-regex@5.0.1", "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
"ansi-styles": ["ansi-styles@4.3.0", "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
"aria-hidden": ["aria-hidden@1.2.6", "https://registry.npmmirror.com/aria-hidden/-/aria-hidden-1.2.6.tgz", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
"balanced-match": ["balanced-match@4.0.4", "https://registry.npmmirror.com/balanced-match/-/balanced-match-4.0.4.tgz", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
@@ -400,10 +408,18 @@
"cacheable": ["cacheable@2.5.0", "https://registry.npmmirror.com/cacheable/-/cacheable-2.5.0.tgz", { "dependencies": { "@cacheable/memory": "^2.2.0", "@cacheable/utils": "^2.5.0", "hookified": "^1.15.0", "keyv": "^5.6.0", "qified": "^0.10.1" } }, "sha512-60cyAOytib/OzBw1JNSoSV/boK1AtHryDIjvVBk7XbN4ugfkM3+Sry7fEjNgPMGgOjuaZPAp8ruZ0Cxafwyq9g=="],
"camelcase": ["camelcase@5.3.1", "https://registry.npmmirror.com/camelcase/-/camelcase-5.3.1.tgz", {}, "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg=="],
"class-variance-authority": ["class-variance-authority@0.7.1", "https://registry.npmmirror.com/class-variance-authority/-/class-variance-authority-0.7.1.tgz", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
"cliui": ["cliui@6.0.0", "https://registry.npmmirror.com/cliui/-/cliui-6.0.0.tgz", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.0", "wrap-ansi": "^6.2.0" } }, "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ=="],
"clsx": ["clsx@2.1.1", "https://registry.npmmirror.com/clsx/-/clsx-2.1.1.tgz", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
"color-convert": ["color-convert@2.0.1", "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
"color-name": ["color-name@1.1.4", "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
"copy-anything": ["copy-anything@4.0.5", "https://registry.npmmirror.com/copy-anything/-/copy-anything-4.0.5.tgz", { "dependencies": { "is-what": "^5.2.0" } }, "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA=="],
"cross-spawn": ["cross-spawn@7.0.6", "https://registry.npmmirror.com/cross-spawn/-/cross-spawn-7.0.6.tgz", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
@@ -416,12 +432,18 @@
"debug": ["debug@4.4.3", "https://registry.npmmirror.com/debug/-/debug-4.4.3.tgz", { "dependencies": { "ms": "^2.1.3" }, "peerDependencies": { "supports-color": "*" }, "optionalPeers": ["supports-color"] }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
"decamelize": ["decamelize@1.2.0", "https://registry.npmmirror.com/decamelize/-/decamelize-1.2.0.tgz", {}, "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA=="],
"deep-is": ["deep-is@0.1.4", "https://registry.npmmirror.com/deep-is/-/deep-is-0.1.4.tgz", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
"defu": ["defu@6.1.7", "https://registry.npmmirror.com/defu/-/defu-6.1.7.tgz", {}, "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ=="],
"detect-libc": ["detect-libc@2.1.2", "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.1.2.tgz", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
"dijkstrajs": ["dijkstrajs@1.0.3", "https://registry.npmmirror.com/dijkstrajs/-/dijkstrajs-1.0.3.tgz", {}, "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA=="],
"emoji-regex": ["emoji-regex@8.0.0", "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
"enhanced-resolve": ["enhanced-resolve@5.21.6", "https://registry.npmmirror.com/enhanced-resolve/-/enhanced-resolve-5.21.6.tgz", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-aNnGCvbJ/RIyWo1IuhNdVjnNF+EjH9wpzpNHt+ci/m9He9LJvUN8wrCcXjp9cWsGNAuvSpVFTx/vraAFQ8qGjQ=="],
"entities": ["entities@7.0.1", "https://registry.npmmirror.com/entities/-/entities-7.0.1.tgz", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
@@ -474,6 +496,8 @@
"fsevents": ["fsevents@2.3.3", "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
"get-caller-file": ["get-caller-file@2.0.5", "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz", {}, "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="],
"glob-parent": ["glob-parent@6.0.2", "https://registry.npmmirror.com/glob-parent/-/glob-parent-6.0.2.tgz", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
"graceful-fs": ["graceful-fs@4.2.11", "https://registry.npmmirror.com/graceful-fs/-/graceful-fs-4.2.11.tgz", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
@@ -492,6 +516,8 @@
"is-extglob": ["is-extglob@2.1.1", "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
"is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
"is-glob": ["is-glob@4.0.3", "https://registry.npmmirror.com/is-glob/-/is-glob-4.0.3.tgz", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
"is-number": ["is-number@7.0.0", "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
@@ -564,6 +590,8 @@
"p-locate": ["p-locate@5.0.0", "https://registry.npmmirror.com/p-locate/-/p-locate-5.0.0.tgz", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
"p-try": ["p-try@2.2.0", "https://registry.npmmirror.com/p-try/-/p-try-2.2.0.tgz", {}, "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ=="],
"path-browserify": ["path-browserify@1.0.1", "https://registry.npmmirror.com/path-browserify/-/path-browserify-1.0.1.tgz", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="],
"path-exists": ["path-exists@4.0.0", "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
@@ -580,6 +608,8 @@
"pinyin-pro": ["pinyin-pro@3.29.4", "https://registry.npmmirror.com/pinyin-pro/-/pinyin-pro-3.29.4.tgz", {}, "sha512-SPXpDT2cHEy+d26V1RXYMlVzXN42hotFAak1fzyWPi4o2dKXb61UqD4pzxDJHwk6gbv8vQ6EfErd+hYX0Qhzug=="],
"pngjs": ["pngjs@5.0.0", "https://registry.npmmirror.com/pngjs/-/pngjs-5.0.0.tgz", {}, "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw=="],
"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=="],
"postcss-selector-parser": ["postcss-selector-parser@7.1.6", "https://registry.npmmirror.com/postcss-selector-parser/-/postcss-selector-parser-7.1.6.tgz", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-7qASPzhKF2l2KLboRZux8CCTRMdGiV08vWmyKzPz22qZ7ZjQBOeY7rNzNoCLSUiftJ7HUq0GERHmxw/t0dCdMw=="],
@@ -590,10 +620,16 @@
"qified": ["qified@0.10.1", "https://registry.npmmirror.com/qified/-/qified-0.10.1.tgz", { "dependencies": { "hookified": "^2.1.1" } }, "sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA=="],
"qrcode": ["qrcode@1.5.4", "https://registry.npmmirror.com/qrcode/-/qrcode-1.5.4.tgz", { "dependencies": { "dijkstrajs": "^1.0.1", "pngjs": "^5.0.0", "yargs": "^15.3.1" }, "bin": { "qrcode": "bin/qrcode" } }, "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg=="],
"queue-microtask": ["queue-microtask@1.2.3", "https://registry.npmmirror.com/queue-microtask/-/queue-microtask-1.2.3.tgz", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
"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=="],
"require-directory": ["require-directory@2.1.1", "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
"require-main-filename": ["require-main-filename@2.0.0", "https://registry.npmmirror.com/require-main-filename/-/require-main-filename-2.0.0.tgz", {}, "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg=="],
"reusify": ["reusify@1.1.0", "https://registry.npmmirror.com/reusify/-/reusify-1.1.0.tgz", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
"rfdc": ["rfdc@1.4.1", "https://registry.npmmirror.com/rfdc/-/rfdc-1.4.1.tgz", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="],
@@ -604,6 +640,8 @@
"semver": ["semver@7.8.5", "https://registry.npmmirror.com/semver/-/semver-7.8.5.tgz", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="],
"set-blocking": ["set-blocking@2.0.0", "https://registry.npmmirror.com/set-blocking/-/set-blocking-2.0.0.tgz", {}, "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw=="],
"shebang-command": ["shebang-command@2.0.0", "https://registry.npmmirror.com/shebang-command/-/shebang-command-2.0.0.tgz", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
"shebang-regex": ["shebang-regex@3.0.0", "https://registry.npmmirror.com/shebang-regex/-/shebang-regex-3.0.0.tgz", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
@@ -612,6 +650,10 @@
"speakingurl": ["speakingurl@14.0.1", "https://registry.npmmirror.com/speakingurl/-/speakingurl-14.0.1.tgz", {}, "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ=="],
"string-width": ["string-width@4.2.3", "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
"strip-ansi": ["strip-ansi@6.0.1", "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"superjson": ["superjson@2.2.6", "https://registry.npmmirror.com/superjson/-/superjson-2.2.6.tgz", { "dependencies": { "copy-anything": "^4" } }, "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA=="],
"tailwind-merge": ["tailwind-merge@3.6.0", "https://registry.npmmirror.com/tailwind-merge/-/tailwind-merge-3.6.0.tgz", {}, "sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w=="],
@@ -660,10 +702,20 @@
"which": ["which@2.0.2", "https://registry.npmmirror.com/which/-/which-2.0.2.tgz", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
"which-module": ["which-module@2.0.1", "https://registry.npmmirror.com/which-module/-/which-module-2.0.1.tgz", {}, "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ=="],
"word-wrap": ["word-wrap@1.2.5", "https://registry.npmmirror.com/word-wrap/-/word-wrap-1.2.5.tgz", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
"wrap-ansi": ["wrap-ansi@6.2.0", "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="],
"xml-name-validator": ["xml-name-validator@5.0.0", "https://registry.npmmirror.com/xml-name-validator/-/xml-name-validator-5.0.0.tgz", {}, "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg=="],
"y18n": ["y18n@4.0.3", "https://registry.npmmirror.com/y18n/-/y18n-4.0.3.tgz", {}, "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="],
"yargs": ["yargs@15.4.1", "https://registry.npmmirror.com/yargs/-/yargs-15.4.1.tgz", { "dependencies": { "cliui": "^6.0.0", "decamelize": "^1.2.0", "find-up": "^4.1.0", "get-caller-file": "^2.0.1", "require-directory": "^2.1.1", "require-main-filename": "^2.0.0", "set-blocking": "^2.0.0", "string-width": "^4.2.0", "which-module": "^2.0.0", "y18n": "^4.0.0", "yargs-parser": "^18.1.2" } }, "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A=="],
"yargs-parser": ["yargs-parser@18.1.3", "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-18.1.3.tgz", { "dependencies": { "camelcase": "^5.0.0", "decamelize": "^1.2.0" } }, "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ=="],
"yocto-queue": ["yocto-queue@0.1.0", "https://registry.npmmirror.com/yocto-queue/-/yocto-queue-0.1.0.tgz", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
"@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "https://registry.npmmirror.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
@@ -694,10 +746,18 @@
"reka-ui/@vueuse/shared": ["@vueuse/shared@14.3.0", "https://registry.npmmirror.com/@vueuse/shared/-/shared-14.3.0.tgz", { "peerDependencies": { "vue": "^3.5.0" } }, "sha512-bZpge9eSXwa4ToSiqJ7j6KRwhAsneMFoSz3LMWKQDkqimm3D/tbFlrklrs/IOqC8tEcYmXQZJ6N0UrjhBirVCg=="],
"yargs/find-up": ["find-up@4.1.0", "https://registry.npmmirror.com/find-up/-/find-up-4.1.0.tgz", { "dependencies": { "locate-path": "^5.0.0", "path-exists": "^4.0.0" } }, "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw=="],
"@vue/language-core/minimatch/brace-expansion": ["brace-expansion@2.1.2", "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-2.1.2.tgz", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA=="],
"reka-ui/@vueuse/core/@vueuse/metadata": ["@vueuse/metadata@14.3.0", "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-14.3.0.tgz", {}, "sha512-BwxmbAzwAVF50+MW57GXOUEV61nFBGnlBvrTqj49PqWJu3uw7hdu72ztXeZ33RdZtDY6kO+bfCAE1PCn88Tktw=="],
"yargs/find-up/locate-path": ["locate-path@5.0.0", "https://registry.npmmirror.com/locate-path/-/locate-path-5.0.0.tgz", { "dependencies": { "p-locate": "^4.1.0" } }, "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g=="],
"@vue/language-core/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
"yargs/find-up/locate-path/p-locate": ["p-locate@4.1.0", "https://registry.npmmirror.com/p-locate/-/p-locate-4.1.0.tgz", { "dependencies": { "p-limit": "^2.2.0" } }, "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A=="],
"yargs/find-up/locate-path/p-locate/p-limit": ["p-limit@2.3.0", "https://registry.npmmirror.com/p-limit/-/p-limit-2.3.0.tgz", { "dependencies": { "p-try": "^2.0.0" } }, "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w=="],
}
}
+2035 -10
View File
File diff suppressed because it is too large. Load diff
+5 -3
View File
@@ -1,7 +1,7 @@
{
"name": "thing",
"private": true,
"version": "26.9.3",
"version": "26.9.4",
"type": "module",
"scripts": {
"dev": "vite",
@@ -14,7 +14,7 @@
"tauri": "tauri"
},
"dependencies": {
"@lucide/vue": "^1.28.0",
"@lucide/vue": "^1.48.0",
"@tailwindcss/vite": "^4.3.2",
"@tauri-apps/api": "^2",
"@tauri-apps/plugin-autostart": "~2",
@@ -33,7 +33,8 @@
"clsx": "^2.1.1",
"pinia": "^3.0.4",
"pinyin-pro": "^3.28.2",
"reka-ui": "^2.10.1",
"qrcode": "^1.5.4",
"reka-ui": "^2.10.5",
"tailwind-merge": "^3.6.0",
"tailwindcss": "^4.3.2",
"vue": "^3.5.13",
@@ -43,6 +44,7 @@
"devDependencies": {
"@tauri-apps/cli": "^2",
"@types/node": "^26.1.1",
"@types/qrcode": "^1.5.6",
"@vitejs/plugin-vue": "^5.2.1",
"@vue/eslint-config-typescript": "^14.9.0",
"eslint": "^10.11.0",
+91
View File
@@ -0,0 +1,91 @@
# SMTC full info query script (must run in Windows PowerShell 5.1)
# Output: EVERY session (not only GetCurrentSession), full media properties
Add-Type -AssemblyName System.Runtime.WindowsRuntime -ErrorAction SilentlyContinue
$null = [Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager, Windows.Media.Control, ContentType=WindowsRuntime]
$null = [Windows.Media.Control.GlobalSystemMediaTransportControlsSessionMediaProperties, Windows.Media.Control, ContentType=WindowsRuntime]
$null = [Windows.Storage.Streams.IInputStream, Windows.Storage.Streams, ContentType=WindowsRuntime]
function Await($WinRtTask, $ResultType) {
$asTask = ([System.WindowsRuntimeSystemExtensions].GetMethods() |
Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and $_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation`1' })[0]
$asTaskGeneric = $asTask.MakeGenericMethod($ResultType)
$netTask = $asTaskGeneric.Invoke($null, @($WinRtTask))
$netTask.Wait(-1) | Out-Null
$netTask.Result
}
$mgr = Await ([Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager]::RequestAsync()) ([Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager])
$current = $mgr.GetCurrentSession()
# IVectorView 用 Size/GetAt 枚举:foreach 在 PS 5.1 上经常拿不到元素
$sessions = New-Object System.Collections.ArrayList
try {
$raw = $mgr.GetSessions()
if ($null -ne $raw) {
$n = $raw.Size
for ($i = 0; $i -lt $n; $i++) {
[void]$sessions.Add($raw.GetAt($i))
}
}
} catch {
Write-Host "GetSessions failed: $_" -ForegroundColor Red
}
Write-Host "===== SMTC Sessions ($($sessions.Count)) =====" -ForegroundColor Cyan
$currentId = if ($current) { $current.SourceAppUserModelId } else { '' }
Write-Host "CurrentSession : $(if ($currentId) { $currentId } else { '(none)' })" -ForegroundColor Yellow
Write-Host ""
if ($sessions.Count -eq 0) {
if ($current) { [void]$sessions.Add($current) }
else {
Write-Host "No SMTC media sessions found." -ForegroundColor Yellow
return
}
}
$index = 0
foreach ($session in $sessions) {
$index++
$appId = $session.SourceAppUserModelId
$isCurrent = $currentId -and ($appId -eq $currentId)
$mark = if ($isCurrent) { " [CURRENT]" } else { "" }
$props = $null
try {
$props = Await ($session.TryGetMediaPropertiesAsync()) ([Windows.Media.Control.GlobalSystemMediaTransportControlsSessionMediaProperties])
} catch {
$props = $null
}
$playback = $session.GetPlaybackInfo()
$timeline = $session.GetTimelineProperties()
$position = $timeline.Position
$duration = $timeline.EndTime - $timeline.StartTime
$progress = if ($duration.TotalSeconds -gt 0) { [math]::Round(($position.TotalSeconds / $duration.TotalSeconds) * 100, 1) } else { 0 }
Write-Host ("----- Session #{0}{1} -----" -f $index, $mark) -ForegroundColor Cyan
Write-Host "App ID : $appId"
if ($props) {
Write-Host "Playback Type : $($props.PlaybackType)"
Write-Host "Title : $($props.Title)"
Write-Host "Subtitle : $($props.Subtitle)"
Write-Host "Artist : $($props.Artist)"
Write-Host "AlbumArtist : $($props.AlbumArtist)"
Write-Host "AlbumTitle : $($props.AlbumTitle)"
Write-Host "TrackNumber : $($props.TrackNumber)"
Write-Host "Genres : $($props.Genres -join ', ')"
$thumbnail = $props.Thumbnail
if ($thumbnail) { Write-Host "Thumbnail : (present)" }
else { Write-Host "Thumbnail : No thumbnail" }
} else {
Write-Host "MediaProperties: (failed to read)"
}
Write-Host "Playback Status: $($playback.PlaybackStatus)"
Write-Host "Progress : $position / $duration ($progress%)"
Write-Host ""
}
Write-Host "===================================" -ForegroundColor Cyan
+434 -2
View File
@@ -104,6 +104,28 @@ version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
[[package]]
name = "alsa"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d"
dependencies = [
"alsa-sys",
"bitflags 2.13.2",
"cfg-if",
"libc",
]
[[package]]
name = "alsa-sys"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04"
dependencies = [
"libc",
"pkg-config",
]
[[package]]
name = "android_system_properties"
version = "0.1.5"
@@ -416,6 +438,7 @@ checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
dependencies = [
"async-trait",
"axum-core 0.4.5",
"base64 0.22.1",
"bytes",
"futures-util",
"http",
@@ -434,8 +457,10 @@ dependencies = [
"serde_json",
"serde_path_to_error",
"serde_urlencoded",
"sha1 0.10.7",
"sync_wrapper",
"tokio",
"tokio-tungstenite",
"tower",
"tower-layer",
"tower-service",
@@ -1153,6 +1178,50 @@ dependencies = [
"libc",
]
[[package]]
name = "coreaudio-rs"
version = "0.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58"
dependencies = [
"bitflags 2.13.2",
"libc",
"objc2-audio-toolbox",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
]
[[package]]
name = "cpal"
version = "0.18.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f02e8d0327b42d3e2e4ab2119af397344eb9fc54a34bf0ddeaa1277af8681f1"
dependencies = [
"alsa",
"block2",
"coreaudio-rs",
"dasp_sample",
"jni 0.22.4",
"js-sys",
"libc",
"mach2",
"ndk",
"ndk-context",
"num-derive",
"num-traits",
"objc2",
"objc2-audio-toolbox",
"objc2-avf-audio",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation",
"web-sys",
"windows 0.62.2",
"windows-core 0.62.2",
]
[[package]]
name = "cpubits"
version = "0.1.1"
@@ -1430,6 +1499,12 @@ dependencies = [
"serde",
]
[[package]]
name = "dasp_sample"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
[[package]]
name = "data-encoding"
version = "2.11.1"
@@ -1940,6 +2015,12 @@ dependencies = [
"pin-project-lite",
]
[[package]]
name = "extended"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
[[package]]
name = "fallible-iterator"
version = "0.3.0"
@@ -3043,9 +3124,22 @@ checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
dependencies = [
"bytemuck",
"byteorder-lite",
"image-webp",
"moxcms",
"num-traits",
"png 0.18.1",
"zune-core",
"zune-jpeg",
]
[[package]]
name = "image-webp"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
dependencies = [
"byteorder-lite",
"quick-error",
]
[[package]]
@@ -3866,6 +3960,12 @@ dependencies = [
"uuid",
]
[[package]]
name = "mach2"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
[[package]]
name = "markup5ever"
version = "0.38.0"
@@ -4076,6 +4176,12 @@ dependencies = [
"thiserror 1.0.69",
]
[[package]]
name = "ndk-context"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
[[package]]
name = "ndk-sys"
version = "0.6.0+11769913"
@@ -4181,7 +4287,7 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8536030f9fea7127f841b45bb6243b27255787fb4eb83958aa1ef9d2fdc0c36"
dependencies = [
"num-complex",
"num-complex 0.2.4",
"num-integer",
"num-iter",
"num-rational",
@@ -4226,12 +4332,32 @@ dependencies = [
"num-traits",
]
[[package]]
name = "num-complex"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
dependencies = [
"num-traits",
]
[[package]]
name = "num-conv"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
[[package]]
name = "num-derive"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.118",
]
[[package]]
name = "num-integer"
version = "0.1.47"
@@ -4317,6 +4443,32 @@ dependencies = [
"objc2-foundation",
]
[[package]]
name = "objc2-audio-toolbox"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08"
dependencies = [
"bitflags 2.13.2",
"libc",
"objc2",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation",
]
[[package]]
name = "objc2-avf-audio"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-cloud-kit"
version = "0.3.2"
@@ -4328,6 +4480,29 @@ dependencies = [
"objc2-foundation",
]
[[package]]
name = "objc2-core-audio"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2"
dependencies = [
"dispatch2",
"objc2",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation",
]
[[package]]
name = "objc2-core-audio-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c"
dependencies = [
"bitflags 2.13.2",
"objc2",
]
[[package]]
name = "objc2-core-data"
version = "0.3.2"
@@ -4345,7 +4520,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
dependencies = [
"bitflags 2.13.2",
"block2",
"dispatch2",
"libc",
"objc2",
]
@@ -5016,6 +5193,15 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
[[package]]
name = "primal-check"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc0d895b311e3af9902528fbb8f928688abbd95872819320517cc24ca6b2bd08"
dependencies = [
"num-integer",
]
[[package]]
name = "primefield"
version = "0.14.0"
@@ -5126,6 +5312,12 @@ dependencies = [
"winapi",
]
[[package]]
name = "quick-error"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
[[package]]
name = "quick-xml"
version = "0.41.0"
@@ -5423,6 +5615,12 @@ dependencies = [
"regex-syntax",
]
[[package]]
name = "regex-lite"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
[[package]]
name = "regex-syntax"
version = "0.8.11"
@@ -5438,6 +5636,7 @@ dependencies = [
"base64 0.22.1",
"bytes",
"encoding_rs",
"futures-channel",
"futures-core",
"futures-util",
"h2",
@@ -5764,6 +5963,20 @@ dependencies = [
"semver",
]
[[package]]
name = "rustfft"
version = "6.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "21db5f9893e91f41798c88680037dba611ca6674703c1a18601b01a72c8adb89"
dependencies = [
"num-complex 0.4.6",
"num-integer",
"num-traits",
"primal-check",
"strength_reduce",
"transpose",
]
[[package]]
name = "rustix"
version = "1.1.4"
@@ -6621,6 +6834,12 @@ version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
[[package]]
name = "strength_reduce"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
[[package]]
name = "string_cache"
version = "0.9.0"
@@ -6668,6 +6887,192 @@ dependencies = [
"serde_json",
]
[[package]]
name = "symphonia"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7edef6a96b696d4e0cab5ee9ebb7ca155ed95f30a6b45bbb8b97d2727f02424"
dependencies = [
"lazy_static",
"symphonia-bundle-flac",
"symphonia-bundle-mp3",
"symphonia-codec-aac",
"symphonia-codec-adpcm",
"symphonia-codec-alac",
"symphonia-codec-pcm",
"symphonia-codec-vorbis",
"symphonia-core",
"symphonia-format-isomp4",
"symphonia-format-mkv",
"symphonia-format-ogg",
"symphonia-format-riff",
"symphonia-metadata",
]
[[package]]
name = "symphonia-bundle-flac"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6405d5c34ff6f8f7ca08a4101efe66d21e180f7322ef9359900a0e55698a7892"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-bundle-mp3"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "98ea5ffc8716bff677dfb3b01b420c7b758de901a72b8c330bf2040ab74b4add"
dependencies = [
"lazy_static",
"log",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-aac"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5bf8e39552d34a3c4c98333370e62f48c92456d2e814f273b5c3ad7c4a5f45c"
dependencies = [
"lazy_static",
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-adpcm"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "445932ecb0c59362fde9c082dd63a75380650c5077fdb8b80b8cac850442a74c"
dependencies = [
"log",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-alac"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "920a78f96f3cf62932d0c497959c0cc2100ef36b03c7ca1417b260f432a482d8"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-pcm"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e04ba75686acbe43542fdd374571195f0530c0b7785ca25cc6840e9c6c4b6eea"
dependencies = [
"log",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-vorbis"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73d90b4fcf796137cc683c538282804ff9629f8ad9dbfd881fcbba331ac4e986"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-common"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2acc3fcc18ec9b8cdd48614e259c4cf0d27b71d41e5d9b120b42c5adab12d7c4"
dependencies = [
"log",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-core"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01c412864d599d4750d0c3d684d7e093ec05e5309681ef5252cc1096a437f6e0"
dependencies = [
"bitflags 2.13.2",
"bytemuck",
"lazy_static",
"log",
"num-complex 0.4.6",
"rustfft",
"smallvec",
]
[[package]]
name = "symphonia-format-isomp4"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e681a70e1870d34e02abf1dbc51e4267c3f1827801474e8870be8c689fc4dc3"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-format-mkv"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d015c5c0558864665894b3f4cbd95e10abb01b9c868e751c72670f326a56360e"
dependencies = [
"lazy_static",
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-format-ogg"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b5495e7f7e3c7035328d82b6d6e377eef289bb0c4105bdeb557fc93a833f994"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-format-riff"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ff70929083a8c1a5f6cd7c904b6071c7914ad04739b510c2f7239dfc9b7dabe"
dependencies = [
"extended",
"log",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-metadata"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83713a97705d77bdef7cdbc0768fd6e5a54e4cd7e48d60a806ae85639e2c87c6"
dependencies = [
"lazy_static",
"log",
"regex-lite",
"smallvec",
"symphonia-core",
]
[[package]]
name = "syn"
version = "1.0.109"
@@ -7241,7 +7646,7 @@ dependencies = [
[[package]]
name = "thing"
version = "26.9.3"
version = "26.9.4"
dependencies = [
"aes 0.8.4",
"async-trait",
@@ -7250,6 +7655,7 @@ dependencies = [
"bytes",
"cbc 0.1.2",
"chrono",
"cpal",
"dashmap",
"dirs 5.0.1",
"encoding_rs",
@@ -7277,6 +7683,7 @@ dependencies = [
"specta",
"specta-typescript",
"ssh-key",
"symphonia",
"sysinfo",
"tauri",
"tauri-build",
@@ -7688,6 +8095,16 @@ dependencies = [
"once_cell",
]
[[package]]
name = "transpose"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
dependencies = [
"num-integer",
"strength_reduce",
]
[[package]]
name = "tray-icon"
version = "0.24.1"
@@ -9263,6 +9680,21 @@ dependencies = [
"pkg-config",
]
[[package]]
name = "zune-core"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"
[[package]]
name = "zune-jpeg"
version = "0.5.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
dependencies = [
"zune-core",
]
[[package]]
name = "zvariant"
version = "5.13.0"
+47 -4
View File
@@ -1,6 +1,6 @@
[package]
name = "thing"
version = "26.9.3"
version = "26.9.4"
description = "A Tauri App"
authors = ["you"]
edition = "2021"
@@ -35,10 +35,13 @@ 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", "multipart"] }
# blocking:音乐播放引擎在**独立 std 线程**上解码(symphonia 的 MediaSource 是同步
# Read+Seek),需要同步 HTTP 客户端去按 Range 拉 NAS 音频流。放在 std 线程上用
# blocking 是安全的(在 tokio 运行时线程里用才会 panic)。
reqwest = { version = "0.12", features = ["json", "stream", "multipart", "blocking"] }
futures-util = "0.3"
tokio = { version = "1", features = ["io-util", "time", "rt-multi-thread", "macros", "sync", "fs", "net"] }
axum = "0.7"
axum = { version = "0.7", features = ["ws"] }
url = "2"
zip = "2"
dirs = "5"
@@ -98,12 +101,22 @@ 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"] }
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp"] }
walkdir = "2"
notify = { version = "6", features = [] }
librqbit = "9"
bytes = "1"
windows-capture = "2.0.1"
# 音频解码(纯 Rust)。**默认特性不含 mp3/aac/alac/isomp4**——0.6 起这几项被移出
# default,必须显式打开,否则 mp3 与 m4a 直接报「不支持的格式」。
# default 已含:flac / wav / ogg / vorbis / pcm / adpcm / mkv + 全部元数据。
# 注意:`ape` 只是**元数据**特性(symphonia-metadata/ape),没有 APE 解码器;
# 也没有 opus 特性(ogg 里若是 Opus 轨道无法解码)。这两点已与用户确认接受。
symphonia = { version = "0.6", features = ["mp3", "aac", "alac", "isomp4"] }
# 音频输出。Windows 走 WASAPI:cpal 的共享模式输出带
# AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | SRC_DEFAULT_QUALITY,因此**可以用源采样率
# 直接建流**,由 Windows 自己转换到设备混音格式 —— 不需要额外引入重采样库。
cpal = "0.18"
# HDR 截图说明:windows-capture 的 Windows Graphics Capture 后端在 HDR 显示器上
# 可能输出 scRGB / rgba16F 或 HDR10(PQ) 格式的帧,与项目其余截图路径
# (GDI BitBlt,sRGB 8bit)色彩空间不一致。capture 层统一转成 sRGB 8bit
@@ -141,6 +154,12 @@ windows-sys = { version = "0.52", features = [
# 注意:0.52 起 ReadFile 定义在 Storage_FileSystem 但被 Win32_System_IO 特性门控,
# 两个特性必须同时开启,否则导入会解析失败。
"Win32_System_IO",
# 音乐模块「解密」:QQ音乐新版 musicex 的 ekey 不落盘,只能联网取;而
# authst 仅存在于 QQMusic.exe 运行期内存里 —— 需要进程枚举(ToolHelp:
# CreateToolhelp32Snapshot / Process32FirstW)与跨进程读内存
# (Diagnostics::Debug::ReadProcessMemory + System::Memory::VirtualQueryEx)。
"Win32_System_Diagnostics_ToolHelp",
"Win32_System_Diagnostics_Debug",
] }
# Explorer ShellWindows COM:用于枚举已打开的资源管理器窗口并取当前路径
# (快速面板「用资源管理器打开」联动)。依赖 Win32_System_Com 特性。
@@ -159,9 +178,33 @@ windows = { version = "0.52", features = [
"Globalization",
"Graphics_Imaging",
"Media_Ocr",
# 音乐模块:系统媒体传输控件(SMTC)。Windows.Media 提供
# SystemMediaTransportControls / DisplayUpdater / MusicDisplayProperties /
# TimelineProperties;Win32_System_WinRT 提供桌面应用唯一的取用入口
# ISystemMediaTransportControlsInterop::GetForWindow。
# 之所以不用前端 navigator.mediaSession 当唯一通道:WebView2 只转发标题/歌手/进度,
# 专辑与封面不送达,且会话挂在浏览器进程 AUMID 上只显示「未知应用」。
"Media",
"Win32_System_WinRT",
# 音乐模块·手机遥控:GSMTC 全局会话管理器(Windows.Media.Control),
# 枚举/监视/控制系统全部 SMTC 会话(MUSIC_REMOTE_PLAN §3.1)
"Media_Control",
# 手机遥控·UDP beacon:GetAdaptersAddresses 枚举各网卡 IPv4/广播地址
# (多网卡/VPN 场景下定向广播,MUSIC_REMOTE_PLAN §3.3)。
# GetAdaptersAddresses 另受 Ndis + WinSock 两个 feature 门控(windows 0.52 源码 cfg)
"Win32_NetworkManagement_IpHelper",
"Win32_NetworkManagement_Ndis",
"Win32_Networking_WinSock",
# 手机遥控·P1 系统音量:MMDevice + IAudioEndpointVolume(Endpoints 有独立 feature 门控;
# IMMDevice::Activate 另需 Com_StructuredStorage)
"Win32_Media_Audio",
"Win32_Media_Audio_Endpoints",
"Win32_System_Com_StructuredStorage",
"Security_Cryptography",
# 划词取词的智能路径:UIA 直读焦点元素选区(IUIAutomation / ITextProvider)
"Win32_UI_Accessibility",
# OCR:CryptographicBuffer / SoftwareBitmap::CreateCopyFromBuffer 的 IBuffer 属于
# Windows.Storage.Streams,缺这个 feature 会 E0599 找不到 CreateFromByteArray
"Storage_Streams",
# HDR 探测:DXGI 的 advanced color 查询用于判断显示器是否处于 HDR / WCG 状态,
# 并读取其色域与传递函数(G2084/PQ 表示 HDR10)。截图前据此决定是否做色调映射。
+26
View File
@@ -0,0 +1,26 @@
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "file-window",
"description": "Capability for the file manager window (singleton, label = file-window). Dual-pane local/SSH browser — needs the same window/event/dialog/opener set as the main window's file page, plus window controls for its self-drawn title bar.",
"windows": ["file-window"],
"permissions": [
"core:default",
"core:window:allow-show",
"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-set-title",
"core:window:allow-start-dragging",
"core:window:allow-set-theme",
"core:window:allow-set-background-color",
"core:event:allow-listen",
"core:event:allow-emit",
"dialog:default",
"opener:default",
"opener:allow-open-path",
"opener:allow-reveal-item-in-dir",
"snap-layout:default"
]
}
@@ -0,0 +1,83 @@
//! **临时**端到端验证:对真实 musicex 样本走完整「取密钥 → 解密 → 校验」流程。
//!
//! 用法(需要 QQ 音乐在运行且已登录):
//! ```text
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\file.mflac"
//! ```
//! 验证完即可删除本文件。
use thing_lib::music::decrypt::probe::{probe_musicex, ProbeOutcome};
fn main() {
let mut args = std::env::args().skip(1);
let path = args.next().expect(
"用法:decrypt_musicex_probe <文件路径> [输出目录]\n\
给了输出目录则会用**生产路径**真正写盘(生成可播放文件)",
);
let out_dir = args.next();
match probe_musicex(std::path::Path::new(&path)) {
Ok(ProbeOutcome {
ekey_len,
key_len,
raw_key_bytes,
cipher_magic,
plain_magic,
decrypted_bytes,
guessed_format,
expiration_secs,
}) => {
println!("=== 成功 ===");
println!("ekey 长度 : {ekey_len}");
println!("派生密钥长度 : {key_len}");
println!(
"密钥前 8 字节 : {:02x?}",
&raw_key_bytes[..raw_key_bytes.len().min(8)]
);
println!("密文头 : {:02x?}", cipher_magic);
println!("解密后字节数 : {decrypted_bytes}");
println!("明文首帧魔数 : {:02x?}", plain_magic);
println!("判定格式 : {guessed_format}");
println!("ekey 有效期(秒) : {expiration_secs}");
if guessed_format == "flac" && plain_magic.starts_with(b"fLaC") {
println!("=> 合法 FLAC 头,产物可播");
} else {
println!("=> 头不合法,需要排查");
}
}
Err(e) => {
println!("=== 失败 ===");
println!("{e}");
std::process::exit(1);
}
}
// 可选:调用**生产路径**真正落盘(验证 decrypt_musicex 本身,而不只是核心算法)
if let Some(dir) = out_dir {
println!("\n=== 生产路径落盘 ===");
match thing_lib::music::decrypt::qq_online::decrypt_musicex(
std::path::Path::new(&path),
std::path::Path::new(&dir),
"QQ音乐",
|done, total| {
if done == total {
println!("进度:{done} 字节(完成)");
}
},
) {
Ok(outcome) => {
let size = std::fs::metadata(&outcome.output)
.map(|m| m.len())
.unwrap_or(0);
println!("产物 : {}", outcome.output.display());
println!("大小 : {size} 字节");
println!("格式 : {}", outcome.format);
println!("备注 : {}", outcome.note);
}
Err(e) => {
println!("落盘失败:{e}");
std::process::exit(1);
}
}
}
}
+59
View File
@@ -0,0 +1,59 @@
//! 诊断:枚举全部 GSMTC 会话的时间轴原始值(判断"来源不提供进度"的形态)。
//!
//! 运行:`cargo run --example gsmtc_dump`
use std::time::{SystemTime, UNIX_EPOCH};
use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
fn ticks_to_unix_ms(ticks: i64) -> i64 {
ticks / 10_000 - 62_135_596_800_000
}
fn main() -> windows::core::Result<()> {
let mgr = GlobalSystemMediaTransportControlsSessionManager::RequestAsync()?.get()?;
let sessions = mgr.GetSessions()?;
let now_ms = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0);
println!("now(unix ms) = {now_ms}");
println!("sessions = {}", sessions.Size()?);
for i in 0..sessions.Size()? {
let s = sessions.GetAt(i)?;
println!("--- [{}] {}", i, s.SourceAppUserModelId()?);
if let Ok(p) = s.TryGetMediaPropertiesAsync()?.get() {
println!(
" title={:?} artist={:?} album={:?}",
p.Title()?,
p.Artist()?,
p.AlbumTitle()?
);
}
let info = s.GetPlaybackInfo()?;
println!(" status={:?}", info.PlaybackStatus()?);
if let Ok(c) = info.Controls() {
println!(
" controls play={} pause={} next={} prev={} seek={}",
c.IsPlayEnabled().unwrap_or(false),
c.IsPauseEnabled().unwrap_or(false),
c.IsNextEnabled().unwrap_or(false),
c.IsPreviousEnabled().unwrap_or(false),
c.IsPlaybackPositionEnabled().unwrap_or(false)
);
}
let tl = s.GetTimelineProperties()?;
let pos = tl.Position()?.Duration;
let end = tl.EndTime().map(|t| t.Duration).unwrap_or(-1);
let upd = tl.LastUpdatedTime()?.UniversalTime;
let upd_ms = ticks_to_unix_ms(upd);
println!(
" position={}s end={}s lastUpdatedTicks={upd} -> unixMs={upd_ms} (deltaMs={})",
pos as f64 / 1e7,
end as f64 / 1e7,
upd_ms - now_ms
);
}
Ok(())
}
+38
View File
@@ -0,0 +1,38 @@
//! GSMTC 可用性探测(MUSIC_REMOTE_PLAN §7 P0 第 1 项 / §6 第 1 条)
//!
//! 关键假设:GSMTC(Windows.Media.Control)在**非打包**桌面应用可用(Windows 10 1809+)。
//! 本 example 以普通控制台进程运行(无 package identity),跑通即证明假设成立。
//!
//! 运行:`cargo run --example gsmtc_probe`
//! 建议先在任意播放器(网易云/浏览器/Thing)放一首歌,可看到当前会话的元数据与时间轴。
use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
use windows::core::Result;
fn main() -> Result<()> {
// 1. 取全局会话管理器(失败 = 整个能力需降级,见计划 §3.1 失败策略)
let mgr = GlobalSystemMediaTransportControlsSessionManager::RequestAsync()?.get()?;
// 2. 枚举系统全部 SMTC 会话(注意:0.52 投影里 GetSessions/GetCurrentSession 是同步的)
let sessions = mgr.GetSessions()?;
println!("[ok] GSMTC 可用(unpackaged),当前会话数: {}", sessions.Size()?);
// 3. 当前活跃会话的元数据 / 播放状态 / 时间轴
// 无会话时 ABI 返回 null → windows-rs 投影为 Err(E_POINTER),按"无会话"处理
match mgr.GetCurrentSession() {
Ok(cur) => {
println!("current: {}", cur.SourceAppUserModelId()?);
let p = cur.TryGetMediaPropertiesAsync()?.get()?;
println!(" {} - {} | album: {}", p.Artist()?, p.Title()?, p.AlbumTitle()?);
println!(" status: {:?}", cur.GetPlaybackInfo()?.PlaybackStatus()?);
let tl = cur.GetTimelineProperties()?;
println!(
" position(ticks): {} | lastUpdated(ticks): {}",
tl.Position()?.Duration,
tl.LastUpdatedTime()?.UniversalTime
);
}
Err(e) => println!("current session: <none> ({e})(先放一首歌再跑,可看完整元数据)"),
}
Ok(())
}
+41
View File
@@ -0,0 +1,41 @@
//! **临时**校验:用产物解析器确认解密出来的文件是合法音频。
//!
//! 用法:`cargo run --example verify_audio -- <文件路径>`
fn main() {
let path = std::env::args()
.nth(1)
.expect("用法:verify_audio <文件路径>");
let p = std::path::Path::new(&path);
let size = std::fs::metadata(p).map(|m| m.len()).unwrap_or(0);
println!("文件 : {}", p.display());
println!("大小 : {size} 字节");
// 1) 头部魔数
let head = std::fs::read(p).map(|b| b[..16.min(b.len())].to_vec());
match head {
Ok(h) => println!("首帧 : {:02x?}", h),
Err(e) => {
println!("读取失败:{e}");
std::process::exit(1);
}
}
// 2) 交给项目同款的解析器(lofty):能读出时长与格式才算真合法
match lofty::probe::Probe::open(p).and_then(|probe| probe.read()) {
Ok(tagged) => {
use lofty::file::AudioFile;
let props = tagged.properties();
println!("时长 : {:?}", props.duration());
println!("码率 : {:?}", props.audio_bitrate());
println!("采样率 : {:?}", props.sample_rate());
println!("声道 : {:?}", props.channels());
println!("=> lofty 成功解析,文件合法可播");
}
Err(e) => {
println!("lofty 解析失败:{e}");
std::process::exit(1);
}
}
}
@@ -379,20 +379,94 @@ async function shouldIntercept(downloadItem) {
}
/**
* 判断是否为"历史下载"(安装插件之前就已存在、随后被浏览器恢复的旧下载)
* 判断是否为"历史下载"(本次浏览器会话开始之前就存在、浏览器重启/恢复后才重新触发的下载)
* 这类下载一律不接管,交给浏览器原生处理,实现"只接管以后的下载,历史都不管"
*
* 三重判据(任一命中即视为历史下载):
* 1. canResume=true:已存在有效的部分文件,说明浏览器在恢复旧下载
* 2. 开始时间早于插件首次安装时间
* 3. 开始时间早于**本次浏览器会话**起点:浏览器重启时会恢复上次未完成的下载,
* 这些下载的 startTime 仍是上次会话的时间,因此一定会落在会话起点之前。
* (只靠 1/2 不够:上次会话启动的下载若被浏览器重新排队,canResume 可能为 false,
* 而 startTime 又晚于安装时间 —— 这正是"关掉浏览器后莫名多出历史下载"的成因)
*/
async function isHistoricalDownload(item) {
// 1) canResume=true 表示已存在有效的部分文件,说明浏览器在恢复旧下载
if (item.canResume) return true
const start = item.startTime ? new Date(item.startTime).getTime() : 0
// 2) 开始时间早于插件首次安装时间(浏览器重启后恢复的旧下载会保留原来的开始时间)
try {
const start = item.startTime ? new Date(item.startTime).getTime() : 0
if (start > 0) {
const stored = await chrome.storage.local.get('installTime')
const installTime = stored.installTime || 0
if (installTime > 0 && start < installTime) return true
if (installTime > 0 && start > 0 && start < installTime) return true
} catch { /* ignore */ }
// 3) 开始时间早于本次浏览器会话起点(含 5s 宽限,避免刚启动时误判新下载)
const sessionStart = await ensureSessionStart()
if (start > 0 && start < sessionStart - RESTORE_GRACE_MS) return true
return false
}
/** 浏览器会话起点(chrome.storage.session 在浏览器关闭后自动清空) */
const SESSION_START_KEY = 'sessionStart'
/** 会话起点宽限:会话刚建立时新下载的 startTime 可能略早于起点记录时刻 */
const RESTORE_GRACE_MS = 5000
let sessionStartCache = 0
/**
* 取本次浏览器会话的起点时间戳(首次调用时写入 storage.session)。
* 用 storage.session 而非 storage.local 的原因:它随浏览器关闭而清空,
* "存在"本身就等价于"本次会话已开始",无需自己判断重启。
*/
async function ensureSessionStart() {
if (sessionStartCache) return sessionStartCache
try {
const s = await chrome.storage.session.get(SESSION_START_KEY)
if (s[SESSION_START_KEY]) {
sessionStartCache = s[SESSION_START_KEY]
return sessionStartCache
}
} catch { /* ignore */ }
sessionStartCache = Date.now()
try {
await chrome.storage.session.set({ [SESSION_START_KEY]: sessionStartCache })
} catch { /* ignore */ }
return sessionStartCache
}
/** 已处理过的下载 guid(持久化,浏览器重启后仍能认出同一条下载) */
const SEEN_GUIDS_KEY = 'seenDownloadGuids'
/** 记录上限:只用于识别"同一条下载被重复通知",不需要长期留存 */
const SEEN_GUIDS_MAX = 300
let seenGuidsCache = null
async function loadSeenGuids() {
if (seenGuidsCache) return seenGuidsCache
try {
const s = await chrome.storage.local.get(SEEN_GUIDS_KEY)
seenGuidsCache = Array.isArray(s[SEEN_GUIDS_KEY]) ? s[SEEN_GUIDS_KEY] : []
} catch {
seenGuidsCache = []
}
return seenGuidsCache
}
/**
* 记录 guid 并返回它此前是否已见过。
* `true` 表示这条下载我们处理过/见过,本次是重复通知(浏览器恢复旧下载时会复用原 guid),
* 必须跳过,否则会把历史下载重新丢进 Thing。
*/
async function markGuidSeen(guid) {
const seen = await loadSeenGuids()
if (seen.includes(guid)) return true
seen.push(guid)
if (seen.length > SEEN_GUIDS_MAX) seen.splice(0, seen.length - SEEN_GUIDS_MAX)
seenGuidsCache = seen
try {
await chrome.storage.local.set({ [SEEN_GUIDS_KEY]: seen })
} catch { /* ignore */ }
return false
}
@@ -417,6 +491,10 @@ async function hasExistingTask(url) {
async function handleDownloadCreated(downloadItem) {
const url = downloadItem.finalUrl || downloadItem.url
// 同一条下载只处理一次:浏览器重启后恢复的旧下载会带着原 guid 再次触发 onCreated,
// 不拦下来就会把「早已看过/已完成」的下载重新丢进 Thing(表现为莫名弹出历史下载)
if (downloadItem.guid && await markGuidSeen(downloadItem.guid)) return
// 回退下载:我们自己用 chrome.downloads.download 创建的,直接跳过,避免无限循环
const fbExp = fallbackUrls.get(url)
if (fbExp && Date.now() < fbExp) {
@@ -1,7 +1,7 @@
{
"manifest_version": 3,
"name": "Thing Extension",
"version": "0.30",
"version": "0.31",
"description": "发送浏览器下载到 Thing 下载引擎,嗅探网页资源。",
"icons": {
"16": "icons/icon-16.png",
+447
View File
@@ -0,0 +1,447 @@
//! OpenAI 兼容的通用对话客户端(非翻译语义)。
//!
//! 一套代码覆盖 DeepSeek / OpenAI / Gemini(OpenAI 兼容端点)/ 通义 DashScope /
//! Kimi / 智谱 / 豆包 / Mistral / Groq / OpenRouter / 本地 Ollama / LM Studio /
//! one-api 等中转——它们都提供 `POST {baseUrl}/chat/completions` 且结构一致。
//!
//! 与 `translate::engines::ai` 的分工:
//! - 本模块:调用方**全量给定 messages**(终端助手等),不含翻译提示词语义;
//! - translate 的 AiEngine:流式、视觉、翻译模板、空流自愈等翻译专属逻辑。
//!
//! 两者共享端点归一、密钥读取(凭据管理器)与 HTTP 错误分类的约定。
use std::time::Duration;
use serde::Deserialize;
use serde_json::json;
use super::{
provider_api_key, AiErrorKind, AiProviderConfig, AiSettings, DEFAULT_CHAT_TIMEOUT_MS,
};
/// 自检与连通性测试使用的探测文本
const PROBE_TEXT: &str = "Hello, world.";
/// 通用对话请求的结构化错误:**分类 + 可直接展示的中文文案**。
///
/// 调用方各自取所需:终端助手只要文案([`chat_once`] 直接给 String),
/// 设置页的连通性测试还需要分类,用来给「改 Key」「查网络」这类不同的下一步提示。
#[derive(Debug, Clone)]
pub struct ChatError {
pub kind: AiErrorKind,
pub message: String,
}
impl ChatError {
fn new(kind: AiErrorKind, message: impl Into<String>) -> Self {
Self {
kind,
message: message.into(),
}
}
}
impl std::fmt::Display for ChatError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.message)
}
}
/// API 根地址。容错:用户常把完整端点(`.../chat/completions`)粘进来,
/// 不剥掉会拼出双重后缀,上游表现为 404。
pub fn api_root(cfg: &AiProviderConfig) -> Result<String, ChatError> {
let raw = cfg.base_url.trim();
if raw.is_empty() {
return Err(ChatError::new(
AiErrorKind::Config,
format!("供应商「{}」尚未配置 Base URL", cfg.name),
));
}
if !(raw.starts_with("http://") || raw.starts_with("https://")) {
return Err(ChatError::new(
AiErrorKind::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)
}
pub fn chat_endpoint(cfg: &AiProviderConfig) -> Result<String, ChatError> {
Ok(format!("{}/chat/completions", api_root(cfg)?))
}
pub fn models_endpoint(cfg: &AiProviderConfig) -> Result<String, ChatError> {
Ok(format!("{}/models", api_root(cfg)?))
}
/// 取本次请求使用的密钥。
///
/// `override_key` 非空时优先——设置页「检查」允许用**刚填好、还没保存**的 Key 直接验证,
/// 省掉「先保存密钥再测试」的来回。它只活在这一次请求里,不入凭据库、不落盘。
fn require_key(cfg: &AiProviderConfig, override_key: Option<&str>) -> Result<String, ChatError> {
let key = match override_key.map(str::trim).filter(|k| !k.is_empty()) {
Some(k) => k.to_string(),
None => provider_api_key(&cfg.id),
};
if key.trim().is_empty() {
return Err(ChatError::new(
AiErrorKind::Auth,
format!(
"供应商「{}」尚未配置 API Key,请在主设置 → AI 服务中填写",
cfg.name
),
));
}
Ok(key)
}
fn require_model(cfg: &AiProviderConfig) -> Result<String, ChatError> {
let model = cfg.model.trim();
if model.is_empty() {
return Err(ChatError::new(
AiErrorKind::Config,
format!(
"供应商「{}」尚未选择模型,可在设置中拉取模型列表后选择",
cfg.name
),
));
}
Ok(model.to_string())
}
/// 解析请求体公共字段(temperature / max_tokens / extra_body)。
fn apply_common_params(body: &mut serde_json::Map<String, serde_json::Value>, cfg: &AiProviderConfig) {
body.insert("temperature".into(), json!(cfg.temperature));
body.insert("max_tokens".into(), json!(cfg.max_tokens));
if let Some(extra) = cfg.extra_body.as_deref().map(str::trim) {
if !extra.is_empty() {
if let Ok(serde_json::Value::Object(map)) = serde_json::from_str::<serde_json::Value>(extra)
{
for (k, v) in map {
body.insert(k, v);
}
}
}
}
}
/// 按设置选择 HTTP 客户端:开了代理且能解析到 mixed 端口 → 走代理,否则直连。
///
/// 与翻译模块同一姿态:代理不可用时**静默回退直连**,让请求自己去失败。
async fn select_client(settings: &AiSettings, data_dir: &std::path::Path) -> reqwest::Client {
let direct = reqwest::Client::builder()
.timeout(Duration::from_secs(120))
.build()
.unwrap_or_else(|_| reqwest::Client::new());
if !settings.use_proxy {
return direct;
}
let Ok(raw) = std::fs::read_to_string(data_dir.join("proxy").join("settings.json")) else {
return direct;
};
let Ok(value) = serde_json::from_str::<serde_json::Value>(&raw) else {
return direct;
};
let Some(port) = value.get("mixedPort").and_then(|v| v.as_u64()) else {
return direct;
};
if port == 0 || port > 65535 {
return direct;
}
let proxy_url = format!("http://127.0.0.1:{port}");
match reqwest::Proxy::all(&proxy_url).ok().and_then(|p| {
reqwest::Client::builder()
.timeout(Duration::from_secs(120))
.proxy(p)
.build()
.ok()
}) {
Some(client) => client,
None => direct,
}
}
/// 通用对话补全(结构化错误版):消息由调用方全量给定。
async fn post_chat(
cfg: &AiProviderConfig,
messages: Vec<(&str, String)>,
api_key_override: Option<&str>,
settings: &AiSettings,
data_dir: &std::path::Path,
) -> Result<String, ChatError> {
let key = require_key(cfg, api_key_override)?;
let model = require_model(cfg)?;
let endpoint = chat_endpoint(cfg)?;
let mut body = serde_json::Map::new();
body.insert("model".into(), json!(model));
body.insert("stream".into(), json!(false));
body.insert(
"messages".into(),
json!(messages
.into_iter()
.map(|(role, content)| json!({ "role": role, "content": content }))
.collect::<Vec<_>>()),
);
apply_common_params(&mut body, cfg);
let client = select_client(settings, data_dir).await;
let resp = client
.post(&endpoint)
.bearer_auth(&key)
.timeout(Duration::from_millis(DEFAULT_CHAT_TIMEOUT_MS))
.json(&serde_json::Value::Object(body))
.send()
.await
.map_err(|e| classify_reqwest(e, &cfg.name))?;
let status = resp.status();
let raw = resp
.text()
.await
.map_err(|e| {
ChatError::new(
AiErrorKind::Network,
format!("读取「{}」响应失败: {e}", cfg.name),
)
})?;
if !status.is_success() {
return Err(classify_http(status.as_u16(), &raw, &cfg.name, &model));
}
let parsed: ChatResponse = serde_json::from_str(&raw).map_err(|e| {
ChatError::new(
AiErrorKind::Parse,
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(ChatError::new(
AiErrorKind::Unknown,
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(|| {
ChatError::new(AiErrorKind::Empty, format!("「{}」返回了空内容", cfg.name))
})
}
/// 通用对话补全:消息由调用方全量给定。
///
/// 只要文案的调用方(终端 AI 助手)走这里;需要错误分类的用 [`test_provider`]。
pub async fn chat_once(
cfg: &AiProviderConfig,
messages: Vec<(&str, String)>,
settings: &AiSettings,
data_dir: &std::path::Path,
) -> Result<String, String> {
post_chat(cfg, messages, None, settings, data_dir)
.await
.map_err(|e| e.message)
}
/// 连通性自检:发一条极短同步请求。
///
/// `api_key_override` 见 [`require_key`]:设置页「检查」可以带上用户刚填、还没保存的 Key。
pub async fn test_provider(
cfg: &AiProviderConfig,
api_key_override: Option<&str>,
settings: &AiSettings,
data_dir: &std::path::Path,
) -> Result<String, ChatError> {
let started = std::time::Instant::now();
let text = post_chat(
cfg,
vec![
("system", "You are a connectivity probe. Reply with OK only.".to_string()),
("user", PROBE_TEXT.to_string()),
],
api_key_override,
settings,
data_dir,
)
.await?;
Ok(format!(
"连通正常 · 模型 {} · {}ms · 回显「{}」",
cfg.model,
started.elapsed().as_millis() as u64,
text.chars().take(40).collect::<String>()
))
}
/// 拉取上游模型列表(`GET {baseUrl}/models`)。
pub async fn list_models(
cfg: &AiProviderConfig,
settings: &AiSettings,
data_dir: &std::path::Path,
) -> Result<Vec<String>, String> {
list_models_typed(cfg, settings, data_dir)
.await
.map_err(|e| e.message)
}
async fn list_models_typed(
cfg: &AiProviderConfig,
settings: &AiSettings,
data_dir: &std::path::Path,
) -> Result<Vec<String>, ChatError> {
let key = require_key(cfg, None)?;
let endpoint = models_endpoint(cfg)?;
let client = select_client(settings, data_dir).await;
let resp = client
.get(&endpoint)
.bearer_auth(&key)
.timeout(Duration::from_millis(15_000))
.send()
.await
.map_err(|e| classify_reqwest(e, &cfg.name))?;
let status = resp.status();
let raw = resp.text().await.map_err(|e| {
ChatError::new(
AiErrorKind::Network,
format!("读取「{}」模型列表失败: {e}", cfg.name),
)
})?;
if !status.is_success() {
return Err(classify_http(
status.as_u16(),
&raw,
&cfg.name,
cfg.model.as_str(),
));
}
let parsed: ModelsResponse = serde_json::from_str(&raw).map_err(|e| {
ChatError::new(
AiErrorKind::Parse,
format!("「{}」的模型列表无法解析: {e}", cfg.name),
)
})?;
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)
}
fn classify_reqwest(e: reqwest::Error, provider: &str) -> ChatError {
if e.is_timeout() {
return ChatError::new(
AiErrorKind::Timeout,
format!("请求「{provider}」超时,可在设置中调大超时时间,或检查网络"),
);
}
if e.is_connect() {
return ChatError::new(
AiErrorKind::Network,
format!("无法连接「{provider}」:{e}(若该服务在境外,请检查网络或在 AI 设置中开启代理)"),
);
}
ChatError::new(
AiErrorKind::Network,
format!("请求「{provider}」失败:{e}"),
)
}
fn classify_http(status: u16, body: &str, provider: &str, model: &str) -> ChatError {
let snippet = body.trim();
let lower = snippet.to_lowercase();
match status {
401 | 403 => ChatError::new(
AiErrorKind::Auth,
format!("「{provider}」认证失败(HTTP {status}),请检查 API Key 是否正确、是否有该模型的权限"),
),
402 => ChatError::new(
AiErrorKind::Auth,
format!("「{provider}」余额不足或未开通计费(HTTP 402)"),
),
429 => ChatError::new(
AiErrorKind::RateLimit,
format!("「{provider}」请求过于频繁(HTTP 429),请稍后重试或降低频率"),
),
400 | 404 | 422 if lower.contains("model") => ChatError::new(
AiErrorKind::Config,
format!(
"「{provider}」不识别模型「{model}」(HTTP {status}):上游模型名可能已变更,\
请在设置中拉取模型列表后重新选择"
),
),
400 | 404 | 422 => ChatError::new(
AiErrorKind::Config,
format!("「{provider}」拒绝了该请求(HTTP {status})"),
),
408 | 504 => ChatError::new(
AiErrorKind::Timeout,
format!("「{provider}」上游超时(HTTP {status})"),
),
s if (500..600).contains(&s) => ChatError::new(
AiErrorKind::Network,
format!("「{provider}」服务端错误(HTTP {status}),可稍后重试"),
),
s => ChatError::new(AiErrorKind::Unknown, format!("「{provider}」返回 HTTP {s}")),
}
}
// ===== 响应结构(宽松解析) =====
#[derive(Debug, Deserialize)]
struct ChatResponse {
#[serde(default)]
choices: Vec<ChatChoice>,
#[serde(default)]
error: Option<ApiErrorBody>,
}
#[derive(Debug, Deserialize)]
struct ChatChoice {
#[serde(default)]
message: ChatMessage,
}
#[derive(Debug, Default, Deserialize)]
struct ChatMessage {
#[serde(default)]
content: Option<String>,
}
#[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,
}
+218
View File
@@ -0,0 +1,218 @@
//! 全局 AI 模块 Tauri 命令层。
//!
//! 与 translate 命令层同一安全约定:
//! - **不存在读取 API Key 明文的命令**。列表只回传「是否已配置」与掩码;
//! - 写入走 `ai_secret_set`,删除走 `ai_secret_clear`。
use serde::{Serialize};
use specta::Type;
use tauri::State;
use super::{AiErrorKind, AiManager, AiProviderConfig, AiSettings, AiTestResult};
/// 供应商前端视图:配置 + 派生状态(密钥是否已配、是否可用)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AiProviderView {
pub config: AiProviderConfig,
pub has_api_key: bool,
pub api_key_masked: String,
pub ready: bool,
pub issue: Option<String>,
}
/// 读取全局 AI 设置。
#[tauri::command]
#[specta::specta]
pub fn ai_get_settings(state: State<'_, AiManager>) -> Result<AiSettings, String> {
Ok(state.load_settings())
}
/// 保存全局 AI 设置(整体覆盖;供应商列表以传入为准)。
#[tauri::command]
#[specta::specta]
pub fn ai_save_settings(
state: State<'_, AiManager>,
settings: AiSettings,
) -> Result<(), String> {
let mut next = settings;
for p in &mut next.providers {
p.id = p.id.trim().to_string();
p.name = p.name.trim().to_string();
}
next.providers.retain(|p| !p.id.is_empty());
next.heal();
state.save_settings(&next)
}
/// 列出供应商视图(含密钥状态与可用性),保持配置中的顺序。
#[tauri::command]
#[specta::specta]
pub fn ai_list_providers(state: State<'_, AiManager>) -> Result<Vec<AiProviderView>, String> {
let settings = state.load_settings();
Ok(settings.providers.iter().map(to_view).collect())
}
/// 新增或更新一个供应商(按 id upsert)。
///
/// 校验 id:它会进入凭据键(`ai-provider-<id>`),限定为字母/数字/下划线/短横线。
#[tauri::command]
#[specta::specta]
pub fn ai_provider_save(
state: State<'_, AiManager>,
config: AiProviderConfig,
) -> Result<(), String> {
let id = config.id.trim().to_string();
if id.is_empty() {
return Err("供应商标识不能为空".to_string());
}
if !id
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
{
return Err("供应商标识只能包含字母、数字、下划线和短横线".to_string());
}
if config.name.trim().is_empty() {
return Err("供应商名称不能为空".to_string());
}
let mut settings = state.load_settings();
let mut next = config;
next.id = id;
// 输出/上下文夹到合法档位上限(UI 提供档位,后端再兜一道)
next.max_tokens = next.max_tokens.clamp(1, 131_072);
next.max_context = next.max_context.clamp(1_024, 1_048_576);
if next.max_tokens == 0 {
next.max_tokens = super::settings::DEFAULT_MAX_OUTPUT;
}
if next.max_context < 1_024 {
next.max_context = super::settings::DEFAULT_MAX_CONTEXT;
}
match settings.providers.iter_mut().find(|p| p.id == next.id) {
Some(slot) => *slot = next,
None => settings.providers.push(next),
}
// 不按优先级排序:优先级是翻译等模块的场景参数,AI 列表保持添加顺序
state.save_settings(&settings)
}
/// 删除供应商(连同它在系统凭据管理器中的密钥)。
#[tauri::command]
#[specta::specta]
pub fn ai_provider_delete(state: State<'_, AiManager>, id: String) -> Result<(), String> {
let mut settings = state.load_settings();
let before = settings.providers.len();
settings.providers.retain(|p| p.id != id);
if settings.providers.len() == before {
return Err(format!("找不到供应商「{id}」"));
}
if settings.default_provider_id == id {
settings.default_provider_id = "auto".to_string();
}
state.save_settings(&settings)?;
if let Err(e) = crate::secrets::secret_delete(&super::provider_secret_key(&id)) {
crate::logger::log_error("ai", &format!("删除供应商「{id}」的密钥失败: {e}"));
}
Ok(())
}
/// 写入供应商的 API Key(明文只在此处进入系统凭据管理器,永不回写配置文件)。
#[tauri::command]
#[specta::specta]
pub fn ai_secret_set(state: State<'_, AiManager>, id: String, api_key: String) -> Result<(), String> {
if state.load_settings().provider(&id).is_none() {
return Err(format!("找不到供应商「{id}」"));
}
let key = super::provider_secret_key(&id);
let value = api_key.trim();
if value.is_empty() {
return crate::secrets::secret_delete(&key);
}
crate::secrets::secret_write(&key, value)
}
/// 清除供应商的 API Key。
#[tauri::command]
#[specta::specta]
pub fn ai_secret_clear(id: String) -> Result<(), String> {
crate::secrets::secret_delete(&super::provider_secret_key(&id))
}
/// 连通性自检:用前端传入的草稿配置测试(**不落盘**)。
///
/// `api_key` 是可选的「临时密钥」覆盖:设置页允许用户**填好 Key、还没保存**就先检查一次,
/// 省掉「先保存再测试」的来回。它只用于这一次请求——不写凭据管理器、不落配置文件,
/// 也不会被回传到前端;为空时退回凭据管理器里已保存的密钥。
///
/// 之所以仍按 `config.id` 取已保存的密钥作为默认值:多数场景(改 Base URL / 换模型后复测)
/// 用户并不想重新输入 Key。
#[tauri::command]
#[specta::specta]
pub async fn ai_provider_test(
state: State<'_, AiManager>,
config: AiProviderConfig,
api_key: Option<String>,
) -> Result<AiTestResult, String> {
if config.id.trim().is_empty() || config.name.trim().is_empty() {
return Ok(AiTestResult::failure(
AiErrorKind::Config,
"供应商标识或名称不能为空,请先保存一次".to_string(),
0,
));
}
let settings = state.load_settings();
let data_dir = state.data_dir().to_path_buf();
let started = std::time::Instant::now();
let override_key = api_key.as_deref();
match super::test_provider(&config, override_key, &settings, &data_dir).await {
Ok(message) => Ok(AiTestResult::success(
message,
started.elapsed().as_millis() as u64,
)),
Err(e) => Ok(AiTestResult::failure(
e.kind,
e.message,
started.elapsed().as_millis() as u64,
)),
}
}
/// 拉取上游模型列表(按已保存的 id;密钥/地址取自磁盘上的配置与凭据库)。
#[tauri::command]
#[specta::specta]
pub async fn ai_provider_models(
state: State<'_, AiManager>,
id: String,
) -> Result<Vec<String>, String> {
let settings = state.load_settings();
let cfg = settings
.provider(&id)
.cloned()
.ok_or_else(|| format!("找不到供应商「{id}」"))?;
let data_dir = state.data_dir().to_path_buf();
super::list_models(&cfg, &settings, &data_dir).await
}
/// 构造供应商视图并给出「是否可用」的判断。
fn to_view(cfg: &AiProviderConfig) -> AiProviderView {
let raw_key = super::provider_api_key(&cfg.id);
let has_api_key = !raw_key.trim().is_empty();
let issue = if cfg.base_url.trim().is_empty() {
Some("未配置 Base URL".to_string())
} else if cfg.model.trim().is_empty() {
Some("未选择模型".to_string())
} else if !has_api_key {
Some("未配置 API Key".to_string())
} else {
None
};
AiProviderView {
config: cfg.clone(),
has_api_key,
api_key_masked: crate::secrets::mask(&raw_key),
ready: issue.is_none() && cfg.enabled,
issue,
}
}
+172
View File
@@ -0,0 +1,172 @@
//! 全局 AI 模块:供应商配置 + OpenAI 兼容客户端。
//!
//! 架构位置(主应用层,不属于任何业务模块):
//!
//! ```text
//! 主设置 → AI 服务卡片
//! ↓ Tauri IPC
//! commands.rs 命令层(列表 / CRUD / 密钥 / 测连通 / 拉模型)
//! ↓
//! AiManager(本文件):设置读写 / 凭据键 / 自愈
//! ↓
//! chat.rs chat_once / test / list_models(OpenAI 兼容)
//! ↓ reqwest
//! DeepSeek / OpenAI / Gemini / 通义 / Kimi / 智谱 / Ollama …
//! ```
//!
//! 消费方:
//! - **翻译模块**:把已加入翻译候选的供应商转换为 TranslateEngineConfig(kind = "ai"),
//! 密钥经 [`provider_api_key`] 读取;翻译专属的提示词模板与优先级仍在 translate 设置。
//! - **终端 AI 助手**:直接列本模块的供应商并调用 [`chat::chat_once`]。
//!
//! **依赖方向:只出不进。** 本模块不引用任何业务模块(translate / terminal …)——
//! 它们是消费者,我们是被消费者。连「把历史翻译设置里的 AI 引擎搬过来」这类一次性
//! 迁移也不在这里:那段代码必然要同时读懂两边,因此归 translate 侧
//! (`translate::migrate_legacy_ai_engines`),由 `setup.rs` 在启动时调用一次。
//!
//! 安全姿态与 translate 一致:**网络只在 Rust 侧发生**;API Key 只进系统凭据管理器
//! (键名 `ai-provider-<id>`),不落 `settings.json`、不经前端明文回传。
mod chat;
mod commands;
mod settings;
mod test_result;
pub use chat::{chat_once, list_models, test_provider};
pub use commands::{
ai_get_settings, ai_list_providers, ai_provider_delete, ai_provider_models,
ai_provider_save, ai_provider_test, ai_save_settings, ai_secret_clear, ai_secret_set,
};
pub use settings::{AiProviderConfig, AiSettings, DEFAULT_CHAT_TIMEOUT_MS, DEFAULT_MAX_CONTEXT};
pub use test_result::{AiErrorKind, AiTestResult};
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::time::{Duration, Instant};
/// 设置内存缓存有效期(与 translate / music 的 500ms 一致)。
const SETTINGS_CACHE_TTL: Duration = Duration::from_millis(500);
/// 供应商 API Key 的凭据键前缀。
const PROVIDER_KEY_PREFIX: &str = "ai-provider-";
/// 某供应商实例的凭据键。
pub fn provider_secret_key(provider_id: &str) -> String {
format!("{PROVIDER_KEY_PREFIX}{provider_id}")
}
/// 读取某供应商的 API Key(未配置或读取失败 → 空串)。
///
/// 只认 `ai-provider-*`。历史上 AI 引擎曾把密钥存在 translate 的 `translate-engine-*`
/// 下,那份由一次性迁移复制过来;这里不做回退读取——回退等于让本模块永久依赖
/// translate 的键名约定。迁移复制失败时会记日志,用户在设置页重填即可(界面会显示
/// 「未配置 API Key」,不会静默走错端点)。
pub fn provider_api_key(provider_id: &str) -> String {
if provider_id.trim().is_empty() {
return String::new();
}
crate::secrets::read_or_empty(&provider_secret_key(provider_id))
}
/// 写入 AI 设置文件(`{data_dir}/ai/settings.json`,目录不存在时创建)。
///
/// 除 `AiManager` 外还单独暴露成自由函数:启动阶段的一次性迁移(由 translate 侧发起)
/// 需要在 `AiManager` 尚未注册为 State 时写这份文件。
pub fn write_settings(data_dir: &Path, settings: &AiSettings) -> Result<(), String> {
let root = data_dir.join("ai");
std::fs::create_dir_all(&root).map_err(|e| format!("创建 AI 目录失败: {e}"))?;
let json =
serde_json::to_string_pretty(settings).map_err(|e| format!("序列化 AI 设置失败: {e}"))?;
std::fs::write(root.join("settings.json"), json).map_err(|e| format!("写入 AI 设置失败: {e}"))
}
struct SettingsCache {
read_at: Instant,
settings: AiSettings,
}
/// 全局 AI 管理器(Tauri State)。
pub struct AiManager {
/// 应用数据目录(与 translate 同级,代理配置也在这一层)
data_dir: PathBuf,
/// 模块自身目录:{app_data_dir}/ai
root: PathBuf,
cache: Mutex<Option<SettingsCache>>,
}
impl AiManager {
pub fn new(app_data_dir: PathBuf) -> Self {
let root = app_data_dir.join("ai");
std::fs::create_dir_all(&root).ok();
Self {
data_dir: app_data_dir,
root,
cache: Mutex::new(None),
}
}
fn settings_path(&self) -> PathBuf {
self.root.join("settings.json")
}
/// 应用数据目录(chat 模块解析代理配置用)。
pub fn data_dir(&self) -> &Path {
&self.data_dir
}
/// 读取设置(带短时缓存;文件缺失时回退默认值;自愈结果落盘)。
pub fn load_settings(&self) -> AiSettings {
if let Ok(cache) = self.cache.lock() {
if let Some(entry) = cache.as_ref() {
if entry.read_at.elapsed() < SETTINGS_CACHE_TTL {
return entry.settings.clone();
}
}
}
let mut settings = std::fs::read_to_string(self.settings_path())
.ok()
.and_then(|s| serde_json::from_str::<AiSettings>(&s).ok())
.unwrap_or_default();
let healed = settings.heal();
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
settings: settings.clone(),
});
}
if healed {
if let Err(e) = self.save_settings(&settings) {
crate::logger::log_error("ai", &format!("设置自愈落盘失败: {e}"));
}
}
settings
}
/// 保存设置并刷新缓存。
pub fn save_settings(&self, settings: &AiSettings) -> Result<(), String> {
write_settings(&self.data_dir, settings)?;
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
settings: settings.clone(),
});
}
Ok(())
}
/// 同步读取 AI 设置(**不经 AiManager 缓存**,供 translate 等在无 State 时使用)。
///
/// 调用前应保证一次性迁移已跑过(`setup::init` 里在建 State 之前调用
/// `translate::migrate_legacy_ai_engines`);文件缺失时回退默认值并自愈,
/// 但不写盘——落盘权在 [`write_settings`] 的调用方。
pub fn load_settings_sync(data_dir: &Path) -> AiSettings {
let path = data_dir.join("ai").join("settings.json");
let mut settings = std::fs::read_to_string(path)
.ok()
.and_then(|s| serde_json::from_str::<AiSettings>(&s).ok())
.unwrap_or_default();
settings.heal();
settings
}
}
+213
View File
@@ -0,0 +1,213 @@
//! 全局 AI 供应商配置(主应用设置)。
//!
//! 持久化位置:`{app_data_dir}/ai/settings.json`。
//! 容器级 `#[serde(default)]`:新增字段对旧配置文件向后兼容。
//!
//! 设计边界(对齐主流桌面 Agent 的「模型/连接」设置):
//! - **本模块只管引擎本身**:Base URL、模型、密钥、最大输出、最大上下文等
//! 与具体调用场景无关的连接与生成参数。
//! - **模块自己的参数留在各模块**:翻译的优先级 / 超时 / 提示词覆盖在
//! translate 设置里(`TranslateAiParams`),终端等调用方自带超时与 system prompt。
//!
//! 安全姿态:**API Key 不在这里**。明文一律进系统凭据管理器,
//! 键名约定 `ai-provider-<id>`(见 [`super::provider_secret_key`])。
use serde::{Deserialize, Serialize};
use specta::Type;
/// 通用对话默认超时(毫秒)。供应商级超时已下沉到翻译等模块。
pub const DEFAULT_CHAT_TIMEOUT_MS: u64 = 60_000;
/// 最大输出(completion tokens)默认值与可选档位(上限 128K)。
pub const DEFAULT_MAX_OUTPUT: u32 = 8_192;
#[allow(dead_code)] // 档位表与前端 AI_PRESETS / Select 选项保持一致,供后续命令校验复用
pub const MAX_OUTPUT_OPTIONS: [u32; 6] = [4_096, 8_192, 16_384, 32_768, 65_536, 131_072];
/// 最大上下文(context window tokens)默认值与可选档位(上限 1M)。
pub const DEFAULT_MAX_CONTEXT: u32 = 131_072;
#[allow(dead_code)]
pub const MAX_CONTEXT_OPTIONS: [u32; 6] =
[32_768, 65_536, 131_072, 262_144, 524_288, 1_048_576];
/// 单个 AI 供应商实例(OpenAI 兼容端点)。
///
/// 「实例」而非「类型」:同一厂商可配置多份(官方 API 与本地 Ollama 并存)。
/// 翻译、终端助手等模块共用连接与生成参数;场景参数(优先级、超时、提示词)
/// 由各模块自行维护。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct AiProviderConfig {
/// 实例唯一标识(同时是凭据键的一部分,创建后不建议修改)
pub id: String,
/// 展示名称
pub name: String,
/// 预设标识:"deepseek" | "openai" | "gemini" | "qwen" | "kimi" | "zhipu"
/// | "doubao" | "mimo" | "mistral" | "groq" | "openrouter" | "siliconflow"
/// | "ollama" | "lmstudio" | "custom" …
pub preset: String,
/// 是否启用(关闭后各模块不再把此供应商当候选)
pub enabled: bool,
/// API 根地址(末尾可有可无 /,不可含 /chat/completions)
pub base_url: String,
/// 模型标识
pub model: String,
/// 采样温度
pub temperature: f64,
/// 最大输出 tokens(completion 上限,对齐 Agent 常见的「回答长度」)
pub max_tokens: u32,
/// 最大上下文窗口 tokens(模型可接受的输入+输出规模,供调用方截断与展示)
pub max_context: u32,
/// 额外请求体字段的 JSON 文本(thinking / enable_thinking 等非标准参数)
pub extra_body: Option<String>,
/// 是否支持图像输入(多模态能力声明;截图翻译「视觉直传」只发给勾选了此项的供应商)
#[serde(default)]
pub supports_vision: bool,
// ===== 旧字段:只读入历史 JSON,迁移后写到 translate.aiParams,不再序列化 =====
/// 旧:供应商级优先级(历史键 `priority`)
#[serde(default, alias = "priority", skip_serializing)]
pub legacy_priority: Option<i32>,
/// 旧:供应商级超时(历史键 `timeoutMs`)
#[serde(default, alias = "timeoutMs", skip_serializing)]
pub legacy_timeout_ms: Option<u64>,
/// 旧:翻译 system prompt 覆盖(历史键 `systemPrompt`)
#[serde(default, alias = "systemPrompt", skip_serializing)]
pub legacy_system_prompt: Option<String>,
}
impl Default for AiProviderConfig {
fn default() -> Self {
Self {
id: String::new(),
name: String::new(),
preset: "custom".to_string(),
enabled: true,
base_url: String::new(),
model: String::new(),
temperature: 0.3,
max_tokens: DEFAULT_MAX_OUTPUT,
max_context: DEFAULT_MAX_CONTEXT,
extra_body: None,
supports_vision: false,
legacy_priority: None,
legacy_timeout_ms: None,
legacy_system_prompt: None,
}
}
}
impl AiProviderConfig {
/// 内置 DeepSeek 预设:默认供应商。模型标识取现行名 `deepseek-flash`
/// (`deepseek-chat` / `deepseek-reasoner` 已于 2026-07-24 停用)。
///
/// 其余预设只在前端 `AI_PRESETS`(`src/types/ai.ts`)维护模板;
/// 后端不硬编码供应商清单——预设标识只是个字符串,谁来加都行。
pub fn deepseek_default() -> Self {
Self {
id: "deepseek".to_string(),
name: "DeepSeek Flash".to_string(),
preset: "deepseek".to_string(),
enabled: true,
base_url: "https://api.deepseek.com".to_string(),
model: "deepseek-flash".to_string(),
temperature: 0.3,
max_tokens: DEFAULT_MAX_OUTPUT,
max_context: DEFAULT_MAX_CONTEXT,
extra_body: None,
supports_vision: false,
legacy_priority: None,
legacy_timeout_ms: None,
legacy_system_prompt: None,
}
}
/// 取出旧场景参数(若历史 JSON 带有 priority/timeoutMs/systemPrompt)。
pub fn take_legacy(&mut self) -> Option<(i32, u64, String)> {
let p = self.legacy_priority.take();
let t = self.legacy_timeout_ms.take();
let s = self.legacy_system_prompt.take();
match (p, t, s) {
(None, None, None) => None,
(p, t, s) => Some((
p.unwrap_or(100),
t.unwrap_or(30_000),
s.unwrap_or_default(),
)),
}
}
}
/// 全局 AI 设置根结构。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct AiSettings {
/// 结构版本号:1 = 含供应商级场景参数;2 = 场景参数下沉到各模块
pub version: u32,
/// 供应商实例列表
pub providers: Vec<AiProviderConfig>,
/// 默认供应商 id("auto" 表示不指定;主要给终端等简单消费方)
pub default_provider_id: String,
/// AI 请求是否走代理模块(mihomo mixed 端口)。
/// 默认关闭:DeepSeek 等境内可直连;境外服务由用户显式打开。
pub use_proxy: bool,
}
impl Default for AiSettings {
fn default() -> Self {
Self {
version: 2,
providers: vec![AiProviderConfig::deepseek_default()],
default_provider_id: "deepseek".to_string(),
use_proxy: false,
}
}
}
impl AiSettings {
/// 按 id 找供应商实例。
pub fn provider(&self, id: &str) -> Option<&AiProviderConfig> {
self.providers.iter().find(|p| p.id == id)
}
/// 自愈:列表为空时补回 DeepSeek;默认 id 失效时回落到「自动」;
/// 输出/上下文越界时夹回档位上限;版本推进到 2。
/// 返回是否发生了变更(由调用方决定落盘)。
pub fn heal(&mut self) -> bool {
let mut changed = false;
if self.providers.is_empty() {
self.providers.push(AiProviderConfig::deepseek_default());
changed = true;
}
for p in &mut self.providers {
if p.max_tokens == 0 {
p.max_tokens = DEFAULT_MAX_OUTPUT;
changed = true;
}
if p.max_context == 0 {
p.max_context = DEFAULT_MAX_CONTEXT;
changed = true;
}
if p.max_tokens > 131_072 {
p.max_tokens = 131_072;
changed = true;
}
if p.max_context > 1_048_576 {
p.max_context = 1_048_576;
changed = true;
}
}
if self.default_provider_id.trim().is_empty() {
self.default_provider_id = "auto".to_string();
changed = true;
}
if self.default_provider_id != "auto" && self.provider(&self.default_provider_id).is_none() {
self.default_provider_id = "auto".to_string();
changed = true;
}
if self.version < 2 {
self.version = 2;
changed = true;
}
changed
}
}
+66
View File
@@ -0,0 +1,66 @@
//! 连通性自检结果与错误分类(与翻译模块 EngineTestResult 同形,失败也返回 Ok)。
use serde::Serialize;
use specta::Type;
/// AI 请求的错误分类。
///
/// **本模块自带一份,不复用 `translate::ErrorKind`**:AI 服务是独立的底座,
/// 不反向依赖任何业务模块(否则「谁依赖谁」会随功能增长变得无法收敛)。
/// 变体名与 translate 的同名枚举刻意保持一致,前端可以共用一套提示文案;
/// 只保留 AI 侧**真会产生的**分类(translate 的 unsupported / captcha 是翻译专属语义)。
/// 将来若两者要做共享层,再把这个枚举上提合并。
#[derive(Debug, Clone, Copy, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AiErrorKind {
/// 配置问题:Base URL / 模型名不对
Config,
/// 认证问题:API Key 无效、无该模型权限、余额不足
Auth,
/// 上游限流
RateLimit,
/// 网络不可达 / 上游服务端错误
Network,
/// 超时
Timeout,
/// 响应格式异常
Parse,
/// 上游返回空内容
Empty,
/// 其它未分类错误
Unknown,
}
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AiTestResult {
pub ok: bool,
pub latency_ms: u64,
pub message: String,
pub error_kind: Option<AiErrorKind>,
pub detail: Option<String>,
}
impl AiTestResult {
/// 失败结果。`kind` 来自 [`crate::ai::chat::ChatError`]——前端据此给出
/// 「改 Key」「查网络」这类不同的下一步提示。
pub fn failure(kind: AiErrorKind, message: String, latency_ms: u64) -> Self {
Self {
ok: false,
latency_ms,
message,
error_kind: Some(kind),
detail: None,
}
}
pub fn success(message: String, latency_ms: u64) -> Self {
Self {
ok: true,
latency_ms,
message,
error_kind: None,
detail: None,
}
}
}
+21
View File
@@ -19,6 +19,13 @@ pub mod windows {
/// 终端独立窗口前缀,实际 label = `${TERMINAL_WINDOW}-<sessionId>`
/// 每个终端窗口承载一个会话,脱离主窗口独立存在。
pub const TERMINAL_WINDOW: &str = "terminal-window";
/// 文件管理器独立窗口。**单例**(label 固定,不含会话 id):
/// 它不绑定会话,左右两栏各自选择连接,因此没有「每会话一个窗口」的语义。
pub const FILE_WINDOW: &str = "file-window";
/// dsh 模块的 Web UI 独立窗口(内容是远端 `http://127.0.0.1:<port>`,
/// 因此**不登记 capability**:远端页面不应获得任何 Tauri 权限)。
#[allow(dead_code)]
pub const DSH_WEB: &str = "dsh-web";
}
/// Tauri 事件名(与前端 constants::EVENTS 对应)
@@ -102,6 +109,13 @@ pub mod events {
pub const TERMINAL_SETTINGS: &str = "terminal-settings";
// 音乐模块:下载任务事件(桥接事件行 → 前端,负载见 bridge.py _emit_event)
pub const MUSIC_DOWNLOAD_EVENT: &str = "music-download-event";
// 音乐模块:本地解密任务事件(负载见 music::decrypt::DecryptEvent)
// 与下载链路同构:命令先回 taskId,进度与逐文件结果都走这个事件。
pub const MUSIC_DECRYPT_EVENT: &str = "music-decrypt-event";
// 音乐模块:Rust 侧播放引擎(music/audio)。曲目自然播完(缓冲也放完)后发出,无负载
pub const MUSIC_AUDIO_ENDED: &str = "music-audio-ended";
/// 音乐模块:Rust 侧播放失败(音源打不开 / 解码失败 / 输出设备异常),负载为错误文本
pub const MUSIC_AUDIO_ERROR: &str = "music-audio-error";
// 后端自动切换节点完成(前端据以刷新节点列表并提示)
pub const PROXY_AUTO_SWITCH: &str = "proxy-auto-switch";
// 应用更新进度
@@ -113,4 +127,11 @@ pub mod events {
pub const DOWNLOAD_REMOVED: &str = "download-removed";
/// 浏览器扩展通过 HTTP API 新增下载(负载 { id },前端据以为该任务创建专属下载窗口)
pub const DOWNLOAD_EXTENSION_ADDED: &str = "download-extension-added";
// dsh 模块:安装/下载进度(负载见 dsh::types::DshInstallProgress)
pub const DSH_INSTALL_PROGRESS: &str = "dsh-install-progress";
// dsh 模块:服务进程状态(负载见 dsh::types::DshServerStatus)
pub const DSH_SERVER_STATE: &str = "dsh-server-state";
/// dsh 模块:全局快捷键触发「打开独立窗口」(无负载)。
/// 窗口由前端创建(它持有带令牌的地址与 label 判重),Rust 侧只负责注册快捷键。
pub const DSH_OPEN_WINDOW: &str = "dsh-open-window";
}
+23 -7
View File
@@ -235,7 +235,12 @@ impl DownloadEngine {
let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
self.ensure_mihomo_proxy().await;
let probe = self.inner.http.probe(url, headers, use_proxy).await;
// 交互式校验(「添加下载」对话框):用户在等结果,保留探测超时避免界面卡死
let probe = self
.inner
.http
.probe(url, headers, use_proxy, Some(super::http_dl::PROBE_TIMEOUT))
.await;
let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
let task_dir = dir.map(|d| d.to_string()).unwrap_or_else(|| settings.download_dir.clone());
@@ -390,13 +395,17 @@ impl DownloadEngine {
/// 生成不冲突的文件名(同名时追加 (1)、(2)...)
/// 冲突来源:磁盘已有同名最终文件、已存在同名临时文件(其他任务正在下载该名)、
/// 以及任务列表中已有任务占用同名(即使最终文件尚未落盘,避免共用同一 .thingdl 临时文件)
fn generate_unique_filename(&self, dir: &str, filename: &str) -> String {
///
/// `exclude_id`:把某个任务排除在「已占用」之外。探测完成后用真实文件名重命名时
/// 必须传自己的 id —— 否则会与**自己**的占位文件名相撞,把每一个下载都改名成
/// `xxx (1).ext`(探测文件名与 URL 推导名一致时必现)。
fn generate_unique_filename(&self, dir: &str, filename: &str, exclude_id: Option<&str>) -> String {
// 任务列表中已占用的文件名(同一目录下)
let taken: std::collections::HashSet<String> = {
let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks
.values()
.filter(|t| t.dir == dir)
.filter(|t| t.dir == dir && Some(t.id.as_str()) != exclude_id)
.map(|t| t.filename.clone())
.collect()
};
@@ -487,7 +496,7 @@ impl DownloadEngine {
.unwrap_or_else(|| format!("download_{}", chrono::Utc::now().timestamp()))
});
if auto_rename {
task_filename = self.generate_unique_filename(&task_dir, &task_filename);
task_filename = self.generate_unique_filename(&task_dir, &task_filename, None);
}
// 3) 立即插入占位任务:Queued(未探测完成前 schedule 会跳过),未知大小单段
@@ -536,7 +545,13 @@ impl DownloadEngine {
let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
tauri::async_runtime::spawn(async move {
engine.ensure_mihomo_proxy().await;
let probe = engine.inner.http.probe(&raw_url, &raw_headers, use_proxy).await;
// 后台探测不设超时:服务器慢就继续等(与下载路径一致),
// 只有真正失败才置 Error;用户暂停/取消走任务的取消标志。
let probe = engine
.inner
.http
.probe(&raw_url, &raw_headers, use_proxy, None)
.await;
// 探测结束,解除 pending 门控
engine
@@ -591,10 +606,11 @@ impl DownloadEngine {
}
};
// 释放 tasks 锁后,若探测返回了真实文件名,重新做唯一化并写回
// 释放 tasks 锁后,若探测返回了真实文件名,重新做唯一化并写回。
// 必须排除自己(`&rid`):占位名往往与探测名相同,不排除就会和自己相撞而改名成 (1)
if let Some((dir_owned, Some(real_name))) = rename_from {
let final_name = if auto_rename {
engine.generate_unique_filename(&dir_owned, &real_name)
engine.generate_unique_filename(&dir_owned, &real_name, Some(&rid))
} else {
real_name
};
+76 -25
View File
@@ -13,11 +13,49 @@ use tokio::task::JoinSet;
use super::rate_limit::RateLimiter;
use super::task::{ProbeResult, Segment};
/// 请求超时:连接 + 响应头必须在 30s 内就绪(分段请求若无超时,
/// 服务器挂死时任务将永久卡在 Active,pause→resume 会出现新旧任务并发写同一临时文件)
const REQUEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 分块读取停滞超时:30s 内无任何数据视为连接挂死,主动中断(配合取消标志及时退出)
const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 取消轮询间隔。
///
/// **这不是下载超时**:下载路径不再因「长时间无数据/无响应头」中断,服务器慢就继续等,
/// 只有用户暂停/取消或真正报错才结束。这个 200ms 轮询的唯一作用是让暂停/取消在
/// 「连接挂死、`stream.next()` 一直 pending」时也能及时被感知——
/// 否则等待 future 永不返回,取消标志就永远读不到。
const CANCEL_POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(200);
/// 交互式探测超时(仅用于「添加下载」校验等用户正盯着界面等结果的场景:
/// 无限等待等于界面卡死)。真正的下载/后台探测路径不设超时。
pub const PROBE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 等待一个 future 完成,期间每 200ms 检查一次取消标志;**不设超时**。
///
/// 返回 `Err("已取消")` 表示用户暂停/取消(调用方据此把任务置为 Paused 而非 Error)。
async fn wait_cancellable<F>(fut: F, cancel: &AtomicBool) -> Result<F::Output, String>
where
F: std::future::Future,
{
tokio::pin!(fut);
loop {
if cancel.load(Ordering::SeqCst) {
return Err("已取消".to_string());
}
tokio::select! {
biased;
_ = tokio::time::sleep(CANCEL_POLL_INTERVAL) => continue,
out = &mut fut => return Ok(out),
}
}
}
/// 按需给「发送请求」加超时:`None` 表示不设超时(服务器慢就继续等)。
/// `Err(())` 只表示超时,这样调用方能把它与「请求失败」区分开(后者要回退 HEAD)。
async fn send_with_optional_timeout(
req: reqwest::RequestBuilder,
timeout: Option<std::time::Duration>,
) -> Result<reqwest::Result<reqwest::Response>, ()> {
match timeout {
Some(d) => tokio::time::timeout(d, req.send()).await.map_err(|_| ()),
None => Ok(req.send().await),
}
}
/// HTTP/HTTPS 下载器
#[derive(Clone)]
@@ -97,19 +135,23 @@ impl HttpDownloader {
/// 探测下载资源信息(大小、是否支持 Range、文件名)
/// 优先用 GET + Range: bytes=0-0(返回 206 + Content-Range),回退到 HEAD。
/// 代理降级:use_proxy=true 时先走系统代理,失败则回退 no_proxy 直连重试一次
/// 代理降级:use_proxy=true 时先走系统代理,失败则回退 no_proxy 直连重试一次。
///
/// `timeout`:`Some` 用于交互式探测(用户正等界面结果);`None` 表示不设超时
/// (后台探测,如更新包下载,服务器慢就继续等)。
pub async fn probe(
&self,
url: &str,
headers: &HashMap<String, String>,
use_proxy: bool,
timeout: Option<std::time::Duration>,
) -> Result<ProbeResult, String> {
let first = self.client(use_proxy);
match self.probe_with_client(&first, url, headers).await {
match self.probe_with_client(&first, url, headers, timeout).await {
Ok(r) => return Ok(r),
Err(e) if use_proxy => {
let direct = self.client(false);
self.probe_with_client(&direct, url, headers)
self.probe_with_client(&direct, url, headers, timeout)
.await
.map_err(|e2| format!("代理探测失败({}),直连重试也失败({})", e, e2))
}
@@ -123,6 +165,7 @@ impl HttpDownloader {
client: &Client,
url: &str,
headers: &HashMap<String, String>,
timeout: Option<std::time::Duration>,
) -> Result<ProbeResult, String> {
// 先尝试 Range 请求(能同时判断 Accept-Ranges 和获取大小)
let mut req = client
@@ -133,10 +176,14 @@ impl HttpDownloader {
req = req.header(k, v);
}
match tokio::time::timeout(REQUEST_TIMEOUT, req.send())
.await
.map_err(|_| "探测超时(30s 内未收到响应头)".to_string())?
{
// 先拿到「发送结果」:超时(仅交互式探测会有)直接上抛,
// 发送失败则回退 HEAD。注意不能把发送失败也上抛——那会让 HEAD 回退失效。
let first = match send_with_optional_timeout(req, timeout).await {
Err(()) => return Err("探测超时(未收到响应头)".to_string()),
Ok(r) => r,
};
match first {
Ok(resp) => {
let status = resp.status();
let headers_map = resp.headers().clone();
@@ -185,9 +232,9 @@ impl HttpDownloader {
for (k, v) in headers {
head_req = head_req.header(k, v);
}
let resp = tokio::time::timeout(REQUEST_TIMEOUT, head_req.send())
let resp = send_with_optional_timeout(head_req, timeout)
.await
.map_err(|_| "探测超时(HEAD 30s 内未收到响应头)".to_string())?
.map_err(|_| "探测超时(HEAD 未收到响应头)".to_string())?
.map_err(|e| format!("探测失败(GET 和 HEAD 均失败): {}", e))?;
let headers_map = resp.headers().clone();
let total_size = headers_map
@@ -421,9 +468,10 @@ async fn download_segment_with_client(
req = req.header(k, v);
}
let resp = tokio::time::timeout(REQUEST_TIMEOUT, req.send())
.await
.map_err(|_| "请求超时(30s 内未收到响应头)".to_string())?
// 等响应头:不设超时(服务器慢就继续等),但期间轮询取消标志,
// 保证用户暂停/取消时能立刻中断这次请求。
let resp = wait_cancellable(req.send(), &cancel)
.await?
.map_err(|e| format!("请求失败: {}", e))?;
let status = resp.status();
@@ -453,9 +501,14 @@ async fn download_segment_with_client(
return Err("已取消".to_string());
}
// 停滞超时:30s 无数据即中断,确保 cancel 标志能及时被感知(配合代际句柄防并发写)
match tokio::time::timeout(READ_STALL_TIMEOUT, stream.next()).await {
Ok(Some(Ok(chunk))) => {
// 读数据:**不做停滞超时**——30s 无数据不代表失败(慢速源、网络抖动很常见),
// 只要用户没暂停就继续等。select 里那个 200ms 计时器只负责周期性回到循环头
// 读一次取消标志:否则 `stream.next()` 一直 pending 时暂停/取消永远感知不到。
tokio::select! {
biased;
_ = tokio::time::sleep(CANCEL_POLL_INTERVAL) => continue,
next = stream.next() => match next {
Some(Ok(chunk)) => {
buf.extend_from_slice(&chunk);
// 接收到数据立即更新进度(避免监控周期内进度无变化导致速度显示为 0)
local_completed += chunk.len() as u64;
@@ -470,10 +523,10 @@ async fn download_segment_with_client(
buf.clear();
}
}
Ok(Some(Err(e))) => {
Some(Err(e)) => {
return Err(format!("读取数据失败: {}", e));
}
Ok(None) => {
None => {
// 流结束,写入剩余数据
if !buf.is_empty() {
file.write_all(&buf)
@@ -494,9 +547,7 @@ async fn download_segment_with_client(
}
break;
}
Err(_) => {
return Err("读取超时(30s 无数据,已中断下载)".to_string());
}
},
}
}
+253
View File
@@ -0,0 +1,253 @@
//! AI 装载:把主设置(AI 服务)里的供应商映射进 dsh 的 `$DSH_HOME/settings.yaml`,
//! 并在启动服务时以环境变量注入 API Key。
//!
//! 安全姿态(对齐 `crate::ai` 与 `crate::secrets`):**密钥不落盘**。
//! settings.yaml 里只写 `apiKeyEnv`(环境变量名),明文由
//! [`crate::ai::provider_api_key`] 从系统凭据管理器读出后随子进程环境注入。
//!
//! 合并规则:只替换 `llm-pi-ai.providers` 下本模块管理的 `thing-*` 键与
//! `agent-default-model`,用户自己写的其它段落(profile patch / 第三方插件配置)
//! 原样保留;写盘前把旧文件备份为 `settings.yaml.bak`。
use serde_yaml::{Mapping, Value};
use tauri::AppHandle;
use super::types::{DshAiPreview, DshAiProvider};
use super::DshManager;
/// 本模块写入 settings.yaml 的供应商键前缀。
const PROVIDER_PREFIX: &str = "thing-";
/// `llm-pi-ai` 段名(dsh 的通用 OpenAI 兼容提供方插件)。
const LLM_SECTION: &str = "llm-pi-ai";
/// 默认模型段名。
const DEFAULT_MODEL_SECTION: &str = "agent-default-model";
impl DshManager {
/// dsh 侧供应商键(`thing-<id>`,只保留小写字母数字与短横线)。
fn dsh_provider_id(id: &str) -> String {
let sanitized: String = id
.trim()
.to_lowercase()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
.collect();
format!("{PROVIDER_PREFIX}{sanitized}")
}
/// 环境变量名(`THING_AI_<ID>_KEY`)。
fn env_name(id: &str) -> String {
let sanitized: String = id
.trim()
.to_uppercase()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
.collect();
format!("THING_AI_{sanitized}_KEY")
}
/// settings.yaml 路径(`$DSH_HOME/settings.yaml`)。
pub fn dsh_settings_path(&self) -> std::path::PathBuf {
self.home_dir().join("settings.yaml")
}
/// 当前将被映射的供应商列表(enabled 且 baseUrl 非空)。
pub fn ai_providers(&self) -> Vec<DshAiProvider> {
let settings = crate::ai::AiManager::load_settings_sync(&self.data_dir);
settings
.providers
.iter()
.filter(|p| p.enabled && !p.base_url.trim().is_empty() && !p.model.trim().is_empty())
.map(|p| DshAiProvider {
id: p.id.clone(),
name: p.name.clone(),
env_name: Self::env_name(&p.id),
base_url: p.base_url.clone(),
model: p.model.clone(),
has_key: !crate::ai::provider_api_key(&p.id).is_empty(),
})
.collect()
}
/// 构造本模块管理的配置片段(`llm-pi-ai.providers` + `agent-default-model`)。
fn build_patch(&self) -> (Mapping, Value, Option<String>, Option<String>) {
let settings = crate::ai::AiManager::load_settings_sync(&self.data_dir);
let mut providers = Mapping::new();
let mut default_pair: Option<(String, String)> = None;
let wanted = self.load_settings().provider_id;
for p in settings.providers.iter() {
if !p.enabled || p.base_url.trim().is_empty() || p.model.trim().is_empty() {
continue;
}
let dsh_id = Self::dsh_provider_id(&p.id);
let mut entry = Mapping::new();
entry.insert(
Value::String("displayName".into()),
Value::String(if p.name.trim().is_empty() {
p.id.clone()
} else {
p.name.clone()
}),
);
entry.insert(
Value::String("api".into()),
Value::String("openai-completions".into()),
);
entry.insert(
Value::String("baseURL".into()),
Value::String(p.base_url.trim().trim_end_matches('/').to_string()),
);
entry.insert(
Value::String("apiKeyEnv".into()),
Value::String(Self::env_name(&p.id)),
);
// 模型目录:当前模型 + 常见上下文窗口(字段名以 dsh 的 catalog 为准,
// 这里只写最稳定的 id/name,避免写错字段导致 dsh 拒绝配置)
let mut model = Mapping::new();
model.insert(Value::String("id".into()), Value::String(p.model.clone()));
model.insert(Value::String("name".into()), Value::String(p.model.clone()));
entry.insert(
Value::String("models".into()),
Value::Sequence(vec![Value::Mapping(model)]),
);
providers.insert(Value::String(dsh_id.clone()), Value::Mapping(entry));
let is_wanted = p.id == wanted || (wanted.is_empty() && default_pair.is_none());
if is_wanted {
default_pair = Some((dsh_id, p.model.clone()));
}
}
let default_value = match &default_pair {
Some((provider, model)) => {
let mut m = Mapping::new();
m.insert(Value::String("provider".into()), Value::String(provider.clone()));
m.insert(Value::String("model".into()), Value::String(model.clone()));
Value::Mapping(m)
}
None => Value::Null,
};
let default_provider = default_pair.as_ref().map(|(p, _)| p.clone());
let default_model = default_pair.map(|(_, m)| m);
(providers, default_value, default_provider, default_model)
}
/// 预览将要写入的 YAML(不含明文密钥)。
pub fn ai_preview(&self) -> DshAiPreview {
let (providers, default_value, default_provider, default_model) = self.build_patch();
let mut root = Mapping::new();
if !default_value.is_null() {
root.insert(Value::String(DEFAULT_MODEL_SECTION.into()), default_value);
}
let mut llm = Mapping::new();
llm.insert(Value::String("providers".into()), Value::Mapping(providers));
root.insert(Value::String(LLM_SECTION.into()), Value::Mapping(llm));
let yaml = serde_yaml::to_string(&Value::Mapping(root))
.unwrap_or_else(|e| format!("# 生成预览失败: {e}"));
DshAiPreview {
yaml,
providers: self.ai_providers(),
default_provider,
default_model,
settings_path: self.dsh_settings_path().to_string_lossy().to_string(),
}
}
/// 生成/合并 `$DSH_HOME/settings.yaml`(写盘前备份旧文件)。
pub fn ai_sync(&self, _app: &AppHandle) -> Result<(), String> {
let (providers, default_value, _, _) = self.build_patch();
let path = self.dsh_settings_path();
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).map_err(|e| format!("创建 $DSH_HOME 失败: {e}"))?;
}
// 读现有文档(缺失/非映射时用空映射起步)
let existing = std::fs::read_to_string(&path).ok();
let mut doc = existing
.as_deref()
.and_then(|t| serde_yaml::from_str::<Value>(t).ok())
.filter(|v| v.is_mapping())
.unwrap_or_else(|| Value::Mapping(Mapping::new()));
let root = doc.as_mapping_mut().ok_or_else(|| "settings.yaml 结构非法".to_string())?;
// 备份
if existing.is_some() {
std::fs::write(path.with_extension("yaml.bak"), existing.as_deref().unwrap_or_default())
.map_err(|e| format!("备份 settings.yaml 失败: {e}"))?;
}
// llm-pi-ai.providers:只替换本模块管理的 thing-* 键
let llm_key = Value::String(LLM_SECTION.into());
let llm_entry = root
.entry(llm_key)
.or_insert_with(|| Value::Mapping(Mapping::new()));
if !llm_entry.is_mapping() {
*llm_entry = Value::Mapping(Mapping::new());
}
let llm_map = llm_entry.as_mapping_mut().expect("已保证为映射");
let providers_key = Value::String("providers".into());
let providers_entry = llm_map
.entry(providers_key)
.or_insert_with(|| Value::Mapping(Mapping::new()));
if !providers_entry.is_mapping() {
*providers_entry = Value::Mapping(Mapping::new());
}
let providers_map = providers_entry.as_mapping_mut().expect("已保证为映射");
// 先清掉上一次由本模块写入的键(用户自建的其它键保留)
let stale: Vec<Value> = providers_map
.keys()
.filter(|k| {
k.as_str()
.map(|s| s.starts_with(PROVIDER_PREFIX))
.unwrap_or(false)
})
.cloned()
.collect();
for key in stale {
providers_map.remove(&key);
}
for (key, value) in providers.iter() {
providers_map.insert(key.clone(), value.clone());
}
// agent-default-model
if default_value.is_null() {
root.remove(&Value::String(DEFAULT_MODEL_SECTION.into()));
} else {
root.insert(Value::String(DEFAULT_MODEL_SECTION.into()), default_value);
}
let text = serde_yaml::to_string(&doc).map_err(|e| format!("序列化 settings.yaml 失败: {e}"))?;
std::fs::write(&path, text).map_err(|e| format!("写入 settings.yaml 失败: {e}"))?;
crate::logger::log_info(
"dsh",
&format!("已同步 AI 供应商到 {}", path.display()),
);
Ok(())
}
/// 启动服务时注入的环境变量(供应商密钥 + DeepSeek 官方变量兜底)。
pub fn ai_env_vars(&self) -> Vec<(String, String)> {
let settings = crate::ai::AiManager::load_settings_sync(&self.data_dir);
let mut vars: Vec<(String, String)> = Vec::new();
for p in settings.providers.iter() {
if !p.enabled || p.base_url.trim().is_empty() || p.model.trim().is_empty() {
continue;
}
let key = crate::ai::provider_api_key(&p.id);
if key.is_empty() {
continue;
}
vars.push((Self::env_name(&p.id), key.clone()));
// DeepSeek 官方通道:dsh 内置 provider 直接读 DEEPSEEK_API_KEY
let is_deepseek = p.id.eq_ignore_ascii_case("deepseek")
|| p.preset.eq_ignore_ascii_case("deepseek")
|| p.base_url.contains("api.deepseek.com");
if is_deepseek {
vars.push(("DEEPSEEK_API_KEY".into(), key));
}
}
vars
}
}
+232
View File
@@ -0,0 +1,232 @@
//! dsh 模块的 Tauri 命令层。
//!
//! 前端统一经 `@/lib/bindings` 的 `commands.dsh*` 调用。
//! 进度事件 `dsh-install-progress`、状态事件 `dsh-server-state` 见
//! `crate::constants::events`(与 `src/lib/constants.ts` 的 `EVENTS` 对应)。
use tauri::Manager;
use tauri::{AppHandle, State};
use tauri_plugin_opener::OpenerExt;
use super::types::{
DshAiPreview, DshEnvStatus, DshInstallStatus, DshNpmRegistryInfo, DshServerStatus, DshSettings,
DshUpdateInfo, NodeStatus,
};
use super::DshManager;
/// 环境总览:Node / dsh / 服务状态 + 模块设置(模块首屏一次拿全)。
///
/// 声明为 `async`:Tauri 的**同步**命令在主线程执行,而本命令要跑
/// `node --version` 子进程探测,放主线程会造成界面卡顿。
/// (async 命令带 `State<'_>` 引用参数时必须返回 `Result`,故这里包一层 Ok。)
#[tauri::command]
#[specta::specta]
pub async fn dsh_env_status(state: State<'_, DshManager>) -> Result<DshEnvStatus, String> {
Ok(DshEnvStatus {
node: state.node_status(),
dsh: state.install_status(),
server: state.server_status(),
settings: state.load_settings(),
})
}
/// 重新探测 Node(系统 PATH + 托管目录)。同样因执行 `node --version` 而用 async。
#[tauri::command]
#[specta::specta]
pub async fn dsh_node_detect(state: State<'_, DshManager>) -> Result<NodeStatus, String> {
Ok(state.node_status())
}
/// 下载并安装便携 Node(`version` 为空 = 自动取满足要求的最新版)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_node_install(
app: AppHandle,
state: State<'_, DshManager>,
version: Option<String>,
) -> Result<NodeStatus, String> {
state.node_install(&app, version).await
}
/// 安装 dsh(`version` 为空 = latest)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_install(
app: AppHandle,
state: State<'_, DshManager>,
version: Option<String>,
) -> Result<DshInstallStatus, String> {
state.install(&app, version).await
}
/// 更新 dsh 到 latest(更新前停止服务,避免文件被占用)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_update(
app: AppHandle,
state: State<'_, DshManager>,
) -> Result<DshInstallStatus, String> {
state.stop_server(&app);
state.install(&app, None).await
}
/// 卸载 dsh(停止服务并删除包目录;保留设置与 $DSH_HOME)。
#[tauri::command]
#[specta::specta]
pub fn dsh_uninstall(app: AppHandle, state: State<'_, DshManager>) -> Result<(), String> {
state.uninstall(&app)
}
/// 取消进行中的下载 / 安装。
#[tauri::command]
#[specta::specta]
pub fn dsh_cancel_install(state: State<'_, DshManager>) {
state.request_cancel();
}
/// 查询 npm 上的可用版本。
#[tauri::command]
#[specta::specta]
pub async fn dsh_check_update(state: State<'_, DshManager>) -> Result<DshUpdateInfo, String> {
state.check_update().await
}
/// 读取「本次安装实际使用的 npm 源」及其来源。
///
/// 设置为空时 npm 会用自己配置链里的源(含系统 Node 的 `~/.npmrc`),
/// 这里把解析结果回给前端展示,让用户能看出「到底走的是哪个源」。
/// async:内部要跑 `node <npm-cli.js> config get registry` 子进程。
#[tauri::command]
#[specta::specta]
pub async fn dsh_npm_registry_info(
state: State<'_, DshManager>,
) -> Result<DshNpmRegistryInfo, String> {
Ok(state.npm_registry_info())
}
#[tauri::command]
#[specta::specta]
pub fn dsh_get_settings(state: State<'_, DshManager>) -> DshSettings {
state.load_settings()
}
/// 保存设置(即时生效;端口等改动在下次启动服务时生效)。
#[tauri::command]
#[specta::specta]
pub fn dsh_save_settings(
state: State<'_, DshManager>,
settings: DshSettings,
) -> Result<DshSettings, String> {
state.save_settings(settings)
}
/// 启动 dsh Web 服务。async:内部要 spawn 子进程 + 读凭据 + 写 settings.yaml,
/// 同步命令会在主线程执行从而卡住界面。
#[tauri::command]
#[specta::specta]
pub async fn dsh_start(app: AppHandle, state: State<'_, DshManager>) -> Result<DshServerStatus, String> {
state.start_server(&app)
}
/// 停止 dsh Web 服务。
#[tauri::command]
#[specta::specta]
pub async fn dsh_stop(app: AppHandle, state: State<'_, DshManager>) -> Result<DshServerStatus, String> {
state.stop_server(&app);
Ok(state.server_status())
}
/// 重启 dsh Web 服务。
#[tauri::command]
#[specta::specta]
pub async fn dsh_restart(app: AppHandle, state: State<'_, DshManager>) -> Result<DshServerStatus, String> {
state.stop_server(&app);
// Windows 上端口释放有延迟,稍等再起,避免 bind 预检误判占用
// (用异步 sleep:同步命令在主线程执行,阻塞 500ms 会冻界面)
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
state.start_server(&app)
}
/// 预览将写入 `$DSH_HOME/settings.yaml` 的内容(不含明文密钥)。
#[tauri::command]
#[specta::specta]
pub fn dsh_ai_preview(state: State<'_, DshManager>) -> DshAiPreview {
state.ai_preview()
}
/// 执行 AI 配置同步(合并写入 settings.yaml,写前备份)。
#[tauri::command]
#[specta::specta]
pub fn dsh_ai_sync(app: AppHandle, state: State<'_, DshManager>) -> Result<DshAiPreview, String> {
state.ai_sync(&app)?;
Ok(state.ai_preview())
}
/// 读取服务日志尾部。
#[tauri::command]
#[specta::specta]
pub fn dsh_log_tail(state: State<'_, DshManager>, lines: u32) -> String {
state.log_tail(lines as usize)
}
/// 读取 dsh 安装输出(npm 的 stdout/stderr 尾部)。
///
/// 只存在内存里(每次安装开始时清空),供「安装引导 → dsh 本体」页临时展示,
/// **不写应用日志、不落盘**。前端在安装进行中轮询这个命令。
#[tauri::command]
#[specta::specta]
pub fn dsh_install_log(state: State<'_, DshManager>) -> String {
state.install_log()
}
#[tauri::command]
#[specta::specta]
pub fn dsh_log_clear(state: State<'_, DshManager>) {
state.clear_log();
}
/// 在资源管理器中打开 dsh 模块目录。
#[tauri::command]
#[specta::specta]
pub fn dsh_open_dir(app: AppHandle, state: State<'_, DshManager>) -> Result<(), String> {
app.opener()
.open_path(state.root().to_string_lossy().to_string(), None::<&str>)
.map_err(|e| format!("打开目录失败: {e}"))
}
/// 注册(或切换)「打开 dsh 独立窗口」全局快捷键;传空字符串则注销。
///
/// 按下时只 emit `dsh-open-window` 事件,**窗口由前端创建**:前端才持有带令牌的
/// 启动地址,也能用 label 判重复用已开窗口(与截图模块「快捷键 → 事件 → 前端开窗」同构)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_register_shortcut(app: AppHandle, shortcut: String) -> Result<(), String> {
crate::shortcut::register_shortcut(&app, "dsh", &shortcut, |a| {
use tauri::Emitter;
let _ = a.emit(crate::constants::events::DSH_OPEN_WINDOW, ());
})
}
/// 注销「打开 dsh 独立窗口」全局快捷键。
#[tauri::command]
#[specta::specta]
pub async fn dsh_unregister_shortcut(app: AppHandle) -> Result<(), String> {
crate::shortcut::unregister_shortcut(&app, "dsh");
Ok(())
}
/// 供 `setup.rs` 在应用启动时按设置自启服务。
pub fn autostart_if_enabled(app: &AppHandle) {
let manager = app.state::<DshManager>();
let settings = manager.load_settings();
if !settings.auto_start {
return;
}
if !manager.install_status().installed {
crate::logger::log_warn("dsh", "设置了自动启动,但 dsh 尚未安装,跳过");
return;
}
if let Err(e) = manager.start_server(app) {
crate::logger::log_warn("dsh", &format!("自动启动 dsh 服务失败: {e}"));
}
}
+397
View File
@@ -0,0 +1,397 @@
//! dsh 本体的安装 / 更新 / 卸载与版本查询。
//!
//! 安装方式:用当前解析出的 Node 自带的 npm,把 `@deepseek-ai/dsh` 装进模块目录
//! (`npm install --prefix {app_data}/dsh`)。好处是版本可锁、可配镜像源、可复用
//! 已下载的依赖,且启动时直接 `node <bin 入口>`,不依赖 PATH 上的全局 shim。
//!
//! npm 调用形态:`node <npm-cli.js> install ...`(不走 npm.cmd,理由见 `node.rs`)。
use std::io::{BufRead, BufReader};
use std::path::PathBuf;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use tauri::{AppHandle, Emitter};
use super::node::NODE_CANCELLED;
use super::types::{DshInstallProgress, DshInstallStatus, DshNpmRegistryInfo, DshUpdateInfo, DSH_PACKAGE};
use super::DshManager;
impl DshManager {
/// dsh 包目录
fn package_dir(&self) -> PathBuf {
self.install_root()
.join("node_modules")
.join("@deepseek-ai")
.join("dsh")
}
/// 已安装版本(读 package.json,不起进程)
pub fn installed_version(&self) -> Option<String> {
let text = std::fs::read_to_string(self.package_dir().join("package.json")).ok()?;
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
value
.get("version")
.and_then(|v| v.as_str())
.map(|s| s.to_string())
}
/// dsh bin 入口(`package.json` 的 `bin.dsh`),启动服务时直接 `node <入口>`。
pub fn bin_entry(&self) -> Option<PathBuf> {
let dir = self.package_dir();
let text = std::fs::read_to_string(dir.join("package.json")).ok()?;
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
let rel = match value.get("bin") {
Some(serde_json::Value::String(s)) => s.clone(),
Some(serde_json::Value::Object(map)) => map.get("dsh")?.as_str()?.to_string(),
_ => return None,
};
let entry = dir.join(rel);
entry.exists().then_some(entry)
}
/// 安装状态
pub fn install_status(&self) -> DshInstallStatus {
let version = self.installed_version();
let entry = self.bin_entry();
DshInstallStatus {
installed: version.is_some() && entry.is_some(),
version,
entry: entry.map(|p| p.to_string_lossy().to_string()),
dir: self.install_root().to_string_lossy().to_string(),
}
}
/// 模块设置里**显式**填写的 npm 源(空 = 未指定,交给 npm 自己解析)。
///
/// 与 [`Self::npm_registry_info`] 的区别:这里只认模块设置。安装时只在
/// 显式填写的情况下才传 `--registry`,其余情况让 npm 走自己的配置链
/// (环境变量 > 安装目录 `.npmrc` > 用户 `~/.npmrc` > 内置),
/// 这样「系统 node 以前配过的镜像」会被自动沿用。
fn registry_setting(&self) -> String {
self.load_settings()
.npm_registry
.trim()
.trim_end_matches('/')
.to_string()
}
/// npm 自身解析出的源(`node <npm-cli.js> config get registry`)。
///
/// 未检测到 Node/npm、或 npm 执行失败时为 None。cwd 取安装目录——
/// npm 的「项目级配置」来自 cwd 下的 `.npmrc`,要与真实安装保持一致。
pub fn npm_config_registry(&self) -> Option<String> {
let env = self.resolve_node_env()?;
let npm = env.npm?;
let mut cmd = std::process::Command::new(&env.node_exe);
cmd.arg(&npm).args(["config", "get", "registry"]);
// 安装目录可能还没创建(首次安装):退回模块目录,保证能起来
let install_root = self.install_root();
cmd.current_dir(if install_root.exists() {
install_root
} else {
self.root.clone()
});
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let out = cmd.output().ok()?;
if !out.status.success() {
return None;
}
let text = String::from_utf8_lossy(&out.stdout);
text.lines()
.map(|l| l.trim())
.find(|l| !l.is_empty())
.map(|l| l.trim_end_matches('/').to_string())
}
/// 本次安装/查询实际使用的源 + 来源(供 UI 展示与快捷切换)。
pub fn npm_registry_info(&self) -> DshNpmRegistryInfo {
let setting = self.registry_setting();
let npm_registry = self.npm_config_registry();
let (effective, source) = if !setting.is_empty() {
(setting.clone(), "setting")
} else if let Some(npm) = npm_registry.as_ref() {
(npm.clone(), "npm")
} else {
("https://registry.npmjs.org".to_string(), "fallback")
};
DshNpmRegistryInfo {
effective,
source: source.to_string(),
npm_registry,
setting,
}
}
/// 版本查询(reqwest)用的源:与安装保持一致(设置 → npm 配置 → 官方源)。
///
/// 之前这里在设置为空时硬编码官方源,导致「安装走国内镜像、检查更新却直连
/// npmjs.org」的不一致。
fn registry_for_query(&self) -> String {
self.npm_registry_info().effective
}
/// 查询 npm 上的可用版本(`dist-tags.latest` + 版本列表)。
pub async fn check_update(&self) -> Result<DshUpdateInfo, String> {
let url = format!("{}/{DSH_PACKAGE}", self.registry_for_query());
let resp = self
.http_client(30)
.get(&url)
.send()
.await
.map_err(|e| format!("查询 npm 版本失败: {e}"))?;
if !resp.status().is_success() {
return Err(format!("查询 npm 版本失败: HTTP {}", resp.status().as_u16()));
}
let value: serde_json::Value = resp
.json()
.await
.map_err(|e| format!("解析 npm 响应失败: {e}"))?;
let latest = value
.get("dist-tags")
.and_then(|t| t.get("latest"))
.and_then(|v| v.as_str())
.ok_or_else(|| "npm 响应缺少 dist-tags.latest".to_string())?
.to_string();
let mut versions: Vec<String> = value
.get("versions")
.and_then(|v| v.as_object())
.map(|m| m.keys().cloned().collect())
.unwrap_or_default();
// 取尾部若干(近似按发布顺序),再反转成最新在前
if versions.len() > 20 {
versions = versions.split_off(versions.len() - 20);
}
versions.reverse();
let current = self.installed_version();
Ok(DshUpdateInfo {
has_update: current.as_deref() != Some(latest.as_str()),
current,
latest,
versions,
})
}
/// 安装 / 更新 dsh(`version` 为空 = 装 latest)。
pub async fn install(&self, app: &AppHandle, version: Option<String>) -> Result<DshInstallStatus, String> {
self.cancel.store(false, Ordering::SeqCst);
// 每次安装开始清空上一次的输出缓冲
self.clear_install_log();
let result = self.install_inner(app, version).await;
self.cancel.store(false, Ordering::SeqCst);
if let Err(ref e) = result {
if e != NODE_CANCELLED {
self.push_install_log(&format!("[错误] {e}"));
self.emit_progress(app, "error", 0, 0, None, e);
}
}
result
}
async fn install_inner(&self, app: &AppHandle, version: Option<String>) -> Result<DshInstallStatus, String> {
let env = self
.resolve_node_env()
.ok_or_else(|| "未找到可用的 Node,请先完成第 1 步".to_string())?;
if !super::satisfies_node_requirement(&env.version) {
return Err(format!(
"当前 Node {} 不满足 dsh 要求({}),请先安装合规的 Node",
env.version,
super::NODE_REQUIRED
));
}
let npm = env
.npm
.clone()
.ok_or_else(|| "未找到 npm(Node 分发中缺少 npm-cli.js)".to_string())?;
let spec = version
.as_deref()
.map(|v| v.trim())
.filter(|v| !v.is_empty())
.map(|v| format!("{DSH_PACKAGE}@{v}"))
.unwrap_or_else(|| DSH_PACKAGE.to_string());
let install_dir = self.install_root();
// npm 的 prefix 目录不存在时由 npm 自己创建;这里先建一次,避免
// 自定义到新盘符目录时 npm 因父级缺失报 ENOENT
std::fs::create_dir_all(&install_dir)
.map_err(|e| format!("创建安装目录失败({}): {e}", install_dir.display()))?;
let mut args: Vec<String> = vec![
npm.to_string_lossy().to_string(),
"install".into(),
"--prefix".into(),
install_dir.to_string_lossy().to_string(),
spec.clone(),
"--no-fund".into(),
"--no-audit".into(),
"--loglevel".into(),
"info".into(),
];
let registry = self.registry_setting();
if !registry.is_empty() {
// 只在显式指定时才覆盖 npm 自己的配置链
args.push("--registry".into());
args.push(registry);
}
self.emit_progress(
app,
"installing",
0,
0,
None,
&format!("正在安装 {spec}(依赖较多,请稍候)..."),
);
// npm 不输出百分比:percent 恒为 0(前端按不确定进度展示),
// message 跟随 npm 自身的汇总行(`added N packages` 等)更新。
//
// 逐行输出**只进内存缓冲**(安装引导页临时展示),不写应用日志:
// npm 的 72 个依赖会刷出上千行,进应用日志只会淹没真正的运行日志。
let progress_app = app.clone();
let install_ring = self.install_ring_handle();
let on_line = Arc::new(move |line: &str| {
super::push_bounded(&install_ring, super::INSTALL_RING_CAPACITY, line);
let trimmed = line.trim();
if trimmed.starts_with("added ")
|| trimmed.starts_with("changed ")
|| trimmed.starts_with("removed ")
|| trimmed.starts_with("up to date")
{
let _ = progress_app.emit(
crate::constants::events::DSH_INSTALL_PROGRESS,
DshInstallProgress {
stage: "installing".into(),
percent: 0,
downloaded_bytes: 0,
total_bytes: None,
message: trimmed.to_string(),
},
);
}
});
let node_exe = env.node_exe.clone();
let pid_ref = self.install_pid.clone();
let result = tauri::async_runtime::spawn_blocking(move || {
run_npm(node_exe, args, install_dir, pid_ref, on_line)
})
.await
.map_err(|e| format!("安装任务执行失败: {e}"))?;
self.install_pid.store(0, Ordering::SeqCst);
if self.cancel.load(Ordering::SeqCst) {
return Err(NODE_CANCELLED.into());
}
result?;
let status = self.install_status();
if !status.installed {
return Err("npm 安装结束,但未找到 dsh 入口(请查看日志)".into());
}
self.emit_progress(
app,
"done",
100,
0,
None,
&format!(
"dsh {} 安装完成",
status.version.as_deref().unwrap_or("unknown")
),
);
crate::logger::log_info(
"dsh",
&format!(
"dsh 安装完成: {}",
status.version.as_deref().unwrap_or("unknown")
),
);
Ok(status)
}
/// 卸载 dsh:停止服务并删除包目录(保留设置与 $DSH_HOME)。
pub fn uninstall(&self, app: &AppHandle) -> Result<(), String> {
self.stop_server(app);
let dir = self.package_dir();
if dir.exists() {
std::fs::remove_dir_all(&dir).map_err(|e| format!("删除 dsh 目录失败: {e}"))?;
}
Ok(())
}
}
/// 同步执行 npm(阻塞线程内),逐行读输出交给 `on_line`;pid 记录供取消时 taskkill。
fn run_npm(
node_exe: PathBuf,
args: Vec<String>,
cwd: PathBuf,
pid_ref: Arc<std::sync::atomic::AtomicU64>,
on_line: Arc<dyn Fn(&str) + Send + Sync>,
) -> Result<(), String> {
let mut cmd = std::process::Command::new(&node_exe);
cmd.args(&args);
cmd.current_dir(&cwd);
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 mut child = cmd
.spawn()
.map_err(|e| format!("启动 npm 失败({}): {e}", node_exe.display()))?;
let pid = child.id();
pid_ref.store(pid as u64, Ordering::SeqCst);
let stdout = child.stdout.take();
let stderr = child.stderr.take();
// 末 40 行留作失败时的错误摘要
let tail = Arc::new(std::sync::Mutex::new(Vec::<String>::new()));
let mut handles = Vec::new();
let pipes: [Option<Box<dyn std::io::Read + Send>>; 2] = [
stdout.map(|p| Box::new(p) as Box<dyn std::io::Read + Send>),
stderr.map(|p| Box::new(p) as Box<dyn std::io::Read + Send>),
];
for pipe in pipes.into_iter().flatten() {
let on_line = on_line.clone();
let tail = tail.clone();
handles.push(std::thread::spawn(move || {
let reader = BufReader::new(pipe);
for line in reader.lines().map_while(Result::ok) {
on_line(&line);
if let Ok(mut t) = tail.lock() {
if t.len() >= 40 {
t.remove(0);
}
t.push(line);
}
}
}));
}
let status = child.wait();
for h in handles {
let _ = h.join();
}
pid_ref.store(0, Ordering::SeqCst);
let status = status.map_err(|e| format!("等待 npm 结束失败: {e}"))?;
if status.success() {
return Ok(());
}
let text = tail.lock().map(|t| t.join("\n")).unwrap_or_default();
let chars: Vec<char> = text.chars().collect();
let skip = chars.len().saturating_sub(800);
Err(format!(
"npm 退出码 {}: {}",
status.code().unwrap_or(-1),
chars[skip..].iter().collect::<String>()
))
}
+484
View File
@@ -0,0 +1,484 @@
//! dsh 模块(DeepSeek Harness 外壳)。
//!
//! 模块定位:为 DeepSeek Harness(npm 包 `@deepseek-ai/dsh`)做安装、更新与
//! 生命周期管理,并把主设置里的 AI 供应商(含 DeepSeek API Key)装载给 dsh。
//! 模块页不内嵌浏览器,dsh 的 Web UI 通过独立窗口 / 系统浏览器打开。
//!
//! 目录布局(`{app_data_dir}/dsh`):
//! ```text
//! settings.json 模块自身设置(版本号 + 自愈)
//! node/ 便携 Node(仅系统 Node 不可用时)
//! node_modules/ @deepseek-ai/dsh 本地安装(npm --prefix)
//! home/ $DSH_HOME(settings.yaml / profiles / 会话)
//! workspace/ 默认工作区(dsh 进程的启动目录)
//! logs/web.log dsh 服务输出
//! ```
//!
//! 安全姿态:模块设置不含任何密钥;API Key 只在 spawn 子进程时以环境变量注入
//! (明文来自系统凭据管理器,见 [`crate::secrets`]),不写 dsh 的
//! `.credentials.yaml`、不落日志、不过前端。
mod ai_sync;
mod commands;
mod install;
mod node;
mod server;
mod types;
pub use commands::{
dsh_ai_preview, dsh_ai_sync, dsh_cancel_install, dsh_check_update, dsh_env_status,
dsh_get_settings, dsh_install, dsh_install_log, dsh_log_clear, dsh_log_tail,
dsh_node_detect, dsh_node_install, dsh_npm_registry_info, dsh_open_dir,
dsh_register_shortcut, dsh_restart, dsh_save_settings, dsh_start, dsh_stop,
dsh_uninstall, dsh_unregister_shortcut, dsh_update,
};
pub use commands::autostart_if_enabled;
// 仅重导出模块自身与子模块会经 `super::` 用到的类型(其余由各子模块直接从 types 取)
pub use types::{DshInstallProgress, DshSettings, NODE_REQUIRED};
use std::collections::VecDeque;
use std::path::PathBuf;
use std::process::Child;
use std::sync::atomic::{AtomicBool, AtomicU64};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tauri::AppHandle;
/// 设置内存缓存有效期(与其他模块的 500ms 一致)。
const SETTINGS_CACHE_TTL: Duration = Duration::from_millis(500);
/// 日志环形缓冲保留的最大行数(供「日志」页签快速读取)。
const LOG_RING_CAPACITY: usize = 500;
/// 安装输出缓冲保留的最大行数(npm 输出较啰嗦,只留最近一段)。
const INSTALL_RING_CAPACITY: usize = 200;
/// 服务进程条目(自管 stdio,不走 ProcessManager)。
pub(crate) struct ServerEntry {
pub child: Child,
pub pid: u32,
pub port: u16,
/// 启动时间(unix 秒)
pub started_at: i64,
}
struct SettingsCacheEntry {
read_at: Instant,
settings: DshSettings,
}
/// 解析出的 Node 运行环境。
pub(crate) struct NodeEnv {
/// system | managed
pub source: &'static str,
pub node_exe: PathBuf,
/// npm 入口(`node_modules/npm/bin/npm-cli.js`,用 `node <此路径>` 调用)
pub npm: Option<PathBuf>,
pub version: String,
}
/// dsh 模块管理器(Tauri State)。
pub struct DshManager {
/// 应用数据目录(`{app_data_dir}`)
data_dir: PathBuf,
/// 模块根目录(`{app_data_dir}/dsh`)
root: PathBuf,
settings_cache: Mutex<Option<SettingsCacheEntry>>,
/// 安装/下载取消标志
cancel: Arc<AtomicBool>,
/// 安装子进程 pid(取消时 taskkill /T)
install_pid: Arc<AtomicU64>,
/// 服务进程
server: Mutex<Option<ServerEntry>>,
/// 启动串行化锁(防并发双开)
start_lock: Mutex<()>,
/// HTTP 就绪标志
ready: Arc<AtomicBool>,
/// 本次进程的「带 token 启动地址」(从 dsh stdout 抓取)。
/// dsh web 的浏览器鉴权靠它首次访问换取 cookie,没它就只会拿到 401。
launch_url: Arc<Mutex<Option<String>>>,
/// 最近一次启动错误(端口占用 / 进程立即退出)
server_error: Mutex<Option<String>>,
/// 日志环形缓冲
log_ring: Arc<Mutex<VecDeque<String>>>,
/// 安装(npm)输出缓冲:只在模块页临时展示,**不落应用日志、不落盘**
install_ring: Arc<Mutex<VecDeque<String>>>,
}
impl DshManager {
pub fn new(app_data_dir: PathBuf) -> Self {
let root = app_data_dir.join("dsh");
for d in ["node", "logs", "home", "workspace"] {
std::fs::create_dir_all(root.join(d)).ok();
}
Self {
data_dir: app_data_dir,
root,
settings_cache: Mutex::new(None),
cancel: Arc::new(AtomicBool::new(false)),
install_pid: Arc::new(AtomicU64::new(0)),
server: Mutex::new(None),
start_lock: Mutex::new(()),
ready: Arc::new(AtomicBool::new(false)),
launch_url: Arc::new(Mutex::new(None)),
server_error: Mutex::new(None),
log_ring: Arc::new(Mutex::new(VecDeque::with_capacity(LOG_RING_CAPACITY))),
install_ring: Arc::new(Mutex::new(VecDeque::with_capacity(INSTALL_RING_CAPACITY))),
}
}
/// 模块根目录(「在文件夹中打开」用)
pub fn root(&self) -> &PathBuf {
&self.root
}
/// 便携 Node 目录
pub fn node_dir(&self) -> PathBuf {
self.root.join("node")
}
/// dsh 本体的安装根目录(npm `--prefix` 目标)。
///
/// 设置留空 = 模块目录。自定义时**只有 dsh 本体与它的 node_modules 跟随**,
/// 便携 Node / `$DSH_HOME` / 日志 / 模块设置仍留在应用数据目录——自定义路径
/// 若被移动或卸载,至少配置与日志还读得到,排障不会失联。
pub fn install_root(&self) -> PathBuf {
let raw = self.load_settings().install_dir;
let raw = raw.trim();
if raw.is_empty() {
self.root.clone()
} else {
PathBuf::from(raw)
}
}
/// `$DSH_HOME`
pub fn home_dir(&self) -> PathBuf {
let settings = self.load_settings();
if settings.dsh_home_mode == "user" {
dirs::home_dir()
.map(|h| h.join(".dsh"))
.unwrap_or_else(|| self.root.join("home"))
} else {
self.root.join("home")
}
}
/// dsh 进程的启动目录(工作区)
pub fn workspace_dir(&self) -> PathBuf {
let settings = self.load_settings();
let raw = settings.workspace.trim();
let dir = if raw.is_empty() {
self.root.join("workspace")
} else {
PathBuf::from(raw)
};
std::fs::create_dir_all(&dir).ok();
dir
}
pub fn log_path(&self) -> PathBuf {
self.root.join("logs").join("web.log")
}
pub fn settings_path(&self) -> PathBuf {
self.root.join("settings.json")
}
// ---------- 设置 ----------
pub fn load_settings(&self) -> DshSettings {
if let Ok(cache) = self.settings_cache.lock() {
if let Some(entry) = cache.as_ref() {
if entry.read_at.elapsed() < SETTINGS_CACHE_TTL {
return entry.settings.clone();
}
}
}
let mut settings = std::fs::read_to_string(self.settings_path())
.ok()
.and_then(|t| serde_json::from_str::<DshSettings>(&t).ok())
.unwrap_or_default();
let changed = settings.heal();
if changed {
self.write_settings(&settings).ok();
}
if let Ok(mut cache) = self.settings_cache.lock() {
*cache = Some(SettingsCacheEntry {
read_at: Instant::now(),
settings: settings.clone(),
});
}
settings
}
pub fn save_settings(&self, mut settings: DshSettings) -> Result<DshSettings, String> {
// 自定义安装目录必须是绝对路径:npm 的 --prefix 用相对路径会落到
// 进程当前目录(开发期即仓库根目录),这种"看起来生效其实装错地方"最难排查
let custom = settings.install_dir.trim();
if !custom.is_empty() && !std::path::Path::new(custom).is_absolute() {
return Err("dsh 安装目录必须是绝对路径(如 D:/Thing/dsh)".to_string());
}
settings.heal();
self.write_settings(&settings)?;
if let Ok(mut cache) = self.settings_cache.lock() {
*cache = Some(SettingsCacheEntry {
read_at: Instant::now(),
settings: settings.clone(),
});
}
Ok(settings)
}
fn write_settings(&self, settings: &DshSettings) -> Result<(), String> {
let json = serde_json::to_string_pretty(settings)
.map_err(|e| format!("序列化 dsh 设置失败: {e}"))?;
std::fs::write(self.settings_path(), json).map_err(|e| format!("写入 dsh 设置失败: {e}"))
}
// ---------- 日志 ----------
/// 追加一行到环形缓冲 + 落盘(服务输出走这里)。
pub(crate) fn push_log(&self, line: &str) {
push_log_shared(&self.log_ring, &self.log_path(), line);
}
/// 读取日志:优先环形缓冲;为空时回落到文件尾部。
pub fn log_tail(&self, lines: usize) -> String {
let lines = lines.clamp(1, LOG_RING_CAPACITY);
if let Ok(ring) = self.log_ring.lock() {
if !ring.is_empty() {
let skip = ring.len().saturating_sub(lines);
return ring
.iter()
.skip(skip)
.cloned()
.collect::<Vec<_>>()
.join("\n");
}
}
let text = std::fs::read_to_string(self.log_path()).unwrap_or_default();
let all: Vec<&str> = text.lines().collect();
let skip = all.len().saturating_sub(lines);
all[skip..].join("\n")
}
pub fn clear_log(&self) {
if let Ok(mut ring) = self.log_ring.lock() {
ring.clear();
}
std::fs::write(self.log_path(), b"").ok();
}
// ---------- 安装输出(仅内存,供安装引导页临时展示) ----------
/// 追加一行安装输出(已过滤疑似密钥)。
pub(crate) fn push_install_log(&self, line: &str) {
push_bounded(&self.install_ring, INSTALL_RING_CAPACITY, line);
}
/// 读取当前安装输出(每次安装开始时清空)。
pub fn install_log(&self) -> String {
self.install_ring
.lock()
.map(|r| r.iter().cloned().collect::<Vec<_>>().join("\n"))
.unwrap_or_default()
}
pub(crate) fn clear_install_log(&self) {
if let Ok(mut ring) = self.install_ring.lock() {
ring.clear();
}
}
/// 安装输出缓冲句柄(阻塞线程内的 on_line 闭包持有;'static 需要)。
pub(crate) fn install_ring_handle(
&self,
) -> Arc<Mutex<VecDeque<String>>> {
self.install_ring.clone()
}
// ---------- 代理 ----------
/// 按设置解析代理地址(mihomo mixed 端口)。返回 None 表示直连。
///
/// 只读代理模块设置文件里的 mixedPort,并用一次 300ms TCP 探测确认内核在线;
/// 内核没起来时静默直连(与 download_engine / translate 的降级姿态一致)。
pub(crate) fn proxy_url(&self) -> Option<String> {
if !self.load_settings().use_proxy {
return None;
}
let text = std::fs::read_to_string(self.data_dir.join("proxy").join("settings.json")).ok()?;
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
let port = value.get("mixedPort").and_then(|v| v.as_u64())?;
if port == 0 || port > u16::MAX as u64 {
return None;
}
let port = port as u16;
let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));
if std::net::TcpStream::connect_timeout(&addr, Duration::from_millis(300)).is_err() {
return None;
}
Some(format!("http://127.0.0.1:{port}"))
}
// ---------- 事件 ----------
/// 推送安装/下载进度(stage: download | extracting | installing | done | error)。
pub(crate) fn emit_progress(
&self,
app: &AppHandle,
stage: &str,
percent: u8,
downloaded_bytes: u64,
total_bytes: Option<u64>,
message: &str,
) {
use tauri::Emitter;
let _ = app.emit(
crate::constants::events::DSH_INSTALL_PROGRESS,
DshInstallProgress {
stage: stage.into(),
percent,
downloaded_bytes,
total_bytes,
message: message.into(),
},
);
}
/// 推送服务状态(启动/停止/就绪变化时)。
pub(crate) fn emit_server_state(&self, app: &AppHandle) {
use tauri::Emitter;
let status = self.server_status();
let _ = app.emit(crate::constants::events::DSH_SERVER_STATE, status);
}
/// 构造 reqwest 客户端:按代理设置决定是否走 mihomo。
pub(crate) fn http_client(&self, timeout_secs: u64) -> reqwest::Client {
let mut builder = reqwest::Client::builder()
.user_agent("thing-app")
.timeout(Duration::from_secs(timeout_secs));
if let Some(proxy) = self.proxy_url() {
if let Ok(p) = reqwest::Proxy::all(&proxy) {
builder = builder.proxy(p);
}
}
builder.build().unwrap_or_else(|_| reqwest::Client::new())
}
}
/// 过滤日志行里的疑似密钥(`sk-` 形态)与 URL 里的会话令牌。
pub(crate) fn sanitize_log_line(line: &str) -> String {
let line = mask_token_in_url(line);
let mut out = String::with_capacity(line.len());
for token in line.split_inclusive(char::is_whitespace) {
let trimmed = token.trim_end();
if trimmed.starts_with("sk-") && trimmed.len() > 12 {
out.push_str("sk-***");
out.push_str(&token[trimmed.len()..]);
} else {
out.push_str(token);
}
}
out
}
/// 掩码 URL 里的 `token=` 取值(`?token=xxx` → `?token=***`)。
///
/// dsh web 的浏览器会话令牌等同于「对该 loopback 服务(能执行代码)的完全访问权」,
/// 不该落进应用日志与 logs/web.log;真正的带令牌地址经 IPC 单独给前端使用。
fn mask_token_in_url(line: &str) -> String {
const NEEDLE: &str = "token=";
let mut out = String::with_capacity(line.len());
let mut cursor = 0usize;
while let Some(rel) = line[cursor..].find(NEEDLE) {
let start = cursor + rel + NEEDLE.len();
out.push_str(&line[cursor..start]);
let after = &line[start..];
let end = after
.find(|c: char| c.is_whitespace() || matches!(c, ')' | ',' | '"' | '\'' | '&'))
.unwrap_or(after.len());
out.push_str("***");
cursor = start + end;
}
out.push_str(&line[cursor..]);
out
}
/// 从 dsh 输出行里解析「带 token 的启动地址」。
///
/// `dsh web` 就绪后会打印(见 dsh-web-app 的 announceReady):
/// `dsh web: http://127.0.0.1:3080/?token=<随机令牌> (LAN: http://<lan>:3080/?token=<...>)`
///
/// 浏览器鉴权靠这个地址首次访问换取签名 cookie(dsh-client-connection 的 BrowserAuth);
/// 令牌是**每次进程随机生成**的,无法推导,只能从输出里取。
/// 取第一个(loopback)地址,忽略随后的 LAN 地址。
pub(crate) fn parse_launch_url(line: &str) -> Option<String> {
let start = line.find("http://").or_else(|| line.find("https://"))?;
let rest = &line[start..];
let end = rest.find(char::is_whitespace).unwrap_or(rest.len());
let url = rest[..end].trim_end_matches(|c: char| c == ')' || c == ',');
url.contains("token=").then(|| url.to_string())
}
/// 共享的日志写入(服务 stdout/stderr reader 线程与探测线程用)。
///
/// reader 线程拿不到 `&DshManager`(需要 'static),因此把环形缓冲与日志路径
/// 单独传进来。
pub(crate) fn push_log_shared(
ring: &Arc<Mutex<VecDeque<String>>>,
log_path: &PathBuf,
line: &str,
) {
let line = push_bounded(ring, LOG_RING_CAPACITY, line);
if let Ok(mut f) = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(log_path)
{
use std::io::Write;
let _ = writeln!(f, "{line}");
}
}
/// 有界环形缓冲追加(**不落盘**),返回写入后的文本。
///
/// 安装输出走这里:只要内存,不写应用日志、不写文件——用户明确要求安装日志
/// 仅在安装引导页临时展示(npm 输出啰嗦,进应用日志只会淹没真正的运行日志)。
pub(crate) fn push_bounded(
ring: &Arc<Mutex<VecDeque<String>>>,
capacity: usize,
line: &str,
) -> String {
let line = sanitize_log_line(line);
if let Ok(mut r) = ring.lock() {
if r.len() >= capacity {
r.pop_front();
}
r.push_back(line.clone());
}
line
}
/// 解析 "v24.9.0" / "24.9.0" → (24, 9, 0)
pub(crate) fn parse_version(raw: &str) -> Option<(u32, u32, u32)> {
let cleaned = raw.trim().trim_start_matches('v');
let core = cleaned.split('-').next().unwrap_or(cleaned);
let mut it = core.split('.');
let major = it.next()?.parse::<u32>().ok()?;
let minor = it.next().unwrap_or("0").parse::<u32>().ok()?;
let patch = it.next().unwrap_or("0").parse::<u32>().ok()?;
Some((major, minor, patch))
}
/// 是否满足 dsh 的要求:`^22.19.0 || >=24.0.0`
pub(crate) fn satisfies_node_requirement(raw: &str) -> bool {
let Some((major, minor, patch)) = parse_version(raw) else {
return false;
};
match major {
22 => (minor, patch) >= (19, 0),
24.. => true,
_ => false,
}
}
+399
View File
@@ -0,0 +1,399 @@
//! Node 运行环境:探测系统 Node / 下载并解压便携 Node。
//!
//! dsh 要求 Node `^22.19.0 || >=24.0.0`。策略(用户已确认):
//! 优先复用 PATH 上的系统 Node,版本不满足或缺失时才下载官方便携版到
//! `{app_data}/dsh/node`(官方 zip 内含 npm/npx,因此托管 Node 自带 npm)。
use std::fs;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::Ordering;
use futures_util::StreamExt;
use tauri::AppHandle;
use super::types::{NodeStatus, NODE_REQUIRED};
use super::{satisfies_node_requirement, DshManager, NodeEnv};
/// 用户取消时返回的错误信息(前端静默处理,不弹错误 toast)。
pub(crate) const NODE_CANCELLED: &str = "已取消";
impl DshManager {
/// 系统 PATH 上的 node.exe
pub fn system_node(&self) -> Option<PathBuf> {
which_node()
}
/// 托管便携 Node 的 node.exe
pub fn managed_node(&self) -> Option<PathBuf> {
let exe = self.node_dir().join(if cfg!(windows) { "node.exe" } else { "bin/node" });
exe.exists().then_some(exe)
}
/// 解析实际使用的 Node 环境(按 nodeSource 设置)。
pub fn resolve_node_env(&self) -> Option<NodeEnv> {
let settings = self.load_settings();
let system = self.system_node();
let managed = self.managed_node();
let system_ok = system
.as_ref()
.and_then(|p| node_version(p))
.map(|v| satisfies_node_requirement(&v))
.unwrap_or(false);
// 选定 (是否托管, 可执行文件)
let chosen: Option<(bool, PathBuf)> = match settings.node_source.as_str() {
"system" => system.map(|p| (false, p)),
"managed" => managed.map(|p| (true, p)),
// auto:系统满足即复用,否则回落托管;两者都没有时退回系统 Node 仅用于展示版本
_ => {
if system_ok {
system.map(|p| (false, p))
} else {
managed
.map(|p| (true, p))
.or_else(|| system.map(|p| (false, p)))
}
}
};
let (is_managed, exe) = chosen?;
let version = node_version(&exe).unwrap_or_default();
let npm = npm_cli_js(&exe);
Some(NodeEnv {
source: if is_managed { "managed" } else { "system" },
node_exe: exe,
npm,
version,
})
}
/// 当前 Node 状态(供 UI 首屏展示)。
pub fn node_status(&self) -> NodeStatus {
match self.resolve_node_env() {
Some(env) => {
let satisfies = satisfies_node_requirement(&env.version);
NodeStatus {
source: if env.source == "managed" { "managed".into() } else { "system".into() },
path: Some(env.node_exe.to_string_lossy().to_string()),
version: Some(env.version),
satisfies,
required: NODE_REQUIRED.into(),
}
}
None => NodeStatus {
source: "none".into(),
path: None,
version: None,
satisfies: false,
required: NODE_REQUIRED.into(),
},
}
}
/// 下载并安装便携 Node(进度经 `dsh-install-progress` 推送)。
///
/// `version` 为空时自动解析满足要求的最新版本(优先 LTS)。
pub async fn node_install(&self, app: &AppHandle, version: Option<String>) -> Result<NodeStatus, String> {
if !cfg!(windows) {
return Err("便携 Node 安装仅支持 Windows,请改用系统 Node(nodeSource = system)".into());
}
self.cancel.store(false, Ordering::SeqCst);
let result = self.node_install_inner(app, version).await;
self.cancel.store(false, Ordering::SeqCst);
if let Err(ref e) = result {
if e != NODE_CANCELLED {
self.emit_progress(app, "error", 0, 0, None, e);
}
}
result
}
async fn node_install_inner(&self, app: &AppHandle, version: Option<String>) -> Result<NodeStatus, String> {
let base = self.node_mirror_base();
let version = match version.filter(|v| !v.trim().is_empty()) {
Some(v) => normalize_version(&v),
None => {
self.emit_progress(app, "download", 0, 0, None, "正在解析 Node 版本...");
let requested = self.load_settings().managed_node_version;
if requested.trim().is_empty() {
self.resolve_latest_node_version(&base).await?
} else {
normalize_version(&requested)
}
}
};
let arch = platform_arch();
let url = format!("{base}/{version}/node-{version}-{arch}.zip");
let zip_path = self.node_dir().join("node-download.zip");
self.emit_progress(
app,
"download",
1,
0,
None,
&format!("正在下载 Node {version}..."),
);
self.download_to_file(app, &url, &zip_path, "正在下载 Node").await?;
if self.cancel.load(Ordering::SeqCst) {
let _ = fs::remove_file(&zip_path);
return Err(NODE_CANCELLED.into());
}
// 解压:官方 zip 顶层是 node-vX-win-x64/,剥掉这一层直接落到 node/
self.emit_progress(app, "extracting", 92, 0, None, "正在解压...");
let dest = self.node_dir();
if dest.exists() {
fs::remove_dir_all(&dest).map_err(|e| format!("清理旧 Node 目录失败: {e}"))?;
}
fs::create_dir_all(&dest).map_err(|e| format!("创建 Node 目录失败: {e}"))?;
if let Err(e) = extract_zip_strip_top(&zip_path, &dest) {
let _ = fs::remove_file(&zip_path);
return Err(format!("解压 Node 失败: {e}"));
}
let _ = fs::remove_file(&zip_path);
let exe = dest.join("node.exe");
if !exe.exists() {
return Err("解压后未找到 node.exe".into());
}
let actual = node_version(&exe).unwrap_or(version.clone());
self.emit_progress(app, "done", 100, 0, None, &format!("Node {actual} 安装完成"));
crate::logger::log_info("dsh", &format!("便携 Node 安装完成: {actual} ({})", exe.display()));
Ok(self.node_status())
}
/// 托管 Node 的镜像基址(`{base}/{version}/node-{version}-win-x64.zip`)。
fn node_mirror_base(&self) -> String {
let mirror = self.load_settings().node_mirror;
let mirror = mirror.trim().trim_end_matches('/');
if mirror.is_empty() {
"https://nodejs.org/dist".to_string()
} else {
mirror.to_string()
}
}
/// 解析满足要求的最新 Node 版本(优先 LTS)。
async fn resolve_latest_node_version(&self, base: &str) -> Result<String, String> {
let url = format!("{base}/index.json");
let resp = self
.http_client(30)
.get(&url)
.send()
.await
.map_err(|e| format!("获取 Node 版本列表失败: {e}"))?;
if !resp.status().is_success() {
return Err(format!("获取 Node 版本列表失败: HTTP {}", resp.status().as_u16()));
}
let list: Vec<serde_json::Value> = resp
.json()
.await
.map_err(|e| format!("解析 Node 版本列表失败: {e}"))?;
let mut latest_lts: Option<(u32, u32, u32, String)> = None;
let mut latest_any: Option<(u32, u32, u32, String)> = None;
for item in list {
let Some(version) = item.get("version").and_then(|v| v.as_str()) else {
continue;
};
if !satisfies_node_requirement(version) {
continue;
}
let Some(parsed) = super::parse_version(version) else {
continue;
};
let is_lts = item.get("lts").map(|l| !l.is_null() && l != false).unwrap_or(false);
if latest_any.as_ref().map(|(maj, min, pat, _)| (parsed.0, parsed.1, parsed.2) > (*maj, *min, *pat)).unwrap_or(true) {
latest_any = Some((parsed.0, parsed.1, parsed.2, version.to_string()));
}
if is_lts
&& latest_lts
.as_ref()
.map(|(maj, min, pat, _)| (parsed.0, parsed.1, parsed.2) > (*maj, *min, *pat))
.unwrap_or(true)
{
latest_lts = Some((parsed.0, parsed.1, parsed.2, version.to_string()));
}
}
latest_lts
.or(latest_any)
.map(|(_, _, _, v)| v)
.ok_or_else(|| "未找到满足 dsh 要求的 Node 版本".to_string())
}
/// 流式下载到文件(带取消 + 进度事件,percent 0-90)。
pub(crate) async fn download_to_file(
&self,
app: &AppHandle,
url: &str,
dest: &Path,
label: &str,
) -> Result<(), String> {
let resp = self
.http_client(1800)
.get(url)
.send()
.await
.map_err(|e| format!("请求下载失败({url}): {e}"))?;
let status = resp.status();
if !status.is_success() {
return Err(format!("下载返回 HTTP {}", status.as_u16()));
}
let total = 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: u8 = 0;
while let Some(chunk) = stream.next().await {
if self.cancel.load(Ordering::SeqCst) {
drop(file);
fs::remove_file(dest).ok();
return Err(NODE_CANCELLED.into());
}
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) * 90.0) as u8)
.unwrap_or(0)
.min(90);
if percent >= last_percent + 1 {
last_percent = percent;
self.emit_progress(
app,
"download",
percent,
downloaded,
total,
&format!("{label} {:.1} MB", downloaded as f64 / 1048576.0),
);
}
}
file.flush().ok();
self.emit_progress(app, "download", 90, downloaded, total, "下载完成");
Ok(())
}
/// 请求取消(下载 / 安装 / 解压均轮询此标志)。
pub(crate) fn request_cancel(&self) {
self.cancel.store(true, Ordering::SeqCst);
let pid = self.install_pid.load(Ordering::SeqCst);
if pid > 0 {
taskkill_tree(pid);
}
}
}
/// 官方分发包的平台标识(Windows x64 / arm64)。
fn platform_arch() -> &'static str {
match std::env::consts::ARCH {
"aarch64" => "win-arm64",
_ => "win-x64",
}
}
/// PATH 上查找 node 可执行文件。
fn which_node() -> Option<PathBuf> {
let name = if cfg!(windows) { "node.exe" } else { "node" };
let path_var = std::env::var_os("PATH")?;
for dir in std::env::split_paths(&path_var) {
let candidate = dir.join(name);
if candidate.is_file() {
return Some(candidate);
}
}
None
}
/// 取 node 目录下的 npm 入口(`node_modules/npm/bin/npm-cli.js`)。
///
/// 直接 `node npm-cli.js` 而不是 `npm.cmd`:`.cmd` 在 Windows 上无法被
/// CreateProcess 直接执行(需经 `cmd /C`,而 cmd 的引号规则易踩坑),
/// 且批处理 shim 会多出一层进程影响取消时的进程树清理。
fn npm_cli_js(node_exe: &Path) -> Option<PathBuf> {
let dir = node_exe.parent()?;
let candidates = [
dir.join("node_modules").join("npm").join("bin").join("npm-cli.js"),
dir.join("lib").join("node_modules").join("npm").join("bin").join("npm-cli.js"),
];
candidates.into_iter().find(|p| p.is_file())
}
/// 执行 `node --version` 取版本号。
fn node_version(node_exe: &Path) -> Option<String> {
let mut cmd = std::process::Command::new(node_exe);
cmd.arg("--version");
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let out = cmd.output().ok()?;
if !out.status.success() {
return None;
}
let text = String::from_utf8_lossy(&out.stdout).trim().to_string();
(!text.is_empty()).then_some(text)
}
/// 规范化版本号:补上 `v` 前缀。
fn normalize_version(raw: &str) -> String {
let t = raw.trim();
if t.starts_with('v') {
t.to_string()
} else {
format!("v{t}")
}
}
/// 解压 zip 并剥掉顶层目录(Node 官方分发包顶层是 `node-vX-win-x64/`)。
pub(crate) fn extract_zip_strip_top(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 Some(name) = entry.enclosed_name() else {
continue;
};
// 剥掉第一层目录;顶层目录条目本身(只有一个组件)跳过
let mut comps = name.components();
comps.next();
let rel: PathBuf = comps.map(|c| c.as_os_str()).collect();
if rel.as_os_str().is_empty() {
continue;
}
let outpath = dest.join(&rel);
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(())
}
/// 强杀进程树(安装子进程取消用)。
pub(crate) fn taskkill_tree(pid: u64) {
let mut cmd = std::process::Command::new("taskkill");
cmd.args(["/F", "/T", "/PID", &pid.to_string()])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let _ = cmd.status();
}
+316
View File
@@ -0,0 +1,316 @@
//! dsh 服务进程生命周期:spawn(自管 stdio)→ 就绪探测 → 日志落盘 → 停止。
//!
//! 进程形态参照 `music/bridge.rs` 的长驻子进程:stdout/stderr 各起一个 reader 线程,
//! 逐行写入日志环形缓冲与 `logs/web.log`;子进程加入 Job Object,应用退出时由
//! 系统自动回收。启动命令为 `node <dsh bin 入口> web --port <端口> --no-open`:
//! `--no-open` 让 dsh 不要自己弹出系统浏览器(由本模块的按钮决定何时打开)。
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{SocketAddr, TcpListener, TcpStream};
use std::process::{Command, Stdio};
use std::sync::atomic::Ordering;
use std::time::{Duration, Instant};
use tauri::AppHandle;
use super::types::DshServerStatus;
use super::{DshManager, ServerEntry};
/// 就绪探测总时长上限。
const READY_TIMEOUT: Duration = Duration::from_secs(60);
impl DshManager {
/// 进程是否存活。
fn server_running(&self) -> bool {
let mut guard = match self.server.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,
}
}
/// 当前服务状态。
pub fn server_status(&self) -> DshServerStatus {
let running = self.server_running();
// 运行中一律用**进程实际使用的端口**(设置可能在启动后被改过,
// 此时 UI 展示的地址必须仍是真正监听的那个)
let entry = self
.server
.lock()
.ok()
.and_then(|g| g.as_ref().map(|e| (e.pid, e.port, e.started_at)));
let (pid, port, started_at) = match (running, entry) {
(true, Some((pid, port, started_at))) => (Some(pid), port, Some(started_at)),
_ => (None, self.load_settings().port, None),
};
DshServerStatus {
running,
ready: running && self.ready.load(Ordering::SeqCst),
pid,
port,
url: format!("http://127.0.0.1:{port}"),
launch_url: if running {
self.launch_url.lock().ok().and_then(|g| g.clone())
} else {
None
},
started_at,
error: self.server_error.lock().ok().and_then(|g| g.clone()),
}
}
/// 启动 dsh Web 服务(幂等:已在运行直接返回当前状态)。
pub fn start_server(&self, app: &AppHandle) -> Result<DshServerStatus, String> {
if self.server_running() {
return Ok(self.server_status());
}
let _guard = self.start_lock.lock().map_err(|e| e.to_string())?;
if self.server_running() {
return Ok(self.server_status());
}
// 清理可能残留的旧条目
if let Ok(mut g) = self.server.lock() {
g.take();
}
self.ready.store(false, Ordering::SeqCst);
if let Ok(mut g) = self.server_error.lock() {
*g = None;
}
// 上一进程的令牌必须清掉:沿用旧令牌会让新进程的首次访问仍然 401
if let Ok(mut g) = self.launch_url.lock() {
*g = None;
}
let settings = self.load_settings();
let port = settings.port;
let env = self
.resolve_node_env()
.ok_or_else(|| "未找到可用的 Node,请先完成环境安装".to_string())?;
if !super::satisfies_node_requirement(&env.version) {
return Err(format!(
"当前 Node {} 不满足 dsh 要求({})",
env.version,
super::NODE_REQUIRED
));
}
let entry = self
.bin_entry()
.ok_or_else(|| "未安装 dsh,请先完成安装".to_string())?;
// 端口预检:dsh 自身在端口占用时的报错不够直观,这里提前给出可读错误
if let Err(e) = TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], port))) {
let msg = format!("端口 {port} 不可用({e}),请在配置中更换端口");
self.set_server_error(&msg);
return Err(msg);
}
// 同步 AI 供应商配置(写 settings.yaml + 收集环境变量)
if settings.ai_sync {
if let Err(e) = self.ai_sync(app) {
// 同步失败不阻塞启动,只记日志(用户可在 dsh 内手动配置)
crate::logger::log_warn("dsh", &format!("AI 配置同步失败(继续启动): {e}"));
}
}
let env_vars = self.ai_env_vars();
let mut cmd = Command::new(&env.node_exe);
cmd.arg(&entry)
.arg("web")
.arg("--port")
.arg(port.to_string())
.arg("--no-open");
cmd.current_dir(self.workspace_dir());
cmd.env("DSH_HOME", self.home_dir());
for (key, value) in env_vars {
cmd.env(key, value);
}
cmd.stdout(Stdio::piped())
.stderr(Stdio::piped())
.stdin(Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let mut child = cmd.spawn().map_err(|e| {
let msg = format!("启动 dsh 失败({}): {e}", env.node_exe.display());
self.set_server_error(&msg);
msg
})?;
let pid = child.id();
crate::process_manager::assign_to_job(&child);
let stdout = child.stdout.take();
let stderr = child.stderr.take();
if let Ok(mut g) = self.server.lock() {
*g = Some(ServerEntry {
child,
pid,
port,
started_at: chrono::Utc::now().timestamp(),
});
}
// 输出 → 日志。stdout 额外承担「抓取带令牌启动地址」的职责:
// dsh 就绪后打印 `dsh web: http://127.0.0.1:<port>/?token=<令牌>`,
// 浏览器鉴权靠这个地址换 cookie(我们传了 --no-open,没别人替它换)。
let ring = self.log_ring_handle();
let log_path = self.log_path();
if let Some(out) = stdout {
spawn_stdout_reader(out, ring.clone(), log_path.clone(), self.launch_url.clone(), app.clone());
}
if let Some(err) = stderr {
spawn_log_reader(err, ring, log_path);
}
crate::logger::log_info(
"dsh",
&format!("dsh 服务已启动 (pid: {pid}, 端口: {port})"),
);
self.emit_server_state(app);
// 就绪探测(后台线程,不阻塞启动返回)
self.spawn_ready_probe(app.clone(), port);
Ok(self.server_status())
}
/// 停止 dsh 服务(kill 快速返回,wait 移到后台线程)。
pub fn stop_server(&self, app: &AppHandle) {
let entry = self.server.lock().ok().and_then(|mut g| g.take());
self.ready.store(false, Ordering::SeqCst);
if let Ok(mut g) = self.launch_url.lock() {
*g = None;
}
if let Some(mut entry) = entry {
// 先杀进程树(dsh 可能派生子进程),再关本进程句柄
super::node::taskkill_tree(entry.pid as u64);
let _ = entry.child.kill();
std::thread::spawn(move || {
let _ = entry.child.wait();
});
crate::logger::log_info("dsh", &format!("dsh 服务已停止 (pid: {})", entry.pid));
}
self.emit_server_state(app);
}
fn set_server_error(&self, message: &str) {
if let Ok(mut g) = self.server_error.lock() {
*g = Some(message.to_string());
}
}
/// 就绪探测:轮询 HTTP,成功置 ready;进程提前退出则记录错误原因。
fn spawn_ready_probe(&self, app: AppHandle, port: u16) {
std::thread::spawn(move || {
use tauri::Manager;
let deadline = Instant::now() + READY_TIMEOUT;
loop {
{
let manager = app.state::<DshManager>();
if http_probe(port) {
manager.ready.store(true, Ordering::SeqCst);
manager.emit_server_state(&app);
return;
}
if !manager.server_running() {
// 进程已退出:不必等到超时
let line = "dsh 服务进程已退出,未能就绪(详见日志)".to_string();
manager.push_log(&line);
manager.set_server_error(&line);
crate::logger::log_warn("dsh", &line);
manager.emit_server_state(&app);
return;
}
}
if Instant::now() >= deadline {
break;
}
std::thread::sleep(Duration::from_millis(500));
}
let manager = app.state::<DshManager>();
manager.emit_server_state(&app);
});
}
/// 日志环形缓冲句柄(reader/探测线程持有)。
pub(crate) fn log_ring_handle(&self) -> std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>> {
self.log_ring.clone()
}
}
/// 起一个 reader 线程把子进程输出逐行写进日志(stdout 与 stderr 类型不同,故泛型化)。
fn spawn_log_reader<R: Read + Send + 'static>(
pipe: R,
ring: std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>>,
log_path: std::path::PathBuf,
) {
std::thread::spawn(move || {
let reader = BufReader::new(pipe);
for line in reader.lines().map_while(Result::ok) {
super::push_log_shared(&ring, &log_path, &line);
}
});
}
/// stdout reader:写日志之外,还从 `dsh web: ...?token=<令牌>` 行里抓取启动地址。
///
/// 抓到后置入 `launch_url` 并推送状态事件,前端据此启用「独立窗口 / 浏览器打开」。
/// 注意锁的粒度:先算好是否需要通知再释放锁——`emit_server_state` 会读
/// `launch_url`,持锁调用会自锁。
fn spawn_stdout_reader<R: Read + Send + 'static>(
pipe: R,
ring: std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>>,
log_path: std::path::PathBuf,
launch_url: std::sync::Arc<std::sync::Mutex<Option<String>>>,
app: tauri::AppHandle,
) {
std::thread::spawn(move || {
let reader = BufReader::new(pipe);
for line in reader.lines().map_while(Result::ok) {
// 先解析原文(落日志时 token 会被掩码)
let parsed = super::parse_launch_url(&line);
if let Some(url) = parsed {
let changed = match launch_url.lock() {
Ok(mut slot) => {
let changed = slot.as_deref() != Some(url.as_str());
if changed {
*slot = Some(url);
}
changed
}
Err(_) => false,
};
if changed {
use tauri::Manager;
if let Some(manager) = app.try_state::<DshManager>() {
manager.emit_server_state(&app);
}
}
}
super::push_log_shared(&ring, &log_path, &line);
}
});
}
/// 极简 HTTP 探测:TCP 连上并收到以 `HTTP/` 开头的响应即视为就绪。
fn http_probe(port: u16) -> bool {
let addr = SocketAddr::from(([127, 0, 0, 1], port));
let Ok(mut stream) = TcpStream::connect_timeout(&addr, Duration::from_millis(500)) else {
return false;
};
let _ = stream.set_read_timeout(Some(Duration::from_millis(800)));
let req = format!("GET / HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n");
if stream.write_all(req.as_bytes()).is_err() {
return false;
}
let mut buf = [0u8; 16];
match stream.read(&mut buf) {
Ok(n) if n >= 5 => &buf[..5] == b"HTTP/",
_ => false,
}
}
+239
View File
@@ -0,0 +1,239 @@
//! dsh 模块(DeepSeek Harness 外壳)的数据类型。
//!
//! 全部走 specta 导出到 `src/lib/bindings.ts`,字段 camelCase。
use serde::{Deserialize, Serialize};
use specta::Type;
/// dsh 对 Node 的版本要求(`^22.19.0 || >=24.0.0`)。
pub const NODE_REQUIRED: &str = "^22.19.0 || >=24.0.0";
/// dsh npm 包名。
pub const DSH_PACKAGE: &str = "@deepseek-ai/dsh";
/// 默认 Web UI 端口。
pub const DEFAULT_PORT: u16 = 3080;
/// 默认「打开独立窗口」全局快捷键(与 quickpanel/截图等同为全局快捷键,格式见
/// `keyboard-types` 的 `Modifiers+Code`:修饰键名大小写不敏感,数字键名即 `5`)。
pub const DEFAULT_SHORTCUT: &str = "Alt+D";
/// 模块设置(`{app_data}/dsh/settings.json`)。
///
/// 独立文件,**不写** `thing_app_settings`(appStore 的 SETTINGS_VERSION 迁移会清空用户设置)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct DshSettings {
/// 结构版本号;变更时按版本校正字段
pub version: u32,
/// Node 来源偏好:auto(系统优先,缺失回落托管)| system | managed
pub node_source: String,
/// 指定下载的 Node 版本(空 = 自动取满足要求的最新版)
pub managed_node_version: String,
/// Node 分发包镜像前缀(空 = 官方 nodejs.org;国内可用 npmmirror)
pub node_mirror: String,
/// npm registry(空 = 官方源)
pub npm_registry: String,
/// 下载 Node / npm 安装是否走代理模块(mihomo mixed 端口)
pub use_proxy: bool,
/// Web UI 端口(dsh 的 `--port` 参数)
pub port: u16,
/// 应用启动时自动拉起 dsh 服务
pub auto_start: bool,
/// 全局快捷键:打开 dsh Web 独立窗口(空 = 未启用)
pub shortcut: String,
/// $DSH_HOME 模式:managed({app_data}/dsh/home)| user(~/.dsh)
pub dsh_home_mode: String,
/// 工作区目录(空 = {app_data}/dsh/workspace),即 dsh 进程的启动目录
pub workspace: String,
/// dsh 本体的安装目录(npm `--prefix` 目标,即 node_modules 所在位置)。
/// 空 = {app_data}/dsh。
/// 只有 dsh 本体与它的 node_modules 跟随此设置;便携 Node、$DSH_HOME、
/// 日志与模块设置仍固定在应用数据目录,避免自定义路径失效时连配置都读不到。
pub install_dir: String,
/// 映射为 dsh 默认模型的 Thing AI 供应商 id
pub provider_id: String,
/// 启动前自动同步 settings.yaml
pub ai_sync: bool,
}
impl Default for DshSettings {
fn default() -> Self {
Self {
version: 1,
node_source: "auto".into(),
managed_node_version: String::new(),
node_mirror: String::new(),
npm_registry: String::new(),
use_proxy: true,
port: DEFAULT_PORT,
auto_start: false,
shortcut: DEFAULT_SHORTCUT.into(),
dsh_home_mode: "managed".into(),
workspace: String::new(),
install_dir: String::new(),
provider_id: "deepseek".into(),
ai_sync: true,
}
}
}
impl DshSettings {
/// 自愈:非法/越界字段夹回默认;版本推进。返回是否发生变更。
pub fn heal(&mut self) -> bool {
let mut changed = false;
if !matches!(self.node_source.as_str(), "auto" | "system" | "managed") {
self.node_source = "auto".into();
changed = true;
}
if !matches!(self.dsh_home_mode.as_str(), "managed" | "user") {
self.dsh_home_mode = "managed".into();
changed = true;
}
if self.port == 0 {
self.port = DEFAULT_PORT;
changed = true;
}
if self.version < 1 {
self.version = 1;
changed = true;
}
// v1 → v2:默认「打开独立窗口」快捷键从 Ctrl+5 改为 Alt+D。
// 仍等于旧默认值 = 用户没改过,直接迁移;改过(或清空禁用)的原样保留 ——
// 版本号已推进,之后即使再改回旧键位也不会被改写(同 translate 的 heal 约定)。
if self.version < 2 {
if self.shortcut.trim().eq_ignore_ascii_case("ctrl+5") {
self.shortcut = DEFAULT_SHORTCUT.to_string();
}
self.version = 2;
changed = true;
}
changed
}
}
/// Node 运行环境状态。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NodeStatus {
/// system | managed | none
pub source: String,
/// node.exe 路径
pub path: Option<String>,
/// 版本号(如 v24.9.0)
pub version: Option<String>,
/// 是否满足 dsh 的版本要求
pub satisfies: bool,
/// 版本要求文案(供 UI 展示)
pub required: String,
}
/// dsh 本体安装状态。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshInstallStatus {
pub installed: bool,
pub version: Option<String>,
/// bin 入口(dist/bin.js 绝对路径)
pub entry: Option<String>,
/// 安装目录
pub dir: String,
}
/// dsh 服务进程状态。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshServerStatus {
/// 进程存活
pub running: bool,
/// HTTP 端口已可访问
pub ready: bool,
pub pid: Option<u32>,
pub port: u16,
/// 规范地址(不含令牌,用于界面展示)
pub url: String,
/// 带令牌的启动地址(**用于打开界面**)。
///
/// dsh web 的浏览器鉴权是「进程级随机令牌 → 首次访问换 cookie」:
/// 直接访问 [`Self::url`] 只会拿到 401。令牌每次启动都不同,只能从
/// dsh 的输出里抓取,因此进程刚起来时这里可能为 None(等它打印)。
pub launch_url: Option<String>,
/// 启动时间(unix 秒)
pub started_at: Option<i64>,
/// 启动失败原因(端口占用 / 进程立即退出等)
pub error: Option<String>,
}
/// 模块首屏环境总览。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshEnvStatus {
pub node: NodeStatus,
pub dsh: DshInstallStatus,
pub server: DshServerStatus,
pub settings: DshSettings,
}
/// 安装/下载进度事件载荷(与 kernel/music 同构)。
/// stage: download | extracting | installing | done | error
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshInstallProgress {
pub stage: String,
pub percent: u8,
#[specta(type = f64)]
pub downloaded_bytes: u64,
#[specta(type = Option<f64>)]
pub total_bytes: Option<u64>,
pub message: String,
}
/// dsh 版本更新信息。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshUpdateInfo {
pub current: Option<String>,
pub latest: String,
pub has_update: bool,
/// 可选版本(倒序,最多 20 个)
pub versions: Vec<String>,
}
/// npm 源信息(安装引导页展示「本次实际用哪个源」并提供快捷切换)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshNpmRegistryInfo {
/// 本次安装/查询实际会使用的源(已去掉末尾 `/`)
pub effective: String,
/// effective 的来源:setting(模块设置显式指定)| npm(npm 自身配置链)| fallback(默认官方源)
pub source: String,
/// npm 自身解析出的源(环境变量 > 安装目录 .npmrc > 用户 ~/.npmrc > 内置),
/// 未检测到 Node/npm 时为 None
pub npm_registry: Option<String>,
/// 模块设置里显式填写的值(空 = 未指定,交给 npm 解析)
pub setting: String,
}
/// AI 供应商映射结果(预览用,不含明文密钥)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshAiProvider {
/// Thing 侧供应商 id
pub id: String,
pub name: String,
/// 写入 settings.yaml 的 apiKeyEnv 变量名
pub env_name: String,
pub base_url: String,
pub model: String,
/// 凭据管理器中是否已配置密钥
pub has_key: bool,
}
/// settings.yaml 同步预览。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshAiPreview {
/// 将被写入的 YAML 文本(密钥位置只有环境变量名)
pub yaml: String,
pub providers: Vec<DshAiProvider>,
pub default_provider: Option<String>,
pub default_model: Option<String>,
pub settings_path: String,
}
+143 -16
View File
@@ -1,12 +1,14 @@
use tauri::Manager;
mod ai;
mod clipboard;
mod constants;
mod download_engine;
mod dsh;
mod logger;
mod mihomo_manager;
mod monitor_kernel;
mod music;
pub mod music;
mod network_monitor;
mod osd_window;
mod process_manager;
@@ -22,6 +24,10 @@ mod tray_menu;
mod updater;
mod win32_util;
use ai::{
ai_get_settings, ai_list_providers, ai_provider_delete, ai_provider_models,
ai_provider_save, ai_provider_test, ai_save_settings, ai_secret_clear, ai_secret_set,
};
use download_engine::{
DownloadEngine,
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,
@@ -51,14 +57,30 @@ use music::{
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_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume,
music_audio_state, music_audio_stop,
music_cancel_runtime_install, music_decrypt_cancel, music_decrypt_qq_status,
music_decrypt_run, music_decrypt_scan,
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_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position,
music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret,
webdav_save_secret, webdav_test,
webdav_upload, MusicManager,
webdav_upload, remote_cancel_pairing, remote_get_config, remote_list_devices,
remote_publish_queue, remote_revoke_device, remote_set_enabled, remote_start_pairing,
remote_status,
AudioEngine, MusicManager, RemoteManager, SmtcController, SmtcMetaCache,
};
use network_monitor::network_status;
use dsh::{
dsh_ai_preview, dsh_ai_sync, dsh_cancel_install, dsh_check_update, dsh_env_status,
dsh_get_settings, dsh_install, dsh_install_log, dsh_log_clear, dsh_log_tail,
dsh_node_detect, dsh_node_install, dsh_npm_registry_info, dsh_open_dir,
dsh_register_shortcut, dsh_restart, dsh_save_settings, dsh_start, dsh_stop,
dsh_uninstall, dsh_unregister_shortcut, dsh_update,
};
use osd_window::{
osd_apply_overlay_style, osd_begin_drag, osd_set_bounds, osd_set_click_through,
osd_set_topmost, osd_start_drag_watch, osd_start_game_watch, osd_start_topmost_watch,
@@ -125,7 +147,10 @@ use terminal::commands::{
// 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,
terminal_sftp_read_link, terminal_sftp_relay, terminal_sftp_rename, terminal_sftp_upload,
terminal_file_window_open,
// 本地文件系统(面板本地栏)
terminal_local_delete, terminal_local_list, terminal_local_mkdir, terminal_local_rename,
// 命令片段(P1)
terminal_delete_snippet, terminal_list_snippets, terminal_render_snippet,
terminal_restore_default_snippets, terminal_run_snippet, terminal_save_snippet,
@@ -145,16 +170,15 @@ use terminal::commands::{
};
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,
translate_abort, translate_ai_engine_remove, translate_ai_params_save, 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,
@@ -226,6 +250,15 @@ fn export_bindings() {
// music(6,豁免 3:music_ping / music_get_sources / music_search 返回 serde_json::Value)
music_env_status, music_install_runtime, music_cancel_runtime_install,
music_stop_bridge, music_get_settings, music_save_settings,
// music 播放引擎(Rust 侧播放,取代前端 <audio>)
music_audio_play, music_audio_set_playing, music_audio_seek, music_audio_stop,
music_audio_set_volume, music_audio_state,
// music 手机互联(remote,8)
remote_get_config, remote_set_enabled, remote_status, remote_start_pairing,
remote_cancel_pairing, remote_list_devices, remote_revoke_device,
remote_publish_queue,
// music 本地解密(「解密」页签)
music_decrypt_run, music_decrypt_cancel, music_decrypt_scan, music_decrypt_qq_status,
// 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,
@@ -238,6 +271,10 @@ fn export_bindings() {
screenshot_set_scroll_hole,
screenshot_copy_image, screenshot_save_png,
screenshot_save_cache, screenshot_load_cache, screenshot_delete_cache,
// ai(9)
ai_get_settings, ai_save_settings, ai_list_providers, ai_provider_save,
ai_provider_delete, ai_secret_set, ai_secret_clear, ai_provider_test,
ai_provider_models,
// translate(20)
translate_get_settings, translate_save_settings, translate_apply_shortcuts,
translate_engines_list, translate_engine_save, translate_engine_delete,
@@ -249,6 +286,7 @@ fn export_bindings() {
translate_history_list, translate_history_delete, translate_history_clear,
translate_history_set_favorited,
translate_stream_start, translate_abort, translate_paste_back,
translate_ai_params_save, translate_ai_engine_remove,
// 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,
@@ -277,6 +315,15 @@ fn export_bindings() {
terminal_history_query, terminal_history_sources,
terminal_history_toggle_favorite, terminal_history_delete,
terminal_history_clear, terminal_history_run,
// AI 命令助手(P2)——与 `run()` 里那份保持一致,否则 bindings.ts 缺类型
terminal_ai_engines, terminal_ai_suggest,
// dsh(22)——与 `run()` 里那份保持一致,否则 bindings.ts 缺类型
dsh_env_status, dsh_node_detect, dsh_node_install, dsh_install, dsh_update,
dsh_uninstall, dsh_cancel_install, dsh_check_update, dsh_npm_registry_info,
dsh_get_settings, dsh_save_settings, dsh_register_shortcut,
dsh_unregister_shortcut, dsh_start, dsh_stop, dsh_restart,
dsh_ai_preview, dsh_ai_sync, dsh_log_tail, dsh_install_log, dsh_log_clear,
dsh_open_dir,
])
.export(Typescript::default(), "../src/lib/bindings.ts")
.expect("failed to export bindings");
@@ -287,12 +334,20 @@ pub fn run() {
#[cfg(debug_assertions)]
export_bindings();
// 必须在创建任何窗口之前:让系统按 AUMID 认出本应用(系统媒体面板/任务栏据此显示
// 应用名与图标,否则只显示「未知应用」)。取值与安装包写进开始菜单快捷方式的
// AppUserModelID 一致,即 Tauri 的 identifier。
// (Chromium 自带媒体会话的压制:环境变量与 additionalBrowserArgs 两条路都已实测
// 不可用,详见 music/smtc.rs 的模块注释。)
#[cfg(windows)]
win32_util::set_app_user_model_id("thing.lfeng.me");
tauri::Builder::default()
.plugin(tauri_plugin_autostart::Builder::new().build())
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_dialog::init())
// 截图快捷键改由 screenshot::shortcut::register_shortcut(on_shortcut)按需注册,
// 支持自定义;默认 Ctrl+Alt+A 由前端 store 启动时注册
// 支持自定义;默认 F3 由前端 store 启动时注册
.plugin(tauri_plugin_global_shortcut::Builder::new().build())
.plugin(tauri_plugin_notification::init())
.plugin(
@@ -302,6 +357,13 @@ pub fn run() {
)
.manage(ProcessManager::new())
.manage(ThinghkUpdateState::new())
.manage(SmtcController::new())
// Rust 侧播放引擎(取代前端 <audio>,见 music/audio 模块注释)
.manage(AudioEngine::new())
// 手机互联:遥控状态容器(MUSIC_REMOTE_PLAN §5.1 平级 manage)+
// SMTC 元数据兜底缓存(remote/glsmtc §5.2 聚合用)
.manage(RemoteManager::new())
.manage(SmtcMetaCache::default())
.invoke_handler(tauri::generate_handler![
quit_app,
app_version,
@@ -391,6 +453,24 @@ pub fn run() {
feiniu_cache_clear,
feiniu_cache_fetch,
feiniu_fnconnect_resolve,
music_smtc_update_metadata,
music_smtc_update_position,
music_smtc_update_playback_state,
music_smtc_clear,
music_audio_play,
music_audio_set_playing,
music_audio_seek,
music_audio_stop,
music_audio_set_volume,
music_audio_state,
remote_get_config,
remote_set_enabled,
remote_status,
remote_start_pairing,
remote_cancel_pairing,
remote_list_devices,
remote_revoke_device,
remote_publish_queue,
webdav_test,
webdav_upload,
webdav_delete,
@@ -398,6 +478,11 @@ pub fn run() {
webdav_save_secret,
music_secret_get,
music_secret_set,
// 音乐模块:本地解密(「解密」页签)
music_decrypt_run,
music_decrypt_cancel,
music_decrypt_scan,
music_decrypt_qq_status,
feiniu_delete_local,
network_status,
osd_apply_overlay_style,
@@ -543,6 +628,17 @@ pub fn run() {
translate_stream_start,
translate_abort,
translate_paste_back,
translate_ai_params_save,
translate_ai_engine_remove,
ai_get_settings,
ai_save_settings,
ai_list_providers,
ai_provider_save,
ai_provider_delete,
ai_secret_set,
ai_secret_clear,
ai_provider_test,
ai_provider_models,
terminal_get_settings,
terminal_save_settings,
terminal_save_appearance,
@@ -601,11 +697,19 @@ pub fn run() {
terminal_sftp_delete,
terminal_sftp_rename,
terminal_sftp_upload,
terminal_sftp_relay,
terminal_sftp_download,
terminal_session_cwd_value,
// 文件窗口(单例)
terminal_file_window_open,
// 本地文件操作(SFTP 面板的「打开 / 在资源管理器中显示」)
terminal_open_local_path,
terminal_reveal_local_path,
// 本地文件系统(面板本地栏的浏览与增删改)
terminal_local_list,
terminal_local_mkdir,
terminal_local_rename,
terminal_local_delete,
// 命令片段(P1)
terminal_list_snippets,
terminal_save_snippet,
@@ -635,7 +739,30 @@ pub fn run() {
terminal_save_template,
// AI 命令助手(P2)
terminal_ai_engines,
terminal_ai_suggest
terminal_ai_suggest,
// dsh(22)
dsh_env_status,
dsh_node_detect,
dsh_node_install,
dsh_install,
dsh_update,
dsh_uninstall,
dsh_cancel_install,
dsh_check_update,
dsh_npm_registry_info,
dsh_get_settings,
dsh_save_settings,
dsh_register_shortcut,
dsh_unregister_shortcut,
dsh_start,
dsh_stop,
dsh_restart,
dsh_ai_preview,
dsh_ai_sync,
dsh_log_tail,
dsh_install_log,
dsh_log_clear,
dsh_open_dir
])
.setup(setup::init)
.on_window_event(|window, event| {
+9
View File
@@ -2,5 +2,14 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
fn main() {
// WebView2 的浏览器参数这里不设置。
//
// 为关掉 Chromium 自带媒体会话(SMTC)而注入浏览器参数的两条路都已实测不可用,
// 详见 music/smtc.rs 的模块注释:
// 1) `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS` 环境变量——本应用支持永久提权,
// 而提权进程下 WebView2 会忽略所有 WEBVIEW2_* 变量(微软文档明确说明);
// 2) tauri.conf.json 的 `additionalBrowserArgs`——参数只加在主窗口上,与其余弹窗
// 的参数不一致却共用同一个 EBWebView 用户数据目录,结果是托盘菜单/截图等窗口
// 的页面永远不执行 JS,彻底唤不出。
thing_lib::run()
}
+500
View File
@@ -0,0 +1,500 @@
//! Rust 侧音频播放引擎:解码 + 输出都在后端完成,前端只发命令、读状态。
//!
//! # 为什么要搬到 Rust(而不是继续用前端 `<audio>`)
//!
//! 前端播放时,Chromium 会为播放中的媒体元素自动注册一条系统媒体会话(SMTC),
//! 与 [`super::smtc`] 投递的原生会话并行 → Windows 媒体面板出现两条「媒体」。
//! 能关掉它的浏览器参数(`--disable-features=MediaSessionService`)会把本应用的
//! 其他 WebView 窗口一起弄死(见 smtc 模块注释),前端 `navigator.mediaSession`
//! 空桩又拦不住浏览器侧的注册。**主窗口只要不再持有 `<audio>`,就没有会话可注册**,
//! 于是不需要任何浏览器参数,其他窗口也恢复原状。
//!
//! # 线程模型
//!
//! - **调用方线程**(Tauri 命令):只做控制(play / pause / seek / stop / 音量)与状态查询,
//! 全部是原子操作或往通道发一条消息,绝不等待。
//! - **播放线程**(每个会话一条 std 线程):打开音源、探测格式、建输出流、解码填缓冲。
//! `cpal::Stream` 不是 `Send`,必须由它自己创建并持有,因此它随会话生灭。
//! - **音频回调线程**(cpal 内部):只做「出队 → 乘增益 → 转格式」,见 [`super::output`]。
//!
//! # 会话隔离
//!
//! [`Shared`] 是**每个会话一份**的:切歌时先把旧会话静音(立刻生效),再建新会话。
//! 若共用一份共享状态,旧线程还在写、新线程已经在读,会出现「两首歌混在一起」。
//!
//! # 暂停/定位的实现取舍
//!
//! 暂停**不清空缓冲**、也不停输出流,只让回调输出静音(见 output::fill):这样恢复播放
//! 是瞬时的,且不会因为反复启停声卡产生爆音。
//! 定位则清空缓冲并让解码器重新定位,位置计数同步跳到目标点。
use std::collections::VecDeque;
use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU64, Ordering};
use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::time::Duration;
use serde::Serialize;
use specta::Type;
use symphonia::core::codecs::audio::AudioDecoderOptions;
use symphonia::core::errors::Error as SymphoniaError;
use symphonia::core::formats::{FormatOptions, FormatReader, SeekMode, SeekTo, TrackType};
use symphonia::core::formats::probe::Hint;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use symphonia::core::units::Time;
use tauri::{AppHandle, Emitter};
use super::{output, source};
/// 播放缓冲上限(秒)。
///
/// 太小:解码抖动(网络流尤其)会来不及补数据 → 断音;
/// 太大:定位时要丢弃更多已解码数据,拖进度条的反应变慢。2 秒是这两者间的常见折中。
const BUFFER_SECONDS: f64 = 2.0;
/// 栈上临时帧数组的容量上限(源声道数超过它时多出的声道被忽略)。
const MAX_CHANNELS: usize = 8;
/// 单个会话的共享状态:解码线程写、音频回调读写、命令线程只读写原子量。
pub(crate) struct Shared {
/// 交错 f32 样本队列(生产 = 解码线程,消费 = 音频回调)
pub buf: Mutex<VecDeque<f32>>,
/// 已播放帧数:**播放位置以它为准**(只有音频回调会自增,定位时由解码线程重置)
pub frames_played: AtomicU64,
/// 源采样率(Hz)
pub rate: AtomicU32,
/// 源声道数
pub src_channels: AtomicU16,
/// 设备输出声道数([`output::build`] 写入)
pub out_channels: AtomicU16,
/// 是否处于播放态(false = 回调输出静音且不消费队列)
pub playing: AtomicBool,
pub muted: AtomicBool,
/// 目标音量(f32 的位表示)
pub volume: AtomicU32,
/// 当前增益(f32 的位表示;音量斜坡用,只有回调写)
pub gain: AtomicU32,
/// 已到达流末尾
pub finished: AtomicBool,
/// 输出流报错(设备被拔/被独占/驱动异常)
pub failed: AtomicBool,
}
impl Shared {
fn new(volume: f32, muted: bool) -> Self {
Self {
buf: Mutex::new(VecDeque::new()),
frames_played: AtomicU64::new(0),
rate: AtomicU32::new(0),
src_channels: AtomicU16::new(0),
out_channels: AtomicU16::new(0),
playing: AtomicBool::new(true),
muted: AtomicBool::new(muted),
volume: AtomicU32::new(volume.to_bits()),
// 起始增益等于目标音量:避免起播瞬间从 0 拉起来产生的淡入延迟
gain: AtomicU32::new(volume.to_bits()),
finished: AtomicBool::new(false),
failed: AtomicBool::new(false),
}
}
fn queue_len(&self) -> usize {
self.buf.lock().unwrap_or_else(|e| e.into_inner()).len()
}
}
/// 播放线程收到的控制消息。音量/静音/暂停走原子量,不进通道(不必串到解码线程)。
enum Control {
/// 定位到指定秒(精确定位由解码线程负责)
Seek(f64),
/// 结束会话(线程随即退出并丢弃输出流)
Stop,
}
/// 一次播放会话的句柄。
struct Session {
shared: Arc<Shared>,
ctrl: Sender<Control>,
/// 播放线程句柄:**故意不 join**(见 `stop_current` 的说明),唯一作用是与会话
/// 同生共死 —— 会话 Arc 释放时它一起被丢弃,丢弃即 detach,线程收到 Stop 后
/// 自行收尾并释放输出流。因为从不解绑/join,此字段除「持有」外没有任何读取。
#[allow(dead_code)]
handle: JoinHandle<()>,
}
/// 播放状态快照(返回前端)。进度用**拉取**而不是每帧推送:
/// 高频 emit 既费 IPC,又会在拖动进度条时和本地状态打架。
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct AudioState {
/// 是否存在有效会话(false = 已停止/无曲目)
pub active: bool,
pub playing: bool,
/// 当前播放位置(秒)
pub position_sec: f64,
/// 已解码待播的秒数
pub buffered_sec: f64,
/// 源采样率(Hz),0 = 尚未探测出来
pub sample_rate: u32,
pub finished: bool,
pub failed: bool,
}
/// 音频引擎:持有当前会话,并保留跨曲目生效的音量/静音。
pub struct AudioEngine {
/// 用 Arc 装:命令线程要能拿到会话去改状态,而结束会话时要能把它整体摘掉
session: Mutex<Option<Arc<Session>>>,
/// 音量与静音在切歌后沿用(用户在播放器或设置里调过之后不该被重置)
volume: AtomicU32,
muted: AtomicBool,
}
impl AudioEngine {
pub fn new() -> Self {
Self {
session: Mutex::new(None),
volume: AtomicU32::new(1.0f32.to_bits()),
muted: AtomicBool::new(false),
}
}
/// 开始播放一个音源。
///
/// `spec` 为本地绝对路径或流地址([`source::open`] 按 scheme 判定);
/// `start_sec` 用于「退出时的进度」续播。旧会话会先被静音并结束。
pub fn play(&self, app: &AppHandle, spec: String, start_sec: f64) -> Result<(), String> {
self.stop_current();
let shared = Arc::new(Shared::new(
f32::from_bits(self.volume.load(Ordering::Relaxed)),
self.muted.load(Ordering::Relaxed),
));
let (ctrl_tx, ctrl_rx) = mpsc::channel();
let thread_shared = shared.clone();
let thread_app = app.clone();
let handle = thread::Builder::new()
.name("music-audio".to_string())
.spawn(move || {
if let Err(e) = run_session(&thread_shared, &ctrl_rx, &thread_app, &spec, start_sec) {
crate::logger::log_error("music-audio", &format!("播放失败({spec}): {e}"));
let _ = thread_app.emit(crate::constants::events::MUSIC_AUDIO_ERROR, e);
}
})
.map_err(|e| format!("创建播放线程失败: {e}"))?;
*self.session.lock().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(Session {
shared,
ctrl: ctrl_tx,
handle,
}));
Ok(())
}
/// 暂停/恢复。走原子量,不进通道,因此是瞬时生效的。
pub fn set_playing(&self, playing: bool) {
if let Some(s) = self.current() {
s.shared.playing.store(playing, Ordering::SeqCst);
}
}
/// 定位到指定秒。
pub fn seek(&self, sec: f64) {
if let Some(s) = self.current() {
let _ = s.ctrl.send(Control::Seek(sec));
}
}
/// 停止播放并释放设备。
pub fn stop(&self) {
self.stop_current();
}
/// 设置音量与静音。目标值立即写入(回调在本块内斜坡过去,无爆音),
/// 同时记在引擎上供下一首沿用。
pub fn set_volume(&self, volume: f32, muted: bool) {
let volume = volume.clamp(0.0, 1.0);
self.volume.store(volume.to_bits(), Ordering::Relaxed);
self.muted.store(muted, Ordering::Relaxed);
if let Some(s) = self.current() {
s.shared.volume.store(volume.to_bits(), Ordering::Relaxed);
s.shared.muted.store(muted, Ordering::Relaxed);
}
}
pub fn state(&self) -> AudioState {
let Some(s) = self.current() else {
return AudioState {
active: false,
playing: false,
position_sec: 0.0,
buffered_sec: 0.0,
sample_rate: 0,
finished: false,
failed: false,
};
};
let rate = s.shared.rate.load(Ordering::Relaxed).max(1);
let ch = s.shared.src_channels.load(Ordering::Relaxed).max(1) as usize;
let frames = s.shared.frames_played.load(Ordering::Relaxed);
let queued = s.shared.queue_len();
AudioState {
active: true,
playing: s.shared.playing.load(Ordering::Relaxed),
position_sec: frames as f64 / rate as f64,
buffered_sec: queued as f64 / (rate as f64 * ch as f64),
sample_rate: s.shared.rate.load(Ordering::Relaxed),
finished: s.shared.finished.load(Ordering::Relaxed),
failed: s.shared.failed.load(Ordering::Relaxed),
}
}
fn current(&self) -> Option<Arc<Session>> {
self.session
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
/// 结束当前会话:**先静音**(立刻生效,避免它继续出声),再通知线程退出。
///
/// 只把会话从引擎里摘掉、不 join:调用方常在 Tauri 命令线程上,join 会把它卡住
/// 最长一个缓冲周期;线程收到 Stop 后自己收尾并丢弃输出流。会话 Arc 在这里
/// 释放后,JoinHandle 也随之丢弃,等于与线程解绑(detach),不会阻塞任何人。
fn stop_current(&self) {
let old = self.session.lock().unwrap_or_else(|e| e.into_inner()).take();
if let Some(old) = old {
old.shared.playing.store(false, Ordering::SeqCst);
// 让「已到末尾正在等缓冲放完」的等待立即退出,否则它要睡到自然结束
old.shared.finished.store(true, Ordering::SeqCst);
let _ = old.ctrl.send(Control::Stop);
}
}
}
impl Default for AudioEngine {
fn default() -> Self {
Self::new()
}
}
/// 播放线程主体:探测 → 建流 → 解码填缓冲,直到播完 / 被停止 / 出错。
fn run_session(
shared: &Arc<Shared>,
ctrl: &Receiver<Control>,
app: &AppHandle,
spec: &str,
start_sec: f64,
) -> Result<(), String> {
// ---------- 1) 打开音源并探测格式 ----------
let media_source = source::open(spec)?;
let mss = MediaSourceStream::new(media_source, Default::default());
// 扩展名能给探测器省不少事(本地文件尤其明显),流地址没有扩展名也无妨
let mut hint = Hint::new();
if let Some(ext) = extension_of(spec) {
hint.with_extension(&ext);
}
let mut format = symphonia::default::get_probe()
.probe(
&hint,
mss,
FormatOptions::default(),
MetadataOptions::default(),
)
.map_err(|e| format!("不支持的音频格式: {e}"))?;
let track = format
.default_track(TrackType::Audio)
.ok_or_else(|| "音频里没有可解码的轨道".to_string())?;
let params = track
.codec_params
.as_ref()
.and_then(|p| p.audio())
.ok_or_else(|| "音频轨道缺少编码参数".to_string())?;
// 采样率缺失时按 44.1k 兜底:宁可位置显示略有偏差,也不能让整首播不出来
let rate = params.sample_rate.unwrap_or(44100).max(1);
let src_ch = params
.channels
.as_ref()
.map(|c| c.count())
.unwrap_or(2)
.clamp(1, MAX_CHANNELS);
let mut decoder = symphonia::default::get_codecs()
.make_audio_decoder(params, &AudioDecoderOptions::default())
.map_err(|e| format!("不支持的音频编码: {e}"))?;
let track_id = track.id;
shared.rate.store(rate, Ordering::SeqCst);
shared.src_channels.store(src_ch as u16, Ordering::SeqCst);
// ---------- 2) 处理起始定位 ----------
let start_frames = (start_sec.max(0.0) * rate as f64).round() as u64;
shared.frames_played.store(start_frames, Ordering::SeqCst);
let mut produced = start_frames;
if start_sec > 0.0 {
seek_format(&mut *format, track_id, start_sec).map_err(|e| format!("续播定位失败: {e}"))?;
decoder.reset();
}
// ---------- 3) 建输出流 ----------
// 必须在**本线程**创建(cpal::Stream 不是 Send),并持有到会话结束
let _stream = output::build(shared)?;
// ---------- 4) 解码循环 ----------
let cap_samples = (rate as f64 * src_ch as f64 * BUFFER_SECONDS) as usize;
let mut samples: Vec<f32> = Vec::new();
let mut eof = false;
loop {
// 控制消息优先:停止要让线程尽快退出、定位要让缓冲尽快换内容
match ctrl.try_recv() {
Ok(Control::Stop) | Err(TryRecvError::Disconnected) => return Ok(()),
Ok(Control::Seek(sec)) => {
let target = sec.max(0.0);
// 顺序很关键:**先清缓冲、把位置计数挪到目标,再去定位**。
//
// 外网连 NAS 时 `format.seek()` 要等一次网络往返(几百毫秒到数秒)。
// 若等它返回再改状态,这段时间里旧缓冲还在出声、帧计数也还在往前走,
// 前端拉到的仍是旧位置 —— 表现就是「拖完进度条先闪回原处,再跳到目标」。
// 先清后定位 = 立刻静音 + 位置立刻到位,网络到了再从目标点出声。
let prev_frames = shared.frames_played.load(Ordering::SeqCst);
let frames = (target * rate as f64).round() as u64;
shared.buf.lock().unwrap_or_else(|e| e.into_inner()).clear();
shared.frames_played.store(frames, Ordering::SeqCst);
produced = frames;
match seek_format(&mut *format, track_id, target) {
Ok(()) => {
decoder.reset();
eof = false;
}
Err(e) => {
// 定位失败:位置计数必须还原,否则界面会停在一个根本没播到的地方。
// 缓冲已被清空,解码会从原位置继续,所以还原计数是对的。
shared.frames_played.store(prev_frames, Ordering::SeqCst);
produced = prev_frames;
crate::logger::log_warn(
"music-audio",
&format!("定位失败({target}s): {e}"),
);
}
}
continue;
}
Err(TryRecvError::Empty) => {}
}
if shared.failed.load(Ordering::Relaxed) {
return Err("音频输出设备异常(已断开或被其他程序独占)".to_string());
}
// 末尾:等缓冲真正放完再报结束,否则会把还没播完的一两秒当成播完
if eof {
if shared.frames_played.load(Ordering::Relaxed) >= produced {
shared.finished.store(true, Ordering::SeqCst);
// 播完就不该再显示「播放中」:状态查询据此立刻回到暂停态,
// 前端在收到事件、切下一首之前不会看到一个假的播放中状态。
shared.playing.store(false, Ordering::SeqCst);
let _ = app.emit(crate::constants::events::MUSIC_AUDIO_ENDED, ());
return Ok(());
}
thread::sleep(Duration::from_millis(20));
continue;
}
// 暂停时不继续填缓冲(否则一会就堆到上限,白占内存)
if !shared.playing.load(Ordering::Relaxed) {
thread::sleep(Duration::from_millis(10));
continue;
}
if shared.queue_len() >= cap_samples {
thread::sleep(Duration::from_millis(5));
continue;
}
let packet = match format.next_packet() {
Ok(Some(p)) => p,
// 正常读完:源读到 EOF 时读写器返回 None
Ok(None) => {
eof = true;
continue;
}
// 轨道表变化(链式 OGG 物理流):按结束处理
Err(SymphoniaError::ResetRequired) => {
eof = true;
continue;
}
// 文件被截断导致的提前结束:当播完处理,不弹错误
Err(SymphoniaError::IoError(ref e))
if e.kind() == std::io::ErrorKind::UnexpectedEof =>
{
eof = true;
continue;
}
// 其余 IO 错误**不能**当结束:那会把「网络断了 / 读超时」伪装成
// 「这首歌播完了」,前端随即自动切下一首,用户只会觉得莫名跳歌。
// 正常读完走的是 Ok(None),所以这里一律按失败上报(前端会弹错误)。
Err(e) => return Err(format!("读取音频流失败: {e}")),
};
if packet.track_id != track_id {
continue;
}
match decoder.decode(&packet) {
Ok(audio) => {
let n = audio.samples_interleaved();
if n == 0 {
continue;
}
samples.resize(n, 0.0);
audio.copy_to_slice_interleaved(&mut samples);
let frames = (samples.len() / src_ch) as u64;
shared
.buf
.lock()
.unwrap_or_else(|e| e.into_inner())
.extend(samples.iter().copied());
produced = produced.saturating_add(frames);
}
// 坏包跳过:单包解不出来不该让整首断掉
Err(SymphoniaError::DecodeError(_)) | Err(SymphoniaError::IoError(_)) => {}
Err(e) => return Err(format!("解码失败: {e}")),
}
}
}
/// 让容器定位到指定秒(精确模式:容器会把定位点之后、目标之前的帧解出来丢弃)。
///
/// `Time` 的字段是私有的,只能走 `try_new(秒, 纳秒)`;把亚秒部分用纳秒传进去,
/// 拖进度条才能落到毫秒级而不是整秒。
fn seek_format(format: &mut dyn FormatReader, track_id: u32, sec: f64) -> Result<(), String> {
let sec = sec.max(0.0);
let whole = sec.floor();
let nanos = (((sec - whole) * 1e9).round() as i64).clamp(0, 999_999_999) as u32;
let time = Time::try_new(whole as i64, nanos).ok_or_else(|| "定位时间非法".to_string())?;
format
.seek(
SeekMode::Accurate,
SeekTo::Time {
time,
track_id: Some(track_id),
},
)
.map(|_| ())
.map_err(|e| e.to_string())
}
/// 从路径/URL 里取扩展名(用于探测提示)。带 query 的流地址要先把 query 去掉。
fn extension_of(spec: &str) -> Option<String> {
let path = spec.split(['?', '#']).next().unwrap_or(spec);
let name = path.rsplit(['/', '\\']).next().unwrap_or(path);
let ext = name.rsplit_once('.')?.1;
if ext.is_empty() || ext.len() > 5 || !ext.chars().all(|c| c.is_ascii_alphanumeric()) {
return None;
}
Some(ext.to_ascii_lowercase())
}
+68
View File
@@ -0,0 +1,68 @@
//! Rust 侧音乐播放:解码与输出全在后端,前端只发命令、读状态。
//!
//! 模块分工:
//! - [`engine`]:会话生命周期、线程模型、播放/暂停/定位/音量的对外接口与状态快照
//! - [`source`]:音源字节流(本地文件 / 飞牛流代理,支持 Range 定位)
//! - [`output`]:cpal 输出流与音频回调(含声道映射、音量斜坡)
//!
//! 命令层只做参数转发,不含业务逻辑;状态查询走**拉取**而非高频事件推送。
mod engine;
mod output;
mod source;
pub use engine::{AudioEngine, AudioState};
use tauri::{AppHandle, State};
/// 开始播放一个音源。
///
/// `source`:本地绝对路径,或飞牛流地址(形如
/// `http://127.0.0.1:<port>/feiniu/stream?guid=...`,由前端按当前连接拼好 ——
/// 鉴权留在原有代理里,引擎不重复实现)。
/// `startSec`:起播位置,用于「恢复上次退出时的进度」。
#[tauri::command]
#[specta::specta]
pub fn music_audio_play(
app: AppHandle,
engine: State<'_, AudioEngine>,
source: String,
start_sec: f64,
) -> Result<(), String> {
engine.play(&app, source, start_sec)
}
/// 暂停 / 恢复。瞬时生效(只改一个原子标志)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_set_playing(engine: State<'_, AudioEngine>, playing: bool) {
engine.set_playing(playing);
}
/// 定位到指定秒。
#[tauri::command]
#[specta::specta]
pub fn music_audio_seek(engine: State<'_, AudioEngine>, sec: f64) {
engine.seek(sec);
}
/// 停止播放并释放音频设备。
#[tauri::command]
#[specta::specta]
pub fn music_audio_stop(engine: State<'_, AudioEngine>) {
engine.stop();
}
/// 设置音量与静音(跨曲目沿用)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_set_volume(engine: State<'_, AudioEngine>, volume: f32, muted: bool) {
engine.set_volume(volume, muted);
}
/// 读取播放状态快照(位置/缓冲/采样率/是否失败)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_state(engine: State<'_, AudioEngine>) -> AudioState {
engine.state()
}
+175
View File
@@ -0,0 +1,175 @@
//! cpal 输出流:把缓冲里的交错 f32 样本按设备格式喂给声卡。
//!
//! # 采样率策略(关系到音质)
//!
//! cpal 的 WASAPI **共享模式**输出带 `AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM |
//! AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY`,因此**可以用源采样率直接建流**,
//! 由 Windows 自己转换到设备混音格式。这样做的两个好处:
//!
//! 1. 不必自己引入重采样器,也就不会临时用一版质量不明的 SRC 把音质拉低;
//! 2. 与现状(WebView2 内部同样把音频交给共享模式输出)**同级**,不构成退步。
//!
//! 后续要做 bit-perfect(独占模式)时,只需把这里换成独占模式的 `IAudioClient`
//! 初始化:源采样率直出、绕过 Windows 混音器,届时**必须**要求源采样率与设备一致,
//! 否则要自己做高质量重采样。
//!
//! # 线程归属
//!
//! `cpal::Stream` 在 Windows 上不是 `Send`,**必须**在创建它的线程上持有与丢弃。
//! 因此本模块只提供 [`build`],由播放线程调用并把返回的流保存在自己内部。
use std::sync::atomic::Ordering;
use std::sync::Arc;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use super::engine::Shared;
/// 建立输出流并立即启动。**必须在播放线程上调用**(见模块注释的线程归属说明)。
pub fn build(shared: &Arc<Shared>) -> Result<cpal::Stream, String> {
let host = cpal::default_host();
let device = host
.default_output_device()
.ok_or_else(|| "没有可用的默认音频输出设备".to_string())?;
let supported = device
.default_output_config()
.map_err(|e| format!("读取默认输出配置失败: {e}"))?;
let sample_format = supported.sample_format();
let out_channels = supported.channels();
let rate = shared.rate.load(Ordering::Relaxed);
shared.out_channels.store(out_channels, Ordering::Relaxed);
// 声道数用**设备**的(AUTOCONVERTPCM 只保证采样率可任意,声道布局仍按设备来),
// 采样率用**源**的。解码出来的样本在 fill() 里做声道映射。
let config = cpal::StreamConfig {
channels: out_channels,
sample_rate: rate.into(),
buffer_size: cpal::BufferSize::Default,
};
let stream = match sample_format {
cpal::SampleFormat::F32 => build_typed::<f32>(&device, config, shared.clone()),
cpal::SampleFormat::I16 => build_typed::<i16>(&device, config, shared.clone()),
cpal::SampleFormat::I32 => build_typed::<i32>(&device, config, shared.clone()),
cpal::SampleFormat::U16 => build_typed::<u16>(&device, config, shared.clone()),
other => Err(format!("不支持的输出采样格式: {other:?}")),
}?;
stream
.play()
.map_err(|e| format!("启动音频输出失败: {e}"))?;
Ok(stream)
}
/// 按设备默认采样格式建流,回调里统一用 f32 计算、再转成设备格式输出。
fn build_typed<T>(
device: &cpal::Device,
config: cpal::StreamConfig,
shared: Arc<Shared>,
) -> Result<cpal::Stream, String>
where
T: cpal::SizedSample + cpal::FromSample<f32>,
{
let err_shared = shared.clone();
device
.build_output_stream(
config,
move |data: &mut [T], _| fill(data, &shared),
move |e| {
// 设备被拔掉 / 被独占 / 驱动异常:只记日志并把会话标记为失败,
// 由引擎把错误转成前端提示。这里**不能** panic —— 它在音频线程上。
crate::logger::log_error("music-audio", &format!("音频输出流错误: {e}"));
err_shared.failed.store(true, Ordering::Relaxed);
},
None,
)
.map_err(|e| format!("创建音频输出流失败: {e}"))
}
/// 音频回调:把队列里的交错样本搬进设备缓冲。
///
/// 全程只做「出队 + 乘增益 + 转格式」,不加锁以外的任何分配/系统调用,
/// 以免在实时线程上引入不可控的延迟(会直接表现为爆音)。
fn fill<T>(data: &mut [T], shared: &Shared)
where
T: cpal::SizedSample + cpal::FromSample<f32>,
{
let out_ch = shared.out_channels.load(Ordering::Relaxed) as usize;
let src_ch = shared.src_channels.load(Ordering::Relaxed) as usize;
// 尚未确定声道数(刚起会话)或异常值:先输出静音,不能除零
if out_ch == 0 || src_ch == 0 {
for s in data.iter_mut() {
*s = T::from_sample(0.0);
}
return;
}
// 暂停:输出静音但**不消费队列**,恢复播放时数据不丢
if !shared.playing.load(Ordering::Relaxed) {
for s in data.iter_mut() {
*s = T::from_sample(0.0);
}
return;
}
let target = if shared.muted.load(Ordering::Relaxed) {
0.0
} else {
f32::from_bits(shared.volume.load(Ordering::Relaxed))
};
let mut gain = f32::from_bits(shared.gain.load(Ordering::Relaxed));
let frames = data.len() / out_ch;
// 音量在本块内线性走到目标值:拖动音量滑块/切静音时不会有台阶式的爆音。
let step = if frames > 0 {
(target - gain) / frames as f32
} else {
0.0
};
let mut consumed: u64 = 0;
{
let mut queue = shared.buf.lock().unwrap_or_else(|e| e.into_inner());
for f in 0..frames {
gain += step;
let base = f * out_ch;
// 一帧源数据 = src_ch 个样本;不足一帧(解码没跟上)就整帧输出静音
let mut src = [0f32; 8];
let has_frame = queue.len() >= src_ch;
if has_frame {
for slot in src.iter_mut().take(src_ch.min(8)) {
*slot = queue.pop_front().unwrap_or(0.0);
}
consumed += 1;
}
for c in 0..out_ch {
let v = if !has_frame {
0.0
} else if out_ch == 1 && src_ch > 1 {
// 多声道 → 单声道:取平均,避免只留左声道
let n = src_ch.min(8);
src[..n].iter().sum::<f32>() / n as f32
} else if src_ch == 1 {
// 单声道 → 任意声道数:复制
src[0]
} else if c < src_ch.min(8) {
src[c]
} else {
// 源声道数少于设备声道数:多出来的声道填静音
0.0
};
data[base + c] = T::from_sample(v * gain);
}
}
}
if consumed > 0 {
shared.frames_played.fetch_add(consumed, Ordering::Relaxed);
}
shared.gain.store(gain.to_bits(), Ordering::Relaxed);
}
+179
View File
@@ -0,0 +1,179 @@
//! 音频字节源:给 symphonia 提供同步的 [`MediaSource`](`Read` + `Seek`)。
//!
//! 两类来源:
//! - **本地文件**:直接交给 `std::fs::File`(symphonia 已为它实现 `MediaSource`)。
//! - **飞牛流**:复用**现有的本地流代理** `http://127.0.0.1:<port>/feiniu/stream?guid=...`。
//! 代理已经处理好登录态 / Cookie / 安全码 / Range 透传,这里只按 Range 拉取即可。
//!
//! 为什么走本地代理而不让引擎直连 NAS:鉴权(连接选择、token、安全码)全在代理里,
//! 复制一份到引擎会立刻产生两套会漂移的逻辑;代理就在 localhost,额外一跳代价可忽略。
//!
//! # 为什么是同步 I/O
//!
//! `MediaSource` 要求 `Read + Seek`,即同步接口。整个播放线程是**独立的 std 线程**
//! (不是 tokio 运行时线程),因此这里用 `reqwest::blocking` 是安全的;若在 tokio
//! 运行时线程上调用会 panic,这一点在改动线程归属时必须留意。
use std::io::{self, Read, Seek, SeekFrom};
use std::time::Duration;
use symphonia::core::io::MediaSource;
/// NAS 流的超时策略:只在**连接**阶段设超时。
///
/// 音频是长时间连续读,一旦给整请求设 timeout,会在播到中途时被掐断(表现为
/// 「播一半突然断流」);而不设连接超时又会在服务器无响应时永久挂住播放线程。
///
/// # 已知限制:读阶段的卡死不设上限
///
/// 想给「连接建立后数据不再来」也加个上限,但 reqwest 的 `read_timeout` 只在**异步**
/// builder 上(blocking 侧没有),而总 timeout 又会掐断长音频。因此链路彻底卡死时
/// 解码线程会停在那次读上(界面表现为一直加载),要等 TCP 自身超时才会报错。
/// 真要兜住它,得在会话上加一个「位置长时间不前进」的看门狗,或让 HttpSource 自己能
/// 被从外部关闭 —— 目前没做。
const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
/// 按规格打开字节源:`http(s)://` 走网络协议,其余一律按本地文件路径处理。
pub fn open(spec: &str) -> Result<Box<dyn MediaSource>, String> {
if spec.starts_with("http://") || spec.starts_with("https://") {
Ok(Box::new(HttpSource::new(spec)?))
} else {
let file = std::fs::File::open(spec).map_err(|e| format!("打开本地音频失败({spec}): {e}"))?;
Ok(Box::new(file))
}
}
/// 走 HTTP 的流式音源,支持按 `Range` 定位。
pub struct HttpSource {
url: String,
client: reqwest::blocking::Client,
/// 已建立的响应体。定位后置空,下次读取时按新位置重新发 Range 请求。
body: Option<reqwest::blocking::Response>,
/// 当前读取位置(字节)
pos: u64,
/// 总字节数(服务端给出 Content-Range / Content-Length 时才有)
len: Option<u64>,
/// 服务端是否支持 Range。不支持时无法定位,引擎会退化为「只能从头顺序播」。
range_ok: bool,
}
impl HttpSource {
fn new(url: &str) -> Result<Self, String> {
let client = reqwest::blocking::Client::builder()
.connect_timeout(CONNECT_TIMEOUT)
.timeout(None)
.build()
.map_err(|e| format!("创建音频 HTTP 客户端失败: {e}"))?;
// 探测总长度与 Range 支持:只取 0-0 一个字节。
// 支持 Range 时服务端回 `206 Partial Content` + `Content-Range: bytes 0-0/<total>`;
// 不支持则回 `200` + `Content-Length`。两种情况都能拿到总长度。
let probe = client
.get(url)
.header(reqwest::header::RANGE, "bytes=0-0")
.send()
.map_err(|e| format!("音频源探测失败: {e}"))?;
let status = probe.status();
if !status.is_success() {
return Err(format!("音频源探测失败: HTTP {status}"));
}
let range_ok = status == reqwest::StatusCode::PARTIAL_CONTENT
|| probe
.headers()
.get(reqwest::header::ACCEPT_RANGES)
.is_some();
let len = parse_content_range_total(&probe)
.or_else(|| probe.content_length().map(|n| n.max(1)));
Ok(Self {
url: url.to_string(),
client,
body: None,
pos: 0,
len,
range_ok,
})
}
/// 打开(或按当前 `pos` 重开)响应体。
fn ensure_body(&mut self) -> io::Result<()> {
if self.body.is_some() {
return Ok(());
}
let mut req = self.client.get(&self.url);
if self.pos > 0 {
if !self.range_ok {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"音频源不支持 Range,无法定位",
));
}
req = req.header(reqwest::header::RANGE, format!("bytes={}-", self.pos));
}
let resp = req.send().map_err(to_io_err)?;
if !resp.status().is_success() {
return Err(io::Error::new(
io::ErrorKind::Other,
format!("音频流请求失败: HTTP {}", resp.status()),
));
}
self.body = Some(resp);
Ok(())
}
}
impl Read for HttpSource {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.ensure_body()?;
let body = self.body.as_mut().expect("ensure_body 已建立响应体");
let n = body.read(buf)?;
self.pos += n as u64;
Ok(n)
}
}
impl Seek for HttpSource {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
let target = match pos {
SeekFrom::Start(p) => p,
SeekFrom::End(off) => {
let len = self.len.ok_or_else(|| {
io::Error::new(io::ErrorKind::Unsupported, "总长度未知,无法从末尾定位")
})?;
(len as i64 + off).max(0) as u64
}
SeekFrom::Current(off) => (self.pos as i64 + off).max(0) as u64,
};
// 丢弃当前响应体,下次读取按新位置重发 Range —— 这样定位既不需要缓存整段音频,
// 也不会把已读过的字节再拉一遍。
self.body = None;
self.pos = target;
Ok(target)
}
}
impl MediaSource for HttpSource {
fn is_seekable(&self) -> bool {
self.range_ok
}
fn byte_len(&self) -> Option<u64> {
self.len
}
}
/// 解析 `Content-Range: bytes 0-0/12345` 里的总长度。
fn parse_content_range_total(resp: &reqwest::blocking::Response) -> Option<u64> {
let raw = resp.headers().get(reqwest::header::CONTENT_RANGE)?.to_str().ok()?;
let total = raw.rsplit('/').next()?.trim();
if total == "*" {
return None;
}
total.parse::<u64>().ok()
}
/// reqwest 的 `Error` → `io::Error`(symphonia 只认 io 错误)。
fn to_io_err(e: reqwest::Error) -> io::Error {
io::Error::new(io::ErrorKind::Other, e.to_string())
}
+324
View File
@@ -0,0 +1,324 @@
//! 音乐模块 · 本地解密的 Tauri 命令层。
//!
//! 与下载链路同构:命令只做参数校验 + 扫描 + 登记任务,立即返回;进度经
//! `music-decrypt-event` 推送。前端 `decryptStore` 常驻监听。
//!
//! 登记位置见 `MUSIC_DECRYPT_PLAN.md` §4.1——**共 3 处**:
//! `music/mod.rs` re-export、`lib.rs` 的 `collect_commands![]` 与 `generate_handler![]`。
use std::path::{Path, PathBuf};
use tauri::{AppHandle, State};
use super::scan;
use super::spawn_batch;
use crate::music::MusicManager;
/// 启动一批本地解密任务。
///
/// 两种输入方式(二选一,`folder` 优先):
/// - `folder`:**文件夹批量**。递归扫描该目录下所有可解密的加密音乐
/// (内容判定优先,见 `scan::route`),并按 `root` 还原相对目录结构。
/// - `files`:显式文件列表(散选场景)。
///
/// `in_place = true` 时产物与源文件同目录同名——文件夹批量推荐这样用,
/// 符合"就地解出来"的直觉;`false` 则统一输出到 `out_dir`。
///
/// 返回 `Ok(())` 表示任务已登记并开始执行;逐文件结果走事件。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_run(
state: State<'_, MusicManager>,
app: AppHandle,
task_id: String,
files: Option<Vec<String>>,
folder: Option<String>,
root: Option<String>,
out_dir: Option<String>,
in_place: Option<bool>,
) -> Result<(), String> {
if task_id.trim().is_empty() {
return Err("缺少任务 id".into());
}
let in_place = in_place.unwrap_or(false);
let out_dir = resolve_out_dir(out_dir)?;
// ---- 收集待处理文件 ----
let scanned: Vec<scan::ScannedFile> = match folder.as_deref().map(str::trim) {
Some(dir) if !dir.is_empty() => {
let folder_path = PathBuf::from(dir);
let root_path = root
.as_deref()
.map(str::trim)
.filter(|r| !r.is_empty())
.map(PathBuf::from)
.unwrap_or_else(|| folder_path.clone());
let found = scan::scan(&folder_path, Some(&root_path))?;
if found.is_empty() {
return Err(format!(
"{} 里没有找到可解密的加密音乐文件(支持网易云 .ncm 与 QQ音乐 QMC 系列)",
folder_path.display()
));
}
found
}
_ => {
let list = files.unwrap_or_default();
if list.is_empty() {
return Err("未选择任何文件或文件夹".into());
}
// 散选:保留用户给的路径,不做递归;引擎按内容/后缀判定。
// 认不出的文件也建条目,让 worker 回报 unsupported(用户能看到原因)。
list.into_iter()
.map(|f| {
let path = PathBuf::from(&f);
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| f.clone());
// 先算引擎再移动 `path`(否则所有权已转移)
let engine = scan::route(&path).unwrap_or(scan::Engine::Ncm);
scan::ScannedFile {
path,
rel_parent: None,
name,
// 默认为网易云引擎;真实平台由解密器在 worker 内报错说明
engine,
}
})
.collect()
}
};
// ---- 输入输出相交保护(仅非就地模式;就地模式本来就写在源目录)----
let scanned = if in_place {
scanned
} else {
let kept = retain_outside(scanned, &out_dir);
if kept.is_empty() {
return Err("所选文件都位于输出目录内,已全部跳过(可改用「就地解密」)".into());
}
kept
};
if scanned.is_empty() {
return Err("没有可处理的文件".into());
}
let tasks = state.decrypt_tasks();
spawn_batch(app, tasks, task_id, scanned, out_dir, in_place);
Ok(())
}
/// 请求取消一个解密任务。
///
/// 队列级语义(与 `music_download_cancel` 一致):**当前文件会做完**,
/// 剩余文件不再开始处理,随后发一个带 `cancelled` 计数的 `finished` 事件。
/// 返回是否命中了一个在跑的任务(false 通常表示任务已结束)。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_cancel(
state: State<'_, MusicManager>,
task_id: String,
) -> Result<bool, String> {
Ok(state.decrypt_tasks().cancel(&task_id))
}
/// 扫描一个文件夹,返回可解密文件的数量与平台分布(**不解密**)。
///
/// 给 UI 做预览:用户选完文件夹先看到"找到 N 个(网易云 x / QQ音乐 y)",
/// 而不是直接开跑一个可能包含几千首的任务。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_scan(folder: String, root: Option<String>) -> Result<ScanSummary, String> {
let root_path = root
.as_deref()
.map(str::trim)
.filter(|r| !r.is_empty())
.map(PathBuf::from);
let found = scan::scan(Path::new(folder.trim()), root_path.as_deref())?;
let ncm = found
.iter()
.filter(|f| f.engine == scan::Engine::Ncm)
.count();
Ok(ScanSummary {
total: found.len(),
ncm,
qmc: found.len() - ncm,
})
}
/// `music_decrypt_scan` 的返回(前端零手写类型)
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct ScanSummary {
pub total: usize,
pub ncm: usize,
pub qmc: usize,
}
/// 探测 QQ 音乐**在线取密钥**能力(新版 musicex 文件解密的前置条件)。
///
/// 只读本机信息,不发网络请求:读 `QQMusicServiceConfig.ini` 的 `uin`,
/// 再从运行中的 `QQMusic.exe` 内存里找 `authst`。
///
/// `authst` **不会**返回给前端(只在后端用于调接口),前端拿到的只有 QQ 号与状态。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_qq_status() -> Result<super::qq_online::QqOnlineStatus, String> {
Ok(super::qq_online::probe_status())
}
/// 过滤掉位于 `out_dir` 内的输入文件。
///
/// 为什么需要:把输出目录选在输入目录内(或直接选输入目录)时,下一次运行会把
/// 上一次的产物再当输入解一遍,产出 `_1`、`_2` 无限膨胀。
///
/// 路径比较用 `canonicalize`,因此能正确处理 `..`、大小写差异与短路径;
/// **无法规范化(文件不存在/无权限)的路径一律保留**——让 worker 去报"读取失败",
/// 比在这里静默丢弃更好(用户能看到原因)。
fn retain_outside(files: Vec<scan::ScannedFile>, out_dir: &Path) -> Vec<scan::ScannedFile> {
let Ok(out_canon) = out_dir.canonicalize() else {
// 输出目录都规范化不了(理论上不会:resolve_out_dir 刚创建过它),
// 此时放弃这层保护而不是误杀全部输入
return files;
};
files
.into_iter()
.filter(|f| match f.path.canonicalize() {
Ok(abs) => !abs.starts_with(&out_canon),
Err(_) => true,
})
.collect()
}
/// 解析输出目录:显式传入优先,否则回退到应用数据目录下的 `music/decrypted`。
fn resolve_out_dir(out_dir: Option<String>) -> Result<PathBuf, String> {
if let Some(d) = out_dir {
let d = d.trim();
if !d.is_empty() {
let p = PathBuf::from(d);
std::fs::create_dir_all(&p)
.map_err(|e| format!("无法创建输出目录 {}:{e}", p.display()))?;
return Ok(p);
}
}
// 兜底:{app_data}/music/decrypted(前端正常都会传 savedir/decrypted)
let base = dirs::data_dir()
.ok_or_else(|| "无法定位应用数据目录".to_string())?
.join("thing")
.join("music")
.join("decrypted");
std::fs::create_dir_all(&base)
.map_err(|e| format!("无法创建输出目录 {}:{e}", base.display()))?;
Ok(base)
}
#[cfg(test)]
mod tests {
use super::*;
fn tmpdir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("dec_cmd_{tag}_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
std::fs::create_dir_all(&d).unwrap();
d
}
fn fake_ncm() -> Vec<u8> {
let mut v = b"CTENFDAM".to_vec();
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
v
}
fn entry(path: PathBuf, rel: Option<&str>) -> scan::ScannedFile {
scan::ScannedFile {
name: path.file_name().unwrap().to_string_lossy().to_string(),
path,
rel_parent: rel.map(PathBuf::from),
engine: scan::Engine::Ncm,
}
}
#[test]
fn retain_outside_drops_inputs_inside_output_dir() {
let root = tmpdir("retain");
let out = root.join("decrypted");
std::fs::create_dir_all(&out).unwrap();
let inside = out.join("a.ncm");
let outside = root.join("b.ncm");
std::fs::write(&inside, fake_ncm()).unwrap();
std::fs::write(&outside, fake_ncm()).unwrap();
let kept = retain_outside(vec![entry(inside, None), entry(outside, None)], &out);
assert_eq!(kept.len(), 1, "应只保留输出目录外的文件");
assert!(kept[0].path.ends_with("b.ncm"));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn retain_outside_drops_nested_paths() {
let root = tmpdir("nested");
let out = root.join("decrypted");
let deep = out.join("2026").join("07");
std::fs::create_dir_all(&deep).unwrap();
let f = deep.join("c.ncm");
std::fs::write(&f, fake_ncm()).unwrap();
let kept = retain_outside(vec![entry(f, None)], &out);
assert!(kept.is_empty(), "输出目录的子目录也应视为相交");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn retain_outside_keeps_unresolvable_paths() {
let root = tmpdir("unresolvable");
let out = root.join("decrypted");
std::fs::create_dir_all(&out).unwrap();
let ghost = root.join("not-here").join("ghost.ncm");
let kept = retain_outside(vec![entry(ghost, None)], &out);
assert_eq!(kept.len(), 1, "不存在的输入不应被静默丢弃");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn resolve_out_dir_uses_explicit_value() {
let root = tmpdir("outdir");
let target = root.join("my").join("out");
let got = resolve_out_dir(Some(target.to_string_lossy().to_string())).unwrap();
assert_eq!(got, target);
assert!(target.is_dir(), "输出目录应被创建");
let fallback = resolve_out_dir(Some(" ".into())).unwrap();
assert!(fallback.ends_with("decrypted"));
assert!(fallback.is_dir());
let _ = std::fs::remove_dir_all(&root);
}
/// 文件夹扫描的汇总(UI 预览用)
#[test]
fn scan_summary_counts_per_engine() {
let root = tmpdir("summary");
std::fs::write(root.join("a.ncm"), fake_ncm()).unwrap();
std::fs::write(root.join("b.qmcflac"), vec![0x22u8; 4096]).unwrap();
std::fs::write(root.join("c.mgg"), vec![0x22u8; 4096]).unwrap();
std::fs::write(root.join("d.mp3"), vec![0x44u8; 1024]).unwrap();
let found = scan::scan(&root, None).unwrap();
let ncm = found
.iter()
.filter(|f| f.engine == scan::Engine::Ncm)
.count();
assert_eq!(found.len(), 3, "mp3 不应被计入");
assert_eq!(ncm, 1);
assert_eq!(found.len() - ncm, 2);
let _ = std::fs::remove_dir_all(&root);
}
}
+266
View File
@@ -0,0 +1,266 @@
//! 本地解密的**统一错误类型与公共格式探测**。
//!
//! 两个引擎([`super::ncm`] 网易云 / [`super::qmc`] QQ音乐)各自的内部错误不同,
//! 但调度层只关心「可读的中文原因」,因此都收敛到 [`DecryptError`]。
//!
//! 输出扩展名统一由 [`detect_format`] 按**音频首帧魔数**判定——
//! 两个平台都不信任容器里声明的格式字段(详见 `MUSIC_DECRYPT_PLAN.md` §3.1⑥ / §3.2 末)。
use std::fmt;
use std::path::PathBuf;
/// 解密失败原因。全部经 `to_string()` 上报为 per-file 失败,**不 panic**
/// (否则一个坏文件会带走整批任务)。
#[derive(Debug)]
pub enum DecryptError {
Io(String),
/// 文件不属于本引擎认得的加密格式
NotEncrypted(String),
/// 容器/尾部结构残缺
Broken(String),
/// 缺少解密密钥(QQ QMC2 的 ekey 情况),文案要能给用户下一步动作
KeyRequired(String),
/// 输出失败
Output(String),
}
impl fmt::Display for DecryptError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DecryptError::Io(e) => write!(f, "读取失败:{e}"),
DecryptError::NotEncrypted(e) => write!(f, "{e}"),
DecryptError::Broken(e) => write!(f, "文件结构损坏:{e}"),
DecryptError::KeyRequired(e) => write!(f, "{e}"),
DecryptError::Output(e) => write!(f, "输出失败:{e}"),
}
}
}
impl std::error::Error for DecryptError {}
impl From<std::io::Error> for DecryptError {
fn from(e: std::io::Error) -> Self {
DecryptError::Io(e.to_string())
}
}
pub type Result<T> = std::result::Result<T, DecryptError>;
/// 解密产物(两引擎统一形状)
#[derive(Debug, Clone)]
pub struct Outcome {
pub output: PathBuf,
/// 落盘用的扩展名(由首帧魔数判定)
pub format: String,
/// 单独落盘的封面(没有则为 None)
pub cover: Option<PathBuf>,
/// 音频明文字节数
pub audio_bytes: u64,
/// 给 UI 的一行备注(平台 / 密钥形态 / 元数据摘要)。
///
/// 结构化元数据目前只用来拼这一行——P2 做标签回填时再把 `NcmMeta` 提升到
/// `Outcome` 上,不要提前加一个没人读的字段。
pub note: String,
}
/// 按音频首帧魔数判定输出扩展名。
///
/// **这是权威来源**:ncm 的 `format` 字段、QMC 的输入后缀都只是声明,
/// 不可信(QKKDecrypt 同样以内容探测为准)。
pub fn detect_format(head: &[u8]) -> &'static str {
detect_format_opt(head).unwrap_or("flac")
}
/// 同上,但认不出时返回 `None`(调用方可据此决定是否回退到后缀/声明格式)。
pub fn detect_format_opt(head: &[u8]) -> Option<&'static str> {
let starts = |m: &[u8]| head.len() >= m.len() && &head[..m.len()] == m;
if starts(b"fLaC") {
Some("flac")
} else if starts(b"OggS") {
Some("ogg")
} else if starts(b"ID3") || (head.len() >= 2 && head[0] == 0xFF && head[1] & 0xE0 == 0xE0) {
// ID3 标签,或无标签 MP3 的帧同步字(0xFFEx / 0xFFFx)
Some("mp3")
} else if starts(b"RIFF") && head.len() >= 12 && &head[8..12] == b"WAVE" {
Some("wav")
} else if head.len() >= 12 && &head[4..8] == b"ftyp" {
Some("m4a")
} else if starts(b"wvpk") {
Some("wv")
} else {
None
}
}
/// 图片扩展名(按魔数)
pub fn image_ext(data: &[u8]) -> &'static str {
const PNG: &[u8] = &[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
if data.len() >= 8 && &data[..8] == PNG {
"png"
} else {
"jpg"
}
}
/// 确保输出目录存在并返回「按相对目录展开后」的目标目录。
///
/// 文件夹批量模式要保留原目录结构(`Pop/a.mflac` → `out/Pop/a.flac`),
/// 否则不同子目录的同名文件会在输出根目录里互相挤兑(虽然去重逻辑会让位成
/// `_1`,但产物与源的对应关系就丢了)。
pub fn ensure_subdir(
dir: &std::path::Path,
rel_parent: Option<&std::path::Path>,
) -> Result<PathBuf> {
let target = match rel_parent {
Some(rel) if !rel.as_os_str().is_empty() => dir.join(rel),
_ => dir.to_path_buf(),
};
std::fs::create_dir_all(&target)?;
Ok(target)
}
/// 在 `dir` 下为 `stem` + `ext` 找一个不冲突的输出路径。
///
/// 不同来源的同名文件若直接扁平落盘会**互相覆盖**,故占用时追加 `_1`/`_2`…
/// `reserved` 是本批次内已占用的名字(磁盘上尚不存在的也算)。
pub fn unique_output(
dir: &std::path::Path,
stem: &str,
ext: &str,
reserved: &mut std::collections::HashSet<String>,
) -> Result<PathBuf> {
let mut candidate = dir.join(format!("{stem}.{ext}"));
let mut n = 1;
loop {
let key = candidate.to_string_lossy().to_lowercase();
if !candidate.exists() && !reserved.contains(&key) {
reserved.insert(key);
return Ok(candidate);
}
candidate = dir.join(format!("{stem}_{n}.{ext}"));
n += 1;
if n > 9999 {
return Err(DecryptError::Output(format!(
"无法为 {stem} 找到不冲突的输出名"
)));
}
}
}
/// 读满 `buf` 或读到 EOF,返回实际字节数。
///
/// 与 `Read::read` 的关键区别:**只有 EOF 才会提前返回**,不会因为底层缓冲的
/// 短读而返回半个块。流密码解密的块边界必须与加密侧严格一致,
/// 否则相位错位、文件中途变噪声(`MUSIC_DECRYPT_PLAN.md` §6.24)。
pub fn read_full(r: &mut impl std::io::Read, buf: &mut [u8]) -> Result<usize> {
let mut filled = 0usize;
while filled < buf.len() {
match r.read(&mut buf[filled..]) {
Ok(0) => break,
Ok(n) => filled += n,
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(e) => return Err(DecryptError::Io(e.to_string())),
}
}
Ok(filled)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detect_format_by_magic() {
assert_eq!(detect_format(b"fLaC\x00\x00\x00\x22"), "flac");
assert_eq!(detect_format(b"OggS\x00\x02"), "ogg");
assert_eq!(detect_format(b"ID3\x04\x00"), "mp3");
assert_eq!(detect_format(&[0xFF, 0xFB, 0x90, 0x00]), "mp3");
assert_eq!(detect_format(b"RIFF\x00\x00\x00\x00WAVEfmt "), "wav");
assert_eq!(detect_format(b"\x00\x00\x00\x20ftypM4A "), "m4a");
assert_eq!(detect_format(b"wvpk\x00\x00"), "wv");
assert_eq!(detect_format(b"\x00\x01\x02\x03"), "flac");
}
#[test]
fn image_ext_by_magic() {
assert_eq!(
image_ext(&[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
"png"
);
assert_eq!(image_ext(&[0xFF, 0xD8, 0xFF, 0xE0]), "jpg");
}
#[test]
fn unique_output_appends_suffix_on_collision() {
let dir = std::env::temp_dir().join(format!("dec_unique_{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let mut reserved = std::collections::HashSet::new();
let a = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
assert_eq!(a.file_name().unwrap(), "song.flac");
let b = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
assert_eq!(b.file_name().unwrap(), "song_1.flac");
let c = unique_output(&dir, "song", "mp3", &mut reserved).unwrap();
assert_eq!(c.file_name().unwrap(), "song.mp3");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn ensure_subdir_preserves_relative_structure() {
let root = std::env::temp_dir().join(format!("dec_subdir_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
// 无相对目录 → 输出根
let flat = ensure_subdir(&root, None).unwrap();
assert_eq!(flat, root);
// 有相对目录 → 逐级创建
let nested = ensure_subdir(
&root,
Some(std::path::Path::new("Pop").join("2026").as_path()),
)
.unwrap();
assert!(nested.is_dir());
assert!(nested.ends_with("Pop/2026") || nested.ends_with(r"Pop\2026"));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn read_full_returns_whole_buffer() {
// 一个每次只吐 3 字节的 reader:read_full 必须凑满整个 buf
struct Drip {
data: Vec<u8>,
pos: usize,
}
impl std::io::Read for Drip {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
if self.pos >= self.data.len() {
return Ok(0);
}
let n = buf.len().min(3).min(self.data.len() - self.pos);
buf[..n].copy_from_slice(&self.data[self.pos..self.pos + n]);
self.pos += n;
Ok(n)
}
}
let src: Vec<u8> = (0..100u8).collect();
let mut r = Drip {
data: src.clone(),
pos: 0,
};
let mut buf = [0u8; 64];
let n = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n, 64, "短读 reader 也必须凑满整块");
assert_eq!(&buf[..], &src[..64]);
// 末尾不足一块时返回实际长度
let n2 = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n2, 36);
let n3 = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n3, 0, "EOF 返回 0");
}
}
+624
View File
@@ -0,0 +1,624 @@
//! 音乐模块 · 本地解密(`music/decrypt/`)。
//!
//! 挂靠音乐模块的「解密」页签,与下载链路同构:命令先回一个 `taskId`,
//! 之后所有进度经 `music-decrypt-event` 推送(前端 `decryptStore` 常驻监听,
//! 页签切换卸载组件也不影响任务)。
//!
//! ## 分工
//!
//! - [`ncm`]:网易云 `.ncm` 的**纯 Rust 离线**引擎(P0 全部范围)。
//! - `qq`(P1,未实施):QQ 音乐三层路由(内嵌 ekey 离线 → musicex API → Frida 兜底)。
//! 见 `MUSIC_DECRYPT_PLAN.md` §3.2。
//! - [`commands`]:Tauri 命令层(run / cancel)。
//!
//! ## 为什么事件在独立线程里发
//!
//! 解密是 CPU + 磁盘密集的同步流程,每读一块就要回报进度。把它放在
//! `spawn_blocking` 里再逐块 `emit` 会阻塞 tokio 的工作线程;
//! 这里改为「`std::thread` 干活 + `mpsc` 回传事件 + 异步任务节流转发」,
//! 读盘线程最多被 `mpsc::send` 短暂挡住,不碰 tokio 运行时。
//!
//! 进度**按时间节流**([`PROGRESS_INTERVAL`]):单个大文件有成千上万个 32KB 块,
//! 不节流会把 WebView 的事件通道打满。
pub mod commands;
pub mod common;
pub mod ncm;
pub mod probe;
pub mod qmc;
pub mod qq_credentials;
pub mod qq_ekey;
pub mod qq_footer;
pub mod qq_online;
pub mod scan;
/// QQ 音乐进程内存扫描:纯 Win32 实现,非 Windows 平台不编译。
#[cfg(windows)]
pub mod qq_memscan;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Emitter};
use common::DecryptError;
/// 进度事件的最小间隔
pub const PROGRESS_INTERVAL: Duration = Duration::from_millis(300);
/// 单文件处理结果的三个状态
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum FileStatus {
/// 解密成功
Ok,
/// 失败(`message` 为可读原因)
Error,
/// 该文件不属于本平台/本阶段支持范围
Unsupported,
}
/// 推送给前端的事件负载(与 `src/lib/bindings.ts` / `decryptStore.ts` 对应)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(tag = "type", rename_all = "kebab-case")]
pub enum DecryptEvent {
/// 批次开始,`total` 为待处理文件数
Start { task_id: String, total: usize },
/// 单个文件处理完毕
File {
task_id: String,
/// 0-based 序号,与任务表行一一对应
index: usize,
name: String,
status: FileStatus,
/// 失败原因,或成功时的备注(平台 / 密钥形态)
message: Option<String>,
/// 主产物路径
output: Option<String>,
/// 单独落盘的封面(网易云 ncm 带内嵌封面时才有)
cover: Option<String>,
},
/// 进度(节流后)
Progress {
task_id: String,
done: usize,
total: usize,
/// 当前文件已处理字节数 / 总字节数(0 表示未知)
bytes_done: u64,
bytes_total: u64,
name: String,
},
/// 批次结束
Finished {
task_id: String,
ok: usize,
failed: usize,
/// 被取消时尚未处理的文件数
cancelled: usize,
},
}
/// 任务表条目。只存「是否被要求取消」,不存进度——
/// 进度的权威在前端 store(事件即真相),Rust 侧不需要镜像状态。
pub struct DecryptTasks {
inner: Mutex<HashMap<String, Arc<AtomicBool>>>,
}
impl Default for DecryptTasks {
fn default() -> Self {
Self::new()
}
}
impl DecryptTasks {
pub fn new() -> Self {
Self {
inner: Mutex::new(HashMap::new()),
}
}
/// 登记一个任务并返回它的取消标志
pub fn register(&self, task_id: &str) -> Arc<AtomicBool> {
let flag = Arc::new(AtomicBool::new(false));
if let Ok(mut m) = self.inner.lock() {
m.insert(task_id.to_string(), flag.clone());
}
flag
}
/// 请求取消;返回是否命中了一个在跑的任务
pub fn cancel(&self, task_id: &str) -> bool {
match self.inner.lock() {
Ok(m) => match m.get(task_id) {
Some(flag) => {
flag.store(true, Ordering::SeqCst);
true
}
None => false,
},
Err(_) => false,
}
}
pub fn finish(&self, task_id: &str) {
if let Ok(mut m) = self.inner.lock() {
m.remove(task_id);
}
}
}
/// 线程 → 异步任务的事件通道消息
enum Msg {
Progress {
bytes_done: u64,
bytes_total: u64,
name: String,
},
File {
index: usize,
name: String,
status: FileStatus,
message: Option<String>,
output: Option<String>,
cover: Option<String>,
},
/// 批次结束。**必须走通道**——否则它会在转发线程尚未冲出积压的
/// `File` 事件之前就被 `emit`,前端会先看到"完成"再看到最后几个文件的结果。
Finished {
ok: usize,
failed: usize,
cancelled: usize,
},
}
/// 该文件是否是「需要联网取密钥」的形态(musicex)。
///
/// 只读尾部 192 字节,代价可忽略;用作"离线失败后要不要转在线"的判据,
/// 避免对普通失败(如尾部损坏)也去发起网络请求。
fn needs_online(path: &std::path::Path) -> bool {
use std::io::{Read, Seek, SeekFrom};
let Ok(mut f) = std::fs::File::open(path) else {
return false;
};
let Ok(size) = f.metadata().map(|m| m.len()) else {
return false;
};
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
if take < 8 || f.seek(SeekFrom::End(-(take as i64))).is_err() {
return false;
}
let mut buf = vec![0u8; take];
if f.read_exact(&mut buf).is_err() {
return false;
}
qq_footer::is_musicex_tail(&buf)
}
/// 启动一个解密批次:登记任务 → 起工作线程 → 异步转发事件。
///
/// 调用方(`commands::music_decrypt_run`)已完成参数校验与目录扫描;本函数只负责调度。
///
/// `in_place = true` 时**忽略 `out_dir`**,产物与源文件同目录同名(扩展名按格式改)。
/// 这是文件夹批量的默认方式——用户的期望是"就地解出来",而不是去另一个目录找。
pub fn spawn_batch(
app: AppHandle,
tasks: Arc<DecryptTasks>,
task_id: String,
files: Vec<scan::ScannedFile>,
out_dir: PathBuf,
in_place: bool,
) {
let flag = tasks.register(&task_id);
let (tx, rx) = mpsc::channel::<Msg>();
let total_files = files.len();
// ---- 工作线程:逐文件解密 ----
let worker_task_id = task_id.clone();
let worker_tasks = tasks.clone();
std::thread::Builder::new()
.name(format!("music-decrypt-{task_id}"))
.spawn(move || {
let total = files.len();
// 批次内已占用的输出名(防同名互相覆盖,见 common::unique_output)
let mut reserved = std::collections::HashSet::new();
let mut ok = 0usize;
let mut failed = 0usize;
let mut cancelled = 0usize;
let mut done = 0usize;
for (index, job) in files.iter().enumerate() {
if flag.load(Ordering::SeqCst) {
cancelled = total - done;
break;
}
// 输出目录:就地模式与源文件同目录;否则按相对目录还原结构
let target_dir = if in_place {
job.path
.parent()
.map(|p| p.to_path_buf())
.unwrap_or_else(|| out_dir.clone())
} else {
common::ensure_subdir(&out_dir, job.rel_parent.as_deref())
.unwrap_or_else(|_| out_dir.clone())
};
// 进度回调:只在文件内部回报,节流交给接收端
let tx_progress = tx.clone();
let name = job.name.clone();
// 「网易云 / QQ音乐」前缀由调度层给出——引擎自己不该知道路由结果
let label = job.engine.label();
let mut progress_cb = |bytes_done: u64, bytes_total: u64| {
let _ = tx_progress.send(Msg::Progress {
bytes_done,
bytes_total,
name: name.clone(),
});
};
let result = match job.engine {
scan::Engine::Ncm => ncm::decrypt_file(
&job.path,
&target_dir,
label,
&mut reserved,
&mut progress_cb,
),
// musicex 的 ekey 不在文件里,离线路径会返回明确的 KeyRequired;
// 命中该形态时改走「本机凭据 → 在线取密钥」。
scan::Engine::Qmc => {
let offline = qmc::decrypt_file(
&job.path,
&target_dir,
label,
&mut reserved,
&mut progress_cb,
);
match offline {
Err(DecryptError::KeyRequired(_)) if needs_online(&job.path) => {
qq_online::decrypt_musicex(
&job.path,
&target_dir,
label,
&mut progress_cb,
)
}
other => other,
}
}
};
done += 1;
match result {
Ok(res) => {
ok += 1;
crate::logger::log_info(
"music-decrypt",
&format!(
"{} → {}({},{} 字节)",
job.path.display(),
res.output.display(),
res.format,
res.audio_bytes
),
);
let _ = tx.send(Msg::File {
index,
name: job.name.clone(),
status: FileStatus::Ok,
// 成功时把备注(平台/密钥形态)与产物一起回报
message: Some(res.note),
output: Some(res.output.to_string_lossy().to_string()),
cover: res.cover.map(|c| c.to_string_lossy().to_string()),
});
}
Err(e) => {
failed += 1;
crate::logger::log_warn(
"music-decrypt",
&format!("{} 解密失败:{e}", job.path.display()),
);
let _ = tx.send(Msg::File {
index,
name: job.name.clone(),
status: FileStatus::Error,
message: Some(e.to_string()),
output: None,
cover: None,
});
}
}
// 文件收尾时必推一次,保证进度条不因节流停在中间
let _ = tx.send(Msg::Progress {
bytes_done: done as u64,
bytes_total: total as u64,
name: job.name.clone(),
});
}
// 通道关闭 → 接收端读完剩余消息后收尾
let _ = tx.send(Msg::Finished {
ok,
failed,
cancelled,
});
drop(tx);
worker_tasks.finish(&worker_task_id);
})
.expect("无法创建解密工作线程");
// ---- 异步转发:节流 + 顺序保证 ----
//
// 语义:
// - `File` 事件(含文件收尾的那次 Progress)**立即转发**,否则结果会看起来卡在末尾。
// - 文件内部的逐块 Progress 只保留最新一条,按 [`PROGRESS_INTERVAL`] 最多发一次,
// 避免单个大文件的成千上万个块把 WebView 事件通道打满。
tauri::async_runtime::spawn(async move {
let mut last_progress: Option<Msg> = None;
let mut last_emit = Instant::now() - PROGRESS_INTERVAL;
let mut current_index = 0usize;
// 批内文件总数:与下面 Start 事件取同一份来源
let current_total = total_files;
// Start 先发:它必须在任何 Progress/File 之前到达,前端据此建行。
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Start {
task_id: task_id.clone(),
total: total_files,
},
);
loop {
// 单次 recv_timeout 同时兼顾「有消息就收」和「到点就 flush」
let msg = match rx.recv_timeout(PROGRESS_INTERVAL) {
Ok(m) => Some(m),
Err(mpsc::RecvTimeoutError::Timeout) => None,
Err(mpsc::RecvTimeoutError::Disconnected) => break,
};
match msg {
Some(Msg::Progress {
bytes_done,
bytes_total,
name,
}) => {
// 攒着;下面的 flush 决定何时真正发出
last_progress = Some(Msg::Progress {
bytes_done,
bytes_total,
name,
});
}
Some(Msg::File {
index,
name,
status,
message,
output,
cover,
}) => {
// 结果事件优先:先把攒住的进度冲掉,再发结果,保证顺序自然
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::File {
task_id: task_id.clone(),
index,
name,
status,
message,
output,
cover,
},
);
current_index = index + 1;
}
Some(Msg::Finished {
ok,
failed,
cancelled,
}) => {
// 收尾前把攒住的进度冲掉,再发 Finished,保证前端不丢最后一格进度
last_emit = Instant::now() - PROGRESS_INTERVAL;
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Finished {
task_id: task_id.clone(),
ok,
failed,
cancelled,
},
);
// 通道随后关闭,循环自然退出
}
None => { /* 超时,走下面的 flush */ }
}
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
}
});
}
/// 到点则把攒下的最新一条进度发出(最多每 [`PROGRESS_INTERVAL`] 一次)。
fn flush_progress(
app: &AppHandle,
task_id: &str,
pending: &mut Option<Msg>,
last_emit: &mut Instant,
index: usize,
total: usize,
) {
if pending.is_none() || last_emit.elapsed() < PROGRESS_INTERVAL {
return;
}
if let Some(Msg::Progress {
bytes_done,
bytes_total,
name,
}) = pending.take()
{
*last_emit = Instant::now();
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Progress {
task_id: task_id.to_string(),
// index = 当前正在处理的文件序号(已完成的文件数)
done: index,
total,
bytes_done,
bytes_total,
name,
},
);
}
}
#[cfg(test)]
mod tests {
use super::*;
/// **跨端契约**:事件的实际 JSON 形状是前端 `decryptStore.ts` 里 `RawEvent`
/// 的镜像。曾经打算写 camelCase(`taskId`),但枚举上只有 `tag` 带了
/// `rename_all`,**字段名仍是 snake_case**——两边不一致时不会编译报错,
/// 只会表现为「任务建好了但进度永远不动」。这个测试把形状钉死。
#[test]
fn event_json_contract() {
let start = serde_json::to_value(DecryptEvent::Start {
task_id: "t1".into(),
total: 3,
})
.unwrap();
assert_eq!(
start,
serde_json::json!({ "type": "start", "task_id": "t1", "total": 3 })
);
let file = serde_json::to_value(DecryptEvent::File {
task_id: "t1".into(),
index: 2,
name: "a.ncm".into(),
status: FileStatus::Error,
message: Some("坏了".into()),
output: None,
cover: None,
})
.unwrap();
assert_eq!(
file,
serde_json::json!({
"type": "file", "task_id": "t1", "index": 2, "name": "a.ncm",
"status": "error", "message": "坏了", "output": null, "cover": null
})
);
let progress = serde_json::to_value(DecryptEvent::Progress {
task_id: "t1".into(),
done: 1,
total: 3,
bytes_done: 10,
bytes_total: 100,
name: "a.ncm".into(),
})
.unwrap();
assert_eq!(
progress,
serde_json::json!({
"type": "progress", "task_id": "t1", "done": 1, "total": 3,
"bytes_done": 10, "bytes_total": 100, "name": "a.ncm"
})
);
let finished = serde_json::to_value(DecryptEvent::Finished {
task_id: "t1".into(),
ok: 2,
failed: 1,
cancelled: 0,
})
.unwrap();
assert_eq!(
finished,
serde_json::json!({
"type": "finished", "task_id": "t1", "ok": 2, "failed": 1, "cancelled": 0
})
);
}
/// `FileStatus` 的三个取值必须是前端 `DecryptFileStatus` 认得的字面量
#[test]
fn file_status_variants_are_lowercase() {
let j = |s| serde_json::to_string(&s).unwrap();
assert_eq!(j(FileStatus::Ok), "\"ok\"");
assert_eq!(j(FileStatus::Error), "\"error\"");
assert_eq!(j(FileStatus::Unsupported), "\"unsupported\"");
}
/// 平台路由见 `scan::route`(内容优先于后缀)——这里只验证单测覆盖到的路径。
#[test]
fn engine_route_by_content_and_extension() {
use scan::Engine;
let dir = std::env::temp_dir().join(format!("dec_route_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 网易云:只看魔数,后缀随便
let ncm = dir.join("x.bin");
let mut bytes = b"CTENFDAM".to_vec();
bytes.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
std::fs::write(&ncm, &bytes).unwrap();
assert_eq!(scan::route(&ncm), Some(Engine::Ncm));
// QQ:后缀在家族里
let qmc = dir.join("y.qmcflac");
std::fs::write(&qmc, vec![0x22u8; 4096]).unwrap();
assert_eq!(scan::route(&qmc), Some(Engine::Qmc));
// 普通音频文件不应被认领
let mp3 = dir.join("z.mp3");
std::fs::write(&mp3, vec![0x44u8; 4096]).unwrap();
assert_eq!(scan::route(&mp3), None);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn task_registry_register_cancel_finish() {
let tasks = DecryptTasks::new();
let flag = tasks.register("t1");
assert!(!flag.load(Ordering::SeqCst));
// 取消命中
assert!(tasks.cancel("t1"));
assert!(flag.load(Ordering::SeqCst));
// 未登记的任务取消不报错、返回 false
assert!(!tasks.cancel("nope"));
tasks.finish("t1");
assert!(!tasks.cancel("t1"), "已结束的任务不应再被取消");
}
}
+734
View File
@@ -0,0 +1,734 @@
//! 网易云音乐 `.ncm` 离线解密引擎(纯 Rust,无外部依赖、无运行时前置)。
//!
//! 算法对照 **MIT 协议** 的 `taurusxin/ncmdump`(`src/ncmcrypt.cpp`)独立重写。
//! 下面每个常量与分支都对应容器里的一个实际字段,注释里标了「为什么」——
//! 这几处正是最容易写错的地方,改动前请先读 `MUSIC_DECRYPT_PLAN.md` §3.1。
//!
//! ## 容器结构
//!
//! ```text
//! 0x00 magic 8B "CTENFDAM"
//! 0x08 2B 固定跳过
//! 0x0A key_len 4B LE
//! key_data XOR 0x64 → AES-128-ECB → 跳 17B → RC4 密钥盒种子
//! meta_len 4B LE
//! meta_data XOR 0x63 → 去 22B 前缀 → base64 → AES-128-ECB → 去 6B 前缀 → JSON
//! 5B 固定跳过(CRC32 4B + 图片版本 1B)
//! cover_len 4B LE / img_len 4B LE / img_data → 跳 cover_len - img_len
//! audio 剩余全部(RC4 变体,按 0x8000 分块)
//! ```
//!
//! 两段 XOR 常量不同(`0x64` / `0x63`)、AES 收尾是 PKCS#7 风格 padding、
//! 密钥盒 KSA 带 `last_byte` 累加——任一写错都会全量解错,
//! 且不会报错,只会产出乱码音频。
use std::fs::File;
use std::io::{BufReader, BufWriter, Read, Write};
use std::path::Path;
use aes::cipher::generic_array::GenericArray;
use aes::cipher::{BlockDecrypt, KeyInit};
use aes::Aes128;
use super::common::{self, DecryptError};
/// 头部魔数(ASCII `CTENFDAM`)
const MAGIC: &[u8; 8] = b"CTENFDAM";
/// key 段的 XOR 常量
const XOR_KEY: u8 = 0x64;
/// meta 段的 XOR 常量(**与 key 段不同**)
const XOR_META: u8 = 0x63;
/// key 段解密后需跳过的前缀:ASCII `neteasecloudmusic`(17 字节,含结尾 NUL)
const CORE_KEY: &[u8; 17] = b"neteasecloudmusic";
/// key 段 **AES 密钥**:ASCII `neteasecloudmusi`——`CORE_KEY` 的前 16 字节。
///
/// 注意与上面 17 字节的「前缀」区分:前缀(`neteasecloudmusic\0`,17B)是解密后
/// 要从明文里剥掉的,AES 密钥(16B)是用来解密的。`aes::Aes128` 只吃 16 字节。
const CORE_AES_KEY: &[u8; 16] = b"neteasecloudmusi";
/// meta 段 AES 密钥:ASCII `#14ljk_!\]&0U<'(`(**与 CORE_KEY 不同**,别复用)
///
/// 注意是 16 字节而非 17——`aes::Aes128` 的密钥长度就是 16。
const MODIFY_KEY: &[u8; 16] = b"#14ljk_!\\]&0U<'(";
/// meta 段 base64 之前的字面量前缀
const META_PREFIX: &[u8] = b"163 key(Don't modify):";
/// meta 段 AES 解密后的字面量前缀
const META_JSON_PREFIX: &[u8] = b"music:";
/// 音频段分块大小。**块之间不额外跳字节**——这个值只是读写块大小。
const CHUNK: usize = 0x8000;
/// ncm 内嵌元数据(meta 段 JSON 的子集)
#[derive(Debug, Clone, Default)]
pub struct NcmMeta {
pub name: Option<String>,
pub artist: Option<String>,
pub album: Option<String>,
pub bitrate: Option<u64>,
pub duration: Option<u64>,
/// 容器内声明的格式。**不用于决定输出扩展名**(那只认音频首帧魔数)。
pub format: Option<String>,
}
/// 本模块的错误类型 = 公共错误类型([`DecryptError`]),
/// 便于调度层对两个引擎用同一套 `?` 与文案处理。
pub type NcmError = DecryptError;
type Result<T> = std::result::Result<T, DecryptError>;
/// AES-128-ECB 解密 + PKCS#7 风格去 padding。
///
/// `aes` crate 只提供块原语(且本项目依赖树里**没有** `ecb` crate),
/// 故这里手写块循环。收尾不是「去前缀」而是取最后一字节当 padding 长度——
/// 这一点在 `MUSIC_DECRYPT_PLAN.md` §3.1③ 有说明。
fn aes_ecb_decrypt(key: &[u8], data: &[u8]) -> Result<Vec<u8>> {
if key.len() != 16 {
return Err(NcmError::Broken(format!(
"AES 密钥长度应为 16,实为 {}",
key.len()
)));
}
if data.is_empty() || data.len() % 16 != 0 {
return Err(NcmError::Broken(format!(
"AES 密文长度 {} 不是 16 的正整数倍",
data.len()
)));
}
let cipher = Aes128::new(GenericArray::from_slice(key));
let blocks = data.len() / 16;
let mut out = Vec::with_capacity(data.len());
let mut buf = [0u8; 16];
for i in 0..blocks {
let block = GenericArray::from_slice(&data[i * 16..i * 16 + 16]);
cipher.decrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
// 最后一块按 padding 截断:末字节即填充长度,>16 视为无填充
if i == blocks - 1 {
let pad = if buf[15] > 16 { 0 } else { buf[15] as usize };
out.extend_from_slice(&buf[..16 - pad.min(16)]);
} else {
out.extend_from_slice(&buf);
}
}
Ok(out)
}
/// 密钥盒构造(KSA)。
///
/// 对照 `ncmdump` `src/ncmcrypt.cpp::buildKeyBox`——**单循环**,但每轮多累加一个
/// `last_byte`(上一轮的 `c`):
///
/// ```text
/// c = (swap + last_byte + key[key_offset]) & 0xff
/// ```
///
/// 这个式子在模 256 下恰好化简为标准 RC4(实测两者密钥盒逐字节相同),
/// 所以**它既不是「关键差异」,也不能靠与标准 RC4 比对来验证**——
/// 验证只能靠固定向量,见单测 `key_box_matches_reference_vectors`。
/// `key_offset` 触 keyLen 归零——即循环取 key。
fn build_key_box(key: &[u8]) -> [u8; 256] {
let mut key_box = [0u8; 256];
for (i, b) in key_box.iter_mut().enumerate() {
*b = i as u8;
}
if key.is_empty() {
return key_box;
}
let mut last_byte: u8 = 0;
let mut key_offset = 0usize;
for i in 0..256usize {
let swap = key_box[i];
let c = swap.wrapping_add(last_byte).wrapping_add(key[key_offset]);
key_offset += 1;
if key_offset >= key.len() {
key_offset = 0;
}
key_box[i] = key_box[c as usize];
key_box[c as usize] = swap;
last_byte = c;
}
key_box
}
/// 原地解密一个音频块。
///
/// 对照 `ncmdump` `src/ncmcrypt.cpp::Dump`——`i` 是**块内下标**,`j = (i + 1) & 0xff`:
///
/// ```text
/// buf[i] ^= mKeyBox[(mKeyBox[j] + mKeyBox[(mKeyBox[j] + j) & 0xff]) & 0xff];
/// ```
///
/// 块与块之间不重置密钥盒、也不额外跳字节(`0x8000` 只是块大小)。
/// 该式只依赖 `i` 与密钥盒,故分块与整体解密结果一致(见单测)。
fn decrypt_audio_chunk(key_box: &[u8; 256], buf: &mut [u8]) {
for i in 0..buf.len() {
let j = (i + 1) & 0xff;
let k = key_box
[key_box[j].wrapping_add(key_box[key_box[j].wrapping_add(j as u8) as usize]) as usize];
buf[i] ^= k;
}
}
/// 封面/标签用的图片扩展名(按魔数,不按 ncm 的说法)
fn image_ext(data: &[u8]) -> &'static str {
common::image_ext(data)
}
/// 读满一块(短读不算块边界)——实现见 [`common::read_full`]。
fn read_full(r: &mut impl Read, buf: &mut [u8]) -> Result<usize> {
common::read_full(r, buf)
}
fn read_u32(r: &mut impl Read) -> Result<u32> {
let mut b = [0u8; 4];
r.read_exact(&mut b)
.map_err(|_| NcmError::Broken("读取长度字段时提前结束".into()))?;
Ok(u32::from_le_bytes(b))
}
fn read_n(r: &mut impl Read, n: usize) -> Result<Vec<u8>> {
let mut buf = vec![0u8; n];
r.read_exact(&mut buf)
.map_err(|_| NcmError::Broken(format!("读取 {n} 字节时提前结束")))?;
Ok(buf)
}
/// 解析 meta JSON 为 `NcmMeta`。
///
/// `artist` 是二维数组(`[["名字", id], ...]`),取每项第 0 个元素并用 `/` 连接。
fn parse_meta(json: &str) -> NcmMeta {
let Ok(v) = serde_json::from_str::<serde_json::Value>(json) else {
return NcmMeta::default();
};
let s = |k: &str| v.get(k).and_then(|x| x.as_str()).map(|x| x.to_string());
let n = |k: &str| v.get(k).and_then(|x| x.as_u64());
let artist = v.get("artist").and_then(|a| a.as_array()).map(|arr| {
arr.iter()
.filter_map(|item| {
item.as_array()
.and_then(|inner| inner.first())
.and_then(|name| name.as_str())
})
.collect::<Vec<_>>()
.join("/")
});
NcmMeta {
name: s("musicName"),
artist: artist.filter(|a| !a.is_empty()),
album: s("album"),
bitrate: n("bitrate"),
duration: n("duration"),
format: s("format"),
}
}
/// 解析头部 + key 段 + meta 段 + 封面,返回 (密钥盒, meta, 封面字节)。
fn read_header(r: &mut impl Read) -> Result<([u8; 256], NcmMeta, Option<Vec<u8>>)> {
// 0x00 magic 8B
let magic = read_n(r, 8)?;
if &magic != MAGIC {
return Err(NcmError::NotEncrypted(
"不是网易云加密文件(头部魔数不是 CTENFDAM)".into(),
));
}
// 0x08 固定 2 字节(读取权重仅为推进游标)
let _ = read_n(r, 2)?;
// ---- key 段 ----
let key_len = read_u32(r)? as usize;
if key_len == 0 {
return Err(NcmError::Broken("key 段长度为 0".into()));
}
let mut key_data = read_n(r, key_len)?;
for b in key_data.iter_mut() {
*b ^= XOR_KEY;
}
let key_plain = aes_ecb_decrypt(CORE_AES_KEY, &key_data)?;
if key_plain.len() <= CORE_KEY.len() {
return Err(NcmError::Broken(format!(
"key 段解密后仅 {} 字节,不足以剥离前缀",
key_plain.len()
)));
}
// 剥离 "neteasecloudmusic\0" 前缀,其余即密钥盒种子
let rc4_key = &key_plain[CORE_KEY.len()..];
let key_box = build_key_box(rc4_key);
// ---- meta 段 ----
let meta_len = read_u32(r)? as usize;
let mut meta = NcmMeta::default();
if meta_len > 0 {
let mut meta_data = read_n(r, meta_len)?;
for b in meta_data.iter_mut() {
*b ^= XOR_META;
}
// 第一层前缀:literal,先剥掉再 base64
if meta_data.len() > META_PREFIX.len() {
let body = &meta_data[META_PREFIX.len()..];
use base64::Engine;
if let Ok(decoded) = base64::engine::general_purpose::STANDARD.decode(body) {
if let Ok(plain) = aes_ecb_decrypt(MODIFY_KEY, &decoded) {
// 第二层前缀:"music:"
let json = if plain.len() > META_JSON_PREFIX.len() {
&plain[META_JSON_PREFIX.len()..]
} else {
&plain[..]
};
// 元数据非 UTF-8 或非 JSON 都不致命:放弃标签即可
if let Ok(s) = std::str::from_utf8(json) {
meta = parse_meta(s);
}
}
}
}
}
// ---- 封面段 ----
// 跳 5 字节:CRC32(4) + 图片版本(1)
let mut five = [0u8; 5];
r.read_exact(&mut five)
.map_err(|_| NcmError::Broken("读取 CRC32/图片版本时提前结束".into()))?;
let cover_frame_len = read_u32(r)? as usize;
let img_len = read_u32(r)? as usize;
let cover = if img_len > 0 {
Some(read_n(r, img_len)?)
} else {
None
};
// 跳到 key 帧末尾
if cover_frame_len > img_len {
let mut discard = vec![0u8; cover_frame_len - img_len];
let _ = r.read_exact(&mut discard);
}
Ok((key_box, meta, cover))
}
/// 判断文件是否为网易云 `.ncm`(只读 8 字节魔数)。
pub fn sniff(path: &Path) -> bool {
let Ok(mut f) = File::open(path) else {
return false;
};
let mut magic = [0u8; 8];
std::io::Read::read_exact(&mut f, &mut magic).is_ok() && &magic == MAGIC
}
/// 解密一个 `.ncm` 文件到 `out_dir`,返回产物信息。
///
/// `progress` 每处理一块回调一次(已处理字节数,总字节数),供上层节流后推事件。
/// `platform_label` 由调度层给出(如「网易云」),用于产物备注。
pub fn decrypt_file<F>(
input: &Path,
out_dir: &Path,
platform_label: &str,
reserved: &mut std::collections::HashSet<String>,
mut progress: F,
) -> Result<common::Outcome>
where
F: FnMut(u64, u64),
{
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
let file = File::open(input)?;
let mut reader = BufReader::with_capacity(CHUNK, file);
let (key_box, meta, cover) = read_header(&mut reader)?;
std::fs::create_dir_all(out_dir)?;
// 先写临时文件:格式要等第一块解出来才知道,而输出名又依赖格式。
// 定稿后再 rename —— 中途失败不会留下半个音频冒充成品。
let tmp = out_dir.join(format!(
".dec_part_{}_{}.tmp",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let mut buf = vec![0u8; CHUNK];
let mut done: u64 = 0;
let mut format: Option<&'static str> = None;
let mut audio_bytes: u64 = 0;
let write_result = (|| -> Result<()> {
let out = File::create(&tmp)?;
let mut writer = BufWriter::with_capacity(CHUNK, out);
loop {
// **必须读满一个块**(或读到 EOF),不能用 `read` 的短读结果当块边界。
// 解密式依赖「块内偏移 i」,块边界一漂移密钥盒相位就错位——
// 表现为文件从中间某处起全是噪声、前面对得上,极难排查(§6.24)。
let n = read_full(&mut reader, &mut buf)?;
if n == 0 {
break;
}
decrypt_audio_chunk(&key_box, &mut buf[..n]);
if format.is_none() {
format = Some(common::detect_format(&buf[..n]));
}
writer.write_all(&buf[..n])?;
done += n as u64;
audio_bytes += n as u64;
progress(done, total);
}
writer.flush()?;
Ok(())
})();
if let Err(e) = write_result {
let _ = std::fs::remove_file(&tmp);
return Err(e);
}
let format = format.ok_or_else(|| {
let _ = std::fs::remove_file(&tmp);
NcmError::Broken("音频段为空".into())
})?;
let stem = input
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "output".to_string());
let target = common::unique_output(out_dir, &stem, format, reserved)?;
std::fs::rename(&tmp, &target).map_err(|e| {
let _ = std::fs::remove_file(&tmp);
NcmError::Output(format!("重命名产物失败:{e}"))
})?;
// 封面单独落盘(标签回填留 P2:需要 lofty 且要按容器分派)
let cover_path = match cover {
Some(data) if !data.is_empty() => {
let ext = image_ext(&data);
let path = common::unique_output(out_dir, &format!("{stem}.cover"), ext, reserved)?;
std::fs::write(&path, &data)?;
Some(path)
}
_ => None,
};
// 标签信息汇总成一行备注(P2 回填标签前,这是元数据唯一的出口)
let mut note = format!("{platform_label} ncm");
if let Some(n) = meta.name.as_deref() {
note.push_str(&format!(" · {n}"));
}
if let Some(a) = meta.artist.as_deref() {
note.push_str(&format!(" - {a}"));
}
// 位率/时长/专辑:解析成本已经付过,顺手带进备注(也避免字段闲置)
let mut bits: Vec<String> = Vec::new();
if let Some(b) = meta.bitrate {
if b > 0 {
bits.push(format!("{} kbps", b / 1000));
}
}
if let Some(d) = meta.duration {
if d > 0 {
let secs = d / 1000;
bits.push(format!("{}:{:02}", secs / 60, secs % 60));
}
}
if let Some(al) = meta.album.as_deref() {
bits.push(format!("专辑《{al}》"));
}
if let Some(f) = meta.format.as_deref() {
bits.push(format!("声明格式 {f}"));
}
if !bits.is_empty() {
note.push_str(&format!("({})", bits.join(" · ")));
}
Ok(common::Outcome {
output: target,
format: format.to_string(),
cover: cover_path,
audio_bytes,
note,
})
}
#[cfg(test)]
mod tests {
use super::*;
use aes::cipher::BlockEncrypt;
const ZERO_KEY: [u8; 16] = [0u8; 16];
/// AES 正向加密(测试用),与 `aes_ecb_decrypt` 互逆。
fn aes_ecb_encrypt(key: &[u8; 16], data: &[u8]) -> Vec<u8> {
let cipher = Aes128::new(GenericArray::from_slice(key));
let mut out = Vec::with_capacity(data.len());
let mut buf = [0u8; 16];
for chunk in data.chunks(16) {
let block = GenericArray::from_slice(chunk);
cipher.encrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
out.extend_from_slice(&buf);
}
out
}
fn pkcs7_pad(data: &[u8]) -> Vec<u8> {
let pad = 16 - (data.len() % 16);
let mut out = data.to_vec();
out.extend(std::iter::repeat(pad as u8).take(pad));
out
}
#[test]
fn aes_ecb_roundtrip_with_pkcs7() {
let plain = b"CTENFDAM-test-payload-1234";
let padded = pkcs7_pad(plain);
assert_eq!(padded.len() % 16, 0);
let enc = aes_ecb_encrypt(&ZERO_KEY, &padded);
let dec = aes_ecb_decrypt(&ZERO_KEY, &enc).expect("decrypt");
assert_eq!(dec, plain);
}
#[test]
fn aes_ecb_rejects_non_block_multiple() {
assert!(aes_ecb_decrypt(&ZERO_KEY, &[0u8; 17]).is_err());
assert!(aes_ecb_decrypt(&ZERO_KEY, &[]).is_err());
}
/// 空 key 时密钥盒必须是恒等置换(KSA 的边界行为)
#[test]
fn key_box_identity_for_empty_key() {
let kb = build_key_box(&[]);
for i in 0..256 {
assert_eq!(kb[i], i as u8);
}
}
/// 已知答案向量:由参考实现(`ncmdump` 的 `buildKeyBox`)独立算出的值。
///
/// 注意**不能**用「与标准 RC4 比对」来验证——`last_byte` 在模 256 下是恒等变形,
/// 两者逐字节相同。只能靠固定向量锁行为。
#[test]
fn key_box_matches_reference_vectors() {
let kb = build_key_box(b"0123456789abcdef");
assert_eq!(
&kb[..8],
&[0x88, 0x62, 0x96, 0xcc, 0x79, 0x85, 0x7a, 0x21],
"密钥盒前 8 字节与参考实现不符"
);
assert_eq!(
&kb[8..16],
&[0x15, 0x49, 0xa5, 0x91, 0x3d, 0xc6, 0x65, 0xda],
"密钥盒第 8..16 字节与参考实现不符"
);
}
/// 已知答案向量:全零明文的密钥流(即 PRGA 输出)前 24 字节。
#[test]
fn keystream_matches_reference_vector() {
let kb = build_key_box(b"0123456789abcdef");
let mut data = [0u8; 24];
decrypt_audio_chunk(&kb, &mut data);
assert_eq!(
data,
[
0x1d, 0xaf, 0xd7, 0x79, 0xfa, 0xce, 0x0c, 0x2b, 0xab, 0xc4, 0x8c, 0xeb, 0x0d, 0xc3,
0x6a, 0x5c, 0xc6, 0x07, 0x79, 0x63, 0x92, 0x72, 0x69, 0x1b
],
"密钥流与参考实现不符"
);
}
/// 密钥必须循环取用满 256 轮:`key_offset` 归零逻辑要正确。
#[test]
fn key_box_cycles_key_correctly() {
let a = vec![7u8; 300];
let mut b = vec![7u8; 300];
b[250] = 8;
assert_ne!(
build_key_box(&a),
build_key_box(&b),
"密钥第 250 字节未参与运算——key_offset 取模有误"
);
// 短密钥(1 字节)也不能 panic,且是合法置换
let kb = build_key_box(&[0x42]);
let mut seen = [false; 256];
for &x in kb.iter() {
seen[x as usize] = true;
}
assert!(seen.iter().all(|&v| v));
}
/// 加密→解密往返:验证 `decrypt_audio_chunk` 与自身一致,
/// 且块边界不改变结果(`i` 是块内下标这一设计的关键性质)。
#[test]
fn audio_chunk_roundtrip_and_block_boundary_invariance() {
let kb = build_key_box(b"0123456789abcdef");
let plain: Vec<u8> = (0..(CHUNK + 777)).map(|i| (i % 251) as u8).collect();
let mut whole = plain.clone();
decrypt_audio_chunk(&kb, &mut whole);
assert_ne!(whole, plain, "解密未改变数据,密钥盒或 XOR 有误");
let mut chunked = plain.clone();
for c in chunked.chunks_mut(CHUNK) {
decrypt_audio_chunk(&kb, c);
}
assert_eq!(chunked, whole, "分块解密与整体解密结果不一致");
decrypt_audio_chunk(&kb, &mut chunked);
assert_eq!(chunked, plain);
}
#[test]
fn parse_meta_reads_nested_artist() {
let json = r#"{"musicName":"歌","album":"专辑","bitrate":999000,
"duration":215000,"format":"flac",
"artist":[["歌手甲",1],["歌手乙",2]]}"#;
let m = parse_meta(json);
assert_eq!(m.name.as_deref(), Some("歌"));
assert_eq!(m.album.as_deref(), Some("专辑"));
assert_eq!(m.artist.as_deref(), Some("歌手甲/歌手乙"));
assert_eq!(m.bitrate, Some(999000));
assert_eq!(m.duration, Some(215000));
assert_eq!(m.format.as_deref(), Some("flac"));
}
#[test]
fn parse_meta_tolerates_garbage() {
let m = parse_meta("not json at all");
assert!(m.name.is_none() && m.artist.is_none());
}
#[test]
fn not_ncm_file_is_rejected() {
let dir = std::env::temp_dir().join(format!("ncm_bad_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let p = dir.join("fake.ncm");
std::fs::write(&p, b"NOTNCM!!\x02\x00\x00\x00\x00").unwrap();
let mut reserved = std::collections::HashSet::new();
let err = decrypt_file(&p, &dir, "网易云", &mut reserved, |_, _| {}).unwrap_err();
assert!(
matches!(err, NcmError::NotEncrypted(_)),
"期望 NotEncrypted,实得 {err:?}"
);
assert!(!sniff(&p), "魔数不符的文件 sniff 应为 false");
let _ = std::fs::remove_dir_all(&dir);
}
/// **正向构造**一个合法 ncm 容器,再解回来。
/// 这样无需把真实音乐样本(体积大、有版权)放进仓库,仍能覆盖:
/// 两段 XOR 常量、两层 meta 前缀、封面段偏移、分块解密、魔数定格式、输出命名。
#[test]
fn synthetic_ncm_roundtrip() {
let dir = std::env::temp_dir().join(format!("ncm_rt_{}", std::process::id()));
let out = dir.join("out");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 与密钥盒用例共用的固定种子
let seed: &[u8] = b"0123456789abcdef";
// 音频明文:以 fLaC 开头,长度跨块边界多一点
let mut plain = b"fLaC".to_vec();
plain.extend((0..(CHUNK + 123)).map(|i| (i % 253) as u8));
// 用它"加密"音频(XOR 自逆)。加密必须与解密用同样的块大小,
// 否则 PRGA 相位错位(这正是 read_full 存在的原因)。
let kb = build_key_box(seed);
let mut cipher_audio = plain.clone();
for c in cipher_audio.chunks_mut(CHUNK) {
decrypt_audio_chunk(&kb, c);
}
// key 段:**必须**是 CORE_KEY 前缀 + 种子——解密端会剥掉这 17 字节前缀,
// 少了它就会拿到错误的种子。
let mut key_plain = CORE_KEY.to_vec();
key_plain.extend_from_slice(seed);
let mut key_seg = aes_ecb_encrypt(CORE_AES_KEY, &pkcs7_pad(&key_plain));
for b in key_seg.iter_mut() {
*b ^= XOR_KEY;
}
// meta 段:META_PREFIX + base64(AES(META_JSON_PREFIX + json)),再 XOR 0x63
let json = r#"{"musicName":"合成曲","album":"合成专辑","bitrate":320000,"duration":1000,"format":"flac","artist":[["测试歌手",1]]}"#;
let mut meta_plain = META_JSON_PREFIX.to_vec();
meta_plain.extend_from_slice(json.as_bytes());
let meta_enc = aes_ecb_encrypt(MODIFY_KEY, &pkcs7_pad(&meta_plain));
use base64::Engine;
let meta_b64 = base64::engine::general_purpose::STANDARD.encode(&meta_enc);
let mut meta_seg = META_PREFIX.to_vec();
meta_seg.extend_from_slice(meta_b64.as_bytes());
for b in meta_seg.iter_mut() {
*b ^= XOR_META;
}
// 封面段:PNG 魔数 + 一点数据;cover_len 故意大于 img_len 以覆盖"跳过尾部"
let img: Vec<u8> = [
&[0x89u8, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A][..],
&[7u8; 40],
]
.concat();
let cover_padding = [0u8; 9];
let cover_frame_len = (img.len() + cover_padding.len()) as u32;
let mut container = Vec::new();
container.extend_from_slice(MAGIC);
container.extend_from_slice(&[0x02, 0x00]); // 固定 2B
container.extend_from_slice(&(key_seg.len() as u32).to_le_bytes());
container.extend_from_slice(&key_seg);
container.extend_from_slice(&(meta_seg.len() as u32).to_le_bytes());
container.extend_from_slice(&meta_seg);
container.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD, 0x01]); // CRC32 + 图片版本
container.extend_from_slice(&cover_frame_len.to_le_bytes());
container.extend_from_slice(&(img.len() as u32).to_le_bytes());
container.extend_from_slice(&img);
container.extend_from_slice(&cover_padding);
container.extend_from_slice(&cipher_audio);
let src = dir.join("测试 曲目.ncm");
std::fs::write(&src, &container).unwrap();
assert!(sniff(&src), "合法容器的 sniff 应为 true");
let mut reserved = std::collections::HashSet::new();
let mut ticks = 0usize;
let res = decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| ticks += 1)
.expect("解密应成功");
assert_eq!(res.format, "flac");
assert_eq!(res.audio_bytes, plain.len() as u64);
assert!(ticks >= 2, "进度回调应至少触发两次(跨块),实得 {ticks}");
// 用长度 + 位置比较,避免 assert_eq! 在失败时倾倒几十万字节
let got = std::fs::read(&res.output).unwrap();
assert_eq!(got.len(), plain.len(), "音频长度不一致");
let first_diff = got.iter().zip(plain.iter()).position(|(a, b)| a != b);
assert!(
got == plain,
"音频明文不一致:第一个不同处在第 {:?} 字节",
first_diff
);
// 元数据不再单独暴露,而是拼进 note——所以直接验 note 里带上了它
assert!(res.note.contains("合成曲"), "note 应含曲名:{}", res.note);
assert!(res.note.contains("测试歌手"), "note 应含歌手:{}", res.note);
assert!(res.note.contains("合成专辑"), "note 应含专辑:{}", res.note);
// 位率 320000 → 320 kbps
assert!(res.note.contains("320 kbps"), "note 应含位率:{}", res.note);
let cover = res.cover.expect("应提取出封面");
let cover_bytes = std::fs::read(&cover).unwrap();
assert_eq!(cover_bytes.len(), img.len(), "封面长度不一致");
assert!(cover_bytes == img, "封面字节不一致");
assert_eq!(cover.extension().unwrap(), "png");
// 中文文件名 + 中文输出路径:产物名应保留原名
assert_eq!(
res.output.file_name().unwrap().to_string_lossy(),
"测试 曲目.flac"
);
// 再解一次:同名必须让位而不是覆盖
let res2 =
decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| {}).expect("二次解密应成功");
assert_eq!(
res2.output.file_name().unwrap().to_string_lossy(),
"测试 曲目_1.flac"
);
let _ = std::fs::remove_dir_all(&dir);
}
}
+113
View File
@@ -0,0 +1,113 @@
//! **开发探针**:不落盘地跑完「musicex 尾部 → 凭据 → 在线取密钥 → 解密」并回传结果。
//!
//! 存在的唯一理由:musicex 这条路径的**真实响应字段**只能靠真机样本验证,
//! 而跑起整个 Tauri 应用再手点一遍成本太高、也没法在命令行里复现。
//! 它不参与产品逻辑——调度层走的是 [`super::qq_online::decrypt_musicex`]。
//!
//! 2026-09-27 用它跑通了首个真机样本(197MB `.mflac`,192kHz/24bit):
//! ekey 704 字符 → 派生 512 字节密钥 → RC4 变体解密 → `fLaC` 头。
//! **这条验证顺带推翻了一个错误假设**:该样本的密文头是 `51 74 03 75`,
//! 并非文档里提到的 `#!Qk`,所以密文头不能当守卫(见 `qq_online` 的注释)。
//!
//! 用法见 `src-tauri/examples/decrypt_musicex_probe.rs`:
//! ```text
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\sample.mflac" [输出目录]
//! ```
use std::io::Read;
use std::path::Path;
use super::common::DecryptError;
use super::qmc;
use super::qq_credentials;
use super::qq_ekey::{self, EvkeyRequest};
use super::qq_footer::{self, MusiCexTail};
/// 探针结果(都是"结论性"字段,便于一眼判断链路是否通了)
pub struct ProbeOutcome {
pub ekey_len: usize,
pub key_len: usize,
pub raw_key_bytes: Vec<u8>,
/// 密文头部 4 字节(应是 `#!Qk`,即 QMC2 魔术)
pub cipher_magic: Vec<u8>,
/// 解密后头部 16 字节(FLAC 应为 `fLaC`)
pub plain_magic: Vec<u8>,
pub decrypted_bytes: usize,
pub guessed_format: String,
pub expiration_secs: i64,
}
/// 对给定样本跑完整链路(**读内存、发网络请求、解密,但不写任何文件**)
pub fn probe_musicex(input: &Path) -> Result<ProbeOutcome, DecryptError> {
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
}
// 1) 尾部
let tail: MusiCexTail = read_tail(input)?;
let audio_len = tail.audio_len(total);
// 2) 凭据
let creds = qq_credentials::read_credentials();
let (Some(uin), Some(authst)) = (creds.uin.as_deref(), creds.authst.as_deref()) else {
return Err(DecryptError::KeyRequired(format!(
"凭据不可用:{}",
creds.status_text()
)));
};
// 3) 取 ekey(真实网络请求)
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(25))
.build()
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
let (ekey, expiration_secs) =
tauri::async_runtime::block_on(qq_ekey::fetch_ekey(&client, &req))?;
// 4) ekey → 原始密钥
let raw = qmc::parse_ekey(&ekey)?;
// 5) 解密音频段(探针只验证单文件,全量读入内存即可)
let mut audio = read_audio(input, audio_len)?;
let cipher_magic = audio[..4.min(audio.len())].to_vec();
qmc::decrypt_with_raw_key(&raw, &mut audio);
let plain_magic = audio[..16.min(audio.len())].to_vec();
let guessed_format = super::common::detect_format_opt(&audio)
.unwrap_or("unknown")
.to_string();
Ok(ProbeOutcome {
ekey_len: ekey.len(),
key_len: raw.len(),
raw_key_bytes: raw,
cipher_magic,
plain_magic,
decrypted_bytes: audio.len(),
guessed_format,
expiration_secs,
})
}
/// 读文件末尾的 musicex 尾部
fn read_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
use std::io::{Seek, SeekFrom};
let mut f = std::fs::File::open(input)?;
let size = f.metadata()?.len();
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
f.seek(SeekFrom::End(-(take as i64)))?;
let mut buf = vec![0u8; take];
f.read_exact(&mut buf)?;
qq_footer::parse_musicex_tail(&buf)
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败".into()))
}
/// 只读音频段
fn read_audio(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
let mut f = std::fs::File::open(input)?;
let mut buf = vec![0u8; audio_len as usize];
f.read_exact(&mut buf)?;
Ok(buf)
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,285 @@
//! QQ音乐本机凭据读取(`uin` + `authst`)。
//!
//! ## 为什么要读进程内存
//!
//! Windows 版 QQ 音乐**没有持久化 `authst`**:`uin` 能从
//! `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 明文读到,但 `authst`
//! 只作为 JSON 字符串存在于运行中的 `QQMusic.exe` 内存里(有效期约 22.3 小时)。
//! 所以「在线取 ekey」的前置条件是:**QQ 音乐正在运行且已登录**。
//!
//! 这里只做**只读**内存访问(`OpenProcess` + `VirtualQueryEx` + `ReadProcessMemory`),
//! 不注入、不改写任何东西——这是它与 Frida 兜底方案的本质区别,
//! 也是它通常不会被安全软件拦截的原因。
//!
//! ## 结构
//!
//! - [`parse_ini_uin`]:纯函数,可跨平台单测;
//! - [`find_authst`]:纯函数,在给定字节里找 `"authst":"<token>"`,可单测;
//! - [`read_credentials`]:平台相关的胶水(Windows 实现 / 其他平台的空实现)。
/// 从 QQ 音乐的 INI 文本里取 `[Account] Uin`。
///
/// 该文件很小(实测 27 字节)且是**纯文本**,格式固定:
///
/// ```ini
/// [Account]
/// Uin=1154027699
/// ```
///
/// 解析上刻意宽松:允许前导空白、大小写不敏感、允许 `Uin` 出现在任意段里
/// (不同版本段名可能变),但**只认第一处**出现的非空 Uin。
pub fn parse_ini_uin(text: &str) -> Option<String> {
for line in text.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with(';') || line.starts_with('#') {
continue;
}
let Some((key, value)) = line.split_once('=') else {
continue;
};
if !key.trim().eq_ignore_ascii_case("uin") {
continue;
}
let v = value.trim().trim_matches('"');
// 必须是纯数字(QQ 号),排除 `Uin=` 之类的空值或占位
if !v.is_empty() && v.bytes().all(|b| b.is_ascii_digit()) {
return Some(v.to_string());
}
}
None
}
/// `authst` 在内存里的 JSON 形态:`"authst":"<base64url-ish>"`。
const AUTHST_KEY: &[u8] = b"\"authst\":\"";
/// 在一段内存字节里查找 `authst` 的值(从 0 开始)。
///
/// 生产路径用 [`find_authst_from`](分块扫描需要偏移),这个薄封装给测试用。
#[cfg_attr(not(test), allow(dead_code))]
pub fn find_authst(haystack: &[u8]) -> Option<String> {
find_authst_from(haystack, 0)
}
/// 从 `start` 起查找(供分块扫描时避免重复命中同一处)
pub fn find_authst_from(haystack: &[u8], start: usize) -> Option<String> {
let mut pos = start;
while pos + AUTHST_KEY.len() <= haystack.len() {
let Some(rel) = find_subslice(&haystack[pos..], AUTHST_KEY) else {
return None;
};
let val_start = pos + rel + AUTHST_KEY.len();
// token 到下一个双引号结束
let Some(end_rel) = haystack[val_start..].iter().position(|&b| b == b'"') else {
return None;
};
let token = &haystack[val_start..val_start + end_rel];
if is_plausible_token(token) {
return Some(String::from_utf8_lossy(token).to_string());
}
// 命中但是假阳性:从下一个字节继续找
pos = val_start;
}
None
}
fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
if needle.is_empty() || haystack.len() < needle.len() {
return None;
}
haystack.windows(needle.len()).position(|w| w == needle)
}
fn is_plausible_token(token: &[u8]) -> bool {
token.len() >= 16
&& token.iter().all(|&b| {
b.is_ascii_alphanumeric()
|| b == b'-'
|| b == b'_'
|| b == b'='
|| b == b'+'
|| b == b'/'
})
}
/// 凭据读取结果
#[derive(Debug, Clone, Default)]
pub struct QqCredentials {
/// QQ 号(来自 INI)
pub uin: Option<String>,
/// 运行期认证令牌(来自进程内存)
pub authst: Option<String>,
}
impl QqCredentials {
/// 是否可用于调用 `GetEVkey`
pub fn usable(&self) -> bool {
self.uin.is_some() && self.authst.is_some()
}
/// 给 UI 的简短状态(三态,供状态卡渲染)
pub fn status_text(&self) -> &'static str {
match (self.uin.is_some(), self.authst.is_some()) {
(true, true) => "已就绪",
(true, false) => "QQ 音乐未运行或未登录",
(false, _) => "未找到本机 QQ 音乐账号",
}
}
}
/// `QQMusic.exe` 的进程名(枚举时用大小写不敏感的子串匹配)
pub const QQ_PROCESS_HINT: &str = "qqmusic";
/// QQ 音乐配置 INI 的路径(Windows)
#[cfg(windows)]
pub fn config_ini_path() -> Option<std::path::PathBuf> {
let appdata = std::env::var_os("APPDATA")?;
Some(
std::path::PathBuf::from(appdata)
.join("Tencent")
.join("QQMusic")
.join("QQMusicServiceConfig.ini"),
)
}
#[cfg(not(windows))]
pub fn config_ini_path() -> Option<std::path::PathBuf> {
None
}
/// 读凭据:`uin` 从 INI,`authst` 扫进程内存。
///
/// 任何一步失败都只是 `None`(并记日志),不返回错误——调用方据
/// [`QqCredentials::usable`] 决定是走在线取 ekey 还是给出引导。
pub fn read_credentials() -> QqCredentials {
let uin = config_ini_path()
.and_then(|p| std::fs::read_to_string(&p).ok())
.and_then(|t| parse_ini_uin(&t))
.or_else(|| {
// 兜底:文件读不到时,从进程内存里找 "uin":"..." 形态
scan_authst_in_process().1
});
let (authst, uin_from_mem) = match uin {
// 有 uin 时只需要 authst
Some(_) => (scan_authst_in_process().0, None),
// 没 uin 时一次扫描同时拿两者
None => {
let (a, u) = scan_authst_in_process();
(a, u)
}
};
QqCredentials {
uin: uin.or(uin_from_mem),
authst,
}
}
#[cfg(windows)]
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
match crate::music::decrypt::qq_memscan::scan_qq_process() {
Ok(found) => (found.authst, found.uin),
Err(e) => {
crate::logger::log_warn("music-decrypt", &format!("扫描 QQ 音乐进程内存失败:{e}"));
(None, None)
}
}
}
#[cfg(not(windows))]
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
(None, None)
}
#[cfg(test)]
mod tests {
use super::*;
// ============ INI 解析 ============
#[test]
fn parses_real_ini_shape() {
// 本机实测就是这个形状(27 字节)
let text = "[Account]\r\nUin=1154027699\r\n";
assert_eq!(parse_ini_uin(text).as_deref(), Some("1154027699"));
}
#[test]
fn parses_ini_leniently() {
// 大小写、空白、引号、注释、其他段
let text = "\u{feff}; comment\r\n[Other]\r\nx=1\r\n\r\n uin = \"123456\" \r\n";
assert_eq!(parse_ini_uin(text).as_deref(), Some("123456"));
}
#[test]
fn ignores_non_numeric_or_empty_uin() {
assert!(parse_ini_uin("Uin=\r\n").is_none());
assert!(parse_ini_uin("Uin=abc\r\n").is_none());
assert!(parse_ini_uin("Uin=12a45\r\n").is_none());
assert!(parse_ini_uin("").is_none());
assert!(parse_ini_uin("[Account]\nFoo=1\n").is_none());
}
// ============ authst 提取 ============
#[test]
fn finds_authst_in_memory_blob() {
let token = "AbCd_-1234567890AbCd_-1234567890";
let blob = format!("junk{{\"uin\":\"1154027699\",\"authst\":\"{token}\",\"other\":1}}tail");
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
}
#[test]
fn rejects_implausible_authst() {
// 太短
assert!(find_authst(b"\"authst\":\"short\"").is_none());
// 含非法字符(像模板/日志)
assert!(find_authst(b"\"authst\":\"this is not a token at all\"").is_none());
// 没有值
assert!(find_authst(b"\"authst\":\"\"").is_none());
// 完全没有
assert!(find_authst(b"nothing here").is_none());
}
/// 第一处是假阳性时,应继续往后找真 token
#[test]
fn skips_false_positive_and_keeps_searching() {
let token = "RealToken_1234567890abcdef";
let blob = format!("\"authst\":\"x\"...\"authst\":\"{token}\"");
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
}
/// 跨缓冲区边界不会误判(分块扫描用 find_authst_from)
#[test]
fn find_from_offset_advances() {
let blob = b"aaaa\"authst\":\"AAAAAAAAAAAAAAAA\"";
let first = find_authst_from(blob, 0).unwrap();
assert_eq!(first, "AAAAAAAAAAAAAAAA");
// 从命中处之后继续找应该没有第二个
let key_at = 4 + AUTHST_KEY.len();
assert!(find_authst_from(blob, key_at).is_none());
}
// ============ 状态文案 ============
#[test]
fn credentials_status_text_covers_three_states() {
let none = QqCredentials::default();
assert!(!none.usable());
assert!(none.status_text().contains("未找到"));
let uin_only = QqCredentials {
uin: Some("1".into()),
authst: None,
};
assert!(!uin_only.usable());
assert!(uin_only.status_text().contains("未运行"));
let full = QqCredentials {
uin: Some("1".into()),
authst: Some("t".into()),
};
assert!(full.usable());
assert_eq!(full.status_text(), "已就绪");
}
}
+342
View File
@@ -0,0 +1,342 @@
//! 通过 QQ 音乐官方接口取 ekey(`music.vkey.GetEVkey`)。
//!
//! ## 前置条件(必须让用户知道)
//!
//! 新版 musicex 文件**不包含 ekey**,只能拿本机已登录的凭据向 QQ 音乐服务器换取:
//!
//! 1. 本机装有 QQ 音乐客户端;
//! 2. **QQ 音乐正在运行且已登录**(`authst` 只存在于运行期内存,见
//! [`super::qq_credentials`]);
//! 3. 文件本身的尾部要有 `media_mid` 与 `filename`(musicex 尾部提供)。
//!
//! ## 接口契约里三个"必须"
//!
//! 对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的协议文档:
//!
//! - `param.filename` **必须带扩展名**(`.mgg` / `.mflac`),否则返回 `104005`;
//! - `param.songtype` **必须为 `1`**(表示请求加密资源的 ekey;为 0 只回 vkey);
//! - `module` 必须是 **`music.vkey.GetEVkey`**(不是 `GetVkey`,后者不返回 ekey)。
//!
//! 另外 `authst` 约 **22.3 小时**过期,失败文案要给出"重新登录 QQ 音乐"的出口。
use serde::{Deserialize, Serialize};
use super::common::DecryptError;
use super::qq_footer::MusiCexTail;
/// 取 ekey 的接口地址
pub const EVKEY_ENDPOINT: &str = "https://u.y.qq.com/cgi-bin/musicu.fcg";
/// PC 端的 platform 标识(Windows)
pub const PLATFORM_WINDOWS: &str = "27";
/// 组装 `GetEVkey` 请求体。
///
/// 抽成纯函数是为了能单测那三个"必须"——它们是这个接口最容易踩的坑。
pub fn build_evkey_request(
uin: &str,
authst: &str,
media_mid: &str,
filename: &str,
login_type: u32,
) -> serde_json::Value {
serde_json::json!({
"comm": {
"authst": authst,
"ct": "19",
"cv": "1859",
"uin": uin,
"tmeLoginType": login_type.to_string(),
},
"req_1": {
"module": "music.vkey.GetEVkey",
"method": "CgiGetEVkey",
"param": {
"filename": [filename],
"guid": "10000",
"songmid": [media_mid],
"songtype": [1],
"uin": uin,
"loginflag": 1,
"platform": PLATFORM_WINDOWS,
"ctx": 1,
}
}
})
}
/// `GetEVkey` 的响应(只声明用得到的字段)
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyResponse {
#[serde(default)]
pub code: i64,
#[serde(default)]
pub req_1: Option<EvkeyReq1>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyReq1 {
#[serde(default)]
pub code: i64,
#[serde(default)]
pub data: Option<EvkeyData>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyData {
#[serde(default)]
pub midurlinfo: Vec<EvkeyItem>,
/// ekey 有效期(秒),实测约 80400
#[serde(default)]
pub expiration: i64,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyItem {
#[serde(default)]
pub ekey: String,
#[serde(default)]
pub result: i64,
#[serde(default)]
pub subcode: i64,
}
/// 把响应解读为 `(ekey, 有效期秒数)` 或一个**可读的**失败原因。
///
/// 这里集中处理错误码,是为了让 UI 能给出下一步动作,而不是丢一个数字出去。
/// 有效期一并返回:`authst` 过期是这条链路最常见的失败原因,把"还能用多久"
/// 讲清楚比让用户猜要好。
pub fn parse_evkey_response(resp: &EvkeyResponse) -> Result<(String, i64), DecryptError> {
let req = resp
.req_1
.as_ref()
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 req_1".into()))?;
let data = req
.data
.as_ref()
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 data".into()))?;
let item = data
.midurlinfo
.first()
.ok_or_else(|| DecryptError::KeyRequired("服务器未返回任何资源信息".into()))?;
if item.ekey.is_empty() {
let hint = match item.result {
104005 => {
"该资源的密钥需要 VIP 或当前账号无权访问(错误码 104005);也可能文件名缺少扩展名"
}
0 => "服务器返回了空 ekey,通常是登录态已过期——请在 QQ 音乐里重新登录后重试",
_ => "服务器未返回 ekey",
};
return Err(DecryptError::KeyRequired(format!(
"{hint}(result={}, subcode={}, code={}/{}/{})",
item.result, item.subcode, resp.code, req.code, item.result
)));
}
Ok((item.ekey.clone(), data.expiration))
}
/// 从响应 JSON 文本解析出 ekey。
///
/// 生产路径走 [`fetch_ekey`](它需要有效期),这个薄封装主要给测试用,
/// 也作为该接口对外的最小 API。
#[cfg_attr(not(test), allow(dead_code))]
pub fn extract_ekey(body: &str) -> Result<String, DecryptError> {
let resp: EvkeyResponse = serde_json::from_str(body)
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?;
parse_evkey_response(&resp).map(|(ekey, _)| ekey)
}
/// 在线取 ekey 的入参(把"要什么"与"怎么取"分开,便于测试与日志)
#[derive(Debug, Clone, Serialize)]
pub struct EvkeyRequest {
pub uin: String,
pub authst: String,
pub media_mid: String,
pub filename: String,
pub login_type: u32,
}
impl EvkeyRequest {
/// 从 musicex 尾部 + 凭据构造
pub fn from_tail(tail: &MusiCexTail, uin: &str, authst: &str) -> Result<Self, DecryptError> {
if tail.media_mid.is_empty() {
return Err(DecryptError::Broken(
"musicex 尾部缺少 media_mid,无法向服务器索取密钥".into(),
));
}
if tail.filename.is_empty() {
return Err(DecryptError::Broken(
"musicex 尾部缺少文件名,无法向服务器索取密钥".into(),
));
}
// 接口要求 filename 必须带扩展名
if !tail.filename.contains('.') {
return Err(DecryptError::Broken(
"musicex 尾部文件名没有扩展名,服务器会拒绝(104005)".into(),
));
}
Ok(Self {
uin: uin.to_string(),
authst: authst.to_string(),
media_mid: tail.media_mid.clone(),
filename: tail.filename.clone(),
// 默认按 QQ 登录;微信登录是 3,两者都能用 authst,不影响取 ekey
login_type: 1,
})
}
pub fn body(&self) -> serde_json::Value {
build_evkey_request(
&self.uin,
&self.authst,
&self.media_mid,
&self.filename,
self.login_type,
)
}
}
/// 实际发请求(异步),返回 `(ekey, 有效期秒数)`。
pub async fn fetch_ekey(
client: &reqwest::Client,
req: &EvkeyRequest,
) -> Result<(String, i64), DecryptError> {
let body = req.body();
let resp = tokio::time::timeout(
std::time::Duration::from_secs(20),
client.post(EVKEY_ENDPOINT).json(&body).send(),
)
.await
.map_err(|_| DecryptError::KeyRequired("请求 QQ 音乐服务器超时".into()))?
.map_err(|e| DecryptError::KeyRequired(format!("请求 QQ 音乐服务器失败:{e}")))?;
let status = resp.status();
let text = resp
.text()
.await
.map_err(|e| DecryptError::KeyRequired(format!("读取服务器响应失败:{e}")))?;
if !status.is_success() {
return Err(DecryptError::KeyRequired(format!(
"QQ 音乐服务器返回 HTTP {status}:{}",
text.chars().take(200).collect::<String>()
)));
}
parse_evkey_response(
&serde_json::from_str(&text)
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?,
)
}
#[cfg(test)]
mod tests {
use super::*;
fn tail() -> MusiCexTail {
MusiCexTail {
song_id: 1,
media_mid: "0012ABCDEF".into(),
filename: "O4M00012ABCDEF.mgg".into(),
footer_size: 192,
version: 1,
..Default::default()
}
}
/// 接口契约的三个"必须"——写错了不会报错,只会静默拿不到 ekey
#[test]
fn request_body_satisfies_api_contract() {
let req = EvkeyRequest::from_tail(&tail(), "1154027699", "TOKEN").unwrap();
let body = req.body();
assert_eq!(body["req_1"]["module"], "music.vkey.GetEVkey");
assert_eq!(body["req_1"]["method"], "CgiGetEVkey");
let param = &body["req_1"]["param"];
// songtype 必须为 1(加密资源)
assert_eq!(param["songtype"][0], 1);
// filename 必须带扩展名
assert_eq!(param["filename"][0], "O4M00012ABCDEF.mgg");
assert!(param["filename"][0].as_str().unwrap().contains('.'));
// songmid 来自 media_mid
assert_eq!(param["songmid"][0], "0012ABCDEF");
// platform = 27(Windows)
assert_eq!(param["platform"], "27");
// comm 里要带 authst / uin
assert_eq!(body["comm"]["authst"], "TOKEN");
assert_eq!(body["comm"]["uin"], "1154027699");
}
#[test]
fn from_tail_rejects_incomplete_tail() {
let mut t = tail();
t.media_mid.clear();
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
let mut t = tail();
t.filename.clear();
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
// 没有扩展名的文件名会被服务器拒绝,提前拦下
let mut t = tail();
t.filename = "O4M00012ABCDEF".into();
let err = EvkeyRequest::from_tail(&t, "1", "T").unwrap_err();
assert!(err.to_string().contains("扩展名"));
}
#[test]
fn parses_successful_response() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "REAL_EKEY", "result": 0, "subcode": 0 }],
"expiration": 80400
}}
}"#;
assert_eq!(extract_ekey(body).unwrap(), "REAL_EKEY");
}
/// 104005:要么需要 VIP,要么 filename 没带扩展名——文案必须点出这两条
#[test]
fn error_104005_is_actionable() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "", "result": 104005, "subcode": 0 }]
}}
}"#;
let err = extract_ekey(body).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("104005"), "应带错误码:{msg}");
assert!(msg.contains("VIP"), "应提示 VIP:{msg}");
assert!(msg.contains("扩展名"), "应提示文件名要求:{msg}");
}
/// result=0 但 ekey 为空 → 登录态过期
#[test]
fn empty_ekey_with_result_zero_suggests_relogin() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "", "result": 0, "subcode": 0 }]
}}
}"#;
let msg = extract_ekey(body).unwrap_err().to_string();
assert!(msg.contains("重新登录"), "应提示重新登录:{msg}");
}
#[test]
fn missing_sections_are_reported() {
assert!(extract_ekey(r#"{"code":0}"#).is_err());
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0}}"#).is_err());
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0,"data":{"midurlinfo":[]}}}"#).is_err());
}
#[test]
fn malformed_json_is_reported() {
let err = extract_ekey("not json").unwrap_err();
assert!(err.to_string().contains("解析"));
}
}
+231
View File
@@ -0,0 +1,231 @@
//! QQ音乐 **musicex** 尾部解析(QQ 客户端 ≥ 19.57 / Windows 22.x)。
//!
//! 新版客户端不再把 ekey 写进文件,只在末尾留 192 字节元数据,ekey 必须联网取。
//! 这个模块只做**纯解析**(无 IO、无网络),因此可以完整单测。
//!
//! ## 尾部布局(对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的格式文档)
//!
//! ```text
//! +0x00 [4B] song_id uint32 LE
//! +0x04 [4B] quality_type1 uint32 LE
//! +0x08 [4B] quality_type2 uint32 LE
//! +0x0C [60B] media_mid UTF-16LE(可能以 NUL 结尾)
//! +0x48 [68B] filename UTF-16LE(含扩展名,如 O4M0xxxx.mgg)
//! +0x8C [48B] padding
//! +0xC0 [4B] footer_size uint32 LE(= 0xC0 = 192)
//! +0xC4 [4B] version uint32 LE(= 1)
//! +0xC8 [8B] magic "musicex\0"
//! ```
//!
//! 因此**音频段 = 文件大小 − footer_size**,且 footer 一定在文件末尾。
/// musicex 尾部魔术(含结尾 NUL)
pub const MUSICEX_MAGIC: &[u8; 8] = b"musicex\0";
/// 尾部固定长度(也是 footer_size 字段的期望值)
pub const MUSICEX_FOOTER_LEN: usize = 0xC0;
/// 解析出的 musicex 元数据
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct MusiCexTail {
pub song_id: u32,
pub quality_type1: u32,
pub quality_type2: u32,
/// 歌曲 mid(取 ekey 需要)
pub media_mid: String,
/// 资源文件名(**必须含扩展名**,否则 API 返回 104005)
pub filename: String,
/// 尾部声明的长度(正常为 192)
pub footer_size: u32,
pub version: u32,
}
impl MusiCexTail {
/// 音频段长度(文件总大小 − 尾部长度)
pub fn audio_len(&self, file_size: u64) -> u64 {
file_size.saturating_sub(self.footer_size as u64)
}
/// 给 UI 的一行说明
pub fn note(&self) -> String {
if self.filename.is_empty() {
format!("musicex(songId={})", self.song_id)
} else {
format!("musicex · {}", self.filename)
}
}
}
/// 判断一段**文件尾部字节**是否是 musicex 尾部。
pub fn is_musicex_tail(buf: &[u8]) -> bool {
buf.len() >= 8 && &buf[buf.len() - 8..] == MUSICEX_MAGIC
}
/// 从文件末尾字节解析 musicex 尾部。
///
/// `buf` 必须至少包含整个尾部([`MUSICEX_FOOTER_LEN`] 字节),否则返回 `None`。
pub fn parse_musicex_tail(buf: &[u8]) -> Option<MusiCexTail> {
if !is_musicex_tail(buf) {
return None;
}
let n = buf.len();
let footer_size = le_u32(buf, n - 16)?;
let version = le_u32(buf, n - 12)?;
// footer_size 是尾部总长;它必须落在缓冲区里才谈得上解析字段
let footer_size_usize = footer_size as usize;
if footer_size_usize < MUSICEX_FOOTER_LEN || footer_size_usize > n {
return None;
}
let start = n - footer_size_usize;
Some(MusiCexTail {
song_id: le_u32(buf, start)?,
quality_type1: le_u32(buf, start + 4)?,
quality_type2: le_u32(buf, start + 8)?,
media_mid: utf16le_at(buf, start + 0x0C, 60)?,
filename: utf16le_at(buf, start + 0x48, 68)?,
footer_size,
version,
})
}
fn le_u32(b: &[u8], at: usize) -> Option<u32> {
let end = at.checked_add(4)?;
let s = b.get(at..end)?;
Some(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
}
/// 读取定长 UTF-16LE 字段并去掉结尾的 NUL。
///
/// 字段是定长补齐的,未用部分为 0;也可能不补 NUL 而恰好占满,故两种都要容忍。
fn utf16le_at(buf: &[u8], at: usize, byte_len: usize) -> Option<String> {
let end = at.checked_add(byte_len)?;
let s = buf.get(at..end)?;
let mut units: Vec<u16> = s
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
while units.last() == Some(&0) {
units.pop();
}
Some(String::from_utf16_lossy(&units))
}
#[cfg(test)]
mod tests {
use super::*;
/// 构造一个合法的 musicex 尾部
fn build_tail(song_id: u32, mid: &str, filename: &str) -> Vec<u8> {
let mut tail = vec![0u8; MUSICEX_FOOTER_LEN];
tail[0..4].copy_from_slice(&song_id.to_le_bytes());
tail[4..8].copy_from_slice(&2u32.to_le_bytes());
tail[8..12].copy_from_slice(&2u32.to_le_bytes());
write_utf16(&mut tail[0x0C..0x0C + 60], mid);
write_utf16(&mut tail[0x48..0x48 + 68], filename);
let n = tail.len();
tail[n - 16..n - 12].copy_from_slice(&(MUSICEX_FOOTER_LEN as u32).to_le_bytes());
tail[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
tail[n - 8..].copy_from_slice(MUSICEX_MAGIC);
tail
}
fn write_utf16(dst: &mut [u8], s: &str) {
for (i, unit) in s.encode_utf16().enumerate() {
let at = i * 2;
if at + 2 > dst.len() {
break;
}
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
}
}
#[test]
fn parses_valid_footer() {
let tail = build_tail(0x0C27ABCD, "0012ABCDEF", "O4M00012ABCDEF.mgg");
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
assert_eq!(parsed.song_id, 0x0C27ABCD);
assert_eq!(parsed.quality_type1, 2);
assert_eq!(parsed.quality_type2, 2);
assert_eq!(parsed.media_mid, "0012ABCDEF");
assert_eq!(parsed.filename, "O4M00012ABCDEF.mgg");
assert_eq!(parsed.footer_size, 192);
assert_eq!(parsed.version, 1);
}
/// 尾部前面还有音频数据时,解析结果不受影响(按 footer_size 定位)
#[test]
fn parses_footer_with_audio_prefix() {
let tail = build_tail(7, "mid123", "F00000mid123.mflac");
let mut file = vec![0xAAu8; 5000];
file.extend_from_slice(&tail);
let parsed = parse_musicex_tail(&file).expect("应解析成功");
assert_eq!(parsed.filename, "F00000mid123.mflac");
assert_eq!(parsed.audio_len(file.len() as u64), 5000);
}
/// 字段恰好占满、没有 NUL 终止符时也要能读全
#[test]
fn parses_full_width_field_without_nul() {
let name = "A".repeat(34); // 68 字节 = 34 个 UTF-16 单元,正好占满
let tail = build_tail(1, "M", &name);
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
assert_eq!(parsed.filename, name);
}
/// 中文文件名(UTF-16LE)要能正确还原
#[test]
fn parses_cjk_filename() {
let tail = build_tail(1, "mid", "歌曲 名.mgg");
let parsed = parse_musicex_tail(&tail).unwrap();
assert_eq!(parsed.filename, "歌曲 名.mgg");
}
#[test]
fn rejects_non_musicex() {
assert!(!is_musicex_tail(b"not a magic at all"));
assert!(parse_musicex_tail(&[0u8; 192]).is_none());
// 魔术对但长度不合理
let mut bad = vec![0u8; 192];
let n = bad.len();
bad[n - 8..].copy_from_slice(MUSICEX_MAGIC);
bad[n - 16..n - 12].copy_from_slice(&0xFFFFu32.to_le_bytes());
assert!(parse_musicex_tail(&bad).is_none(), "footer_size 越界应拒绝");
}
#[test]
fn rejects_truncated_buffer() {
// 只有 16 字节,放不下 192 字节的尾部结构
let mut short = vec![0u8; 16];
let n = short.len();
short[n - 8..].copy_from_slice(MUSICEX_MAGIC);
short[n - 16..n - 12].copy_from_slice(&192u32.to_le_bytes());
assert!(parse_musicex_tail(&short).is_none());
}
#[test]
fn audio_len_saturates() {
let t = MusiCexTail {
footer_size: 192,
..Default::default()
};
assert_eq!(t.audio_len(1000), 808);
// 文件比尾部还小:不能下溢
assert_eq!(t.audio_len(10), 0);
}
#[test]
fn note_includes_filename_when_present() {
let t = MusiCexTail {
filename: "a.mgg".into(),
song_id: 5,
..Default::default()
};
assert!(t.note().contains("a.mgg"));
let empty = MusiCexTail {
song_id: 9,
..Default::default()
};
assert!(empty.note().contains("9"));
}
}
+216
View File
@@ -0,0 +1,216 @@
//! `QQMusic.exe` 进程内存扫描(**只读**)。
//!
//! Windows 版 QQ 音乐把 `authst` 只放在运行期内存里,因此联网取 ekey 必须先把它捞出来。
//! 这是纯 Win32 胶水层:真正的解析逻辑([`super::qq_credentials::find_authst`] /
//! [`super::qq_credentials::parse_ini_uin`])是跨平台纯函数,已单独单测。
//!
//! ## 实现要点(踩过的坑)
//!
//! 1. **`MEMORY_BASIC_INFORMATION` 的 `PartitionId`**:Windows 10 1803+ 在
//! `AllocationProtect` 与 `RegionSize` 之间插入了 2 字节。结构体里**必须**包含它,
//! 否则 `RegionSize`/`State`/`Protect` 全部从错误偏移读取——症状是
//! `VirtualQueryEx` 返回的 `State` 读成了 `Protect` 的值(如 `PAGE_READWRITE=0x04`
//! 而不是 `MEM_COMMIT=0x1000`),于是**所有内存区域都被跳过**、永远扫不到。
//! `windows-sys` 的定义已经包含该字段,这里直接用官方结构体。
//! 2. **只扫 `MEM_COMMIT` 且可读的区域**,并跳过 `PAGE_GUARD` / `PAGE_NOACCESS`。
//! 3. **分块读取**(1 MB),避免一次 `ReadProcessMemory` 大区域时中途失败整块丢。
//! 4. 跨块保留 `AUTHST_KEY.len() - 1` 字节的重叠,防止 token 恰好横跨块边界。
use std::ffi::c_void;
use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
use windows_sys::Win32::System::Diagnostics::Debug::ReadProcessMemory;
use windows_sys::Win32::System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, TH32CS_SNAPPROCESS,
};
use windows_sys::Win32::System::Memory::{
VirtualQueryEx, MEMORY_BASIC_INFORMATION, MEM_COMMIT, PAGE_GUARD, PAGE_NOACCESS,
};
use windows_sys::Win32::System::Threading::{
OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ,
};
use super::qq_credentials::{find_authst_from, QQ_PROCESS_HINT};
/// 单次读取的块大小
const CHUNK: usize = 1024 * 1024;
/// 跨块重叠长度(`"authst":"` 的长度 - 1,防止 token 横跨块边界)
const OVERLAP: usize = 16;
/// 扫描上限:避免异常进程占用过久(每个进程最多读这么多字节)
const MAX_SCAN_BYTES: usize = 512 * 1024 * 1024;
/// 扫描结果
#[derive(Debug, Clone, Default)]
pub struct Found {
pub authst: Option<String>,
pub uin: Option<String>,
}
/// 按进程名(大小写不敏感子串)找 PID
pub fn find_process_pid(hint: &str) -> Option<u32> {
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return None;
}
let mut entry: PROCESSENTRY32W = std::mem::zeroed();
entry.dwSize = std::mem::size_of::<PROCESSENTRY32W>() as u32;
// 提前小写化,避免在进程列表里反复分配(进程数可达数百)
let needle = hint.to_lowercase();
let mut pid: Option<u32> = None;
if Process32FirstW(snapshot, &mut entry) != 0 {
loop {
let name_len = entry
.szExeFile
.iter()
.position(|&c| c == 0)
.unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..name_len]);
if name.to_lowercase().contains(&needle) {
pid = Some(entry.th32ProcessID);
break;
}
if Process32NextW(snapshot, &mut entry) == 0 {
break;
}
}
}
CloseHandle(snapshot);
pid
}
}
/// QQ 音乐是否在运行
pub fn is_qqmusic_running() -> bool {
find_process_pid(QQ_PROCESS_HINT).is_some()
}
/// 扫描 QQ 音乐进程内存,捞出 `authst`(顺带尝试 `"uin":"..."`)。
pub fn scan_qq_process() -> Result<Found, String> {
let pid = find_process_pid(QQ_PROCESS_HINT).ok_or("未找到 QQMusic.exe 进程")?;
// windows-sys 0.52 的 HANDLE 是 isize(0 表示失败)
let handle = unsafe { OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, pid) };
if handle == 0 {
return Err("无法打开 QQMusic.exe(权限不足;请尝试以管理员身份运行本应用)".to_string());
}
let result = unsafe { scan_handle(handle) };
unsafe { CloseHandle(handle) };
result
}
unsafe fn scan_handle(handle: isize) -> Result<Found, String> {
let mut found = Found::default();
let mut address: usize = 0;
let mut buf = vec![0u8; CHUNK];
let mut scanned: usize = 0;
while address < usize::MAX {
let mut mbi: MEMORY_BASIC_INFORMATION = std::mem::zeroed();
let written = VirtualQueryEx(
handle,
address as *const c_void,
&mut mbi,
std::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
);
if written == 0 {
break;
}
let region_size = mbi.RegionSize;
let base = mbi.BaseAddress as usize;
// 只读「已提交、且不是 guard/noaccess」的区域
let readable = mbi.State == MEM_COMMIT
&& (mbi.Protect & PAGE_GUARD) == 0
&& (mbi.Protect & PAGE_NOACCESS) == 0
&& mbi.Protect != 0;
if readable && region_size > 0 {
let mut offset = 0usize;
while offset < region_size && scanned < MAX_SCAN_BYTES {
let want = CHUNK.min(region_size - offset);
// 末尾留出重叠,保证 token 不因分块被截断
let read_len = want.min(buf.len());
let mut got = 0usize;
let ok = ReadProcessMemory(
handle,
(base + offset) as *const c_void,
buf.as_mut_ptr() as *mut c_void,
read_len,
&mut got,
);
if ok != 0 && got > 0 {
scanned += got;
let slice = &buf[..got];
if found.authst.is_none() {
if let Some(t) = find_authst_from(slice, 0) {
found.authst = Some(t);
}
}
if found.uin.is_none() {
found.uin = find_json_string(slice, b"\"uin\":\"");
}
if found.authst.is_some() && found.uin.is_some() {
return Ok(found);
}
}
// 前进:整块减去重叠,避免漏掉跨块的匹配
if want <= OVERLAP {
break;
}
offset += want - OVERLAP;
}
}
// 前进到下一个区域;RegionSize 为 0 时强制前进,防止死循环
let step = if region_size == 0 {
0x1000
} else {
region_size
};
match address.checked_add(step) {
Some(next) if next > address => address = next,
_ => break,
}
}
Ok(found)
}
/// 在字节里找 `"<key>":"<value>"` 形态的字符串值(用于 uin)
unsafe fn find_json_string(haystack: &[u8], key: &[u8]) -> Option<String> {
let mut pos = 0usize;
while pos + key.len() <= haystack.len() {
let rel = haystack[pos..].windows(key.len()).position(|w| w == key)?;
let start = pos + rel + key.len();
let end = haystack[start..].iter().position(|&b| b == b'"')?;
let val = &haystack[start..start + end];
if !val.is_empty() && val.iter().all(|b| b.is_ascii_digit()) {
return Some(String::from_utf8_lossy(val).to_string());
}
pos = start;
}
None
}
#[cfg(test)]
mod tests {
use super::*;
/// 「QQ 在不在运行」必须能在本机跑通且不 panic
/// (本机装了 QQ 音乐,结果可能是 true 或 false,取决于是否启动)
#[test]
fn process_detection_does_not_panic() {
let running = is_qqmusic_running();
// 只要求"不 panic 且能给出结论";不假设本机是否开着 QQ 音乐
eprintln!("QQMusic running = {running}");
}
/// 不存在的进程名必须返回 None,而不是卡住或 panic
#[test]
fn unknown_process_returns_none() {
assert!(find_process_pid("definitely-not-a-real-process-xyzzy").is_none());
}
}
+361
View File
@@ -0,0 +1,361 @@
//! QQ音乐解密的**编排层**:把「尾部形态 → 密钥来源 → 流密码」串起来。
//!
//! 密钥来源按 `MUSIC_DECRYPT_PLAN.md` §3.2 分层:
//!
//! | 尾部 | 密钥来源 | 需要联网 |
//! |---|---|---|
//! | QMC1 | 内置静态表 | 否 |
//! | QTag / V1 | 尾部内嵌 ekey | 否 |
//! | musicex | **本机已登录凭据 → `GetEVkey`** | 是 |
//!
//! 之所以单开一个模块而不是塞进 `qmc.rs`:联网那一路牵涉 HTTP 客户端、
//! 凭据与工作线程里的运行时,与纯算法拆开后 `qmc.rs` 可以保持零 IO 依赖。
use std::path::Path;
use super::common::{self, DecryptError};
use super::qmc;
use super::qq_credentials;
use super::qq_ekey::{self, EvkeyRequest};
use super::qq_footer::{self, MusiCexTail};
/// 在线能力状态(给 UI 状态卡用)
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct QqOnlineStatus {
/// QQMusic.exe 是否在运行
pub running: bool,
/// 是否取到了 authst(= 已登录且能读到内存)
pub logged_in: bool,
/// 本机读到的 QQ 号(仅用于展示;没有则为 None)
pub uin: Option<String>,
/// 是否具备在线取 ekey 的能力
pub ready: bool,
/// 给用户的一句话状态
pub message: String,
/// 需要用户照做的步骤(ready 时为一条"无需额外设置")
pub steps: Vec<String>,
}
/// 探测在线能力(**只读**:读 INI + 扫进程内存,不发网络请求)
pub fn probe_status() -> QqOnlineStatus {
let running = qq_memscan_running();
let creds = qq_credentials::read_credentials();
let ready = creds.usable();
let message = if ready {
"已就绪:可直接解密 QQ 音乐新版 musicex 文件".to_string()
} else if !running {
"QQ 音乐未运行——新版 musicex 文件的密钥只在登录后存在于内存中".to_string()
} else if creds.uin.is_none() {
"QQ 音乐在运行,但没读到本机账号(可能尚未登录)".to_string()
} else {
"QQ 音乐在运行,但未取到登录令牌(authst),请确认已登录".to_string()
};
let steps = if ready {
vec!["无需额外设置;QMC1 与尾部内嵌 ekey 的文件本来就不需要登录。".to_string()]
} else {
vec![
"1. 在电脑上启动 QQ 音乐客户端(Windows 版)。".to_string(),
"2. 用它登录你的账号(扫码或账号密码均可),并保持客户端开着。".to_string(),
"3. 回到本页点「重新检测」;状态变为「已就绪」后即可解密 musicex 文件。".to_string(),
"4. 若显示未取到登录令牌:先播放任意一首歌触发一次网络请求,再重新检测。".to_string(),
"5. 若仍失败,试过以管理员身份运行本应用(读取进程内存可能受权限限制)。".to_string(),
"6. 登录令牌约 22.3 小时过期;过期后重新检测即可。".to_string(),
]
};
QqOnlineStatus {
running,
logged_in: creds.authst.is_some(),
uin: creds.uin.clone(),
ready,
message,
steps,
}
}
fn qq_memscan_running() -> bool {
#[cfg(windows)]
{
super::qq_memscan::is_qqmusic_running()
}
#[cfg(not(windows))]
{
false
}
}
/// musicex 的联网取密钥 + 解密。
///
/// `client` 用于发请求;调用方负责给它一个带超时的实例。整个流程会在
/// 当前线程上建一个最小 tokio 运行时来 `block_on`——调度层本来就是
/// 独立工作线程,不占 tokio 的工作线程。
pub fn decrypt_musicex<F>(
input: &Path,
out_dir: &Path,
platform_label: &str,
mut progress: F,
) -> Result<common::Outcome, DecryptError>
where
F: FnMut(u64, u64),
{
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
}
// 1) 解析尾部
let tail = read_musicex_tail(input)?;
let audio_len = tail.audio_len(total);
// 2) 取凭据
let creds = qq_credentials::read_credentials();
let (uin, authst) = match (creds.uin.as_deref(), creds.authst.as_deref()) {
(Some(u), Some(a)) => (u, a),
_ => {
return Err(DecryptError::KeyRequired(format!(
"{}。请在电脑上启动并登录 QQ 音乐客户端后重试,或在「解密」页点「重新检测」查看当前状态。",
creds.status_text()
)))
}
};
// 3) 请求 ekey
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(25))
.build()
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
let (ekey, expiration) = block_on(fetch_ekey_async(&client, &req))?;
// 4) ekey → 原始密钥
let raw = qmc::parse_ekey(&ekey)?;
if raw.len() < 16 || raw.len() > 4096 {
return Err(DecryptError::KeyRequired(format!(
"服务器返回的密钥长度异常({} 字节),已放弃以免解出噪声",
raw.len()
)));
}
// 5) 解密音频段
let audio = read_audio_segment(input, audio_len)?;
// 用**解密结果**判定密钥是否正确,而不是猜密文头。
//
// 曾经的写法是"密文必须以 `#!Qk` 开头,否则拒绝"——**这个假设是错的**:
// 真机样本(Avicii - Heaven,musicex)的密文头是 `51 74 03 75`,
// 按那条守卫会把完全合法的文件误拒。QMC2 密文头没有稳定魔术,
// 而"用取到的密钥解出的前 16 字节是不是已知音频魔术"才可靠:
// 密钥错时它是随机噪声,几乎不可能凑成 `fLaC` / `OggS` / `ID3` / `ftyp`。
let mut plaintext = audio;
qmc::decrypt_with_raw_key(&raw, &mut plaintext);
let Some(format) = super::common::detect_format_opt(&plaintext) else {
return Err(DecryptError::KeyRequired(format!(
"取到的密钥没能解出可识别的音频头(前 16 字节 {:02x?})——可能是该资源的 ekey \
与文件不匹配,或登录态已过期;请重新检测后重试",
&plaintext[..16.min(plaintext.len())]
)));
};
let decrypted = plaintext;
let stem = input
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "output".to_string());
std::fs::create_dir_all(out_dir)?;
let mut reserved = std::collections::HashSet::new();
let target = super::common::unique_output(out_dir, &stem, format, &mut reserved)?;
std::fs::write(&target, &decrypted)?;
progress(decrypted.len() as u64, decrypted.len() as u64);
Ok(common::Outcome {
output: target,
format: format.to_string(),
cover: None,
audio_bytes: decrypted.len() as u64,
note: format!(
"{platform_label} · {} · 在线取密钥解密(密钥有效期约 {} 小时)",
tail.note(),
// expiration 单位为秒(实测约 80400 ≈ 22.3 小时)
if expiration > 0 {
format!("{:.1}", expiration as f64 / 3600.0)
} else {
"未知".to_string()
}
),
})
}
/// 读文件末尾的 musicex 尾部
fn read_musicex_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
use std::io::{Read, Seek, SeekFrom};
let mut f = std::fs::File::open(input)?;
let size = f.metadata()?.len();
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
f.seek(SeekFrom::End(-(take as i64)))?;
let mut buf = vec![0u8; take];
f.read_exact(&mut buf)?;
// 注意:这里只读了尾部 192 字节,而 footer_size 可能 > 192(版本变化)——
// 那就退化成"按已知长度解析",字段偏移仍以文件末尾为基准。
qq_footer::parse_musicex_tail(&buf)
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败(魔术或长度字段异常)".into()))
}
/// 只读音频段(musicex 场景下文件不大,但依然按大小一次读入以便就地解密)
fn read_audio_segment(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
use std::io::Read;
let mut f = std::fs::File::open(input)?;
let mut buf = vec![0u8; audio_len as usize];
f.read_exact(&mut buf)?;
Ok(buf)
}
/// 在**当前线程**上跑一个最小 tokio 运行时。
///
/// 调度层用独立 `std::thread` 干活,所以这里 `block_on` 是安全的
/// (不会在 tokio 的 worker 线程里嵌套)。
fn block_on<F: std::future::Future>(fut: F) -> F::Output {
match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(rt) => rt.block_on(fut),
Err(_) => {
// 极端情况下退化为全局运行时(项目里已有 rt-multi-thread)
tauri::async_runtime::block_on(fut)
}
}
}
async fn fetch_ekey_async(
client: &reqwest::Client,
req: &EvkeyRequest,
) -> Result<(String, i64), DecryptError> {
qq_ekey::fetch_ekey(client, req).await
}
#[cfg(test)]
mod tests {
use super::*;
/// 状态探测必须能跑通且文案自洽(不假设本机 QQ 是否开着)
#[test]
fn probe_status_is_self_consistent() {
let s = probe_status();
assert_eq!(s.ready, s.running && s.logged_in);
assert!(!s.message.is_empty());
assert!(!s.steps.is_empty());
if s.ready {
assert!(s.steps.len() == 1, "就绪时只应给一条说明");
} else {
assert!(s.steps.len() >= 3, "未就绪时步骤要能照做");
}
}
/// 把本机真实探测结果打出来,便于人工核对「在线能力」是否按预期工作。
/// 不加断言(依赖本机是否开着 QQ 音乐),只在 `--nocapture` 时可见。
#[test]
fn probe_status_reports_machine_state() {
let s = probe_status();
eprintln!(
"[qq-online] running={} logged_in={} uin={:?} ready={}\n message: {}\n steps: {}",
s.running,
s.logged_in,
s.uin,
s.ready,
s.message,
s.steps.len()
);
}
/// musicex 文件必须被**离线路径**判为「需要密钥」,并且在有凭据时被识别为
/// 「该走在线路径」。
///
/// 刻意**不**真的发网络请求:单元测试不该依赖 QQ 服务器可达性与账号状态,
/// 否则本机登录后测试就会变慢、变脆。
#[test]
fn musicex_routes_to_online_path() {
let dir = std::env::temp_dir().join(format!("qq_online_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 造一个 musicex 文件:尾部合法(含 media_mid / filename)。
// 音频段的内容无所谓——这条只验证"路由与入参构造",不发网络请求。
let mut file = vec![0u8; 4096];
let n = file.len();
let tail_start = n - qq_footer::MUSICEX_FOOTER_LEN;
write_utf16(
&mut file[tail_start + 0x0C..tail_start + 0x0C + 60],
"0012ABCDEF",
);
write_utf16(
&mut file[tail_start + 0x48..tail_start + 0x48 + 68],
"O4M00012ABCDEF.mgg",
);
file[n - 16..n - 12].copy_from_slice(&(qq_footer::MUSICEX_FOOTER_LEN as u32).to_le_bytes());
file[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
file[n - 8..].copy_from_slice(qq_footer::MUSICEX_MAGIC);
let src = dir.join("a.mgg");
std::fs::write(&src, &file).unwrap();
// 1) 尾部能被解析出取密钥所需的两个字段
let tail = read_musicex_tail(&src).expect("尾部应解析成功");
assert_eq!(tail.media_mid, "0012ABCDEF");
assert_eq!(tail.filename, "O4M00012ABCDEF.mgg");
assert_eq!(tail.audio_len(file.len() as u64), (tail_start) as u64);
// 2) 离线路径必须明确报「需要密钥」,而不是解出噪声
let offline = super::super::qmc::sniff_tail(&src).unwrap();
assert_eq!(offline.kind, super::super::qmc::TailKind::MusiCex);
// 3) 请求能从尾部正确构造(这正是联网那一步的入参)
let req = EvkeyRequest::from_tail(&tail, "1154027699", "TOKEN").unwrap();
assert_eq!(req.media_mid, "0012ABCDEF");
assert_eq!(req.filename, "O4M00012ABCDEF.mgg");
let _ = std::fs::remove_dir_all(&dir);
}
/// 密钥错误时不应产出"看起来成功"的垃圾:
/// 判据是**解密结果**能否识别成已知音频魔术。
///
/// 这条同时固化一个真机结论:QMC2 的**密文头没有稳定魔术**
/// (真机 musicex 样本头为 `51 74 03 75`,而 MIT/Apache 文档里提到的
/// `#!Qk` 并不适用于它),所以**不能**用密文头做守卫。
#[test]
fn wrong_key_yields_unrecognizable_header() {
// 用一段随机数据当"密文",配一个随便的密钥
let mut data = vec![0x51u8, 0x74, 0x03, 0x75];
data.extend((0..4092).map(|i| (i * 7 % 251) as u8));
let key: Vec<u8> = (0..64).map(|i| (i * 3 + 1) as u8).collect();
super::super::qmc::decrypt_with_raw_key(&key, &mut data);
// 解出来必须是"认不出",才会走到 KeyRequired 那条错误分支
assert!(
super::super::common::detect_format_opt(&data).is_none(),
"随机数据不应被识别成音频"
);
}
/// `#!Qk` 是 QMC2 的一种形态,但**不是** musicex 的头部——这里留一条记录性断言,
/// 防止后人再次把它当成通用守卫。
#[test]
fn qmc2_ciphertext_header_is_not_a_reliable_magic() {
assert_ne!(b"#!Qk", &[0x51u8, 0x74, 0x03, 0x75]);
// 真机样本的头就是后者;`detect_format_opt` 对两者都不应误判成音频
assert!(super::super::common::detect_format_opt(b"#!Qk\x00\x00\x00\x00").is_none());
}
/// 把一个定长 UTF-16LE 字段写进缓冲区(测试辅助)
fn write_utf16(dst: &mut [u8], s: &str) {
for (i, unit) in s.encode_utf16().enumerate() {
let at = i * 2;
if at + 2 > dst.len() {
break;
}
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
}
}
}
+249
View File
@@ -0,0 +1,249 @@
//! 文件夹批量:递归扫描 + 平台路由。
//!
//! 用户要的是「以文件夹为单位处理」,所以这里的判定原则是:
//!
//! 1. **内容优先于后缀**。同一个曲库里 `.ncm` / `.mflac` / `.qmcflac` / `.mgg` 混放是常态,
//! 而后者还有 `.mgg0`、`.mflac0` 这类后缀变体;靠后缀枚举会漏。
//! 因此先看头部魔数(网易云 `CTENFDAM`),再看尾部形态(QMC 家族)。
//! 2. **只扫一次、只走一层递归**。目录树遍历用 `walkdir`,过滤在遍历中完成,
//! 不把整个目录列表灌进内存(几万首的曲库会很难看)。
//! 3. 扫描结果按**路径排序**,保证同一目录每次处理的顺序稳定(进度条与任务表可预期)。
use std::path::{Path, PathBuf};
use walkdir::WalkDir;
use super::{ncm, qmc};
/// 一个待处理的文件
#[derive(Debug, Clone)]
pub struct ScannedFile {
/// 绝对路径
pub path: PathBuf,
/// 相对扫描根的父目录(用于在输出目录里还原目录结构);根目录下的文件为 None
pub rel_parent: Option<PathBuf>,
/// 文件名(含后缀),给 UI 显示
pub name: String,
/// 该用哪个引擎
pub engine: Engine,
}
/// 引擎路由结果
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Engine {
/// 网易云 ncm
Ncm,
/// QQ音乐 QMC 家族
Qmc,
}
impl Engine {
pub fn label(self) -> &'static str {
match self {
Engine::Ncm => "网易云",
Engine::Qmc => "QQ音乐",
}
}
}
/// 单文件路由:读 8 字节魔数 + 4KB 尾部即可判定,不做全文件读。
///
/// 返回 `None` 表示这个文件不是我们认得的加密音乐(目录扫描时直接跳过,
/// 用户显式选中的文件则会得到一条 `unsupported` 结果)。
pub fn route(path: &Path) -> Option<Engine> {
if ncm::sniff(path) {
return Some(Engine::Ncm);
}
// QMC:尾部能判出形态就算认得
if qmc::sniff_tail(path).is_ok() {
// 后缀也在 QMC 家族里、或尾部形态明确(非纯 QMC1 兜底)时才算
let ext = path
.extension()
.map(|e| e.to_string_lossy().to_string())
.unwrap_or_default();
if qmc::is_qmc_extension(&ext) {
return Some(Engine::Qmc);
}
// 后缀不认识时,只有明确的尾部形态(QTag/V1/musicex)才认;
// 否则任何末尾凑巧不是 QTag 的文件都会被判成"QMC1",噪声太大。
if let Ok(tail) = qmc::sniff_tail(path) {
if tail.kind != qmc::TailKind::Qmc1 {
return Some(Engine::Qmc);
}
}
}
None
}
/// 递归扫描 `folder`,返回所有可解密的加密音乐文件。
///
/// `root` 用于计算相对路径(输出时还原目录结构)。`folder == root` 时即
/// 「以这个文件夹为单位处理」。传 `root = None` 则所有文件平铺。
///
/// 排序保证稳定;`max_depth` 为 `None` 时递归全部层级。
pub fn scan(folder: &Path, root: Option<&Path>) -> Result<Vec<ScannedFile>, String> {
if !folder.is_dir() {
return Err(format!("{} 不是文件夹", folder.display()));
}
let root = root.unwrap_or(folder);
let mut out = Vec::new();
for entry in WalkDir::new(folder)
.follow_links(false)
.into_iter()
.filter_map(|e| e.ok())
{
if !entry.file_type().is_file() {
continue;
}
let path = entry.path();
let Some(engine) = route(path) else {
continue;
};
let rel_parent = path
.parent()
.and_then(|p| p.strip_prefix(root).ok())
.filter(|p| !p.as_os_str().is_empty())
.map(|p| p.to_path_buf());
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| path.display().to_string());
out.push(ScannedFile {
path: path.to_path_buf(),
rel_parent,
name,
engine,
});
}
// 稳定排序:按相对目录 + 文件名,处理顺序可预期
out.sort_by(|a, b| {
a.rel_parent
.cmp(&b.rel_parent)
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
});
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
fn tmpdir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("dec_scan_{tag}_{}", std::process::id()));
let _ = fs::remove_dir_all(&d);
fs::create_dir_all(&d).unwrap();
d
}
/// 构造一个最小合法 ncm 头(只需魔数即可被 route 认出来)
fn fake_ncm() -> Vec<u8> {
let mut v = b"CTENFDAM".to_vec();
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
v
}
#[test]
fn route_detects_ncm_by_magic_not_extension() {
let dir = tmpdir("route");
// 后缀故意起错,内容是对的 → 应按内容识别
let p = dir.join("mystery.bin");
fs::write(&p, fake_ncm()).unwrap();
assert_eq!(route(&p), Some(Engine::Ncm));
// 后缀像 ncm 但内容不对 → 不应识别(尾部判成 QMC1 但后缀不在家族里)
let q = dir.join("wrong.ncm");
fs::write(&q, vec![0x11u8; 1024]).unwrap();
assert_eq!(route(&q), None);
let _ = fs::remove_dir_all(&dir);
}
/// QMC1 靠后缀识别(尾部形态是兜底,不做主判据)
#[test]
fn route_detects_qmc_by_extension() {
let dir = tmpdir("qmc");
let p = dir.join("a.qmcflac");
fs::write(&p, vec![0x22u8; 4096]).unwrap();
assert_eq!(route(&p), Some(Engine::Qmc));
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_is_recursive_and_preserves_relative_dirs() {
let dir = tmpdir("scan");
fs::create_dir_all(dir.join("Pop").join("2026")).unwrap();
fs::create_dir_all(dir.join("Rock")).unwrap();
fs::write(dir.join("root.ncm"), fake_ncm()).unwrap();
fs::write(dir.join("Pop").join("a.qmcflac"), vec![0x22u8; 512]).unwrap();
fs::write(dir.join("Pop").join("2026").join("b.ncm"), fake_ncm()).unwrap();
fs::write(dir.join("Rock").join("c.txt"), b"not audio").unwrap();
let files = scan(&dir, Some(&dir)).unwrap();
assert_eq!(files.len(), 3, "应找到 3 个加密文件(txt 被跳过)");
// 排序稳定:先根目录,再 Pop,再 Pop/2026
assert_eq!(files[0].name, "root.ncm");
assert!(
files[0].rel_parent.is_none(),
"根目录文件 rel_parent 应为 None"
);
let a = files.iter().find(|f| f.name == "a.qmcflac").unwrap();
assert_eq!(a.rel_parent.as_deref(), Some(Path::new("Pop")));
assert_eq!(a.engine, Engine::Qmc);
let b = files.iter().find(|f| f.name == "b.ncm").unwrap();
assert_eq!(
b.rel_parent.as_deref(),
Some(Path::new("Pop").join("2026").as_path())
);
assert_eq!(b.engine, Engine::Ncm);
let _ = fs::remove_dir_all(&dir);
}
/// 以子目录为根时,相对路径相对**子目录**而不是父目录
#[test]
fn scan_uses_given_root_for_relative_paths() {
let dir = tmpdir("root");
let sub = dir.join("Album");
fs::create_dir_all(sub.join("Disc1")).unwrap();
fs::write(sub.join("Disc1").join("x.qmc0"), vec![0x33u8; 512]).unwrap();
// 以子目录为 root:Disc1 在 root 内 → rel_parent = Disc1
let files = scan(&sub, Some(&sub)).unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].rel_parent.as_deref(), Some(Path::new("Disc1")));
// 以上级为 root:rel_parent = Album/Disc1
let files2 = scan(&sub, Some(&dir)).unwrap();
assert_eq!(
files2[0].rel_parent.as_deref(),
Some(Path::new("Album").join("Disc1").as_path())
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_rejects_non_directory() {
let dir = tmpdir("notdir");
let f = dir.join("a.txt");
fs::write(&f, b"x").unwrap();
assert!(scan(&f, None).is_err());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_on_empty_dir_returns_empty() {
let dir = tmpdir("empty");
let files = scan(&dir, None).unwrap();
assert!(files.is_empty());
let _ = fs::remove_dir_all(&dir);
}
}
+69 -2
View File
@@ -14,17 +14,38 @@
//! - [`runtime`]:Python 运行时探测与便携版安装
//! - [`bridge`]:桥接进程生命周期(spawn / JSON 协议 / ping / 停止)
//! - [`commands`]:Tauri 命令层
//! - [`smtc`]:Windows 系统媒体传输控件(原生,取代前端 navigator.mediaSession 元数据)
mod audio;
mod bridge;
mod commands;
pub mod decrypt;
mod feiniu;
mod remote;
mod runtime;
mod secrets;
mod smtc;
pub use audio::{
music_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume,
music_audio_state, music_audio_stop, AudioEngine,
};
pub use feiniu::{
extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection,
};
pub use remote::{
init_on_launch, remote_cancel_pairing, remote_get_config, remote_list_devices,
remote_publish_queue, remote_revoke_device, remote_set_enabled, remote_start_pairing,
remote_status, RemoteManager,
};
pub use smtc::{
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position, SmtcController,
};
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,
@@ -38,6 +59,10 @@ pub use commands::{
webdav_save_secret, webdav_test, webdav_upload,
};
pub use decrypt::commands::{
music_decrypt_cancel, music_decrypt_qq_status, music_decrypt_run, music_decrypt_scan,
};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::HashMap;
@@ -113,6 +138,23 @@ pub struct MusicInstallProgress {
pub message: String,
}
/// 前端最近一次推给 SMTC 的曲目信息(`music_smtc_update_metadata` 回填)。
///
/// 用途:**手机遥控的兜底聚合**——GSMTC 不可用时,`AudioEngine.state()` 只有
/// 位置/播放态没有标题/歌手(队列元数据在前端 feiniuStore),故以本缓存补全
/// (MUSIC_REMOTE_PLAN §5.2)。
#[derive(Default)]
pub struct SmtcMetaCache(pub Mutex<SmtcMetaSnapshot>);
/// [`SmtcMetaCache`] 的内容(字段与 `music_smtc_update_metadata` 命令对齐)。
/// cover_url 暂不存:兜底聚合的封面策略是 None(GSMTC 主路径自带缩略图,§5.2)。
#[derive(Default, Clone)]
pub struct SmtcMetaSnapshot {
pub title: String,
pub artist: String,
pub album: String,
}
/// 音乐模块设置(settings.json 持久化;变更即时生效)
#[derive(Serialize, Deserialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
@@ -178,6 +220,18 @@ pub struct MusicSettings {
/// 下载完成后自动上传到飞牛曲库
#[serde(default)]
pub feiniu_auto_upload: bool,
/// 手机互联:总开关(变更即时生效,MUSIC_REMOTE_PLAN §5.1)
#[serde(default)]
pub remote_enabled: bool,
/// 手机互联:期望端口(0 = 默认 26124 起自动探测至 26139)
#[serde(default)]
pub remote_port: u16,
/// 本机标识(beacon / NowPlaying.deviceId 同源;首次启动自动生成)
#[serde(default)]
pub remote_device_id: String,
/// 已配对设备表(仅元数据;token 在系统凭据管理器 `music-remote-token-*`)
#[serde(default)]
pub remote_devices: Vec<remote::RemoteDeviceMeta>,
}
impl MusicSettings {
@@ -298,6 +352,9 @@ pub struct MusicManager {
feiniu: Feiniu,
/// AppHandle(桥接 reader 线程据此将事件转发给前端;setup 时设置)
app: Mutex<Option<AppHandle>>,
/// 本地解密任务表(「解密」页签)。放这里而不是单独 `manage`,
/// 是为了让解密命令与其余音乐命令一样只取 `State<'_, MusicManager>`。
decrypt: Arc<decrypt::DecryptTasks>,
}
impl MusicManager {
@@ -324,9 +381,15 @@ impl MusicManager {
settings_cache: Mutex::new(None),
feiniu,
app: Mutex::new(None),
decrypt: Arc::new(decrypt::DecryptTasks::new()),
}
}
/// 解密任务表(供 `music/decrypt/commands.rs` 取用)
pub(crate) fn decrypt_tasks(&self) -> Arc<decrypt::DecryptTasks> {
self.decrypt.clone()
}
/// 设置 AppHandle(setup 阶段调用;桥接 reader 线程据此转发事件到前端)
pub fn set_app(&self, app: AppHandle) {
if let Ok(mut guard) = self.app.lock() {
@@ -372,6 +435,10 @@ impl MusicManager {
feiniu_play_mode: "stream".to_string(),
feiniu_library_nas_path: String::new(),
feiniu_auto_upload: false,
remote_enabled: false,
remote_port: 0,
remote_device_id: String::new(),
remote_devices: Vec::new(),
}
}
@@ -456,7 +523,7 @@ impl MusicManager {
/// 解析桥接要用的 Python 运行时。
/// 便携版优先:musicdl 只装入便携运行时,系统 Python 无法保证装有 musicdl;
/// 无便携版时退回系统 Python(此时 search 会报 musicdl 未安装,引导用户装便携版)。
pub fn resolve_python(&self) -> Result<PythonEnv, String> {
pub(crate) fn resolve_python(&self) -> Result<PythonEnv, String> {
if let Some(env) = self.detect_bundled_python() {
return Ok(env);
}
@@ -467,7 +534,7 @@ impl MusicManager {
}
/// 便携 Python 是否可用(exe 存在且能跑 --version)
pub fn detect_bundled_python(&self) -> Option<PythonEnv> {
pub(crate) fn detect_bundled_python(&self) -> Option<PythonEnv> {
detect_bundled_python_at(&self.bundled_python_exe())
}
+181
View File
@@ -0,0 +1,181 @@
//! 设备发现:UDP beacon(MUSIC_REMOTE_PLAN §3.3,P0 主路径)。
//!
//! 电脑每 3s 向 `255.255.255.255:26123` **与各网卡的定向广播地址**发 JSON 包;
//! 手机被动监听 26123 收集。beacon 不含任何敏感信息(无 token、无配对码)。
//!
//! 各网卡定向广播是必须的:本机常驻 VPN/虚拟网卡(mihomo 等),默认路由可能
//! 不在 LAN 网卡上,仅发 255.255.255.255 会从默认路由出去、手机收不到(§8 风险行
//! "多网卡/VPN 虚拟网卡"的对策)。地址枚举走 `GetAdaptersAddresses`。
use std::net::{Ipv4Addr, UdpSocket};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread::JoinHandle;
use std::time::Duration;
/// 手机监听的 beacon 端口(与 LFMusic `bind :26123` 对齐)。
pub const BEACON_PORT: u16 = 26123;
/// beacon 广播周期(与对端文档 §5.1"每 3s 广播"对齐)。
const BEACON_INTERVAL: Duration = Duration::from_secs(3);
/// beacon 负载(§3.3)。`addrs` 供手机在多地址场景按连通性优选(§8 对策)。
#[derive(Clone, serde::Serialize)]
pub struct BeaconPayload {
pub service: &'static str,
#[serde(rename = "deviceId")]
pub device_id: String,
pub name: String,
pub port: u16,
#[serde(rename = "protoVer")]
pub proto_ver: u32,
/// 本机各网卡 IPv4(去重、去回环、去 169.254 链路本地)
pub addrs: Vec<String>,
}
/// 枚举本机可用的 IPv4 与对应定向广播地址(网段广播,prefix<32 才有)。
///
/// 失败时返回空(beacon 退化为只发 255.255.255.255,不阻断启动)。
#[cfg(windows)]
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
use windows::Win32::NetworkManagement::IpHelper::{
GAA_FLAG_INCLUDE_PREFIX, GAA_FLAG_SKIP_ANYCAST, GAA_FLAG_SKIP_DNS_SERVER,
GAA_FLAG_SKIP_MULTICAST, GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH,
IP_ADAPTER_UNICAST_ADDRESS_LH,
};
use windows::Win32::Networking::WinSock::{AF_INET, SOCKADDR_IN};
let mut out: Vec<(Ipv4Addr, Ipv4Addr)> = Vec::new();
unsafe {
let mut size: u32 = 0;
let flags = GAA_FLAG_INCLUDE_PREFIX
| GAA_FLAG_SKIP_ANYCAST
| GAA_FLAG_SKIP_MULTICAST
| GAA_FLAG_SKIP_DNS_SERVER;
// 第一次调用只探长度(返回 ERROR_BUFFER_OVERFLOW = 111)
let _ = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, None, &mut size);
if size == 0 {
return out;
}
let mut buf = vec![0u8; size as usize];
let ptr = buf.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH;
let ret = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, Some(ptr), &mut size);
if ret != 0 {
crate::logger::log_warn(
"music-remote",
&format!("GetAdaptersAddresses 失败: {ret}(beacon 退化为受限广播)"),
);
return out;
}
let mut adapter = (*ptr).FirstUnicastAddress;
while !adapter.is_null() {
let ua: *mut IP_ADAPTER_UNICAST_ADDRESS_LH = adapter;
let sa = (*ua).Address;
let sockaddr = sa.lpSockaddr as *const SOCKADDR_IN;
if !sockaddr.is_null() {
let raw = u32::from_be((*sockaddr).sin_addr.S_un.S_addr);
let ip = Ipv4Addr::from(raw);
// 跳过回环与链路本地(APIPA)
if !ip.is_loopback() && !ip.is_link_local() {
let prefix = (*ua).OnLinkPrefixLength.min(32);
if prefix == 0 {
out.push((ip, Ipv4Addr::BROADCAST));
} else {
let mask = u32::MAX << (32 - prefix);
let bcast = Ipv4Addr::from(raw | !mask);
if bcast != ip && !bcast.is_loopback() {
out.push((ip, bcast));
} else {
out.push((ip, Ipv4Addr::BROADCAST));
}
}
}
}
adapter = (*ua).Next;
}
}
// 去重(多网卡同地址 / 多地址同广播)
let mut seen = std::collections::HashSet::new();
out.retain(|p| seen.insert(*p));
out
}
#[cfg(not(windows))]
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
Vec::new()
}
/// 取一个适合放进二维码 payload 的本机 LAN IP(首个非链路本地 IPv4)。
pub fn primary_ipv4() -> Option<Ipv4Addr> {
ipv4_broadcast_pairs()
.into_iter()
.map(|(ip, _)| ip)
.find(|ip| !ip.is_loopback() && !ip.is_link_local())
}
/// 启动 beacon 广播线程;`shutdown` 置 true 后最迟一个周期内退出。
pub fn spawn_beacon(payload: BeaconPayload, shutdown: Arc<AtomicBool>) -> JoinHandle<()> {
std::thread::Builder::new()
.name("remote-beacon".to_string())
.spawn(move || {
let sock = match UdpSocket::bind("0.0.0.0:0") {
Ok(s) => s,
Err(e) => {
crate::logger::log_error(
"music-remote",
&format!("beacon 套接字绑定失败: {e}"),
);
return;
}
};
let _ = sock.set_broadcast(true);
let json = serde_json::to_string(&payload).unwrap_or_default();
let bytes = json.as_bytes();
crate::logger::log_info(
"music-remote",
&format!(
"beacon 已启动 → :{BEACON_PORT},addrs={:?},payload={json}",
payload.addrs
),
);
while !shutdown.load(Ordering::Relaxed) {
// 受限广播(默认路由 NIC)
let _ = sock.send_to(bytes, ("255.255.255.255", BEACON_PORT));
// 各网卡定向广播(VPN/多网卡场景的保底路径)
for (_, bcast) in ipv4_broadcast_pairs() {
let _ = sock.send_to(bytes, (bcast, BEACON_PORT));
}
for _ in 0..(BEACON_INTERVAL.as_millis() / 100).max(1) {
if shutdown.load(Ordering::Relaxed) {
break;
}
std::thread::sleep(Duration::from_millis(100));
}
}
crate::logger::log_info("music-remote", "beacon 已停止");
})
.expect("创建 beacon 线程失败")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn payload_shape_matches_phone_expectation() {
let p = BeaconPayload {
service: "thing-music",
device_id: "d1".into(),
name: "Thing".into(),
port: 26124,
proto_ver: 1,
addrs: vec!["192.168.1.5".into()],
};
let json = serde_json::to_string(&p).unwrap();
// 手机端按 service 过滤、按 deviceId 去重(LFMusic §5.1)
assert!(json.contains("\"service\":\"thing-music\""));
assert!(json.contains("\"deviceId\":\"d1\""));
assert!(json.contains("\"protoVer\":1"));
assert!(json.contains("\"port\":26124"));
}
}
+828
View File
@@ -0,0 +1,828 @@
//! GSMTC 全局会话监视与控制(MUSIC_REMOTE_PLAN §3.1 / §5.1 `glsmtc.rs`)。
//!
//! # 线程模型(§3.1,实测修订版)
//!
//! - 监视跑在**专用线程**(`remote-gsmtc`):该线程首次 WinRT 调用即按 MTA 初始化,
//! `RequestAsync().get()` 等阻塞等待全部发生在本线程——既满足"`.get()` 不在主线程"
//! 的 STA 死锁约束,也不需要像 `smtc.rs` 那样把发起抛回主线程(GSMTC 不绑窗口,
//! 无 HWND 交互)。事件订阅也在本线程完成;回调从线程池触发,对象 agile,直接读写。
//! - 控制(`Try*Async.get`)由 server 在 `spawn_blocking` 里调 [`control`]。
//!
//! # 节流(§6.3)
//!
//! 事件风暴合并后**最快 1Hz** 发布 `state`;进度靠手机本地推算。例外:`Force`
//! (cmd 触发)立即发布一帧,绕过节流。语义变化(歌/状态/会话)不等节流窗口。
//!
//! # 失败策略(§3.1)
//!
//! GSMTC 任何失败只记日志;初始化失败 → `gsmtc_ok=false`,聚合切换到
//! AudioEngine + SmtcMetaCache 兜底(§5.2)。
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tauri::{AppHandle, Manager};
use tokio::sync::watch;
use windows::Foundation::TypedEventHandler;
use windows::Media::Control::{
CurrentSessionChangedEventArgs, GlobalSystemMediaTransportControlsSession as GsSession,
GlobalSystemMediaTransportControlsSessionManager as GsManager,
GlobalSystemMediaTransportControlsSessionMediaProperties as GsMediaProperties,
GlobalSystemMediaTransportControlsSessionPlaybackStatus as GsStatus,
MediaPropertiesChangedEventArgs, PlaybackInfoChangedEventArgs, SessionsChangedEventArgs,
TimelinePropertiesChangedEventArgs,
};
use super::proto::{
self, CanControl, CmdAction, CmdArgs, NowPlaying, PlayStatus, THING_SELF_SESSION,
};
use super::volume;
use super::CoverStore;
use crate::music::{AudioEngine, MusicManager, SmtcMetaCache};
/// 100 纳秒 ticks/秒。
const TICKS_PER_SEC: i64 = 10_000_000;
/// 位置跳变阈值(秒):超过它就补发一帧。与手机端 `rebaseProgress` 的
/// 1.5s 判定一致——发出来的跳变一定能被手机端识别为「来源已更新」。
const POSITION_JUMP_SEC: f64 = 1.5;
/// 封面读取上限(防异常大图)。
const MAX_COVER_BYTES: u32 = 10 * 1024 * 1024;
/// 监视线程消息。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MonitorMsg {
/// 事件到达(合并处理)
Change,
/// cmd 后立即发布(绕过 1Hz 节流,§6.3 例外)
Force,
/// 退出
Stop,
}
/// GSMTC 监视器句柄(RemoteManager 持有)。
pub struct GsmtcMonitor {
tx: Sender<MonitorMsg>,
handle: Mutex<Option<std::thread::JoinHandle<()>>>,
}
impl GsmtcMonitor {
#[allow(clippy::too_many_arguments)]
pub fn start(
app: AppHandle,
state_tx: Arc<watch::Sender<NowPlaying>>,
covers: Arc<CoverStore>,
gsmtc_ok: Arc<AtomicBool>,
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
selected: Arc<Mutex<Option<String>>>,
) -> Self {
let (tx, rx) = mpsc::channel::<MonitorMsg>();
let thread_tx = tx.clone();
let handle = std::thread::Builder::new()
.name("remote-gsmtc".to_string())
.spawn(move || {
run(
app, state_tx, covers, gsmtc_ok, sessions_tx, selected, thread_tx, rx,
)
})
.expect("创建 gsmtc 监视线程失败");
Self {
tx,
handle: Mutex::new(Some(handle)),
}
}
pub fn send(&self, msg: MonitorMsg) {
let _ = self.tx.send(msg);
}
pub fn notify_force(&self) {
self.send(MonitorMsg::Force);
}
/// 停止并等待线程退出(先 Stop 唤醒,join 最迟在下一次 500ms 节拍内完成)。
pub fn stop(&self) {
self.send(MonitorMsg::Stop);
let handle = self
.handle
.lock()
.unwrap_or_else(|e| e.into_inner())
.take();
if let Some(h) = handle {
let _ = h.join();
}
}
}
impl Drop for GsmtcMonitor {
fn drop(&mut self) {
self.send(MonitorMsg::Stop);
}
}
// ---------------------------------------------------------------------------
// 聚合(监视线程)
// ---------------------------------------------------------------------------
/// 语义指纹:不含 position/updatedAt(它们每秒都变,单独走进度窗口)。
fn fingerprint(np: &NowPlaying) -> String {
// 引用 + 元组整体 Debug:避开逐字段 format 的 Display/Debug 混用与 move 错误
format!(
"{:?}",
(
&np.session_id,
&np.source_app,
np.is_thing,
&np.title,
&np.artist,
&np.album,
&np.cover_hash,
np.status,
np.duration_sec,
&np.can_control,
np.volume,
np.muted,
)
)
}
fn run(
app: AppHandle,
state_tx: Arc<watch::Sender<NowPlaying>>,
covers: Arc<CoverStore>,
gsmtc_ok: Arc<AtomicBool>,
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
selected: Arc<Mutex<Option<String>>>,
tx: Sender<MonitorMsg>,
rx: Receiver<MonitorMsg>,
) {
// 首次 WinRT 调用在此线程自动按 MTA 初始化(见模块注释)
// RequestAsync() → Result<IAsyncOperation<_>>;外层 Result 与异步 get() 分两步
let manager = GsManager::RequestAsync().and_then(|op| op.get());
match &manager {
Ok(_) => {
gsmtc_ok.store(true, Ordering::Relaxed);
crate::logger::log_info("music-remote", "GSMTC 已初始化(专用线程 MTA)");
}
Err(e) => {
gsmtc_ok.store(false, Ordering::Relaxed);
crate::logger::log_error(
"music-remote",
&format!("GSMTC 初始化失败,远程查看/控制降级为「仅 Thing 自身」: {e}"),
);
}
}
// 事件订阅:任一变更 → Change(合并节流在下方发布逻辑里)
if let Ok(m) = &manager {
let t = tx.clone();
let _ = m.CurrentSessionChanged(
&TypedEventHandler::<GsManager, CurrentSessionChangedEventArgs>::new(move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
}),
);
let t = tx.clone();
let _ = m.SessionsChanged(
&TypedEventHandler::<GsManager, SessionsChangedEventArgs>::new(move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
}),
);
// 说明:MediaProperties/Timeline/PlaybackInfo 是 **Session 级**事件(挂在每条会话上,
// 需随会话变化反复订阅/退订)。P0 简化为不订阅——聚合本身以 500ms 节拍轮询,
// 语义变化最多延迟 ~500ms 上屏(发布规则见下),1Hz 进度窗口不受影响;
// 会话级事件的精细化订阅列入 P1(计划 §7)。
}
let mut last_publish: Option<Instant> = None;
let mut last_fp = String::new();
// 上次**发布**时的位置:位置不进语义指纹(每秒都变),单独用来识别跳变
let mut last_pos: Option<f64> = None;
// 封面快捷缓存:coverKey → hash(避免同曲反复读缩略图;字节在 CoverStore)
let mut cover_local: HashMap<String, String> = HashMap::new();
// AUMID → 显示名缓存(注册表友好名,P1 §7)
let mut name_cache: HashMap<String, String> = HashMap::new();
// 会话列表指纹(变化才推 sessions 消息)
let mut last_sessions_fp = String::new();
// 当前目标会话的事件订阅(P1 §7 会话级事件:随目标切换订阅/退订)
let mut subs: Option<SessionSubs> = None;
let mut last_sub_aumid = String::new();
loop {
// 收一轮消息(风暴合并)
let mut force = false;
let mut running = true;
match rx.recv_timeout(Duration::from_millis(500)) {
Ok(MonitorMsg::Stop) => running = false,
Ok(MonitorMsg::Force) => force = true,
Ok(MonitorMsg::Change) => {}
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => running = false,
}
while running {
match rx.try_recv() {
Ok(MonitorMsg::Stop) => {
running = false;
break;
}
Ok(MonitorMsg::Force) => force = true,
Ok(MonitorMsg::Change) => {}
Err(_) => break,
}
}
if !running {
break;
}
// 设置读取:remote_device_id(MusicManager 500ms 缓存,开销可忽略)
let device_id = app
.try_state::<MusicManager>()
.map(|m| m.load_settings().remote_device_id)
.unwrap_or_default();
// 目标会话:手机选中覆盖优先,否则系统 current(P1 多会话切换;
// WinRT 无 SetCurrentSession,选中是 Thing 侧覆盖而非改系统判定)
let (target, needs_clear) = match &manager {
Ok(m) => {
let sel = selected
.lock()
.map(|g| g.clone())
.unwrap_or_default();
pick_target(m, sel.as_deref())
}
Err(_) => (None, false),
};
if needs_clear {
if let Ok(mut s) = selected.lock() {
s.take();
}
}
// 会话级事件订阅跟随目标(P1 §7:Media/Timeline/PlaybackInfo 随会话退订换绑)
if manager.is_ok() {
let aumid = target
.as_ref()
.and_then(|s| s.SourceAppUserModelId().ok())
.map(|h| h.to_string())
.unwrap_or_default();
if aumid != last_sub_aumid {
if let Some(old) = subs.take() {
old.remove_all();
}
if let Some(t) = &target {
subs = Some(SessionSubs::subscribe(t, &tx));
}
last_sub_aumid = aumid;
}
}
// 系统主音量轮询(P1 §7;500ms 一次,端点不可用时 volume=None)
let (vol, muted) = volume::read().map(|(v, m)| (Some(v), m)).unwrap_or((None, false));
let mut np = if manager.is_err() {
aggregate_fallback(&app, &device_id)
} else if let Some(sess) = &target {
aggregate_session(&app, sess, &device_id, &covers, &mut cover_local, &mut name_cache)
} else {
NowPlaying::stopped(&device_id)
};
np.volume = vol;
np.muted = muted;
// 会话列表(变化才推;连接时 watch 快照兜底)
if let Ok(m) = &manager {
let list = build_sessions(m, np.session_id.as_str(), &mut name_cache);
let fp_s = format!("{:?}", list);
if fp_s != last_sessions_fp {
last_sessions_fp = fp_s;
sessions_tx.send_replace(list);
}
}
let fp = fingerprint(&np);
let semantic = fp != last_fp;
let playing = np.status == PlayStatus::Playing;
let progress_due = last_publish
.map(|t| t.elapsed() >= Duration::from_secs(1))
.unwrap_or(true);
// 位置跳变(seek)单独发帧:`position` 不进指纹,暂停态又没有 1Hz 进度帧,
// 不补这一帧的话,手机端刚拖好的位置永远等不到来源确认
// (保持窗口到期后只能回退到旧位置,表现为「先保持再跳回去」)
let position_jump = last_pos
.map(|p| (np.position_sec - p).abs() > POSITION_JUMP_SEC)
.unwrap_or(false);
if force || semantic || position_jump || (playing && progress_due) {
last_publish = Some(Instant::now());
last_fp = fp;
last_pos = Some(np.position_sec);
// watch:无接收者时 send_replace 仍更新值(新客户端从 borrow 拿快照)
state_tx.send_replace(np);
}
}
if let Some(s) = subs.take() {
s.remove_all();
}
crate::logger::log_info("music-remote", "GSMTC 监视线程已退出");
}
/// 把目标会话聚合成 `NowPlaying`(§5.2 主路径;目标由 [`pick_target`] 选定)。
fn aggregate_session(
app: &AppHandle,
session: &GsSession,
device_id: &str,
covers: &CoverStore,
cover_local: &mut HashMap<String, String>,
name_cache: &mut HashMap<String, String>,
) -> NowPlaying {
let aumid = session
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
let is_thing = proto::is_thing_aumid(&aumid);
// 元数据(§6.2 缩略图)
let props = session.TryGetMediaPropertiesAsync().and_then(|op| op.get());
let (title, artist, album) = match &props {
Ok(p) => (
p.Title().map(|h| h.to_string()).unwrap_or_default(),
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
p.AlbumTitle().map(|h| h.to_string()).unwrap_or_default(),
),
Err(_) => (String::new(), String::new(), String::new()),
};
let cover_hash = props.as_ref().ok().and_then(|p| {
let key = format!("{aumid}|{title}|{album}");
cover_for(p, &key, covers, cover_local)
});
// 播放状态与能力位
let info = session.GetPlaybackInfo();
let status = match info.as_ref().ok().and_then(|i| i.PlaybackStatus().ok()) {
Some(GsStatus::Playing) => PlayStatus::Playing,
Some(GsStatus::Paused) => PlayStatus::Paused,
_ => PlayStatus::Stopped,
};
let can = match info.as_ref().ok().and_then(|i| i.Controls().ok()) {
// Thing 自身会话:控制走前端事件链直通(play/pause/next/prev/seek 全部可用),
// 不看 SMTC 的能力位——系统面板那套 IsXxxEnabled 里没有 seek 位,
// 照抄会把手机端的进度条锁成只读(seek 实际由 AudioEngine 直接处理)
Some(_) if is_thing => CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
Some(c) => CanControl {
play: c.IsPlayEnabled().unwrap_or(false),
pause: c.IsPauseEnabled().unwrap_or(false),
next: c.IsNextEnabled().unwrap_or(false),
prev: c.IsPreviousEnabled().unwrap_or(false),
// WinRT 无 IsSeekEnabled,seek 能力位叫 IsPlaybackPositionEnabled
seek: c.IsPlaybackPositionEnabled().unwrap_or(false),
},
None if is_thing => CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
None => CanControl {
play: false,
pause: false,
next: false,
prev: false,
seek: false,
},
};
// PlaybackRate 是 IReference<f64>(可空)→ Value() 解引用
let playback_rate = info
.as_ref()
.ok()
.and_then(|i| i.PlaybackRate().ok())
.and_then(|r| r.Value().ok())
.filter(|r| r.is_finite() && *r > 0.0)
.unwrap_or(1.0);
// 时间轴(§6.4:位置基准用 LastUpdatedTime)
let (position_sec, duration_sec, position_updated_at_ms) = match session.GetTimelineProperties()
{
Ok(tl) => {
let pos = tl
.Position()
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
.unwrap_or(0.0);
let dur = tl
.EndTime()
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
.unwrap_or(0.0);
// `LastUpdatedTime = 0` = 来源从未上报过时间轴(bilibili PC 实测:
// position=0 / EndTime=0 / LastUpdatedTime=0)。换算出的负值同样没有意义,
// 一律归 0 作「无进度基准」哨兵,手机端据此停掉进度推算(否则每秒一帧
// 从 0 起算,进度条原地抽搐)。
let updated = tl
.LastUpdatedTime()
.map(|d| proto::winrt_ticks_to_unix_ms(d.UniversalTime))
.unwrap_or(0);
(pos.max(0.0), dur.max(0.0), updated.max(0))
}
// 取不到时间轴 = 没有可用基准,不能拿本机时间伪装成"刚更新过"
Err(_) => (0.0, 0.0, 0),
};
// Thing 自身会话:位置改用 AudioEngine 快照。SMTC 那份由前端按 1s 节流上报、
// 暂停态甚至不刷新,手机端拖完 seek 会一直等不到「来源已到新位置」的确认,
// 保持窗口到期后只能回退到旧位置。引擎快照是逐次读取的权威值,seek 后立即反映。
let (position_sec, position_updated_at_ms) = if is_thing {
let engine_pos = app.try_state::<AudioEngine>().and_then(|e| {
let st = e.state();
st.active.then_some(st.position_sec)
});
match engine_pos {
Some(p) => (p.max(0.0), now_unix_ms()),
None => (position_sec, position_updated_at_ms), // 引擎无会话:退回 SMTC 值
}
} else {
(position_sec, position_updated_at_ms)
};
NowPlaying {
session_id: proto::session_key(&aumid),
source_app: friendly_name(&aumid, name_cache),
is_thing,
title,
artist,
album,
cover_hash,
status,
duration_sec,
position_sec,
position_updated_at_ms,
playback_rate,
can_control: can,
volume: None,
muted: false,
device_id: device_id.to_string(),
}
}
/// 读取会话缩略图 → 存 CoverStore → 返回 hash(§6.2:WS 只带 hash)。
fn cover_for(
props: &GsMediaProperties,
key: &str,
covers: &CoverStore,
local: &mut HashMap<String, String>,
) -> Option<String> {
if let Some(h) = local.get(key) {
return Some(h.clone());
}
// 无缩略图(null → Err)直接返回 None;同 key 不重试(记空串占位)
let reference = match props.Thumbnail() {
Ok(r) => r,
Err(_) => {
local.insert(key.to_string(), String::new());
return None;
}
};
let bytes = read_thumb(&reference)?;
let hash = covers.put(&bytes)?;
// 快捷缓存防膨胀(同曲重读的代价可接受)
if local.len() > 128 {
local.clear();
}
local.insert(key.to_string(), hash.clone());
Some(hash)
}
/// `IRandomAccessStreamReference` → 字节(DataReader 路径,无需 Cryptography feature)。
fn read_thumb(reference: &windows::Storage::Streams::IRandomAccessStreamReference) -> Option<Vec<u8>> {
use windows::Storage::Streams::DataReader;
let stream = reference.OpenReadAsync().ok()?.get().ok()?;
let size = stream.Size().ok()? as u32;
if size == 0 || size > MAX_COVER_BYTES {
return None;
}
let reader = DataReader::CreateDataReader(&stream).ok()?;
reader.LoadAsync(size).ok()?.get().ok()?;
let mut buf = vec![0u8; size as usize];
reader.ReadBytes(&mut buf).ok()?;
Some(buf)
}
/// 兜底聚合(§5.2:GSMTC 不可用时):AudioEngine 状态 + 前端已推送的 SMTC 元数据。
fn aggregate_fallback(app: &AppHandle, device_id: &str) -> NowPlaying {
let engine = match app.try_state::<AudioEngine>() {
Some(e) => e,
None => return NowPlaying::stopped(device_id),
};
let st = engine.state();
if !st.active {
return NowPlaying::stopped(device_id);
}
let meta = app
.try_state::<SmtcMetaCache>()
.map(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
.unwrap_or_default();
NowPlaying {
session_id: THING_SELF_SESSION.to_string(),
source_app: proto::source_display(proto::THING_AUMID),
is_thing: true,
title: meta.title,
artist: meta.artist,
album: meta.album,
cover_hash: None,
status: if st.playing {
PlayStatus::Playing
} else {
PlayStatus::Paused
},
position_sec: st.position_sec,
position_updated_at_ms: now_unix_ms(),
playback_rate: 1.0,
can_control: CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
device_id: device_id.to_string(),
..NowPlaying::default()
}
}
fn now_unix_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
// ---------------------------------------------------------------------------
// 会话选择 / 列表 / 事件订阅 / 友好名(P1 §7)
// ---------------------------------------------------------------------------
/// 选定目标会话:`selected` 命中则用之;否则系统 current。
/// 返回 `(目标, 是否需要清除选中)`——选中项已消失时回退 current 并标记清除。
/// (WinRT **没有** SetCurrentSession:选中是 Thing 侧覆盖,不改系统判定。)
fn pick_target(manager: &GsManager, selected: Option<&str>) -> (Option<GsSession>, bool) {
if let Some(sid) = selected.filter(|s| !s.is_empty()) {
let mut found: Option<GsSession> = None;
if let Ok(list) = manager.GetSessions() {
for i in 0..list.Size().unwrap_or(0) {
if let Ok(s) = list.GetAt(i) {
let key = s
.SourceAppUserModelId()
.ok()
.map(|h| proto::session_key(&h.to_string()));
if key.as_deref() == Some(sid) {
found = Some(s);
break;
}
}
}
}
return match found {
Some(s) => (Some(s), false),
None => (manager.GetCurrentSession().ok(), true),
};
}
(manager.GetCurrentSession().ok(), false)
}
/// 枚举全部会话为手机端列表(`is_current` = 是否当前展示目标)。
fn build_sessions(
manager: &GsManager,
current_key: &str,
name_cache: &mut HashMap<String, String>,
) -> Vec<proto::SessionInfo> {
let Ok(list) = manager.GetSessions() else {
return Vec::new();
};
let mut out = Vec::new();
for i in 0..list.Size().unwrap_or(0) {
let Ok(s) = list.GetAt(i) else { continue };
let aumid = s
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
let key = proto::session_key(&aumid);
let (title, artist) = match s.TryGetMediaPropertiesAsync().and_then(|op| op.get()) {
Ok(p) => (
p.Title().map(|h| h.to_string()).unwrap_or_default(),
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
),
Err(_) => (String::new(), String::new()),
};
let status = match s.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()) {
Ok(GsStatus::Playing) => PlayStatus::Playing,
Ok(GsStatus::Paused) => PlayStatus::Paused,
_ => PlayStatus::Stopped,
};
out.push(proto::SessionInfo {
is_current: key == current_key,
session_id: key,
source_app: friendly_name(&aumid, name_cache),
title,
artist,
status,
is_thing: proto::is_thing_aumid(&aumid),
});
}
out
}
/// 目标会话的三个事件订阅(P1 §7:随目标切换退订/换绑,唤醒聚合循环)。
struct SessionSubs {
session: GsSession,
tokens: Vec<(SubKind, windows::Foundation::EventRegistrationToken)>,
}
enum SubKind {
Props,
Timeline,
Info,
}
impl SessionSubs {
fn subscribe(sess: &GsSession, tx: &Sender<MonitorMsg>) -> Self {
let mut tokens = Vec::new();
// 三个事件的 args 类型各不相同,逐个构造 handler(不能复用闭包)
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, MediaPropertiesChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.MediaPropertiesChanged(&h) {
tokens.push((SubKind::Props, tok));
}
}
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, TimelinePropertiesChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.TimelinePropertiesChanged(&h) {
tokens.push((SubKind::Timeline, tok));
}
}
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, PlaybackInfoChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.PlaybackInfoChanged(&h) {
tokens.push((SubKind::Info, tok));
}
}
Self {
session: sess.clone(),
tokens,
}
}
fn remove_all(self) {
for (kind, tok) in self.tokens {
let r = match kind {
SubKind::Props => self.session.RemoveMediaPropertiesChanged(tok),
SubKind::Timeline => self.session.RemoveTimelinePropertiesChanged(tok),
SubKind::Info => self.session.RemovePlaybackInfoChanged(tok),
};
if let Err(e) = r {
crate::logger::log_warn("music-remote", &format!("退订会话事件失败: {e}"));
}
}
}
}
/// AUMID → 显示名:注册表友好名(`HKCU\\Software\\Classes\\AppUserModelId\\<aumid>`)
/// 缓存优先,查不到退回 AUMID 简化段(§6.7 P1)。
fn friendly_name(aumid: &str, cache: &mut HashMap<String, String>) -> String {
if let Some(v) = cache.get(aumid) {
return v.clone();
}
let name = if proto::is_thing_aumid(aumid) {
"Thing".to_string()
} else {
registry_display_name(aumid).unwrap_or_else(|| proto::source_display(aumid))
};
if cache.len() > 128 {
cache.clear();
}
cache.insert(aumid.to_string(), name.clone());
name
}
fn registry_display_name(aumid: &str) -> Option<String> {
// 路径形 AUMID(含反斜杠)无法作注册表单键名;空串跳过
if aumid.is_empty() || aumid.contains('\\') {
return None;
}
use winreg::RegKey;
use winreg::enums::HKEY_CURRENT_USER;
let key = RegKey::predef(HKEY_CURRENT_USER)
.open_subkey(format!(r"Software\Classes\AppUserModelId\{aumid}"))
.ok()?;
key.get_value::<String, _>("DisplayName")
.ok()
.filter(|s| !s.trim().is_empty())
}
// ---------------------------------------------------------------------------
// 控制(server 在 spawn_blocking 里调用)
// ---------------------------------------------------------------------------
/// 对指定会话执行控制动作(§3.1:统一走 GSMTC `Try*Async`)。
///
/// **阻塞**(`.get()` 等待 WinRT async):调用方必须在 `spawn_blocking` / 专用线程。
/// `session_id` 为 [`proto::NowPlaying::session_id`](控制"手机上正在显示的那条")。
pub fn control(session_id: &str, action: CmdAction, args: Option<CmdArgs>) -> Result<(), String> {
let manager = GsManager::RequestAsync()
.and_then(|op| op.get())
.map_err(|e| format!("GSMTC 不可用: {e}"))?;
let session = find_session(&manager, session_id)?;
// toggle 需要先读当前状态
let playing = matches!(
session.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()),
Ok(GsStatus::Playing)
);
let op = match action {
CmdAction::Play => session.TryPlayAsync().map_err(err_of)?,
CmdAction::Pause => session.TryPauseAsync().map_err(err_of)?,
CmdAction::Toggle => {
if playing {
session.TryPauseAsync().map_err(err_of)?
} else {
session.TryPlayAsync().map_err(err_of)?
}
}
CmdAction::Next => session.TrySkipNextAsync().map_err(err_of)?,
CmdAction::Prev => session.TrySkipPreviousAsync().map_err(err_of)?,
CmdAction::Stop => session.TryStopAsync().map_err(err_of)?,
CmdAction::Seek => {
let pos = args
.as_ref()
.map(|a| a.pos_sec)
.ok_or_else(|| "seek 缺少 args.posSec".to_string())?;
let v = if pos.is_finite() && pos > 0.0 {
pos
} else {
0.0
};
// WinRT 签名是 INT64(100ns ticks),不是 TimeSpan
session
.TryChangePlaybackPositionAsync((v * TICKS_PER_SEC as f64) as i64)
.map_err(err_of)?
}
// Volume/Select/Jump 由 server 直接处理(音量走 IAudioEndpointVolume、选中走 Thing 侧覆盖、
// 选歌走前端事件链),不会路由到这里;列全仅为 match 穷尽
CmdAction::Volume | CmdAction::Select | CmdAction::Jump => {
return Err("volume/select/jump 不走 GSMTC 控制路径".into())
}
};
// 阻塞等待完成(语义 = 指令已派发,§4.2 cmd-ack)
let _ = op.get().map_err(err_of)?;
Ok(())
}
fn err_of<E: std::fmt::Display>(e: E) -> String {
format!("{e}")
}
/// 按 sessionId 找会话(`thing.self` → AUMID 匹配;否则 AUMID 全等;回退 current)。
fn find_session(manager: &GsManager, session_id: &str) -> Result<GsSession, String> {
let sessions = manager.GetSessions().map_err(err_of)?;
let n = sessions.Size().map_err(err_of)?;
for i in 0..n {
let s = sessions.GetAt(i).map_err(err_of)?;
let aumid = s
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
if proto::session_key(&aumid) == session_id {
return Ok(s);
}
}
manager
.GetCurrentSession()
.map_err(|_| format!("目标会话不存在: {session_id}"))
}
+756
View File
@@ -0,0 +1,756 @@
//! 手机遥控子系统(MUSIC_REMOTE_PLAN §5.1)。
//!
//! [RemoteManager] 是本子系统的唯一状态容器(**平级 manage**,不塞进 MusicManager,
//! 见计划 §5.1):服务生命周期、配对会话、封面缓存、鉴权限速、在线设备、
//! 聚合状态(`watch<NowPlaying>`)。
//!
//! | 文件 | 职责 |
//! |---|---|
//! | [`proto`] | NowPlaying / WS 消息类型(§4)+ 单测 |
//! | [`discovery`] | UDP beacon(§3.3,含各网卡定向广播) |
//! | [`pairing`] | 配对码、设备表、token、限速(§3.4) |
//! | [`glsmtc`] | GSMTC 监视/聚合/封面 LRU/节流 + Try*Async 控制(§3.1) |
//! | [`server`] | axum HTTP+WS、鉴权、广播、心跳(§3.2 / §4.2) |
//!
//! 设置字段(`MusicSettings`,settings.json):`remote_enabled` / `remote_port` /
//! `remote_device_id` / `remote_devices`——设备**元数据**落 settings,**token** 入
//! 系统凭据管理器(键名 `music-remote-token-{id}`,§3.4-3)。
mod discovery;
mod glsmtc;
mod pairing;
mod proto;
mod server;
mod volume;
pub use pairing::RemoteDeviceMeta;
pub use proto::{NowPlaying, PROTO_VER};
/// 手机选歌 → 前端播放器的事件名(载荷 = 队列绝对下标)。
pub const REMOTE_JUMP_EVENT: &str = "music-remote-jump";
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Manager};
use tokio::sync::watch;
use discovery::BeaconPayload;
use glsmtc::GsmtcMonitor;
use pairing::PairingSession;
use super::MusicManager;
// ---------------------------------------------------------------------------
// 封面缓存(§6.2:内存 LRU,上限 ~20 张;/cover/:hash 由此供给)
// ---------------------------------------------------------------------------
struct CoverEntry {
bytes: Vec<u8>,
seq: u64,
}
/// 封面字节 LRU(内容哈希为键;seq 兼作 LRU 计数)。
/// P1 §7:写透到磁盘目录(`{app_data}/remote_covers`),Thing 重启后手机仍能拉到封面。
pub struct CoverStore {
map: Mutex<HashMap<String, CoverEntry>>,
seq: AtomicU64,
/// 磁盘目录(None = 仅内存;start() 时 attach)
dir: Mutex<Option<std::path::PathBuf>>,
}
impl CoverStore {
pub fn new() -> Self {
Self {
map: Mutex::new(HashMap::new()),
seq: AtomicU64::new(0),
dir: Mutex::new(None),
}
}
/// 挂载持久化目录(服务启动时调用;创建目录,失败只记日志)。
pub fn attach_dir(&self, dir: std::path::PathBuf) {
if let Err(e) = std::fs::create_dir_all(&dir) {
crate::logger::log_warn(
"music-remote",
&format!("封面持久化目录创建失败(仅内存缓存): {e}"),
);
return;
}
if let Ok(mut g) = self.dir.lock() {
*g = Some(dir);
}
}
fn dir_opt(&self) -> Option<std::path::PathBuf> {
self.dir.lock().ok().and_then(|g| g.clone())
}
/// 存入封面,返回内容哈希(同内容同哈希);超限淘汰最旧。
pub fn put(&self, bytes: &[u8]) -> Option<String> {
if bytes.is_empty() || bytes.len() > 10 * 1024 * 1024 {
return None;
}
let mut hasher = std::collections::hash_map::DefaultHasher::new();
bytes.hash(&mut hasher);
let hash = format!("{:016x}", hasher.finish());
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
map.insert(
hash.clone(),
CoverEntry {
bytes: bytes.to_vec(),
seq: self.seq.fetch_add(1, Ordering::Relaxed),
},
);
while map.len() > 20 {
let oldest = map
.iter()
.min_by_key(|(_, e)| e.seq)
.map(|(k, _)| k.clone());
match oldest {
Some(k) => {
map.remove(&k);
}
None => break,
}
}
drop(map);
// 写透磁盘(尽力而为;失败不影响内存路径)
if let Some(dir) = self.dir_opt() {
let path = dir.join(format!("{hash}.img"));
if std::fs::write(&path, bytes).is_ok() {
// 目录同样限 20 张:按修改时间淘汰最旧
if let Ok(rd) = std::fs::read_dir(&dir) {
let mut files: Vec<(std::time::SystemTime, std::path::PathBuf)> = rd
.flatten()
.filter_map(|e| {
let p = e.path();
if p.extension().and_then(|x| x.to_str()) != Some("img") {
return None;
}
let t = e.metadata().ok()?.modified().ok()?;
Some((t, p))
})
.collect();
if files.len() > 20 {
files.sort_by_key(|(t, _)| *t);
for (_, p) in files.iter().take(files.len() - 20) {
let _ = std::fs::remove_file(p);
}
}
}
}
}
Some(hash)
}
/// 读取(内存 → 磁盘回源;命中即刷新 LRU 序号)。
pub fn get(&self, hash: &str) -> Option<Vec<u8>> {
{
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
if let Some(entry) = map.get_mut(hash) {
entry.seq = seq;
return Some(entry.bytes.clone());
}
}
// 磁盘回源(Thing 重启 / 冷缓存)
let dir = self.dir_opt()?;
let bytes = std::fs::read(dir.join(format!("{hash}.img"))).ok()?;
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
map.insert(
hash.to_string(),
CoverEntry {
bytes: bytes.clone(),
seq: self.seq.fetch_add(1, Ordering::Relaxed),
},
);
while map.len() > 20 {
let oldest = map
.iter()
.min_by_key(|(_, e)| e.seq)
.map(|(k, _)| k.clone());
match oldest {
Some(k) => {
map.remove(&k);
}
None => break,
}
}
Some(bytes)
}
}
impl Default for CoverStore {
fn default() -> Self {
Self::new()
}
}
// ---------------------------------------------------------------------------
// 对外状态视图(命令返回值)
// ---------------------------------------------------------------------------
/// 远程配置(§5.1 命令 `remote_get_config` / `remote_set_enabled`)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteConfig {
/// 开关(持久化)
pub enabled: bool,
/// 期望端口(0 = 默认 26124 起自动探测)
pub port: u16,
/// 服务是否在运行
pub running: bool,
/// 实际监听端口(未运行为 0)
pub running_port: u16,
/// 本机标识(beacon / NowPlaying.deviceId 同源)
pub device_id: String,
}
/// 进行中的配对信息(二维码 payload 见计划 §3.3 扫码行)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemotePairingInfo {
pub code: String,
/// `thingmusic://connect?ip=…&port=…&code=…`
pub qr_payload: String,
pub seconds_left: u64,
}
/// 设备视图(settings 元数据 + 在线态)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteDeviceView {
pub id: String,
pub name: String,
pub last_connected_ms: i64,
pub online: bool,
}
/// 服务状态(`remote_status`)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteStatus {
pub running: bool,
pub port: u16,
pub online: Vec<RemoteDeviceView>,
pub pairing: Option<RemotePairingInfo>,
}
// ---------------------------------------------------------------------------
// RemoteManager
// ---------------------------------------------------------------------------
/// 服务内部状态(start/stop 独占)。
struct Inner {
running: bool,
port: u16,
server_task: Option<tokio::task::JoinHandle<()>>,
beacon_stop: Option<Arc<AtomicBool>>,
beacon_handle: Option<JoinHandle<()>>,
pairing: Option<PairingSession>,
}
impl Default for Inner {
fn default() -> Self {
Self {
running: false,
port: 0,
server_task: None,
beacon_stop: None,
beacon_handle: None,
pairing: None,
}
}
}
pub struct RemoteManager {
/// 聚合状态(监视线程写、WS/REST 读)
pub(crate) state_tx: Arc<watch::Sender<NowPlaying>>,
/// 会话列表(P1 多会话切换;监视线程写、WS 读)
pub(crate) sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
/// Thing 本机播放队列(前端 `remote_publish_queue` 写、WS 读)
pub(crate) queue_tx: Arc<watch::Sender<proto::QueueSnapshot>>,
/// 手机选中的目标会话覆盖(None = 跟随系统 current;WinRT 无 SetCurrentSession)
pub(crate) selected: Arc<Mutex<Option<String>>>,
/// 封面 LRU(glsmtc 写、/cover 读)
pub(crate) covers: Arc<CoverStore>,
/// hello / /pair 限速(§3.4-4)
pub(crate) auth: Arc<pairing::FailTracker>,
/// GSMTC 是否可用(false → 控制走前端事件链兜底,§5.2)
pub(crate) gsmtc_ok: Arc<AtomicBool>,
/// 服务停止信号(每个 WS 连接订阅一份)
shutdown_tx: watch::Sender<bool>,
online: Mutex<std::collections::HashSet<String>>,
monitor: Mutex<Option<GsmtcMonitor>>,
inner: Mutex<Inner>,
}
impl RemoteManager {
pub fn new() -> Self {
let (state_tx, _) = watch::channel(NowPlaying::default());
let (sessions_tx, _) = watch::channel(Vec::new());
let (queue_tx, _) = watch::channel(proto::QueueSnapshot::default());
let (shutdown_tx, _) = watch::channel(false);
Self {
state_tx: Arc::new(state_tx),
sessions_tx: Arc::new(sessions_tx),
queue_tx: Arc::new(queue_tx),
selected: Arc::new(Mutex::new(None)),
covers: Arc::new(CoverStore::new()),
auth: Arc::new(pairing::FailTracker::default()),
gsmtc_ok: Arc::new(AtomicBool::new(false)),
shutdown_tx,
online: Mutex::new(std::collections::HashSet::new()),
monitor: Mutex::new(None),
inner: Mutex::new(Inner::default()),
}
}
/// 当前聚合状态快照。
pub fn now_playing(&self) -> NowPlaying {
self.state_tx.borrow().clone()
}
/// 会话列表快照(WS 连接建立时下发)。
pub fn sessions_snapshot(&self) -> Vec<proto::SessionInfo> {
self.sessions_tx.borrow().clone()
}
/// 订阅会话列表变更(每个 WS 连接一份)。
pub fn sessions_rx(&self) -> watch::Receiver<Vec<proto::SessionInfo>> {
self.sessions_tx.subscribe()
}
/// 队列快照(WS 连接建立时下发;Thing 本机播放的队列)。
pub fn queue_snapshot(&self) -> proto::QueueSnapshot {
self.queue_tx.borrow().clone()
}
/// 订阅队列变更(每个 WS 连接一份)。
pub fn queue_rx(&self) -> watch::Receiver<proto::QueueSnapshot> {
self.queue_tx.subscribe()
}
/// 前端发布队列快照;内容没变时不推送(避免播放中反复触发 WS 帧)。
pub fn set_queue(&self, snapshot: proto::QueueSnapshot) {
let unchanged = *self.queue_tx.borrow() == snapshot;
if unchanged {
return;
}
self.queue_tx.send_replace(snapshot);
}
/// 设置目标会话覆盖;空串 = 清除(跟随系统 current)。P1 多会话切换。
pub fn set_selected(&self, session_id: &str) {
let mut g = self.selected.lock().unwrap_or_else(|e| e.into_inner());
*g = if session_id.trim().is_empty() {
None
} else {
Some(session_id.to_string())
};
}
/// cmd 后立即推一帧(§6.3 例外)。
pub fn notify_state_force(&self) {
let guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
if let Some(m) = guard.as_ref() {
m.notify_force();
}
}
pub fn is_running(&self) -> bool {
self.inner
.lock()
.map(|g| g.running)
.unwrap_or(false)
}
pub fn running_port(&self) -> u16 {
self.inner.lock().map(|g| g.port).unwrap_or(0)
}
pub fn shutdown_rx(&self) -> watch::Receiver<bool> {
self.shutdown_tx.subscribe()
}
pub fn mark_online(&self, id: &str, on: bool) {
if let Ok(mut set) = self.online.lock() {
if on {
set.insert(id.to_string());
} else {
set.remove(id);
}
}
}
fn online_ids(&self) -> std::collections::HashSet<String> {
self.online
.lock()
.map(|s| s.clone())
.unwrap_or_default()
}
// ---------- 配对(§3.4) ----------
/// 开始配对:生成 6 位码(5 分钟有效、一次性)。服务未运行时拒绝(二维码需要端口)。
pub fn start_pairing(&self) -> Result<RemotePairingInfo, String> {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if !inner.running {
return Err("远程服务未启动,请先开启「手机互联」".into());
}
let session = PairingSession::generate();
// 联调辅助:配对码写入本地日志(屏幕同样可见;日志仅本机)
crate::logger::log_info(
"music-remote",
format!("配对码已生成: {}(5 分钟内有效)", session.code).as_str(),
);
let info = Self::pairing_info_of(&session, inner.port);
inner.pairing = Some(session);
Ok(info)
}
pub fn cancel_pairing(&self) {
if let Ok(mut inner) = self.inner.lock() {
inner.pairing = None;
}
}
pub fn pairing_info(&self) -> Option<RemotePairingInfo> {
let inner = self.inner.lock().ok()?;
let s = inner.pairing.as_ref()?;
if s.is_expired() {
return None;
}
Some(Self::pairing_info_of(s, inner.port))
}
fn pairing_info_of(s: &PairingSession, port: u16) -> RemotePairingInfo {
let ip = discovery::primary_ipv4()
.map(|i| i.to_string())
.unwrap_or_default();
RemotePairingInfo {
code: s.code.clone(),
qr_payload: format!("thingmusic://connect?ip={ip}&port={port}&code={}", s.code),
seconds_left: s.seconds_left(),
}
}
/// 校验并消费配对码(一次性);成功返回 Ok 并清除会话。
pub fn take_pairing_if_match(&self, code: &str) -> Result<(), String> {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let s = inner
.pairing
.as_ref()
.ok_or_else(|| "没有进行中的配对,请先在电脑上点「连接手机」".to_string())?;
if s.is_expired() {
inner.pairing = None;
return Err("配对码已过期(5 分钟),请重新生成".into());
}
if s.code != code.trim() {
return Err("配对码不正确".into());
}
inner.pairing = None; // 一次性
Ok(())
}
// ---------- 生命周期(§5.4) ----------
/// 启动:探测端口 → axum serve → beacon → GSMTC 监视。
pub async fn start(&self, app: &AppHandle) -> Result<(), String> {
{
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if inner.running {
return Ok(());
}
}
// 本机标识:首次生成后持久化(beacon / NowPlaying 同源)
let music = app.state::<MusicManager>();
let mut settings = music.load_settings();
if settings.remote_device_id.trim().is_empty() {
settings.remote_device_id = pairing::random_device_id();
music.save_settings(&settings)?;
}
// 1) HTTP+WS 服务(端口探测 26124..26139)
let (port, server_task) = server::start(app.clone(), settings.remote_port).await?;
self.shutdown_tx.send_replace(false);
// 2) UDP beacon(3s;各网卡定向广播)
let payload = BeaconPayload {
service: "thing-music",
device_id: settings.remote_device_id.clone(),
name: std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Thing".to_string()),
port,
proto_ver: PROTO_VER,
addrs: discovery::ipv4_broadcast_pairs()
.into_iter()
.map(|(ip, _)| ip.to_string())
.collect(),
};
let beacon_stop = Arc::new(AtomicBool::new(false));
let beacon_handle = discovery::spawn_beacon(payload, beacon_stop.clone());
// 封面持久化目录(P1 §7:重启后冷缓存可回源)
if let Ok(dir) = app.path().app_data_dir() {
self.covers.attach_dir(dir.join("remote_covers"));
}
// 3) GSMTC 监视(聚合/节流/封面/音量/会话事件;失败自动兜底,§3.1 失败策略)
let monitor = GsmtcMonitor::start(
app.clone(),
self.state_tx.clone(),
self.covers.clone(),
self.gsmtc_ok.clone(),
self.sessions_tx.clone(),
self.selected.clone(),
);
{
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
inner.running = true;
inner.port = port;
inner.server_task = Some(server_task);
inner.beacon_stop = Some(beacon_stop);
inner.beacon_handle = Some(beacon_handle);
inner.pairing = None;
}
*self.monitor.lock().unwrap_or_else(|e| e.into_inner()) = Some(monitor);
crate::logger::log_info(
"music-remote",
format!("手机互联已启动: ws://0.0.0.0:{port}(beacon :26123)").as_str(),
);
Ok(())
}
/// 停止:abort serve → 停 beacon → 停监视线程 → 清在线/配对。
pub fn stop(&self) {
let (server_task, beacon_stop, beacon_handle) = {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if !inner.running {
return;
}
inner.running = false;
inner.port = 0;
inner.pairing = None;
(
inner.server_task.take(),
inner.beacon_stop.take(),
inner.beacon_handle.take(),
)
};
// 停止信号:在途 WS 连接退出(§5.4 graceful;serve 直接 abort,手机端走重连)
self.shutdown_tx.send_replace(true);
if let Some(t) = server_task {
t.abort();
}
if let Some(stop) = beacon_stop {
stop.store(true, Ordering::Relaxed);
}
if let Some(h) = beacon_handle {
let _ = h.join(); // beacon 循环 ≤100ms 检查一次退出标志
}
let monitor = {
let mut guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
guard.take()
};
if let Some(m) = monitor {
m.stop();
}
if let Ok(mut set) = self.online.lock() {
set.clear();
}
if let Ok(mut sel) = self.selected.lock() {
sel.take();
}
self.gsmtc_ok.store(false, Ordering::Relaxed);
crate::logger::log_info("music-remote", "手机互联已停止");
}
}
impl Default for RemoteManager {
fn default() -> Self {
Self::new()
}
}
// ---------------------------------------------------------------------------
// 启动钩子(setup.rs 调用)
// ---------------------------------------------------------------------------
/// 随应用启动:`remote_enabled = true` 时自动拉起服务(§5.4)。
pub fn init_on_launch(app: &AppHandle) {
let enabled = app
.try_state::<MusicManager>()
.map(|m| m.load_settings().remote_enabled)
.unwrap_or(false);
if !enabled {
return;
}
let app = app.clone();
tauri::async_runtime::spawn(async move {
let remote = app.state::<RemoteManager>();
if let Err(e) = remote.start(&app).await {
crate::logger::log_error(
"music-remote",
&format!("开机自启手机互联失败: {e}"),
);
}
});
}
// ---------------------------------------------------------------------------
// Tauri 命令(§5.1 命令表)
// ---------------------------------------------------------------------------
#[tauri::command]
#[specta::specta]
pub fn remote_get_config(app: AppHandle) -> RemoteConfig {
let music = app.state::<MusicManager>();
let s = music.load_settings();
let remote = app.state::<RemoteManager>();
RemoteConfig {
enabled: s.remote_enabled,
port: s.remote_port,
running: remote.is_running(),
running_port: remote.running_port(),
device_id: s.remote_device_id,
}
}
/// 开关(即时生效,§5.1)。
#[tauri::command]
#[specta::specta]
pub async fn remote_set_enabled(app: AppHandle, enabled: bool) -> Result<RemoteConfig, String> {
let music = app.state::<MusicManager>();
let mut s = music.load_settings();
s.remote_enabled = enabled;
music.save_settings(&s)?;
let remote = app.state::<RemoteManager>();
if enabled {
if let Err(e) = remote.start(&app).await {
// 启动失败:保留开关意图(下次启动重试),但如实上报未运行
crate::logger::log_error("music-remote", &format!("启动失败: {e}"));
return Err(e);
}
} else {
remote.stop();
}
Ok(RemoteConfig {
enabled,
port: s.remote_port,
running: remote.is_running(),
running_port: remote.running_port(),
device_id: s.remote_device_id,
})
}
#[tauri::command]
#[specta::specta]
pub fn remote_status(app: AppHandle) -> RemoteStatus {
let remote = app.state::<RemoteManager>();
let music = app.state::<MusicManager>();
let s = music.load_settings();
let online = remote.online_ids();
RemoteStatus {
running: remote.is_running(),
port: remote.running_port(),
online: s
.remote_devices
.iter()
.filter(|d| online.contains(&d.id))
.map(|d| RemoteDeviceView {
id: d.id.clone(),
name: d.name.clone(),
last_connected_ms: d.last_connected_ms,
online: true,
})
.collect(),
pairing: remote.pairing_info(),
}
}
/// 生成配对码 + 二维码 payload(前端 `qrcode` 渲染,§5.3)。
#[tauri::command]
#[specta::specta]
pub fn remote_start_pairing(app: AppHandle) -> Result<RemotePairingInfo, String> {
app.state::<RemoteManager>().start_pairing()
}
#[tauri::command]
#[specta::specta]
pub fn remote_cancel_pairing(app: AppHandle) {
app.state::<RemoteManager>().cancel_pairing();
}
/// 设备列表(元数据 + 在线态;token 永不出现在这里)。
#[tauri::command]
#[specta::specta]
pub fn remote_list_devices(app: AppHandle) -> Vec<RemoteDeviceView> {
let music = app.state::<MusicManager>();
let s = music.load_settings();
let remote = app.state::<RemoteManager>();
let online = remote.online_ids();
s.remote_devices
.into_iter()
.map(|d| RemoteDeviceView {
online: online.contains(&d.id),
id: d.id,
name: d.name,
last_connected_ms: d.last_connected_ms,
})
.collect()
}
/// 吊销设备(删表 + 删凭据;已建立的 WS 在下次重连时被拒)。
#[tauri::command]
#[specta::specta]
pub fn remote_revoke_device(app: AppHandle, id: String) -> Result<(), String> {
let music = app.state::<MusicManager>();
let mut s = music.load_settings();
s.remote_devices.retain(|d| d.id != id);
music.save_settings(&s)?;
crate::secrets::secret_delete(&pairing::token_key(&id))?;
let remote = app.state::<RemoteManager>();
remote.mark_online(&id, false);
crate::logger::log_info("music-remote", format!("已吊销设备 {id}").as_str());
Ok(())
}
/// 前端发布 Thing 本机播放队列(手机端「播放队列 / 选歌」的数据源)。
///
/// 队列活在前端 store(feiniuStore),Rust 只做快照转发;`items` 允许是完整队列
/// 的一段(见 [`proto::QueueItem::index`]),`total` 恒为完整长度。
#[tauri::command]
#[specta::specta]
pub fn remote_publish_queue(
app: AppHandle,
items: Vec<proto::QueueItem>,
index: i64,
total: i64,
) {
crate::logger::log_info(
"music-remote",
&format!(
"遥控队列更新: 本次 {} 条 / 共 {} 条,当前第 {} 条",
items.len(),
total,
index
),
);
app.state::<RemoteManager>()
.set_queue(proto::QueueSnapshot {
items,
index,
total: total.max(0),
});
}
+202
View File
@@ -0,0 +1,202 @@
//! 配对与设备表(MUSIC_REMOTE_PLAN §3.4)。
//!
//! - 配对码:6 位数字,Thing 设置页弹窗展示,**5 分钟有效期、一次性**
//! - 设备 token:32 字节随机 hex,入系统凭据管理器(`secrets.rs` 范式,键名
//! `music-remote-token-{deviceId}`);设备元数据(id/名/最后连接)落 settings
//! - 限速:hello 校验失败 3 次拉黑该 IP 60s;`/pair` 配对码校验同一限速(§3.4-4)
use std::collections::HashMap;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use rand::Rng;
use serde::{Deserialize, Serialize};
use specta::Type;
/// 配对码有效期(§3.4-2)。
pub const PAIRING_TTL: Duration = Duration::from_secs(5 * 60);
/// 单 IP 失败阈值与拉黑时长(§3.4-4)。
const FAIL_LIMIT: u8 = 3;
const FAIL_BLOCK: Duration = Duration::from_secs(60);
/// 设备元数据(settings.json 持久化;**token 不在此**,见键名约定)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteDeviceMeta {
pub id: String,
pub name: String,
/// 最后一次成功连接(Unix 毫秒;0 = 从未连接)
#[serde(default)]
pub last_connected_ms: i64,
}
/// 进行中的配对会话(同一时刻至多一个)。
#[derive(Debug, Clone)]
pub struct PairingSession {
pub code: String,
pub created: Instant,
}
impl PairingSession {
pub fn generate() -> Self {
let code: u32 = rand::thread_rng().gen_range(0..1_000_000);
Self {
code: format!("{code:06}"),
created: Instant::now(),
}
}
pub fn is_expired(&self) -> bool {
self.created.elapsed() > PAIRING_TTL
}
/// 剩余秒数(前端倒计时用;已过期返回 0)。
pub fn seconds_left(&self) -> u64 {
PAIRING_TTL
.saturating_sub(self.created.elapsed())
.as_secs()
}
}
/// 凭据键名:与 `secrets.rs` 的服务名 `Thing` 组合成完整凭据项。
pub fn token_key(device_id: &str) -> String {
format!("music-remote-token-{device_id}")
}
/// 生成 32 字节随机 hex token(§3.4-3)。
pub fn random_token() -> String {
let mut buf = [0u8; 32];
rand::thread_rng().fill(&mut buf);
hex_encode(&buf)
}
/// 生成 16 字节随机 hex 设备 id。
pub fn random_device_id() -> String {
let mut buf = [0u8; 16];
rand::thread_rng().fill(&mut buf);
hex_encode(&buf)
}
fn hex_encode(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
/// 按 token 找设备:遍历 settings 中的设备 id,逐个读凭据库比对。
/// 设备数很少(个位数),O(n) 读可接受;token 不落 settings(§3.4-3)。
pub fn device_by_token(
devices: &[RemoteDeviceMeta],
token: &str,
) -> Option<RemoteDeviceMeta> {
if token.is_empty() {
return None;
}
for d in devices {
let stored = crate::secrets::read_or_empty(&token_key(&d.id));
if !stored.is_empty() && stored == token {
return Some(d.clone());
}
}
None
}
/// 单 IP 失败计数 / 拉黑表(hello 与 /pair 共用)。
#[derive(Default)]
pub struct FailTracker {
inner: Mutex<HashMap<String, FailState>>,
}
#[derive(Clone, Copy)]
struct FailState {
fails: u8,
last: Instant,
blocked_until: Option<Instant>,
}
impl FailTracker {
/// 该 IP 当前是否允许尝试(在拉黑窗口内 → false)。
pub fn allowed(&self, ip: &str) -> bool {
let map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
match map.get(ip) {
Some(s) => match s.blocked_until {
Some(t) => Instant::now() >= t,
None => true,
},
None => true,
}
}
/// 记一次失败:累计 3 次拉黑 60s;60s 后的失败重新计数。
pub fn fail(&self, ip: &str) {
let mut map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let now = Instant::now();
let s = map.entry(ip.to_string()).or_insert(FailState {
fails: 0,
last: now,
blocked_until: None,
});
if let Some(t) = s.blocked_until {
if now >= t {
s.fails = 0;
s.blocked_until = None;
}
}
if now.duration_since(s.last) > FAIL_BLOCK {
s.fails = 0;
}
s.last = now;
s.fails += 1;
if s.fails >= FAIL_LIMIT {
s.blocked_until = Some(now + FAIL_BLOCK);
crate::logger::log_warn(
"music-remote",
&format!("IP {ip} 鉴权失败 {FAIL_LIMIT} 次,拉黑 60s"),
);
}
}
/// 成功后清零。
pub fn ok(&self, ip: &str) {
self.inner
.lock()
.unwrap_or_else(|e| e.into_inner())
.remove(ip);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pairing_code_format_and_ttl() {
let p = PairingSession::generate();
assert_eq!(p.code.len(), 6);
assert!(p.code.chars().all(|c| c.is_ascii_digit()));
assert!(!p.is_expired());
assert!(p.seconds_left() <= 300);
}
#[test]
fn fail_tracker_blocks_after_three() {
let t = FailTracker::default();
assert!(t.allowed("1.2.3.4"));
t.fail("1.2.3.4");
t.fail("1.2.3.4");
assert!(t.allowed("1.2.3.4"));
t.fail("1.2.3.4");
assert!(!t.allowed("1.2.3.4"));
// 其他 IP 不受影响
assert!(t.allowed("5.6.7.8"));
t.ok("1.2.3.4");
assert!(t.allowed("1.2.3.4"));
}
#[test]
fn token_shape() {
let t = random_token();
assert_eq!(t.len(), 64);
assert!(t.chars().all(|c| c.is_ascii_hexdigit()));
assert_eq!(random_device_id().len(), 32);
assert_eq!(token_key("abc"), "music-remote-token-abc");
}
}
+523
View File
@@ -0,0 +1,523 @@
//! 遥控协议类型(MUSIC_REMOTE_PLAN §4)。
//!
//! WS 线格式:JSON,`type` 字段判别,字段一律 camelCase。
//! 这些类型**不进 specta bindings**——协议对端是手机(LFMusic 在 `remote-proto.ts`
//! 手写一份镜像类型),Thing 前端不直接消费 WS;此处只负责 serde 序列化与单测。
//! 双端字段一旦改动,必须同步对端文档 §4 与 LFMusic 的镜像类型(计划"复制+注释互指")。
use serde::{Deserialize, Serialize};
/// 协议版本:不匹配时 `welcome` 带最新版本号,手机端提示升级(§4.2)。
pub const PROTO_VER: u32 = 1;
/// Thing 自身会话的 sessionId(§4.1)。
pub const THING_SELF_SESSION: &str = "thing.self";
/// Thing 自身的 AUMID(与 lib.rs `set_app_user_model_id` 一致)。
pub const THING_AUMID: &str = "thing.lfeng.me";
/// 控制能力位:手机端据此置灰按钮(§4.1)。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanControl {
pub play: bool,
pub pause: bool,
pub next: bool,
pub prev: bool,
pub seek: bool,
}
/// 播放状态(§4.1 `status`)。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PlayStatus {
Playing,
Paused,
Stopped,
}
impl Default for PlayStatus {
fn default() -> Self {
Self::Stopped
}
}
/// 当前播放状态快照:WS `state` 消息的载荷(§4.1)。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NowPlaying {
/// 会话 key:Thing 自身 = [`THING_SELF_SESSION`],其余为 SourceAppUserModelId
pub session_id: String,
/// 来源应用显示名(AUMID 简化,友好名映射 P1)
pub source_app: String,
/// 是否 Thing 自身播放(封面/元数据兜底、seek 直通判定)
pub is_thing: bool,
pub title: String,
pub artist: String,
pub album: String,
/// 封面缓存键;封面从 `GET /cover/:hash` 拉取
pub cover_hash: Option<String>,
pub status: PlayStatus,
pub duration_sec: f64,
/// 推送时刻的播放位置(秒)
pub position_sec: f64,
/// 电脑时钟毫秒(源自 TimelineProperties.LastUpdatedTime,§6.4)。
/// **仅供校准**:手机端 elapsed 一律以本地收包时刻起算(§6.10)
pub position_updated_at_ms: i64,
pub playback_rate: f64,
pub can_control: CanControl,
/// 系统主音量(0.0~1.0;None = 音频端点不可用,手机端隐藏音量条)。P1 §7
pub volume: Option<f64>,
/// 系统主音量静音位
pub muted: bool,
/// 电脑标识(beacon 同源,多电脑预留)
pub device_id: String,
}
impl Default for NowPlaying {
fn default() -> Self {
Self {
session_id: String::new(),
source_app: String::new(),
is_thing: false,
title: String::new(),
artist: String::new(),
album: String::new(),
cover_hash: None,
status: PlayStatus::Stopped,
duration_sec: 0.0,
position_sec: 0.0,
position_updated_at_ms: 0,
playback_rate: 1.0,
can_control: CanControl {
play: false,
pause: false,
next: false,
prev: false,
seek: false,
},
volume: None,
muted: false,
device_id: String::new(),
}
}
}
impl NowPlaying {
/// 「无播放」快照(§5.2 两者都无:status = stopped,手机显示"电脑未在播放")。
pub fn stopped(device_id: &str) -> Self {
Self {
device_id: device_id.to_string(),
..Default::default()
}
}
}
/// 会话列表条目(P1 §7 多会话切换:手机端可选"控制哪个应用")。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionInfo {
pub session_id: String,
pub source_app: String,
pub title: String,
pub artist: String,
pub status: PlayStatus,
pub is_thing: bool,
/// 是否当前展示/控制目标(Thing 侧选中覆盖;无覆盖时为系统 current)
pub is_current: bool,
}
/// 播放队列条目(Thing 专属:本机播放器的队列,手机端可选歌)。
///
/// `index` 是**在完整队列里的绝对下标**——下发时允许只带当前附近的一段
/// (前端最多推 500 条,见 feiniuStore),手机端跳歌直接把 index 回传。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct QueueItem {
pub index: i64,
pub title: String,
pub artist: String,
pub duration_sec: f64,
}
/// 播放队列快照(WS `queue` 消息;`total` 是完整队列长度,可能大于 `items` 条数)。
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct QueueSnapshot {
pub items: Vec<QueueItem>,
/// 当前播放条目在完整队列中的下标(-1 = 未在队列中播放)
pub index: i64,
pub total: i64,
}
/// 会话 key(§4.1 / §6.5):Thing 自身固定为 `thing.self`,其余直接用 AUMID。
pub fn session_key(aumid: &str) -> String {
if is_thing_aumid(aumid) {
THING_SELF_SESSION.to_string()
} else {
aumid.to_string()
}
}
/// AUMID 是否为 Thing 自身。
pub fn is_thing_aumid(aumid: &str) -> bool {
aumid.eq_ignore_ascii_case(THING_AUMID)
}
/// 来源应用显示名(P0:取 AUMID 简化段;注册表友好名映射在 P1 §6.7)。
///
/// AUMID 形态:`PackageFamilyName!App` | `C:\Path\App.exe -Args` | `ProgId.App`。
pub fn source_display(aumid: &str) -> String {
// Thing 自身 AUMID 是标识符而非程序名,直接给友好名
if is_thing_aumid(aumid) {
return "Thing".to_string();
}
let core = aumid
.split(['!', '\\'])
.next_back()
.unwrap_or(aumid)
.split(' ')
.next()
.unwrap_or(aumid);
core.trim().trim_end_matches(".exe").to_string()
}
/// 控制动作(§4.2 `cmd.action`;Volume/Select 为 P1 扩展)。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum CmdAction {
Play,
Pause,
Toggle,
Next,
Prev,
Stop,
Seek,
/// 系统主音量:args.level(0.0~1.0;>0 时顺带解除静音)
Volume,
/// 切换展示/控制的会话:args.sessionId(空串 = 取消覆盖,跟随系统 current)
Select,
/// 跳到队列指定条目(Thing 专属):args.index = 队列绝对下标
Jump,
}
/// `cmd` 的可选参数(serde default:缺省字段按0/空处理,各动作只读自己需要的)。
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CmdArgs {
/// seek 目标位置(秒)
#[serde(default)]
pub pos_sec: f64,
/// volume 目标音量(0.0~1.0)
#[serde(default)]
pub level: f64,
/// select 目标会话(空串 = 跟随系统)
#[serde(default)]
pub session_id: String,
/// jump 目标下标(队列绝对下标;-1 = 未提供)
#[serde(default = "jump_index_default")]
pub index: i64,
}
fn jump_index_default() -> i64 {
-1
}
/// WS 消息(§4.2)。`type` 字段判别;`state` 展平 [`NowPlaying`] 字段。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "type",
rename_all = "camelCase",
rename_all_fields = "camelCase"
)]
pub enum WsMessage {
/// c→s:连接后首条,失败即断开
Hello {
token: String,
device_name: String,
proto_ver: u32,
},
/// s→c:鉴权通过
Welcome {
device_id: String,
device_name: String,
proto_ver: u32,
},
/// s→c:全量状态(连接后、变更、cmd 触发立即帧)
State {
#[serde(flatten)]
now: NowPlaying,
},
/// s→c:会话列表(P1;连接后、列表或当前目标变化时推送)
Sessions {
sessions: Vec<SessionInfo>,
},
/// s→c:Thing 本机播放队列(连接后、队列或当前曲目变化时推送)
Queue {
items: Vec<QueueItem>,
index: i64,
total: i64,
},
/// c→s:用户操作
Cmd {
id: String,
action: CmdAction,
#[serde(default, skip_serializing_if = "Option::is_none")]
args: Option<CmdArgs>,
},
/// s→c:回执(语义 = 指令已被接受/派发,状态以随后的 `state` 为准)
///
/// 显式 rename:外层 `rename_all = "camelCase"` 会把变体名也转成 `cmdAck`,
/// 而 §4.2 线格式与手机端都写的是 `cmd-ack` —— 不锁死就会让手机端把
/// **每一条错误回执都静默丢掉**(见 `cmd_ack_wire_type` 单测)。
#[serde(rename = "cmd-ack")]
CmdAck {
id: String,
ok: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
error: Option<String>,
},
/// c→s / s→c:30s 心跳
Ping { ts: i64 },
Pong { ts: i64 },
}
/// WinRT `DateTime.UniversalTime`(100ns since **1601-01-01 UTC**,即 FILETIME 纪元)→ Unix 毫秒。
/// `positionUpdatedAtMs` 的换算基准(§6.4:源是 `LastUpdatedTime`)。
///
/// 纪元是实测确认的(不是 .NET 的 0001-01-01):`gsmtc_dump` 里 QQMusic/Thing 会话的
/// `LastUpdatedTime` ≈1.343e17 ticks,按 1601 纪元换算分别落在"47 分钟前 / 4.5 秒前",
/// 与实际播放/暂停时刻吻合;按 0001 纪元则落在公元 426 年——Windows.Media.Control 的
/// `TimelineProperties.LastUpdatedTime` 走 FILETIME,用错纪元会得到巨额负数,
/// 手机端 `positionUpdatedAtMs > 0` 判定恒假 → 时钟偏差冻结(§6.10)形同虚设。
pub fn winrt_ticks_to_unix_ms(ticks: i64) -> i64 {
// 1601-01-01 → 1970-01-01:621355968 天 × 86400s × 1e7 ticks ÷ 1e4
ticks / 10_000 - 11_644_473_600_000
}
#[cfg(test)]
mod tests {
use super::*;
/// 序列化往返:保证双端 JSON 形状与字段名(camelCase)稳定(P0 单测项)。
#[test]
fn now_playing_roundtrip() {
let np = NowPlaying {
session_id: THING_SELF_SESSION.to_string(),
source_app: "网易云播放器".to_string(),
is_thing: false,
title: "园游会".to_string(),
artist: "周杰伦".to_string(),
album: "七里香".to_string(),
cover_hash: Some("ab12".to_string()),
status: PlayStatus::Playing,
duration_sec: 255.5,
position_sec: 12.25,
position_updated_at_ms: 1_790_000_000_000,
playback_rate: 1.0,
can_control: CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
volume: Some(0.66),
muted: false,
device_id: "dev1".to_string(),
};
let msg = WsMessage::State { now: np.clone() };
let json = serde_json::to_string(&msg).unwrap();
// 字段名锁定(camelCase;双端漂移防线)
assert!(json.contains("\"type\":\"state\""));
assert!(json.contains("\"sessionId\""));
assert!(json.contains("\"coverHash\""));
assert!(json.contains("\"positionUpdatedAtMs\""));
assert!(json.contains("\"canControl\""));
assert!(json.contains("\"isThing\""));
assert!(json.contains("\"status\":\"playing\""));
assert!(json.contains("\"volume\":0.66"));
assert!(json.contains("\"muted\":false"));
let back: WsMessage = serde_json::from_str(&json).unwrap();
assert_eq!(back, msg);
}
/// P1:sessions 消息与 select/volume 动作的线格式锁定。
#[test]
fn sessions_and_p1_actions_roundtrip() {
let msg = WsMessage::Sessions {
sessions: vec![SessionInfo {
session_id: THING_SELF_SESSION.to_string(),
source_app: "Thing".into(),
title: "园游会".into(),
artist: "周杰伦".into(),
status: PlayStatus::Playing,
is_thing: true,
is_current: true,
}],
};
let json = serde_json::to_string(&msg).unwrap();
assert!(json.contains("\"type\":\"sessions\""));
assert!(json.contains("\"isCurrent\":true"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), msg);
let volume = WsMessage::Cmd {
id: "v1".into(),
action: CmdAction::Volume,
args: Some(CmdArgs {
level: 0.5,
..Default::default()
}),
};
let json = serde_json::to_string(&volume).unwrap();
assert!(json.contains("\"action\":\"volume\""));
assert!(json.contains("\"level\":0.5"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), volume);
let select = WsMessage::Cmd {
id: "s1".into(),
action: CmdAction::Select,
args: Some(CmdArgs {
session_id: THING_SELF_SESSION.into(),
..Default::default()
}),
};
let json = serde_json::to_string(&select).unwrap();
assert!(json.contains("\"action\":\"select\""));
assert!(json.contains("\"sessionId\":\"thing.self\""));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), select);
// 队列下发 + 选歌(Thing 专属能力)的线格式锁定
let queue = WsMessage::Queue {
items: vec![QueueItem {
index: 7,
title: "园游会".into(),
artist: "周杰伦".into(),
duration_sec: 255.5,
}],
index: 7,
total: 120,
};
let json = serde_json::to_string(&queue).unwrap();
assert!(json.contains("\"type\":\"queue\""));
assert!(json.contains("\"items\""));
assert!(json.contains("\"durationSec\":255.5"));
assert!(json.contains("\"total\":120"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), queue);
let jump = WsMessage::Cmd {
id: "j1".into(),
action: CmdAction::Jump,
args: Some(CmdArgs {
index: 7,
..Default::default()
}),
};
let json = serde_json::to_string(&jump).unwrap();
assert!(json.contains("\"action\":\"jump\""));
assert!(json.contains("\"index\":7"));
// 缺 index 的旧客户端 → 反序列化为 -1(服务端据此拒绝)
assert_eq!(serde_json::from_str::<CmdArgs>(r#"{}"#).unwrap().index, -1);
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), jump);
}
#[test]
fn hello_ack_cmd_roundtrip() {
for msg in [
WsMessage::Hello {
token: "t".repeat(64),
device_name: "Pixel".to_string(),
proto_ver: PROTO_VER,
},
WsMessage::Welcome {
device_id: "d".to_string(),
device_name: "Thing".to_string(),
proto_ver: PROTO_VER,
},
WsMessage::Cmd {
id: "1".to_string(),
action: CmdAction::Seek,
args: Some(CmdArgs {
pos_sec: 42.0,
..Default::default()
}),
},
WsMessage::Cmd {
id: "2".to_string(),
action: CmdAction::Toggle,
args: None,
},
WsMessage::CmdAck {
id: "1".to_string(),
ok: false,
error: Some("frontend-unavailable".to_string()),
},
WsMessage::Ping { ts: 1 },
WsMessage::Pong { ts: 1 },
] {
let json = serde_json::to_string(&msg).unwrap();
let back: WsMessage = serde_json::from_str(&json).unwrap();
assert_eq!(back, msg, "{json}");
}
// action 枚举的线格式锁定
let json = serde_json::to_string(&WsMessage::Cmd {
id: "3".into(),
action: CmdAction::Next,
args: None,
})
.unwrap();
assert!(json.contains("\"action\":\"next\""));
// 无 args 时不出现该键
assert!(!json.contains("args"));
}
/// 回执的 `type` 必须是 `cmd-ack`(§4.2 表格与手机端 switch 的字面量)。
/// 外层 `rename_all = "camelCase"` 连变体名一起转,会产出 `cmdAck`——
/// 漏掉显式 rename 时手机端匹配不上,**每一条错误回执都被静默丢掉**
/// (表现为:指令被拒绝却无提示、手机端保持窗口只能等超时才回退)。
#[test]
fn cmd_ack_wire_type() {
let ack = WsMessage::CmdAck {
id: "1".into(),
ok: false,
error: Some("boom".into()),
};
let json = serde_json::to_string(&ack).unwrap();
assert!(json.contains("\"type\":\"cmd-ack\""), "{json}");
assert!(!json.contains("cmdAck"), "{json}");
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), ack);
}
#[test]
fn session_key_and_display() {
assert_eq!(session_key(THING_AUMID), THING_SELF_SESSION);
assert_eq!(session_key("cloudmusic.exe"), "cloudmusic.exe");
assert!(is_thing_aumid("Thing.Lfeng.ME"));
assert_eq!(
source_display(r"KuGou\kugou.exe"),
"kugou".to_string()
);
assert_eq!(source_display("Museify_zzdnekvpz2s88!Spotify"), "Spotify");
// Thing 自身 AUMID → 友好名(手机端不应看到 thing.lfeng.me)
assert_eq!(source_display(THING_AUMID), "Thing");
}
/// WinRT DateTime(100ns since **1601-01-01**,FILETIME 纪元)→ Unix 毫秒(§6.4 换算基准)。
#[test]
fn winrt_datetime_to_unix_ms() {
// 1970-01-01 的 FILETIME ticks:621355968 天 × 86400s × 1e7
assert_eq!(winrt_ticks_to_unix_ms(116_444_736_000_000_000), 0);
// 2026-09-25 00:00:00 UTC ≈ 1_790_332_800_000 ms
let unix_ms = 1_790_332_800_000i64;
let ticks = (unix_ms + 11_644_473_600_000) * 10_000;
assert_eq!(winrt_ticks_to_unix_ms(ticks), unix_ms);
// 实测样本(gsmtc_dump 抓到的 Thing 自身会话 LastUpdatedTime):
// 对应 1790499938437 ms,即抓取时刻 4.5 秒前——按 0001 纪元算会落到公元 426 年
assert_eq!(
winrt_ticks_to_unix_ms(134_349_735_384_378_473),
1_790_499_938_437
);
// 0 = 来源从未上报过时间轴(bilibili PC 实测)→ 换算必为负,
// 调用方(glsmtc)据此钳成 0 作「无进度基准」哨兵
assert!(winrt_ticks_to_unix_ms(0) < 0);
}
}
+610
View File
@@ -0,0 +1,610 @@
//! 局域网服务:axum HTTP + WebSocket(MUSIC_REMOTE_PLAN §3.2 / §4.2 / §5.1 `server.rs`)。
//!
//! | 端点 | 用途 |
//! |---|---|
//! | `/ws` | 主通道:hello 鉴权、state 推送、cmd 控制、心跳 |
//! | `/api/state` | REST 快照兜底(Bearer) |
//! | `/cover/:hash` | 封面字节流(`<img>` 带不了 header → `?t=token`) |
//! | `/pair` | 配对换 token(6 位码 + 限速) |
//!
//! 全部监听 `0.0.0.0`;实际端口在启动时按 26124→26139 探测(§3.2),
//! 由 RemoteManager 写回 beacon 与配对二维码。
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use axum::extract::ws::{Message as AxumWs, WebSocket, WebSocketUpgrade};
use axum::extract::{ConnectInfo, Path, Query, State};
use axum::http::{header, HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::{get, post};
use axum::{Json, Router};
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Emitter, Manager};
use super::glsmtc;
use super::pairing::{self, RemoteDeviceMeta};
use super::proto::{
CmdAction, CmdArgs, NowPlaying, WsMessage, PROTO_VER,
};
use super::RemoteManager;
use crate::music::{AudioEngine, MusicManager};
use crate::music::smtc::SMTC_BUTTON_EVENT;
/// WS 首条消息(hello)超时(§4.2 连接后首条)。
const HELLO_TIMEOUT: Duration = Duration::from_secs(10);
/// 心跳周期(§4.2 30s 双向判活)。
const HEARTBEAT: Duration = Duration::from_secs(30);
/// 超过该时长无任何入站消息 → 判死断开(§5.4 心跳判活)。
const IDLE_TIMEOUT: Duration = Duration::from_secs(90);
#[derive(Clone)]
pub struct AppState {
pub app: AppHandle,
}
/// 构建路由(§3.2 四个端点)。
pub fn router(app: AppHandle) -> Router {
Router::new()
.route("/ws", get(ws_upgrade))
.route("/api/state", get(api_state))
.route("/cover/:hash", get(cover))
.route("/pair", post(pair))
.with_state(AppState { app })
}
/// 启动服务:preferred=0 时从 26124 起,被占 +1 直至 26139(§3.2)。
/// 成功返回(实际端口, serve 任务句柄);stop 时由 RemoteManager abort。
pub async fn start(
app: AppHandle,
preferred: u16,
) -> Result<(u16, tokio::task::JoinHandle<()>), String> {
let from = if preferred == 0 { 26124 } else { preferred };
let to = from.clamp(26124, 26139).min(26139);
let mut bound: Option<(u16, tokio::net::TcpListener)> = None;
for port in from..=to {
match tokio::net::TcpListener::bind(("0.0.0.0", port)).await {
Ok(l) => {
bound = Some((port, l));
break;
}
Err(e) => {
crate::logger::log_warn(
"music-remote",
&format!("端口 {port} 绑定失败({e}),尝试下一个"),
);
}
}
}
let (port, listener) = bound.ok_or_else(|| {
format!("远程服务端口 {from}-{to} 全部不可用(被占用或无权限)")
})?;
let router = router(app);
let handle = tokio::task::spawn(async move {
let svc = router.into_make_service_with_connect_info::<SocketAddr>();
if let Err(e) = axum::serve(listener, svc).await {
// abort 时 axum::serve 返回的错误走这里降级为日志(abort 本身另算)
crate::logger::log_warn("music-remote", &format!("axum 服务结束: {e}"));
}
});
Ok((port, handle))
}
// ---------------------------------------------------------------------------
// 鉴权
// ---------------------------------------------------------------------------
fn bearer_token(headers: &HeaderMap) -> Option<String> {
headers
.get(header::AUTHORIZATION)?
.to_str()
.ok()?
.strip_prefix("Bearer ")
.map(|s| s.to_string())
}
/// 校验设备 token → 设备信息;失败为 None(不做限速——限速由调用方按场景加)。
fn validate_token(app: &AppHandle, token: &str) -> Option<RemoteDeviceMeta> {
let music = app.state::<MusicManager>();
let settings = music.load_settings();
pairing::device_by_token(&settings.remote_devices, token)
}
fn require_bearer(app: &AppHandle, headers: &HeaderMap) -> Result<RemoteDeviceMeta, StatusCode> {
let token = bearer_token(headers).ok_or(StatusCode::UNAUTHORIZED)?;
validate_token(app, &token).ok_or(StatusCode::UNAUTHORIZED)
}
// ---------------------------------------------------------------------------
// REST:/api/state、/cover/:hash
// ---------------------------------------------------------------------------
async fn api_state(
State(st): State<AppState>,
headers: HeaderMap,
) -> Result<Json<NowPlaying>, StatusCode> {
require_bearer(&st.app, &headers)?;
let remote = st.app.state::<RemoteManager>();
Ok(Json(remote.now_playing()))
}
#[derive(Deserialize)]
struct CoverQuery {
/// 鉴权 token(`<img>` 无法带 Authorization header,§3.2)
#[serde(rename = "t")]
t: Option<String>,
}
async fn cover(
State(st): State<AppState>,
Path(hash): Path<String>,
Query(q): Query<CoverQuery>,
headers: HeaderMap,
) -> Result<Response, StatusCode> {
let token = q.t.or_else(|| bearer_token(&headers));
let token = token.ok_or(StatusCode::UNAUTHORIZED)?;
validate_token(&st.app, &token).ok_or(StatusCode::UNAUTHORIZED)?;
let remote = st.app.state::<RemoteManager>();
let bytes = remote.covers.get(&hash).ok_or(StatusCode::NOT_FOUND)?;
// 访问日志不打印 query(§3.2):logger 不记录请求行,天然满足;此处只管响应
let ct = sniff_content_type(&bytes);
Ok(([(header::CONTENT_TYPE, ct)], bytes).into_response())
}
fn sniff_content_type(bytes: &[u8]) -> &'static str {
if bytes.starts_with(&[0x89, b'P', b'N', b'G']) {
"image/png"
} else if bytes.starts_with(&[0xFF, 0xD8]) {
"image/jpeg"
} else if bytes.len() > 12 && &bytes[0..4] == b"RIFF" && &bytes[8..12] == b"WEBP" {
"image/webp"
} else {
"application/octet-stream"
}
}
// ---------------------------------------------------------------------------
// POST /pair(§3.4)
// ---------------------------------------------------------------------------
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct PairRequest {
pairing_code: String,
device_name: String,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PairResponse {
token: String,
device_id: String,
}
#[derive(Serialize)]
struct HttpError {
error: String,
}
async fn pair(
State(st): State<AppState>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
Json(req): Json<PairRequest>,
) -> Result<(StatusCode, Json<PairResponse>), (StatusCode, Json<HttpError>)> {
let ip = addr.ip().to_string();
let remote = st.app.state::<RemoteManager>();
let denied = |msg: &str| {
(
StatusCode::TOO_MANY_REQUESTS,
Json(HttpError {
error: msg.to_string(),
}),
)
};
if !remote.auth.allowed(&ip) {
return Err(denied("尝试过于频繁,60s 后再试"));
}
// 配对码校验:存在 + 未过期 + 匹配(一次性:成功即清除)
match remote.take_pairing_if_match(&req.pairing_code) {
Ok(()) => remote.auth.ok(&ip),
Err(e) => {
remote.auth.fail(&ip);
return Err((
StatusCode::FORBIDDEN,
Json(HttpError { error: e }),
));
}
}
let device_id = pairing::random_device_id();
let token = pairing::random_token();
// token 先入凭据库,成功才落设备表(§3.4-3 顺序)
let key = pairing::token_key(&device_id);
if let Err(e) = crate::secrets::secret_write(&key, &token) {
crate::logger::log_error("music-remote", &format!("设备 token 写入凭据库失败: {e}"));
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
Json(HttpError {
error: "保存设备凭据失败".to_string(),
}),
));
}
let name = if req.device_name.trim().is_empty() {
format!("手机设备 {}", &device_id[..6])
} else {
req.device_name.trim().to_string()
};
let music = st.app.state::<MusicManager>();
let mut settings = music.load_settings();
settings.remote_devices.push(RemoteDeviceMeta {
id: device_id.clone(),
name,
last_connected_ms: 0,
});
if let Err(e) = music.save_settings(&settings) {
crate::logger::log_error("music-remote", &format!("设备表落盘失败: {e}"));
}
crate::logger::log_info(
"music-remote",
format!("设备配对成功: {device_id}({ip})").as_str(),
);
Ok((
StatusCode::OK,
Json(PairResponse { token, device_id }),
))
}
// ---------------------------------------------------------------------------
// WebSocket(§4.2)
// ---------------------------------------------------------------------------
async fn ws_upgrade(
State(st): State<AppState>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
upgrade: WebSocketUpgrade,
) -> Response {
// 升级阶段不鉴权:手机 WebSocket 无法带 Authorization header,
// token 在升级后的首条 `hello` 消息里(§4.2)
upgrade
.on_upgrade(move |socket| handle_socket(st.app, addr, socket))
.into_response()
}
async fn handle_socket(app: AppHandle, addr: SocketAddr, socket: WebSocket) {
let ip = addr.ip().to_string();
let (mut sink, mut stream) = socket.split();
// 1) 首条必须是 hello(10s 超时)
let hello = match tokio::time::timeout(HELLO_TIMEOUT, stream.next()).await {
Ok(Some(Ok(AxumWs::Text(t)))) => match serde_json::from_str::<WsMessage>(&t) {
Ok(WsMessage::Hello {
token,
device_name,
..
}) => (token, device_name),
_ => {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
},
_ => {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
};
let (token, device_name) = hello;
let remote = app.state::<RemoteManager>();
if !remote.auth.allowed(&ip) {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
let device = match validate_token(&app, &token) {
Some(d) => {
remote.auth.ok(&ip);
d
}
None => {
remote.auth.fail(&ip);
crate::logger::log_warn("music-remote", &format!("hello 鉴权失败({ip})"));
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
};
// 2) 上线登记 + 最后连接时间
remote.mark_online(&device.id, true);
touch_last_connected(&app, &device.id);
// 3) welcome + 首帧 state + 会话列表(§5.1 welcome → 全量;sessions 为 P1)
let mut state_rx = remote.state_tx.subscribe();
let mut sessions_rx = remote.sessions_rx();
let mut queue_rx = remote.queue_rx();
let mut rx = remote.shutdown_rx();
let device_id = device.id.clone();
let send_json = |msg: &WsMessage| -> String { serde_json::to_string(msg).unwrap_or_default() };
if sink
.send(AxumWs::Text(send_json(&WsMessage::Welcome {
device_id: device_id.clone(),
device_name: device_name.clone(),
proto_ver: PROTO_VER,
})))
.await
.is_err()
{
remote.mark_online(&device_id, false);
return;
}
{
let now = remote.now_playing();
let _ = sink
.send(AxumWs::Text(send_json(&WsMessage::State { now })))
.await;
}
{
let sessions = remote.sessions_snapshot();
let _ = sink
.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions })))
.await;
}
{
let q = remote.queue_snapshot();
let _ = sink.send(AxumWs::Text(send_json(&queue_msg(&q)))).await;
}
crate::logger::log_info(
"music-remote",
format!("WS 已连接: {device_name}({ip})").as_str(),
);
// 4) 主循环:入站消息 / 状态变更推送 / 心跳
let mut last_in = Instant::now();
let mut beat = tokio::time::interval(HEARTBEAT);
beat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tokio::select! {
// 心跳与判活(§4.2 / §5.4)
_ = beat.tick() => {
if last_in.elapsed() > IDLE_TIMEOUT {
crate::logger::log_warn("music-remote", &format!("心跳超时,断开 {device_name}({ip})"));
break;
}
if sink.send(AxumWs::Text(send_json(&WsMessage::Ping { ts: now_ms() }))).await.is_err() {
break;
}
}
// 服务停止
_ = rx.changed() => {
if *rx.borrow() { break; }
}
// 状态推送(watch:节流/Force 均已在监视线程收敛,§6.3)
changed = state_rx.changed() => {
if changed.is_err() { break; }
let now = state_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&WsMessage::State { now }))).await.is_err() {
break;
}
}
// 会话列表变更(P1 多会话切换)
changed = sessions_rx.changed() => {
if changed.is_err() { break; }
let sessions = sessions_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions }))).await.is_err() {
break;
}
}
// Thing 本机队列变更(前端发布:切歌 / 增删队列)
changed = queue_rx.changed() => {
if changed.is_err() { break; }
let snap = queue_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&queue_msg(&snap)))).await.is_err() {
break;
}
}
incoming = stream.next() => {
match incoming {
Some(Ok(AxumWs::Text(t))) => {
last_in = Instant::now();
match serde_json::from_str::<WsMessage>(&t) {
Ok(WsMessage::Cmd { id, action, args }) => {
let res = dispatch_cmd(&app, action, args).await;
let ack = WsMessage::CmdAck {
id,
ok: res.is_ok(),
error: res.err(),
};
if sink.send(AxumWs::Text(send_json(&ack))).await.is_err() {
break;
}
// cmd 触发的 state 立即帧由监视线程 Force 产生(§6.3 例外)
}
Ok(WsMessage::Ping { ts }) => {
if sink.send(AxumWs::Text(send_json(&WsMessage::Pong { ts }))).await.is_err() {
break;
}
}
Ok(WsMessage::Pong { .. }) => {}
// 重复 hello / 非法消息:忽略(连接保持,状态以服务端为准)
_ => {}
}
}
Some(Ok(AxumWs::Ping(p))) => {
last_in = Instant::now();
if sink.send(AxumWs::Pong(p)).await.is_err() { break; }
}
Some(Ok(AxumWs::Pong(_))) => { last_in = Instant::now(); }
Some(Ok(AxumWs::Close(_))) | None => break,
Some(Err(_)) => break,
_ => {}
}
}
}
}
remote.mark_online(&device_id, false);
crate::logger::log_info(
"music-remote",
format!("WS 已断开: {device_name}({ip})").as_str(),
);
let _ = sink.send(AxumWs::Close(None)).await;
}
fn now_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
/// 队列快照 → WS 消息(`items`/`index`/`total` 展平成顶层字段)。
fn queue_msg(q: &super::proto::QueueSnapshot) -> WsMessage {
WsMessage::Queue {
items: q.items.clone(),
index: q.index,
total: q.total,
}
}
fn touch_last_connected(app: &AppHandle, device_id: &str) {
let music = app.state::<MusicManager>();
let mut settings = music.load_settings();
if let Some(d) = settings
.remote_devices
.iter_mut()
.find(|d| d.id == device_id)
{
d.last_connected_ms = now_ms();
if let Err(e) = music.save_settings(&settings) {
crate::logger::log_warn("music-remote", &format!("更新最后连接时间失败: {e}"));
}
}
}
/// 执行一条控制指令(§5.1 数据流 + §5.2 兜底规则;P1 扩展 Volume/Select 与 isThing 直通)。
async fn dispatch_cmd(
app: &AppHandle,
action: CmdAction,
args: Option<CmdArgs>,
) -> Result<(), String> {
let remote = app.state::<RemoteManager>();
let np = remote.now_playing();
let gsmtc_ok = remote.gsmtc_ok.load(std::sync::atomic::Ordering::Relaxed);
let a = args.clone().unwrap_or_default();
match action {
// seek:Thing 自身直通 AudioEngine(SMTC 回环无 seek 通道);其他会话走 GSMTC
CmdAction::Seek => {
if args.is_none() || a.pos_sec < 0.0 || !a.pos_sec.is_finite() {
return Err("seek 缺少/非法 args.posSec".into());
}
if np.is_thing {
let engine = app.state::<AudioEngine>();
let active = engine.state().active;
crate::logger::log_info(
"music-remote",
&format!("远程 seek(Thing) pos={:.1} 引擎会话={active}", a.pos_sec),
);
// 引擎无会话(重启后只恢复了队列、还没起播)时 seek 是静默空转,
// 手机端会白等保持窗口才回退——如实报错,让手机端立刻复位并提示
if !active {
return Err("电脑端播放器还没开始播放,先起播才能拖动进度".into());
}
engine.seek(a.pos_sec);
} else if gsmtc_ok {
gctl(np.session_id.clone(), action, args).await?;
} else {
return Err("当前模式不支持该会话的 seek".into());
}
}
// 系统主音量(P1 §7):level>0 自动解除静音(volume::set 内处理)
CmdAction::Volume => {
let Some(_) = args else {
return Err("volume 缺少 args.level".into());
};
if !a.level.is_finite() {
return Err("volume args.level 非法".into());
}
let level = a.level;
tokio::task::spawn_blocking(move || super::volume::set(level))
.await
.map_err(|e| format!("音量任务异常: {e}"))??;
}
// 目标会话切换(P1 §7):空 sessionId = 取消覆盖、跟随系统 current
CmdAction::Select => {
if args.is_none() {
return Err("select 缺少 args.sessionId".into());
}
remote.set_selected(&a.session_id);
}
// 选歌(Thing 专属):队列在前端 store,事件交回前端执行
CmdAction::Jump => {
if !np.is_thing {
return Err("只有 Thing 本机播放支持选歌".into());
}
if args.is_none() || a.index < 0 {
return Err("jump 缺少 args.index".into());
}
let total = remote.queue_snapshot().total;
if total > 0 && a.index >= total {
return Err(format!("队列里没有第 {} 首(共 {total} 首)", a.index + 1));
}
app.emit(super::REMOTE_JUMP_EVENT, a.index)
.map_err(|e| format!("派发到前端失败: {e}"))?;
}
// 按钮类:isThing 直通(P1 §7 跳过系统 SMTC 回环);其他会话 GSMTC;再退事件链兜底
_ => {
if np.is_thing {
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
app.emit(SMTC_BUTTON_EVENT, name)
.map_err(|e| format!("派发到前端失败: {e}"))?;
} else if gsmtc_ok {
gctl(np.session_id.clone(), action, args).await?;
} else {
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
app.emit(SMTC_BUTTON_EVENT, name)
.map_err(|e| format!("派发到前端失败: {e}"))?;
}
}
}
// cmd 触发立即推一帧(§6.3 例外)
remote.notify_state_force();
Ok(())
}
/// 按钮动作 → music-smtc-button 事件载荷(与 smtc.rs 的映射一致)。
fn button_name(action: CmdAction, playing: bool) -> Result<&'static str, String> {
Ok(match action {
CmdAction::Play => "play",
CmdAction::Pause => "pause",
CmdAction::Toggle => {
if playing {
"pause"
} else {
"play"
}
}
CmdAction::Next => "next",
CmdAction::Prev => "prev",
CmdAction::Stop => "stop",
_ => return Err("该动作不支持事件派发".into()),
})
}
/// GSMTC 控制:`.get()` 阻塞等待放 spawn_blocking(§3.1,绝不占 tokio worker/主线程)。
async fn gctl(
session_id: String,
action: CmdAction,
args: Option<CmdArgs>,
) -> Result<(), String> {
tokio::task::spawn_blocking(move || glsmtc::control(&session_id, action, args))
.await
.map_err(|e| format!("控制任务异常: {e}"))?
}
+57
View File
@@ -0,0 +1,57 @@
//! 系统主音量(MUSIC_REMOTE_PLAN P1 §7):MMDevice 默认输出端点的
//! `IAudioEndpointVolume`。
//!
//! 设计取舍:每次调用**现取 COM 对象**(CoCreate + Activate,µs 级开销),
//! 不跨线程持有接口指针——避开 windows-rs 接口的 Send/Sync 争议;
//! 调用频率受控(监视线程 500ms 读一次 + 手机拖动结束发一次 set)。
use windows::core::GUID;
use windows::Win32::Foundation::BOOL;
use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
use windows::Win32::Media::Audio::{eMultimedia, eRender, IMMDevice, IMMDeviceEnumerator};
use windows::Win32::System::Com::{CLSCTX_ALL, CoCreateInstance};
/// CLSID_MMDeviceEnumerator(mmdevapi.h 固定值)
fn clsid_mm_device_enumerator() -> GUID {
GUID::from_u128(0xBCDE0395_E52F_467C_8E3D_C4579291_692E)
}
fn endpoint() -> Result<IAudioEndpointVolume, String> {
unsafe {
let enumerator: IMMDeviceEnumerator =
CoCreateInstance(&clsid_mm_device_enumerator(), None, CLSCTX_ALL)
.map_err(|e| format!("MMDeviceEnumerator 创建失败: {e}"))?;
let device: IMMDevice = enumerator
.GetDefaultAudioEndpoint(eRender, eMultimedia)
.map_err(|e| format!("默认音频输出端点不可用: {e}"))?;
device
.Activate(CLSCTX_ALL, None)
.map_err(|e| format!("IAudioEndpointVolume 激活失败: {e}"))
}
}
/// 读主音量(0.0~1.0)与静音位;端点不可用返回 None(NowPlaying.volume 置空)。
pub fn read() -> Option<(f64, bool)> {
let vol = endpoint().ok()?;
unsafe {
let v = vol.GetMasterVolumeLevelScalar().ok()? as f64;
let muted = vol.GetMute().ok()?.as_bool();
Some((v.clamp(0.0, 1.0), muted))
}
}
/// 设置主音量(0..1 自动 clamp);**level > 0 时顺带解除静音**——
/// 手机拖音量条本意就是"要出声",静音态下拖动即恢复(P1 手机端音量条语义)。
pub fn set(level: f64) -> Result<(), String> {
let vol = endpoint()?;
let l = level.clamp(0.0, 1.0) as f32;
unsafe {
vol.SetMasterVolumeLevelScalar(l, std::ptr::null())
.map_err(|e| format!("设置音量失败: {e}"))?;
if l > 0.0 {
vol.SetMute(BOOL(0), std::ptr::null())
.map_err(|e| format!("解除静音失败: {e}"))?;
}
}
Ok(())
}
+410
View File
@@ -0,0 +1,410 @@
//! Windows 系统媒体传输控件(SMTC)集成。
//!
//! # 为什么不用前端的 `navigator.mediaSession`
//!
//! WebView2(Chromium 内核)确实会把 `navigator.mediaSession` 桥接到 Windows SMTC,
//! 但实测**只转发标题、歌手、播放状态与时长进度**:专辑(`AlbumTitle` / `AlbumArtist` /
//! `Subtitle` 全为空)与封面(同一首曲子缩略图时有时无)都不会送达;
//! 且会话挂在 WebView2 浏览器进程的 AUMID 上,系统面板只显示「未知应用」。
//! 因此这里改用原生 SMTC 直接投递全部字段:歌名、歌手、专辑、时长、进度、封面,
//! 并把系统侧的按钮(播放/暂停/上一首/下一首/停止)回传前端。
//!
//! # 与 WebView2 自动会话的关系(当前未解决,系统面板会同时出现两条「媒体」)
//!
//! Chromium 会为播放中的 `<audio>` 自动再注册一条 SMTC 会话,和本模块并行时
//! 系统面板会出现两条「媒体」。已排除的三条压制路径:
//!
//! - **前端把 `navigator.mediaSession` 置空**:无效。那条会话由浏览器进程按 WebContents
//! 的播放状态创建,**与页面碰不碰 mediaSession 无关**;JS 侧置空只是不再往会话里写
//! 元数据,拦不住它的注册。
//! - **`WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS` 环境变量**(关掉 MediaSessionService):
//! 无效。本应用支持永久提权,而提权进程下 WebView2 会忽略所有 WEBVIEW2_* 环境变量
//! (微软文档 *Develop secure WebView2 apps → For an elevated host app*)。
//! - **`tauri.conf.json` 的 `additionalBrowserArgs`**:能关掉 Chromium 那条会话,但代价是
//! 把这个应用的其他窗口一起弄死——参数只落在主窗口,其余弹窗走 wry 默认参数,两者却
//! 共用同一个 EBWebView 用户数据目录。结果是托盘菜单/截图/剪贴板等窗口的页面**永远
//! 不执行 JS**(日志里没有任何 `xxx窗口启动` 记录),因而永远唤不出;启动也会偶发
//! 卡住一两分钟。
//!
//! 根治只能让主窗口不再持有 `<audio>`(播放搬到 Rust 侧):Chromium 无会话可注册,
//! 也就不需要任何浏览器参数。
//!
//! # 线程与套间
//!
//! `SystemMediaTransportControls` 通过
//! [`ISystemMediaTransportControlsInterop::GetForWindow`] 绑定到主窗口 HWND。
//! WinRT 对象要求所在线程已初始化 COM:主线程由 WebView2 完成初始化,而 tokio 工作线程
//! 没有,因此所有 SMTC 调用统一 `run_on_main_thread` 抛到主线程执行
//! (对象本身是 agile 的,跨线程只涉及调用点,不涉及状态迁移)。
//!
//! # 失败策略
//!
//! 系统媒体控件属于「锦上添花」:任何一步失败都只记日志,绝不影响播放本身。
use std::sync::Mutex;
use tauri::{AppHandle, Emitter, Manager};
use windows::core::{factory, HSTRING};
use windows::Foundation::{TimeSpan, TypedEventHandler};
use windows::Media::{
MediaPlaybackStatus, MediaPlaybackType, SystemMediaTransportControls,
SystemMediaTransportControlsButton, SystemMediaTransportControlsButtonPressedEventArgs,
SystemMediaTransportControlsTimelineProperties,
};
use windows::Storage::Streams::RandomAccessStreamReference;
use windows::Win32::Foundation::HWND;
use windows::Win32::System::WinRT::ISystemMediaTransportControlsInterop;
/// 系统媒体控件按钮事件名:前端监听它来执行播放/暂停/切歌/停止。
pub const SMTC_BUTTON_EVENT: &str = "music-smtc-button";
/// 100 纳秒 ticks/秒(WinRT `TimeSpan` 的单位)。
const TICKS_PER_SEC: f64 = 10_000_000.0;
/// SMTC 控制器:惰性绑定主窗口后缓存。
pub struct SmtcController {
ctrl: Mutex<Option<SystemMediaTransportControls>>,
}
impl SmtcController {
pub fn new() -> Self {
Self {
ctrl: Mutex::new(None),
}
}
}
impl Default for SmtcController {
fn default() -> Self {
Self::new()
}
}
/// 秒 → WinRT `TimeSpan`(100ns ticks),负数与非有限值按 0 处理。
fn ticks(sec: f64) -> TimeSpan {
let v = if sec.is_finite() && sec > 0.0 { sec } else { 0.0 };
TimeSpan {
Duration: (v * TICKS_PER_SEC) as i64,
}
}
/// 取(必要时创建)SMTC 控制器。**必须在主线程调用**。
fn ensure_controls(app: &AppHandle) -> Result<SystemMediaTransportControls, String> {
let state = app.state::<SmtcController>();
if let Some(c) = state
.ctrl
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
{
return Ok(c);
}
let window = app.get_webview_window("main").ok_or("主窗口不存在")?;
let hwnd = window.hwnd().map_err(|e| format!("取窗口句柄失败: {e}"))?;
let interop: ISystemMediaTransportControlsInterop =
factory::<SystemMediaTransportControls, ISystemMediaTransportControlsInterop>()
.map_err(|e| format!("取 SMTC 工厂失败: {e}"))?;
// SAFETY: HWND 来自当前进程的真实主窗口,且在调用期间保持有效。
let ctrl: SystemMediaTransportControls = unsafe {
interop
.GetForWindow(HWND(hwnd.0 as isize))
.map_err(|e| format!("SMTC GetForWindow 失败: {e}"))?
};
// 系统侧按钮 → 前端事件(事件可能从任意线程触发,emit 本身线程安全)。
// 注册失败**不**中断初始化:元数据/封面是主要目的,按钮是附加能力。
let emitter = app.clone();
let handler = TypedEventHandler::<
SystemMediaTransportControls,
SystemMediaTransportControlsButtonPressedEventArgs,
>::new(move |_, args| {
if let Some(args) = args.as_ref() {
if let Ok(button) = args.Button() {
let name = if button == SystemMediaTransportControlsButton::Play {
"play"
} else if button == SystemMediaTransportControlsButton::Pause {
"pause"
} else if button == SystemMediaTransportControlsButton::Next {
"next"
} else if button == SystemMediaTransportControlsButton::Previous {
"prev"
} else if button == SystemMediaTransportControlsButton::Stop {
"stop"
} else {
""
};
if !name.is_empty() {
let _ = emitter.emit(SMTC_BUTTON_EVENT, name);
}
}
}
Ok(())
});
if let Err(e) = ctrl.ButtonPressed(&handler) {
crate::logger::log_error("music", &format!("注册 SMTC 按钮事件失败(按钮不可用): {e}"));
}
// 启用按钮(不启用的话系统面板上的按钮是灰的)
let _ = ctrl.SetIsEnabled(true);
let _ = ctrl.SetIsPlayEnabled(true);
let _ = ctrl.SetIsPauseEnabled(true);
let _ = ctrl.SetIsStopEnabled(true);
let _ = ctrl.SetIsNextEnabled(true);
let _ = ctrl.SetIsPreviousEnabled(true);
*state.ctrl.lock().unwrap_or_else(|e| e.into_inner()) = Some(ctrl.clone());
crate::logger::log_info("music", "SMTC 已初始化(原生系统媒体控件已绑定主窗口)");
Ok(ctrl)
}
/// 把一次 SMTC 操作抛到主线程执行;失败只记日志。
fn on_main<F>(app: &AppHandle, what: &'static str, f: F)
where
F: FnOnce(&SystemMediaTransportControls) + Send + 'static,
{
let app = app.clone();
if let Err(e) = app.clone().run_on_main_thread(move || {
match ensure_controls(&app) {
Ok(ctrl) => f(&ctrl),
Err(e) => crate::logger::log_error("music", &format!("SMTC {what} 失败: {e}")),
}
}) {
crate::logger::log_error("music", &format!("SMTC {what} 投递主线程失败: {e}"));
}
}
/// 更新曲目信息:歌名 / 歌手 / 专辑 / 封面。
///
/// 封面**由我们自己下载字节**再写进内存流交给 SMTC:早先让系统按 URI 自行取图
/// (`RandomAccessStreamReference::CreateFromUri`)实测拿不到(本地代理地址与外链都静默失败),
/// 自取字节才能保证取到的是界面上显示的那张图。
///
/// `cover_url` 为空表示该曲目没有封面——此时必须清掉上一次的缩略图,
/// 否则换到无封面的曲子会继续显示上一首的封面。
#[tauri::command]
#[specta::specta]
pub async fn music_smtc_update_metadata(
app: AppHandle,
title: String,
artist: String,
album: String,
cover_url: Option<String>,
) {
// 回填手机遥控的兜底聚合缓存(MUSIC_REMOTE_PLAN §5.2):先记原始值,
// 后面封面下载/转码失败都不影响这份元数据
if let Some(cache) = app.try_state::<super::SmtcMetaCache>() {
if let Ok(mut g) = cache.0.lock() {
*g = super::SmtcMetaSnapshot {
title: title.clone(),
artist: artist.clone(),
album: album.clone(),
};
}
}
// 下载放在 tokio 线程(主线程不能阻塞);失败只跳过封面,不影响标题/歌手/专辑
let cover = match cover_url.as_deref().filter(|u| !u.is_empty()) {
Some(url) => {
let raw = download_cover(url).await;
// SMTC 的缩略图解码器不认 WebP(飞牛封面接口返回的就是 WebP),
// 必须转成 PNG/JPEG,否则 SetThumbnail 静默失败、面板上永远没有封面
let bytes = raw.as_deref().and_then(normalize_cover_format);
// 留痕便于定位「面板上没有封面」到底是没传地址、下载失败还是格式不支持
crate::logger::log_info(
"music",
&format!(
"SMTC 封面: {url} → {}",
match (&raw, &bytes) {
(None, _) => "下载失败".to_string(),
(Some(r), Some(b)) if r.len() == b.len() => format!("{} 字节", r.len()),
(Some(r), Some(b)) => format!("{} 字节 → 转码后 {} 字节", r.len(), b.len()),
(Some(r), None) => format!("{} 字节但无法解码为图片", r.len()),
}
),
);
bytes
}
None => {
crate::logger::log_info("music", "SMTC 封面: 该曲目未提供封面地址");
None
}
};
on_main(&app, "metadata", move |ctrl| {
apply_metadata(ctrl, &title, &artist, &album, cover.as_deref());
});
}
/// 把元数据与封面写进 SMTC(主线程执行)。
fn apply_metadata(
ctrl: &SystemMediaTransportControls,
title: &str,
artist: &str,
album: &str,
cover: Option<&[u8]>,
) {
let Ok(updater) = ctrl.DisplayUpdater() else {
return;
};
// ClearAll 会连元数据一起清,因此无封面时先清再整体重写(顺序不能颠倒)
if cover.is_none() {
let _ = updater.ClearAll();
}
let _ = updater.SetType(MediaPlaybackType::Music);
if let Ok(props) = updater.MusicProperties() {
let _ = props.SetTitle(&HSTRING::from(title));
let _ = props.SetArtist(&HSTRING::from(artist));
let _ = props.SetAlbumTitle(&HSTRING::from(album));
}
if let Some(bytes) = cover {
match stream_reference_from_bytes(bytes) {
Ok(reference) => {
let _ = updater.SetThumbnail(&reference);
}
Err(e) => crate::logger::log_error("music", &format!("设置 SMTC 封面失败: {e}")),
}
}
let _ = updater.Update();
}
/// 把封面字节统一成 SMTC 能解码的格式(PNG)。
///
/// Windows 系统媒体面板的缩略图解码器只认常见位图格式,**不认 WebP**——而飞牛封面接口
/// 返回的正是 WebP(`image/webp`)。不转码的话 `SetThumbnail` 会静默失败,
/// 表现就是「歌名/歌手/专辑都对,就是没有封面」。
/// 已经是 PNG/JPEG 时原样返回,避免无谓的重新编码。
fn normalize_cover_format(bytes: &[u8]) -> Option<Vec<u8>> {
use image::ImageFormat;
match image::guess_format(bytes) {
Ok(ImageFormat::Png) | Ok(ImageFormat::Jpeg) => Some(bytes.to_vec()),
Ok(other) => match image::load_from_memory(bytes) {
Ok(img) => {
let mut out = std::io::Cursor::new(Vec::new());
match img.write_to(&mut out, ImageFormat::Png) {
Ok(()) => Some(out.into_inner()),
Err(e) => {
crate::logger::log_error("music", &format!("封面转 PNG 失败({other:?}): {e}"));
None
}
}
}
Err(e) => {
crate::logger::log_error("music", &format!("封面解码失败({other:?}): {e}"));
None
}
},
Err(e) => {
crate::logger::log_error("music", &format!("无法识别封面格式: {e}"));
None
}
}
}
/// 下载封面图片字节;任何失败都返回 `None`(只记日志,不影响其余元数据)。
async fn download_cover(url: &str) -> Option<Vec<u8>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(10))
.build()
.ok()?;
let resp = match client
.get(url)
.header("User-Agent", "Thing/1.0")
.send()
.await
{
Ok(r) if r.status().is_success() => r,
Ok(r) => {
crate::logger::log_error("music", &format!("封面下载失败(HTTP {}): {url}", r.status()));
return None;
}
Err(e) => {
crate::logger::log_error("music", &format!("封面下载失败({e}): {url}"));
return None;
}
};
match resp.bytes().await {
Ok(b) if !b.is_empty() => Some(b.to_vec()),
Ok(_) => None,
Err(e) => {
crate::logger::log_error("music", &format!("封面读取失败({e}): {url}"));
None
}
}
}
/// 把图片字节写进内存流,并包装成 SMTC 需要的流引用。
fn stream_reference_from_bytes(bytes: &[u8]) -> Result<RandomAccessStreamReference, String> {
use windows::Storage::Streams::{DataWriter, InMemoryRandomAccessStream};
let stream = InMemoryRandomAccessStream::new().map_err(|e| format!("创建内存流失败: {e}"))?;
let output = stream
.GetOutputStreamAt(0)
.map_err(|e| format!("取输出流失败: {e}"))?;
let writer = DataWriter::CreateDataWriter(&output).map_err(|e| format!("创建写入器失败: {e}"))?;
writer
.WriteBytes(bytes)
.map_err(|e| format!("写入封面字节失败: {e}"))?;
// 内存流的异步写入会立刻完成,这里同步等待即可(get() 阻塞至完成)
writer
.StoreAsync()
.map_err(|e| format!("提交封面字节失败: {e}"))?
.get()
.map_err(|e| format!("提交封面字节失败: {e}"))?;
let _ = writer.FlushAsync();
// 读指针回到起点,否则 SMTC 会读到空数据
stream.Seek(0).map_err(|e| format!("复位流失败: {e}"))?;
RandomAccessStreamReference::CreateFromStream(&stream)
.map_err(|e| format!("创建流引用失败: {e}"))
}
/// 更新时长与当前进度(系统面板的进度条)。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_update_position(app: AppHandle, position_sec: f64, duration_sec: f64) {
on_main(&app, "position", move |ctrl| {
let Ok(props) = SystemMediaTransportControlsTimelineProperties::new() else {
return;
};
let duration = ticks(duration_sec);
let _ = props.SetStartTime(ticks(0.0));
let _ = props.SetEndTime(duration);
let _ = props.SetMinSeekTime(ticks(0.0));
let _ = props.SetMaxSeekTime(duration);
let _ = props.SetPosition(ticks(position_sec.min(duration_sec)));
let _ = ctrl.UpdateTimelineProperties(&props);
});
}
/// 更新播放状态(系统面板据此显示播放/暂停按钮)。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_update_playback_state(app: AppHandle, playing: bool) {
on_main(&app, "playback", move |ctrl| {
let status = if playing {
MediaPlaybackStatus::Playing
} else {
MediaPlaybackStatus::Paused
};
let _ = ctrl.SetPlaybackStatus(status);
});
}
/// 停止播放:清空曲目信息并从系统面板移除。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_clear(app: AppHandle) {
// 兜底缓存同步清空(遥控端随下一帧 state 显示"未在播放")
if let Some(cache) = app.try_state::<super::SmtcMetaCache>() {
if let Ok(mut g) = cache.0.lock() {
*g = super::SmtcMetaSnapshot::default();
}
}
on_main(&app, "clear", move |ctrl| {
let _ = ctrl.SetPlaybackStatus(MediaPlaybackStatus::Stopped);
if let Ok(updater) = ctrl.DisplayUpdater() {
let _ = updater.ClearAll();
let _ = updater.Update();
}
});
}
+6 -2
View File
@@ -377,8 +377,12 @@ pub async fn quickpanel_delete_file(path: String) -> Result<(), String> {
.map_err(|e| format!("删除任务失败: {}", e))?
}
/// 删除文件实现:PowerShell + Microsoft.VisualBasic 移到回收站
fn delete_file_impl(path: &str) -> Result<(), String> {
/// 删除文件实现:PowerShell + Microsoft.VisualBasic 移到回收站。
///
/// `pub(crate)` 是给终端模块的文件面板用的(本地栏的删除同样走回收站,
/// 见 `terminal::local_fs::delete`)—— 回收站语义与「不弹系统错误对话框」
/// 这两点只该有一份实现。
pub(crate) fn delete_file_impl(path: &str) -> Result<(), String> {
#[cfg(windows)]
{
use crate::process_manager::setup_creation_flags;
+24 -1
View File
@@ -14,6 +14,7 @@
use std::sync::Arc;
use tauri::{App, Manager, Wry};
use crate::ai::AiManager;
use crate::download_engine::{DownloadEngine, ExtensionServer};
use crate::logger::LogManager;
use crate::mihomo_manager::MihomoManager;
@@ -64,6 +65,24 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
music.set_app(app.handle().clone());
app.manage(music);
// ===== 手机互联:按设置自启(RemoteManager 本体在 lib.rs 平级 manage)=====
crate::music::init_on_launch(app.handle());
// ===== AI 模块:AiManager(全局供应商配置,主设置 → AI 服务)=====
// 迁移必须在建 State 之前跑:把旧版存在翻译设置里的 AI 引擎(含密钥)搬过来,
// 否则 AiManager 预热缓存时会读走默认配置。迁移逻辑在 translate 侧(要同时读懂
// 两份设置,放这里会让 AI 模块反向依赖业务模块)。
crate::translate::migrate_legacy_ai_engines(&app_data_dir);
let ai = AiManager::new(app_data_dir.clone());
let _ = ai.load_settings();
app.manage(ai);
// ===== dsh 模块:DshManager(DeepSeek Harness 外壳) =====
// 仅注册状态:Node/dsh 的安装、服务进程与 settings.yaml 同步都在命令调用时按需触发
// (启动阶段只有 autoStart 开启时才拉起服务,见 init 末尾)。
let dsh = crate::dsh::DshManager::new(app_data_dir.clone());
app.manage(dsh);
// ===== 翻译模块:TranslateManager =====
// 仅注册状态:设置与密钥都在命令调用时按需读取,启动阶段不发任何网络请求
// (模型可用性校验因此改为懒校验:首次翻译失败时解释原因 + 设置页手动拉取模型列表)。
@@ -168,8 +187,12 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
monitor.auto_start_on_launch(app.handle());
}
// dsh:开启"自动启动"且已安装时拉起 Web 服务(后台线程执行就绪探测,不阻塞启动)。
// 「打开独立窗口」快捷键由前端 dshStore 启动时注册(同截图模块约定)。
crate::dsh::autostart_if_enabled(app.handle());
// 截图快捷键由前端 screenshotStore 启动时调用 screenshot_register_shortcut 注册
// (支持自定义,默认 Ctrl+Alt+A),此处不再硬编码注册
// (支持自定义,默认 F3),此处不再硬编码注册
Ok(())
}
+24 -27
View File
@@ -1,8 +1,8 @@
//! AI 命令助手(P2)。
//!
//! 根据用户意图(+ 可选的终端上下文)生成可执行的命令建议。
//! **复用翻译模块的 AI 引擎配置**:引擎列表、Base URL、模型、密钥
//! (凭据管理器)全部来自 translate 的设置——用户只需配置一份 API。
//! **复用主设置的全局 AI 供应商**(`ai` 模块):引擎列表、Base URL、模型、密钥
//! 全部来自主设置 → AI 服务——用户只需配置一份 API。
//!
//! # 输出契约(与模型约定的 JSON)
//!
@@ -14,11 +14,9 @@
use serde::Serialize;
use specta::Type;
use crate::translate::chat_once;
use crate::translate::TranslateEngineConfig;
use crate::translate::TranslateSettings;
use crate::ai::{chat_once, AiProviderConfig, AiSettings};
/// 可用于命令生成的引擎(kind = "ai" 且配置完整)。
/// 可用于命令生成的供应商(已启用且配置了 Base URL)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AiEngineOption {
@@ -48,27 +46,18 @@ const SYSTEM_PROMPT: &str = r#"你是终端命令助手。根据用户的意图
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| {
/// 列出可用于命令生成的 AI 供应商(保持主设置顺序;已启用且配置了 Base URL)。
pub fn ai_engine_options(settings: &AiSettings) -> Vec<AiEngineOption> {
settings
.engines
.providers
.iter()
.find(|e| e.id == o.id)
.map(|e| e.priority)
.unwrap_or(100)
});
opts
.filter(|p| p.enabled && !p.base_url.trim().is_empty())
.map(|p| AiEngineOption {
id: p.id.clone(),
name: p.name.clone(),
model: p.model.clone(),
})
.collect()
}
/// 生成命令建议。
@@ -76,9 +65,11 @@ pub fn ai_engine_options(settings: &TranslateSettings) -> Vec<AiEngineOption> {
/// `context` 是可选的终端最近输出/选中文本(前端从 xterm 缓冲取),
/// 帮助模型理解「接着上一步做什么」;为空则只看意图。
pub async fn suggest(
engine: &TranslateEngineConfig,
engine: &AiProviderConfig,
intent: &str,
context: &str,
settings: &AiSettings,
data_dir: &std::path::Path,
) -> Result<Vec<CommandSuggestion>, String> {
if intent.trim().is_empty() {
return Err("请先描述你想做什么".to_string());
@@ -92,7 +83,13 @@ pub async fn suggest(
user.push_str(&format!("\n\n终端最近的输出(供参考):\n{ctx}"));
}
let raw = chat_once(engine, vec![("system", SYSTEM_PROMPT.to_string()), ("user", user)]).await?;
let raw = chat_once(
engine,
vec![("system", SYSTEM_PROMPT.to_string()), ("user", user)],
settings,
data_dir,
)
.await?;
parse_suggestions(&raw)
}
+184 -21
View File
@@ -31,7 +31,7 @@ use super::settings::{
ShortcutBinding, SshHost, TerminalSettings,
};
use super::ssh::{self, hostkey, SshConnectParams};
use super::{encoding, manager, shell, window, TerminalManager};
use super::{encoding, local_fs, manager, shell, window, TerminalManager};
// ===== 通用返回 =====
@@ -204,8 +204,9 @@ pub async fn terminal_save_shell(
) -> Result<Vec<ShellProfile>, String> {
let m = manager(&app)?;
// 校验可执行文件存在:不存在的路径存进去,用户新建会话时才失败,
// 那时的错误信息离「配置错了」很远,很难定位。
if !std::path::Path::new(&shell_profile.path).is_file() {
// 那时的错误信息离「配置错了」很远,很难定位。裸命令名(如 `wsl.exe`)
// 按 PATH 解析后再校验,避免手填的命令名被误判为不存在。
if shell::resolve_executable(&shell_profile.path).is_none() {
return Err(format!("可执行文件不存在:{}", shell_profile.path));
}
if shell_profile.id.trim().is_empty() {
@@ -279,12 +280,14 @@ pub async fn terminal_open_local(
.cloned()
.ok_or_else(|| format!("Shell {shell_id} 不存在,请到终端设置中重新探测。"))?;
if !std::path::Path::new(&profile.path).is_file() {
return Err(format!(
// 存在性校验走 resolve_executable:老配置里 WSL 的 path 是裸命令名 `wsl.exe`,
// 按路径直接判存在会误报「可执行文件不存在」,这里允许用 PATH 把它解析出来。
let resolved = shell::resolve_executable(&profile.path).ok_or_else(|| {
format!(
"Shell 可执行文件不存在:{}。请重新探测或修正路径。",
profile.path
));
}
)
})?;
let id = m.sessions.next_session_id();
let cols = cols.unwrap_or(super::session::DEFAULT_COLS);
@@ -293,6 +296,7 @@ pub async fn terminal_open_local(
// ===== 组装命令行(含 cwd 跟踪 hook)=====
let (hook_args, _hook_file) = shell::cwd_hook_args(&profile, &m.hooks_dir());
let mut effective = profile.clone();
effective.path = resolved;
// hook 参数追加在用户参数之后:用户自定义参数优先(如 `-NoProfile`)
effective.args.extend(hook_args);
let command_line = shell::build_command_line(&effective);
@@ -1491,17 +1495,21 @@ pub async fn terminal_test_shell(shell_id: String, app: AppHandle) -> Result<Act
.cloned()
.ok_or_else(|| format!("Shell {shell_id} 不存在"))?;
if !std::path::Path::new(&profile.path).is_file() {
let resolved = match shell::resolve_executable(&profile.path) {
Some(p) => p,
None => {
return Ok(ActionOutcome {
ok: false,
message: format!("可执行文件不存在:{}", profile.path),
});
})
}
};
// 真启动一次再立刻杀掉:比只检查文件存在更能发现问题
// (如缺少运行时依赖、参数非法、权限不足)
let (hook_args, _f) = shell::cwd_hook_args(&profile, &m.hooks_dir());
let mut eff = profile.clone();
eff.path = resolved;
eff.args.extend(hook_args);
let cmd = shell::build_command_line(&eff);
@@ -1877,6 +1885,74 @@ pub async fn terminal_sftp_rename(
ssh::sftp::rename(&h, &from, &to).await
}
// ===== 本地文件系统(面板本地栏)=====
//
// 四个命令都走 `spawn_blocking`:`read_dir` / `canonicalize` 在**映射的网络盘**
// 或休眠的机械盘上会阻塞数秒,直接在 async 上下文里调用会占住 tokio worker,
// 而 worker 是有限的(面板开着的同时终端还在推输出)。命令本身没有并发需求。
/// 列举本地目录(`path` 为空则用用户主目录)。
#[tauri::command]
#[specta::specta]
pub async fn terminal_local_list(path: String) -> Result<local_fs::LocalDir, String> {
tauri::async_runtime::spawn_blocking(move || local_fs::list_dir(&path))
.await
.map_err(|e| format!("列举本地目录的任务异常退出: {e}"))?
}
/// 创建本地目录(递归)。
#[tauri::command]
#[specta::specta]
pub async fn terminal_local_mkdir(path: String) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || local_fs::create_dir(&path))
.await
.map_err(|e| format!("创建本地目录的任务异常退出: {e}"))?
}
/// 重命名 / 移动本地条目。
#[tauri::command]
#[specta::specta]
pub async fn terminal_local_rename(from: String, to: String) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || local_fs::rename(&from, &to))
.await
.map_err(|e| format!("重命名本地条目的任务异常退出: {e}"))?
}
/// 删除本地条目(**移入回收站**,不是永久删除)。
///
/// 部分成功时 `ok=false` 但 `message` 里带上成功数:面板据此把提示做成
/// 「警告」而不是「失败」—— 选中的 10 个文件里有一个正被占用,
/// 另外 9 个确实已经进了回收站,报成失败会让用户以为都没删掉。
#[tauri::command]
#[specta::specta]
pub async fn terminal_local_delete(paths: Vec<String>) -> Result<ActionOutcome, String> {
let (removed, failed) = tauri::async_runtime::spawn_blocking(move || local_fs::delete(&paths))
.await
.map_err(|e| format!("删除本地条目的任务异常退出: {e}"))?;
if failed.is_empty() {
return Ok(ActionOutcome::ok(format!("已移入回收站 {removed} 项")));
}
Ok(ActionOutcome {
ok: false,
message: format!(
"已移入回收站 {removed} 项,失败 {} 项:{}",
failed.len(),
failed.join(";")
),
})
}
/// 打开(或唤出)文件管理器独立窗口。
///
/// 单例:窗口已存在时只 show + focus(见 `window::open_file_window`)。
#[tauri::command]
#[specta::specta]
pub async fn terminal_file_window_open(app: AppHandle) -> Result<ActionOutcome, String> {
window::open_file_window(&app)?;
Ok(ActionOutcome::ok("文件窗口已就绪"))
}
/// 上传本地文件到远端。
///
/// 进度经 `terminal-transfer-progress` 事件回报;本命令在传输完成后返回。
@@ -2046,6 +2122,94 @@ pub async fn terminal_sftp_download(
)))
}
/// 在两个 SSH 会话之间中继文件(远端 → 远端,不经本地磁盘)。
///
/// 进度事件里的 `sessionId` 取**目标**会话:进度条要跟着「东西落到哪」那一侧,
/// 而失败原因(目标写不进去)也都是目标侧的。
#[tauri::command]
#[specta::specta]
pub async fn terminal_sftp_relay(
app: AppHandle,
from_session_id: String,
from_path: String,
to_session_id: String,
to_path: String,
) -> Result<ActionOutcome, String> {
if from_session_id == to_session_id && from_path == to_path {
return Err("源与目标是同一个文件".to_string());
}
let m = manager(&app)?;
let from = m
.sftp
.get(&from_session_id)
.ok_or_else(|| "源会话的文件管理器尚未打开".to_string())?;
let to = m
.sftp
.get(&to_session_id)
.ok_or_else(|| "目标会话的文件管理器尚未打开".to_string())?;
let id = format!("t{}", super::session::now_millis());
let sid = to_session_id.clone();
// 与上传/下载同款:每 200ms 才发一次事件(见 `terminal_sftp_upload` 的说明)
let last_emit = std::sync::Arc::new(std::sync::Mutex::new(0u64));
let progress_app = app.clone();
let progress_id = id.clone();
let src = from_path.clone();
let dst = to_path.clone();
let sid_for_progress = sid.clone();
let sent = match ssh::sftp::relay_file(&from, &from_path, &to, &to_path, |done, total| {
let now = super::session::now_millis();
let mut last = last_emit.lock().unwrap_or_else(|e| e.into_inner());
if done < total && now - *last < 200 {
return;
}
*last = now;
crate::terminal::emit_transfer(
&progress_app,
&super::ssh::sftp::TransferProgress {
id: progress_id.clone(),
session_id: sid_for_progress.clone(),
direction: "relay".to_string(),
source: src.clone(),
target: dst.clone(),
transferred: done,
total,
state: if done >= total { "done" } else { "running" }.to_string(),
error: None,
},
);
})
.await
{
Ok(n) => n,
Err(e) => {
crate::terminal::emit_transfer(
&app,
&super::ssh::sftp::TransferProgress {
id,
session_id: sid,
direction: "relay".to_string(),
source: from_path,
target: to_path,
transferred: 0,
total: 0,
state: "failed".to_string(),
error: Some(e.clone()),
},
);
return Err(e);
}
};
Ok(ActionOutcome::ok(format!(
"已中继 {} 字节到 {to_path}",
sent
)))
}
/// 会话当前工作目录(供 SFTP 面板「跟随终端目录」)。
#[tauri::command]
#[specta::specta]
@@ -2558,19 +2722,19 @@ pub async fn terminal_delete_template(
Ok(m.settings().templates)
}
// ===== AI 命令助手(P2,复用 translate 的 AI 引擎配置)=====
// ===== AI 命令助手(P2,复用主设置的全局 AI 供应商)=====
/// 列出可用于命令生成的 AI 引擎(来自翻译设置;按优先级排序)。
/// 列出可用于命令生成的 AI 供应商(来自主设置 → AI 服务;按优先级排序)。
///
/// 没有可用引擎时返回空列表——前端据此引导用户去翻译设置里配置,
/// 没有可用供应商时返回空列表——前端据此引导用户去主设置里配置,
/// 而不是在点击「生成」后才报错。
#[tauri::command]
#[specta::specta]
pub async fn terminal_ai_engines(
app: AppHandle,
) -> Result<Vec<assistant::AiEngineOption>, String> {
let tm = app.state::<crate::translate::TranslateManager>();
let s = tm.load_settings();
let ai = app.state::<crate::ai::AiManager>();
let s = ai.load_settings();
Ok(assistant::ai_engine_options(&s))
}
@@ -2586,16 +2750,15 @@ pub async fn terminal_ai_suggest(
intent: String,
context: String,
) -> Result<Vec<assistant::CommandSuggestion>, String> {
let tm = app.state::<crate::translate::TranslateManager>();
let s = tm.load_settings();
let ai = app.state::<crate::ai::AiManager>();
let s = ai.load_settings();
let engine = s
.engines
.iter()
.find(|e| e.id == engine_id && e.kind == "ai")
.provider(&engine_id)
.cloned()
.ok_or_else(|| "所选引擎不存在或不是 AI 类型".to_string())?;
.ok_or_else(|| "所选 AI 供应商不存在".to_string())?;
let suggestions = assistant::suggest(&engine, &intent, &context).await?;
let data_dir = ai.data_dir().to_path_buf();
let suggestions = assistant::suggest(&engine, &intent, &context, &s, &data_dir).await?;
crate::logger::log_info(
"terminal",
&format!(
+240
View File
@@ -0,0 +1,240 @@
//! 本地文件系统:SFTP 面板「本地栏」的后端。
//!
//! # 为什么本地栏最终还是要自己列目录
//!
//! 面板最初的设计是「本地栏只做定位与选取,浏览交给系统资源管理器」。这条取舍
//! 在**单向上传**的场景下成立,但只要用户想「先看看本地目录里有什么、挑几个传上去」,
//! 就会出现一条断头路:系统对话框只能一次性选出文件,选完就没了,
//! 既不能进目录翻找,也不能就地改名/删除。
//!
//! 代价评估(决定落地):`read_dir` + `create_dir` + `rename` + 回收站删除
//! 是四个薄封装,不引入任何依赖;而浏览体验与远端栏**完全对称**,
//! 用户不需要为「左边和右边为什么不一样」建立两套心智模型。
//!
//! # 与远端栏的一处刻意不对称
//!
//! 远端 `kind` 里 `symlink` 是独立取值(SFTP 的 `attrs` 普遍不带目标类型,
//! 判定链接指向什么要再发一次请求)。本地这边 `symlink_metadata` + `metadata`
//! 两次调用就能**免费**拿到解析结果,因此 `kind` 一律是**解析后**的类型
//! (`dir` / `file` / `other`),是不是链接另由 `linkTarget` 表达。
//! 这样「双击进目录」「这个文件能不能上传」判断逻辑两边一致。
//!
//! # 安全边界
//!
//! 路径来自面板里用户自己的输入/浏览,不做「限制在某个根目录下」的约束 ——
//! 这是本地文件管理器,限制根目录只会挡住用户自己。唯一的硬守卫是
//! **拒绝删除盘符根**(见 [`delete`])。
use std::path::Path;
use std::time::UNIX_EPOCH;
use serde::{Deserialize, Serialize};
use specta::Type;
/// 一个本地目录项(回传前端渲染)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct LocalEntry {
pub name: String,
/// 完整路径(本地形态,Windows 下用 `\` 分隔)
pub path: String,
/// "dir" | "file" | "other"(符号链接返回**目标**的类型,见模块注释)
pub kind: String,
/// 字节数;目录为 0(前端显示为「—」)
pub size: u64,
/// 修改时间(Unix 毫秒;系统未提供时为 None)
pub modified_at: Option<u64>,
/// 符号链接的目标(非链接为 None)
pub link_target: Option<String>,
}
/// 目录列举结果。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct LocalDir {
/// 规范化之后的目录(`canonicalize` 结果,已去掉 Windows 的 `\\?\` 前缀)
pub cwd: String,
/// 父目录;已是盘符根时为 None(前端据此禁用「上一级」)
pub parent: Option<String>,
pub entries: Vec<LocalEntry>,
}
/// 列举本地目录。`path` 为空时用用户主目录(面板首次打开的落点)。
pub fn list_dir(path: &str) -> Result<LocalDir, String> {
let requested = if path.trim().is_empty() {
dirs::home_dir().ok_or_else(|| "无法确定用户主目录".to_string())?
} else {
let p = Path::new(path.trim());
p.to_path_buf()
};
// 规范化:把用户手输的 `C:\a\..\b`、尾部斜杠、符号链接目录统一成真实位置。
// 失败(不存在 / 无权限)时直接报错 —— 继续读也是同一个错误,早失败信息更准。
let dir = std::fs::canonicalize(&requested)
.map_err(|e| format!("打开目录 {} 失败: {e}", display_path(&requested)))?;
let rd = std::fs::read_dir(&dir).map_err(|e| format!("读取目录 {} 失败: {e}", display_path(&dir)))?;
let mut entries: Vec<LocalEntry> = Vec::new();
for item in rd {
// 单个目录项读取失败(权限/竞态删除)不该让整次列举失败:跳过它,
// 列表照常给出 —— 用户看到少一项,好过看到「读取目录失败」
let Ok(item) = item else { continue };
let name = item.file_name().to_string_lossy().to_string();
let full = item.path();
// `symlink_metadata` 不跟随链接,用它判断「这条是不是链接」;
// 再用 `metadata` 拿目标的类型与大小。
let Ok(link_meta) = item.metadata() else { continue };
let is_link = link_meta.file_type().is_symlink();
let link_target = if is_link {
std::fs::read_link(&full).ok().map(|t| display_path(&t))
} else {
None
};
// 目标不可达(悬空链接 / 无权限)时退回「other」而不是报错
let target_meta = if is_link { std::fs::metadata(&full).ok() } else { None };
let meta = target_meta.as_ref().unwrap_or(&link_meta);
let kind = if meta.is_dir() {
"dir"
} else if meta.is_file() {
"file"
} else {
"other"
};
let size = if meta.is_file() { meta.len() } else { 0 };
let modified_at = meta
.modified()
.ok()
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
.map(|d| d.as_millis() as u64);
entries.push(LocalEntry {
name,
path: display_path(&full),
kind: kind.to_string(),
size,
modified_at,
link_target,
});
}
// 排序与远端栏同一口径:目录优先,其次按名称(不区分大小写)
entries.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()))
});
Ok(LocalDir {
cwd: display_path(&dir),
parent: dir.parent().map(display_path),
entries,
})
}
/// 创建目录(递归,允许用户输入 `a/b`)。
pub fn create_dir(path: &str) -> Result<(), String> {
std::fs::create_dir_all(path).map_err(|e| format!("创建目录 {path} 失败: {e}"))
}
/// 重命名 / 移动。
pub fn rename(from: &str, to: &str) -> Result<(), String> {
if Path::new(to).exists() {
return Err(format!("{to} 已存在"));
}
std::fs::rename(from, to).map_err(|e| format!("重命名失败: {e}"))
}
/// 删除若干个本地项(移入回收站,不是永久删除)。
///
/// # 复用 quickpanel 的实现
///
/// 回收站的落地方案(PowerShell + `Microsoft.VisualBasic.FileIO.FileSystem`
/// 的 `SendToRecycleBin`)在 quickpanel 模块里已经处理过「目录/文件分流」
/// 与「不弹出系统错误对话框」这些细节,这里直接复用而不重写一份 ——
/// 两份实现最大的风险不是重复代码,而是**某一份漏掉 `FOF_ALLOWUNDO` 等价物
/// 变成永久删除**,那种差异没人会去比对。
///
/// # 唯一的硬守卫:盘符根不可删
///
/// UI 上「上一级」到 `C:\` 就会停在根目录,删除按钮在此期间仍然可用。
/// 若不加判断,`C:\` 会走到「递归删除驱动器」上 —— 这是**不可恢复的数据事故**,
/// 因此这里在进入实现之前就挡住(`"\\.\C:"` 这类形态没有 `parent`,同样命中)。
///
/// # 返回值
///
/// `(成功数, 失败明细)`。批量删除里单个失败不该中断其余项 —— 用户选中的 10 个
/// 文件里有一个正被占用,另外 9 个仍然应该删掉。
pub fn delete(paths: &[String]) -> (usize, Vec<String>) {
let mut removed = 0usize;
let mut failed: Vec<String> = Vec::new();
for path in paths {
let p = Path::new(path);
if p.parent().is_none() {
failed.push(format!("{path}:盘符根目录不可删除"));
continue;
}
if !p.exists() {
failed.push(format!("{path}:路径不存在"));
continue;
}
match crate::quickpanel::commands::delete_file_impl(path) {
Ok(()) => removed += 1,
Err(e) => failed.push(format!("{path}:{e}")),
}
}
(removed, failed)
}
/// 把路径转成「能给人看、也能回传给其他接口」的字符串。
///
/// `canonicalize` 在 Windows 上返回 `\\?\C:\...` 扩展长度前缀:它对本进程的
/// `std::fs` 可用,但对 `ShellExecuteW`、系统对话框、`explorer /select` 一律不认。
/// 面板要把这个字符串回传给「用默认程序打开 / 在资源管理器中显示 / 上传源路径」,
/// 因此统一在这里剥掉前缀。
pub fn display_path(p: &Path) -> String {
let s = p.to_string_lossy().to_string();
match s.strip_prefix(r"\\?\") {
Some(rest) => rest.to_string(),
None => s,
}
}
#[cfg(test)]
mod tests {
use super::*;
/// 盘符根必须被拒(`parent()` 为 None),其余路径不受守卫影响 ——
/// 这条守卫的失效后果是递归删除整个驱动器,必须锁住。
#[test]
fn delete_refuses_drive_root() {
#[cfg(windows)]
{
let (removed, failed) = delete(&[r"C:\".to_string()]);
assert_eq!(removed, 0);
assert!(failed[0].contains("盘符根目录不可删除"), "{failed:?}");
}
}
/// 列举主目录必须真的返回条目与规范化后的 cwd(不带 `\\?\` 前缀)。
#[test]
fn list_dir_home_returns_entries() {
let d = list_dir("").expect("主目录应可列举");
assert!(!d.cwd.is_empty());
assert!(!d.cwd.starts_with(r"\\?\"), "cwd 不应带扩展长度前缀: {}", d.cwd);
assert!(!d.entries.is_empty(), "主目录不该是空的");
// 排序口径:目录优先
let first_file = d.entries.iter().position(|e| e.kind != "dir");
let last_dir = d.entries.iter().rposition(|e| e.kind == "dir");
if let (Some(f), Some(l)) = (first_file, last_dir) {
assert!(l < f, "目录必须排在文件之前");
}
}
}
+2
View File
@@ -8,6 +8,7 @@
//! | [`pty::conpty`] | 本地 ConPTY 后端(含三个已知坑的处理) |
//! | [`shell`] | Shell 探测、命令行组装、OSC 7 cwd 跟踪 |
//! | [`ssh`] | SSH 后端(russh)、认证、主机密钥校验、SFTP |
//! | [`local_fs`] | 本地文件系统(SFTP 面板本地栏的列举/新建/重命名/删除) |
//! | [`keys`] | SSH 密钥生成/导入/管理 |
//! | [`settings`] | 设置模型与默认值(容器级 `#[serde(default)]`) |
//! | [`events`] | 事件负载类型 |
@@ -44,6 +45,7 @@ pub mod encoding;
pub mod events;
pub mod history;
pub mod keys;
pub mod local_fs;
pub mod pty;
pub mod session;
pub mod settings;
+21 -3
View File
@@ -662,9 +662,10 @@ impl Default for TemplateEntry {
/// - 新建/关闭标签用 `Ctrl+Shift+T/W`,与浏览器习惯一致。
/// - 跳转标签用 `Alt+1..9`:`Ctrl+数字` 已被翻译模块的 `Ctrl+2`(翻译面板)占用,
/// 而 `Alt+数字` 在终端里通常不产生控制字符,冲突面最小。
/// - `newDetachedWindow`(`Ctrl+3`)是这张表里唯一**全局**生效的一条:它由前端
///- `newDetachedWindow`(`Alt+T`)是这张表里唯一**全局**生效的一条:它由前端
/// `TerminalQuickLaunch` 注册成系统级热键(任意应用前台可触发),放在这里只为
/// 跟着终端设置一起存与改。`Ctrl+2` 已被翻译面板占用,`Ctrl+3` 是空闲的相邻键位。
/// 跟着终端设置一起存与改。`Alt+T` 与翻译面板的 `Alt+F`、dsh 的 `Alt+D`
/// 同处 `Alt+字母` 段,互不冲突。
pub fn default_shortcuts() -> Vec<ShortcutBinding> {
let pairs: &[(&str, &str)] = &[
("copy", "Ctrl+Shift+C"),
@@ -692,7 +693,7 @@ pub fn default_shortcuts() -> Vec<ShortcutBinding> {
// action(未知 action 会被剔除),前端设置表里有而这里没有 = 用户改完下次启动就被清掉。
("detachWindow", "Ctrl+Shift+N"),
// 全局生效的一条(见上方说明):新建独立窗口 + 选择会话
("newDetachedWindow", "Ctrl+3"),
("newDetachedWindow", "Alt+T"),
];
pairs
.iter()
@@ -832,6 +833,23 @@ impl TerminalSettings {
changed = true;
}
// v2 → v3:新建独立窗口的默认键位从 Ctrl+3 改为 Alt+T(Ctrl+数字 与
// 翻译面板、终端「Alt+数字 跳标签」两处分段冲突,统一收到 Alt+字母)。
// 仍等于旧默认值 = 用户没改过,直接迁移;改过的原样保留。
if self.version < 3 {
if let Some(binding) = self
.shortcuts
.iter_mut()
.find(|s| s.action == "newDetachedWindow")
{
if binding.keys.trim().eq_ignore_ascii_case("ctrl+3") {
binding.keys = "Alt+T".to_string();
}
}
self.version = 3;
changed = true;
}
changed
}
}
+94 -15
View File
@@ -117,17 +117,42 @@ pub fn detect_shells() -> Vec<ShellProfile> {
list.push(ShellProfile::new("gitbash", "Git Bash", &p, "bash"));
}
// WSL 发行版:每个发行版一个条目
for distro in list_wsl_distros() {
if let Some(wsl) = find_wsl() {
for distro in list_wsl_distros(&wsl) {
let id = format!("wsl-{}", sanitize_id(&distro));
let name = format!("WSL · {distro}");
let mut profile = ShellProfile::new(&id, &name, "wsl.exe", "wsl");
let mut profile = ShellProfile::new(&id, &name, &wsl, "wsl");
profile.args = vec!["-d".to_string(), distro];
list.push(profile);
}
}
list
}
/// 把配置里的可执行文件路径解析成**可直接启动**的路径。
///
/// - 已存在的路径 → 原样返回;
/// - 裸命令名(不含路径分隔符,如老配置里存下的 `wsl.exe`)→ 查 PATH。
///
/// 存在这层解析是因为「探测」与「连接」对路径的要求不同:探测时用
/// `Command::new("wsl.exe")` 由系统搜索 PATH 即可跑通,但存进设置的值随后要
/// 按**路径**判存在(见 `terminal_open_session`),裸命令名会被判成「文件不存在」,
/// 表现为「探测到了 WSL,点连接却报找不到 wsl.exe」。
pub fn resolve_executable(path: &str) -> Option<String> {
let p = path.trim();
if p.is_empty() {
return None;
}
if Path::new(p).is_file() {
return Some(p.to_string());
}
if !p.contains('\\') && !p.contains('/') {
return find_in_path(&[p]);
}
None
}
/// 在 PATH 中查找可执行文件。
fn find_in_path(names: &[&str]) -> Option<String> {
let path = std::env::var_os("PATH")?;
@@ -203,12 +228,36 @@ fn find_git_bash() -> Option<String> {
})
}
/// 定位 `wsl.exe`。
///
/// 优先系统目录(权威路径,避免 PATH 上的同名伪装程序),其次
/// `WindowsApps` 下的应用执行别名,最后才查 PATH。
fn find_wsl() -> Option<String> {
let root = std::env::var_os("SystemRoot")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from(r"C:\Windows"));
let sys = root.join("System32").join("wsl.exe");
if sys.is_file() {
return Some(sys.to_string_lossy().to_string());
}
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
let alias = PathBuf::from(local)
.join("Microsoft")
.join("WindowsApps")
.join("wsl.exe");
if alias.is_file() {
return Some(alias.to_string_lossy().to_string());
}
}
find_in_path(&["wsl.exe"])
}
/// 枚举 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")
fn list_wsl_distros(wsl_exe: &str) -> Vec<String> {
let out = match std::process::Command::new(wsl_exe)
.args(["-l", "-q"])
.creation_flags_no_window()
.output()
@@ -906,11 +955,25 @@ fn strip_leading_label(s: &str) -> Option<&str> {
Some(s[idx..].trim_start_matches(|c| c == ':' || c == ':' || c == ' '))
}
/// 从 OSC 7 的载荷解析出本地路径。
/// 从 OSC 7 的载荷解析出路径。
///
/// 载荷形如 `file://HOST/C:/Users/foo` 或 `file:///home/user`。
/// Windows 上要处理 `file://HOST/C:/...` → `C:\...` 的还原:
/// 去掉开头的 `/`,把 `/` 换回 `\`,并把 `C:` 前面的多余斜杠去掉。
/// 载荷形如 `file://HOST/PATH`,而 `PATH` 的形态由**上报它的 shell 所在系统**决定:
///
/// - Windows 侧(本项目的 PowerShell hook、Windows Terminal 一类)
/// 上报 `/C:/Users/foo` —— 盘符前多一个 `/`,须还原成 `C:\Users\foo`;
/// - POSIX 侧(远端 bash/zsh、WSL、Git Bash)上报 `/home/ops`。
/// 这是**对面系统的真实路径**,只能原样保留。
///
/// # 这里曾经把 POSIX 路径也换成了反斜杠(已修)
///
/// 早先的写法是「非盘符形态就 `replace('/', "\\")`」,于是远端上报的
/// `/home/Atie` 被存成 `\home\Atie`。后果不是「显示得不好看」:文件管理器
/// 拿这个字符串去 SFTP `read_dir`,服务端直接回 `No such file`,
/// 现象是「SSH 会话的远端目录永远列不出来」——而真正的原因(一次无害的
/// 斜杠替换)与现象之间隔着 OSC 解析、会话状态、SFTP 三层,最难查。
///
/// 因此判据收紧到**只有盘符形态才动路径**:`^/[A-Za-z]:` 之外一律原样返回。
/// `ssh/mod.rs` 里「远端路径是 POSIX 形态」的假设由此才真正成立。
fn parse_osc7(payload: &str) -> Option<String> {
let rest = payload.strip_prefix("file://").unwrap_or(payload);
// 跳过主机名(第一个 '/' 之前的部分)
@@ -922,16 +985,15 @@ fn parse_osc7(payload: &str) -> Option<String> {
return None;
}
let decoded = percent_decode(path_part);
// Windows 盘符形态:/C:/Users → C:\Users
let normalized = if decoded.len() >= 3
// Windows 盘符形态:/C:/Users → C:\Users(去掉盘符前那个多余的 `/`)
let drive_form = decoded.len() >= 3
&& decoded.starts_with('/')
&& decoded.as_bytes()[2] == b':'
{
&& decoded.as_bytes()[2] == b':';
Some(if drive_form {
decoded[1..].replace('/', "\\")
} else {
decoded.replace('/', "\\")
};
Some(normalized)
decoded
})
}
/// 极简百分号解码(OSC 7 里的路径可能含 `%20` 等)。
@@ -1006,6 +1068,23 @@ mod tests {
assert_eq!(p.consumed, stream.len(), "完整序列应全部被消费");
}
/// OSC 7 的路径形态必须按**上报方**区分:Windows 盘符还原成 `\`,
/// POSIX 路径原样保留。
///
/// 这条守着「SSH 会话的远端目录永远列不出来」那个 bug:曾经对所有非盘符
/// 路径都做了 `/` → `\` 替换,`/home/Atie` 变成 `\home\Atie`,
/// SFTP 服务端直接回 `No such file`。
#[test]
fn parse_osc7_kind_by_reporter() {
// POSIX(远端 bash/zsh)与 Git Bash:原样保留
assert_eq!(parse_osc7("file://host/home/Atie").unwrap(), "/home/Atie");
assert_eq!(parse_osc7("file:///home/atie/proj").unwrap(), "/home/atie/proj");
// Windows 盘符:还原成本地形态
assert_eq!(parse_osc7("file://host/C:/Users/foo").unwrap(), "C:\\Users\\foo");
// 百分号编码仍要解码(路径里可能含空格)
assert_eq!(parse_osc7("file://host/home/a%20b").unwrap(), "/home/a b");
}
/// 序列被切在两批数据之间时必须保留尾部,等下一批拼接后再解析 ——
/// 否则 `Cmd` 与 `D` 各被截断一次,历史同样一条不记。
#[test]
+86 -1
View File
@@ -93,7 +93,7 @@ pub struct TransferProgress {
/// 传输任务 id(前端据此更新对应行的进度条)
pub id: String,
pub session_id: String,
/// "upload" | "download"
/// "upload"(本地→远端)| "download"(远端→本地)| "relay"(远端→远端)
pub direction: String,
/// 源路径(展示用)
pub source: String,
@@ -656,6 +656,91 @@ pub async fn download_file(
Ok(got)
}
/// 在两个 SSH 会话之间**流式中继**一个文件(ssh → ssh)。
///
/// # 为什么不走「下载到本地再上传」
///
/// 双远端传输是文件面板里的常用动作(把构建产物从跳板机搬到目标机)。中转方案
/// 有三个实际代价:本地磁盘要有 ≥ 文件大小的空间;链路被走两遍(本机成了不必要
/// 的中转站);临时文件的清理时机还得再定一套规则。中继只搬一次:
/// 从源会话按块读、直接写进目标会话,本地只留一个 [`CHUNK_SIZE`] 缓冲。
///
/// # 为什么只取目标侧的并发许可
///
/// `semaphore` 限制的是「同时在跑的传输数」。中继严格对称地占源、目标两把信号量
/// 会在两个方向的中继同时进行时成环(A 持源等目标、B 持目标等源)。这里只取
/// **目标**侧:会把服务端窗口打满的始终是写入方,而中继本身是低频动作
/// (人点一次搬一个文件)。
///
/// # 不做断点续传
///
/// 上传/下载能续传是因为本地侧有文件可以比对大小;中继的两端都不在本地,
/// 没有可信的进度锚点。目标文件一律 `TRUNCATE` 重写 —— 与上传「远端已有更大文件
/// 时退回整文件重传」同一取舍:宁可重传,不能写出一半新一半旧的损坏文件。
pub async fn relay_file(
from: &SftpHandle,
from_path: &str,
to: &SftpHandle,
to_path: &str,
on_progress: impl Fn(u64, u64),
) -> Result<u64, String> {
let _permit = to
.semaphore
.acquire()
.await
.map_err(|e| format!("获取传输许可失败: {e}"))?;
let total = from
.sftp
.metadata(from_path)
.await
.ok()
.and_then(|m| m.size)
.unwrap_or(0);
let mut src = from
.sftp
.open(from_path)
.await
.map_err(|e| format!("打开源文件 {from_path} 失败: {e}"))?;
let mut dst = to
.sftp
.open_with_flags(
to_path,
OpenFlags::WRITE | OpenFlags::CREATE | OpenFlags::TRUNCATE,
)
.await
.map_err(|e| format!("创建目标文件 {to_path} 失败: {e}"))?;
let mut buf = vec![0u8; CHUNK_SIZE];
let mut sent = 0u64;
on_progress(0, total);
loop {
let n = src
.read(&mut buf)
.await
.map_err(|e| format!("读取源文件失败: {e}"))?;
if n == 0 {
break;
}
dst.write_all(&buf[..n])
.await
.map_err(|e| format!("写入目标文件失败: {e}"))?;
sent += n as u64;
on_progress(sent, total);
}
// 目标必须 `shutdown`(发 CLOSE,见 `upload_file` 的说明);源只是读,
// 但同样显式关掉句柄,免得服务端一直留着一个打开的文件描述符。
dst.shutdown()
.await
.map_err(|e| format!("关闭目标文件失败(数据可能未完整落盘): {e}"))?;
let _ = src.shutdown().await;
Ok(sent)
}
/// 类型占位:确保 `SshHandler` 与 `Handle<SshHandler>` 的关联在编译期成立。
#[allow(dead_code)]
fn _assert_handle_type(h: &Handle<SshHandler>) -> &Handle<SshHandler> {
+49
View File
@@ -129,6 +129,55 @@ pub fn close_for_session(app: &AppHandle, session_id: &SessionId) -> Result<(),
Ok(())
}
/// 打开(或唤出)**文件管理器独立窗口**。
///
/// # 为什么是单例而不是「每会话一个窗口」
///
/// 终端窗口的粒度是会话(「把某个会话拖出来放大盯」),而文件管理器窗口的粒度是
/// **两台机器之间的关系**(本地 ↔ ssh1、ssh1 ↔ ssh2…)—— 左右两栏各自选择连接,
/// 所以同一时刻只该存在一个:开第二个只会让两边显示同一份状态,
/// 用户还得记住自己改的是哪一个。label 因此固定为 [`W::FILE_WINDOW`],
/// 幂等打开(已存在则 show + focus)。
///
/// # 不绑定会话意味着什么都不用清理
///
/// 窗口关闭时不需要重置任何会话标记(对比 [`open_for_session`]):它没有 detached
/// 之类的状态要维护,两栏的连接选择留在窗口内存在即弃 —— 下次打开回到默认
/// (左本地、右首个 SSH 会话)。SFTP 通道由 Rust 侧的会话注册表持有,
/// 会话关闭时随会话一起回收(见 `TerminalManager::remove_session`)。
pub fn open_file_window(app: &AppHandle) -> Result<(), String> {
if let Some(win) = app.get_webview_window(W::FILE_WINDOW) {
// 可能是被最小化的:show 会还原,再聚焦
win.show().map_err(|e| format!("显示文件窗口失败: {e}"))?;
win.set_focus().map_err(|e| format!("聚焦文件窗口失败: {e}"))?;
return Ok(());
}
WebviewWindowBuilder::new(
app,
W::FILE_WINDOW,
// 路由到前端的文件窗口入口(main.ts 中按 hash 分派)
WebviewUrl::App("index.html#file-window".into()),
)
.title("文件 · Thing")
// 双栏 + 四列信息,比终端窗口更宽;高度取常见笔记本的可视高度
.inner_size(1180.0, 720.0)
.min_inner_size(720.0, 420.0)
.resizable(true)
// 与终端窗口同款:无系统边框,窗口内自绘控制栏
.decorations(false)
.shadow(true)
.center()
// **隐藏创建**:由 FileWindow.vue 应用完主题(含 setBackgroundColor)再 show,
// 否则深色模式下会先闪一下纯白窗口。理由与 `open_for_session` 完全一致。
.visible(false)
.focused(false)
.build()
.map_err(|e| format!("创建文件窗口失败: {e}"))?;
Ok(())
}
/// 把会话的 `detached` 标记与窗口状态对齐。
///
/// 应用启动后(或窗口被外部关闭后)可能存在不一致:标记说已分离但窗口不在。
+120 -29
View File
@@ -17,7 +17,7 @@ use tauri::{AppHandle, Manager, State};
use super::engines::{EngineRequest, ErrorKind, TranslateError, TranslateMode, TranslateResult};
use super::history::HistoryItem;
use super::settings::TranslateEngineConfig;
use super::{engine_api_key, engine_secret_key, popup, TranslateManager, TranslateSettings};
use super::{engine_secret_key, popup, TranslateManager, TranslateSettings};
/// 引擎实例的前端视图:配置 + 派生状态(密钥是否已配、是否可用)。
///
@@ -154,21 +154,22 @@ pub fn translate_popup_prefs_set(
// ===== 引擎管理 =====
/// 列出引擎实例(含密钥状态与可用性)
/// 列出引擎实例(含密钥状态与可用性)。
///
/// 返回**本模块 free/cloud 引擎 + 全局 AI 供应商**(AI 转换为 kind = "ai"),
/// 供工作台选择与「默认引擎」下拉使用。AI 的增删改走主设置 → AI 服务。
#[tauri::command]
#[specta::specta]
pub async fn translate_engines_list(
state: State<'_, TranslateManager>,
) -> Result<Vec<EngineView>, String> {
let settings = state.load_settings();
Ok(settings
.engines
.iter()
.map(|cfg| to_view(cfg))
.collect())
Ok(state.all_engines().iter().map(to_view).collect())
}
/// 新增或更新一个引擎实例(按 id upsert)。
/// 新增或更新一个**非 AI** 引擎实例(按 id upsert)。
///
/// AI 引擎(kind = "ai")由主设置 → AI 服务管理,这里显式拒绝,
/// 避免出现「翻译设置里改了一份、主设置里还是旧的」的双源分裂。
///
/// 校验 id:它会进入凭据键(`translate-engine-<id>`),含特殊字符会让键名难以排查,
/// 因此限定为字母/数字/下划线/短横线。
@@ -178,6 +179,11 @@ pub fn translate_engine_save(
state: State<'_, TranslateManager>,
config: TranslateEngineConfig,
) -> Result<(), String> {
if config.kind == "ai" {
return Err(
"AI 引擎已移至「常规设置 → AI 服务」统一管理,请到主设置中修改".to_string(),
);
}
// 先把 id 取成自有值:下面要整体移动 config,不能再持有对 config.id 的借用
let id = config.id.trim().to_string();
if id.is_empty() {
@@ -205,9 +211,13 @@ pub fn translate_engine_save(
}
/// 删除引擎实例(连同它在系统凭据管理器中的密钥)。
/// AI 引擎请到主设置 → AI 服务删除。
#[tauri::command]
#[specta::specta]
pub fn translate_engine_delete(state: State<'_, TranslateManager>, id: String) -> Result<(), String> {
if state.all_engines().iter().any(|e| e.id == id && e.kind == "ai") {
return Err("AI 引擎请在「常规设置 → AI 服务」中删除".to_string());
}
let mut settings = state.load_settings();
let before = settings.engines.len();
settings.engines.retain(|e| e.id != id);
@@ -227,6 +237,8 @@ pub fn translate_engine_delete(state: State<'_, TranslateManager>, id: String) -
}
/// 写入引擎的 API Key(明文只在此处进入系统凭据管理器,永不回写配置文件)。
///
/// AI 供应商的 Key 写 `ai-provider-*`;free/cloud 写 `translate-engine-*`。
#[tauri::command]
#[specta::specta]
pub fn translate_secret_set(
@@ -234,10 +246,16 @@ pub fn translate_secret_set(
id: String,
api_key: String,
) -> Result<(), String> {
if state.load_settings().engine(&id).is_none() {
return Err(format!("找不到引擎实例「{id}」"));
}
let key = engine_secret_key(&id);
let engines = state.all_engines();
let cfg = engines
.iter()
.find(|e| e.id == id)
.ok_or_else(|| format!("找不到引擎实例「{id}」"))?;
let key = if cfg.kind == "ai" {
crate::ai::provider_secret_key(&id)
} else {
engine_secret_key(&id)
};
let value = api_key.trim();
if value.is_empty() {
return crate::secrets::secret_delete(&key);
@@ -245,11 +263,83 @@ pub fn translate_secret_set(
crate::secrets::secret_write(&key, value)
}
/// 清除引擎的 API Key
/// 清除引擎的 API Key(按 kind 选凭据键,与 write 对称)。
#[tauri::command]
#[specta::specta]
pub fn translate_secret_clear(id: String) -> Result<(), String> {
crate::secrets::secret_delete(&engine_secret_key(&id))
pub fn translate_secret_clear(
state: State<'_, TranslateManager>,
id: String,
) -> Result<(), String> {
let engines = state.all_engines();
let is_ai = engines.iter().any(|e| e.id == id && e.kind == "ai");
let key = if is_ai {
crate::ai::provider_secret_key(&id)
} else {
engine_secret_key(&id)
};
crate::secrets::secret_delete(&key)
}
/// 把某个全局 AI 供应商加入翻译候选,或更新它的**翻译场景参数**(启用 / 优先级 / 超时 / 提示词)。
///
/// 连接配置(Base URL、模型、密钥)在主设置 → AI 服务;这里只写 translate 自己的编排语义。
/// 首次调用即「加入」——`ai_params` 有记录就代表该供应商参与翻译候选。
#[tauri::command]
#[specta::specta]
pub fn translate_ai_params_save(
state: State<'_, TranslateManager>,
params: super::TranslateAiParams,
) -> Result<(), String> {
let id = params.provider_id.trim().to_string();
if id.is_empty() {
return Err("供应商标识不能为空".to_string());
}
let ai = crate::ai::AiManager::load_settings_sync(&state.data_dir);
if ai.provider(&id).is_none() {
return Err(format!(
"全局 AI 供应商「{id}」不存在,请先在主设置 → AI 服务中配置"
));
}
let mut settings = state.load_settings();
let next = super::TranslateAiParams {
provider_id: id,
enabled: params.enabled,
priority: params.priority,
timeout_ms: params.timeout_ms.max(1_000),
system_prompt: params.system_prompt,
};
match settings.ai_params_mut(&next.provider_id) {
Some(slot) => *slot = next,
None => settings.ai_params.push(next),
}
settings.ai_params.sort_by_key(|p| p.priority);
state.save_settings(&settings)
}
/// 把某个全局 AI 供应商**移出翻译候选**(供应商本身与它的密钥都不动)。
///
/// 只删 `ai_params` 里的这条记录。默认引擎指向它时改为「自动」——否则默认引擎会指向
/// 一个已经不在候选里的 id,用户看到的是「设置对了但翻译报找不到引擎」。
#[tauri::command]
#[specta::specta]
pub fn translate_ai_engine_remove(
state: State<'_, TranslateManager>,
provider_id: String,
) -> Result<(), String> {
let id = provider_id.trim().to_string();
if id.is_empty() {
return Err("供应商标识不能为空".to_string());
}
let mut settings = state.load_settings();
let before = settings.ai_params.len();
settings.ai_params.retain(|p| p.provider_id != id);
if settings.ai_params.len() == before {
return Err(format!("供应商「{id}」不在翻译候选里"));
}
if settings.default_engine_id == id {
settings.default_engine_id = "auto".to_string();
}
state.save_settings(&settings)
}
/// 连通性自检:用前端传入的配置测试(**不落盘**)。
@@ -289,17 +379,17 @@ pub async fn translate_engine_test_config(
}
/// 拉取上游模型列表(应对「上游改名」导致预设失效的自救入口)。
/// 免密钥源没有模型概念,返回空列表。
/// 免密钥源没有模型概念,返回空列表。AI 供应商从全局列表按 id 查找。
#[tauri::command]
#[specta::specta]
pub async fn translate_engine_models(
state: State<'_, TranslateManager>,
id: String,
) -> Result<Vec<String>, String> {
let settings = state.load_settings();
let cfg = settings
.engine(&id)
.cloned()
let cfg = state
.all_engines()
.into_iter()
.find(|e| e.id == id)
.ok_or_else(|| format!("找不到引擎实例「{id}」"))?;
let engine = state.build(&cfg).await.map_err(|e| e.message)?;
engine.list_models().await.map_err(|e| e.message)
@@ -488,7 +578,7 @@ pub async fn translate_screenshot_region(
// ===== 视觉直译:跳过本地 OCR,识别 + 翻译一步完成 =====
if sc.ocr_mode == "vision" {
// 配置类失败也弹窗:覆盖层已隐藏,静默早退会让用户点了按钮毫无反应
let cfg = match pick_vision_engine(&settings) {
let cfg = match pick_vision_engine(&state, &settings) {
Ok(c) => c,
Err(e) => {
popup::show_screenshot_error(
@@ -699,23 +789,24 @@ fn crop_region_png_blocking(x: i32, y: i32, w: i32, h: i32) -> Result<Vec<u8>, T
}
/// 视觉直译的引擎选择:优先默认引擎(若它声明支持图像输入),否则按优先级取第一个支持的。
/// 候选来自「本模块引擎 + 已加入翻译候选的 AI 供应商」。
fn pick_vision_engine(
state: &TranslateManager,
settings: &TranslateSettings,
) -> Result<TranslateEngineConfig, TranslateError> {
if let Some(cfg) = settings.engine(&settings.default_engine_id) {
let all = state.all_engines();
if let Some(cfg) = all.iter().find(|e| e.id == settings.default_engine_id) {
if cfg.supports_vision && cfg.kind == "ai" {
return Ok(cfg.clone());
}
}
settings
.engines
.iter()
all.into_iter()
.filter(|c| c.supports_vision && c.kind == "ai" && c.enabled)
.min_by_key(|c| c.priority)
.cloned()
.ok_or_else(|| {
TranslateError::config(
"视觉直译需要一个支持图像输入的引擎:请在引擎设置中勾选「支持图像输入」",
"视觉直译需要一个支持图像输入的引擎:请在主设置 → AI 服务中勾选「图像输入」,\
再在翻译设置里把它加入翻译候选",
)
})
}
@@ -1024,7 +1115,7 @@ fn failure(e: TranslateError, latency_ms: u64) -> EngineTestResult {
fn to_view(
cfg: &TranslateEngineConfig,
) -> EngineView {
let raw_key = engine_api_key(&cfg.id);
let raw_key = super::engine_api_key_with_kind(&cfg.id, Some(cfg.kind.as_str()));
let has_api_key = !raw_key.trim().is_empty();
let issue = match cfg.kind.as_str() {
+2 -68
View File
@@ -75,8 +75,9 @@ impl AiEngine {
}
/// 密钥只从系统凭据管理器读,不进配置文件、不经前端。
/// AI 引擎走 `ai-provider-*`(含对旧 `translate-engine-*` 的回退)。
fn api_key(cfg: &TranslateEngineConfig) -> String {
crate::translate::engine_api_key(&cfg.id)
crate::translate::engine_api_key_with_kind(&cfg.id, Some("ai"))
}
fn require_key(cfg: &TranslateEngineConfig) -> Result<String, TranslateError> {
@@ -592,70 +593,3 @@ struct ModelEntry {
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))
}
+246
View File
@@ -0,0 +1,246 @@
//! 历史配置的一次性迁移:把「AI 引擎曾经存在翻译设置里」搬进主设置 → AI 服务。
//!
//! 为什么这段代码在 translate 而不是 ai:它必须同时读懂两份设置——读 translate 的
//! 引擎列表、写 ai 的供应商列表、还要复制凭据。放在 ai 里等于让 AI 服务反向依赖
//! 业务模块;放在消费方(translate→ai 本来就是合法方向)则两边都不别扭。
//!
//! 由 `setup::init` 在注册 State 之前调用一次(必须早于任何 `AiManager::load_settings`
//! 的缓存预热,否则会出现「刚迁完,但缓存里还是旧值」的短窗口)。
//!
//! 两件事:
//! 1. **搬引擎**:`ai/settings.json` 不存在且 translate 里有 `kind = "ai"` 的引擎时,
//! 把它们转成 AI 供应商(连同 `translate-engine-*` → `ai-provider-*` 的密钥复制),
//! 并从 translate 设置里移除,改为写入 `aiParams`(翻译侧的场景参数)。
//! 2. **下沉场景字段**:`ai/settings.json` 里残留的 `priority` / `timeoutMs` /
//! `systemPrompt`(曾是供应商字段,后改为翻译侧参数)搬到 `translate.aiParams`。
//! 没有旧字段时是空操作。
use std::path::{Path, PathBuf};
use crate::ai::{AiProviderConfig, AiSettings, DEFAULT_MAX_CONTEXT};
use super::settings::{TranslateAiParams, TranslateSettings};
use super::engine_secret_key;
/// 执行一次性迁移。失败只记日志——迁移是「让老配置继续可用」的尽力而为,
/// 不该因为一次写盘失败就让应用起不来(用户仍可在设置页手动重建)。
pub fn migrate_legacy_ai_engines(data_dir: &Path) {
if !ai_settings_path(data_dir).exists() {
migrate_engines(data_dir);
}
// 与搬引擎分开判断:残留字段可能出现在「ai/settings.json 已存在」的机器上
drain_legacy_params(data_dir);
}
fn ai_settings_path(data_dir: &Path) -> PathBuf {
data_dir.join("ai").join("settings.json")
}
fn translate_settings_path(data_dir: &Path) -> PathBuf {
data_dir.join("translate").join("settings.json")
}
/// 把 translate 设置里的 `kind = "ai"` 引擎搬成 AI 供应商。
fn migrate_engines(data_dir: &Path) {
let translate_path = translate_settings_path(data_dir);
let Ok(raw) = std::fs::read_to_string(&translate_path) else {
// 没有旧配置:无需迁移
return;
};
let Ok(mut translate) = serde_json::from_str::<TranslateSettings>(&raw) else {
crate::logger::log_warn(
"ai",
"translate/settings.json 无法解析,跳过 AI 引擎迁移,使用默认 AI 配置",
);
return;
};
let (ai_engines, free_engines): (Vec<_>, Vec<_>) = translate
.engines
.iter()
.cloned()
.partition(|e| e.kind == "ai");
if ai_engines.is_empty() {
return;
}
let providers: Vec<AiProviderConfig> = ai_engines
.iter()
.map(|e| AiProviderConfig {
id: e.id.clone(),
name: e.name.clone(),
preset: e.preset.clone(),
enabled: e.enabled,
base_url: e.base_url.clone(),
model: e.model.clone(),
temperature: e.temperature,
max_tokens: e.max_tokens.clamp(1, 131_072),
max_context: if e.max_tokens > 0 {
// 旧配置没有上下文字段:用输出上限的常见比例推一个合法档位
e.max_tokens.clamp(32_768, 1_048_576)
} else {
DEFAULT_MAX_CONTEXT
},
extra_body: e.extra_body.clone(),
supports_vision: e.supports_vision,
legacy_priority: None,
legacy_timeout_ms: None,
legacy_system_prompt: None,
})
.collect();
// 翻译场景参数(启用 / 优先级 / 超时 / 提示词覆盖)留在翻译设置
let ai_params: Vec<TranslateAiParams> = ai_engines
.iter()
.map(|e| TranslateAiParams {
provider_id: e.id.clone(),
enabled: e.enabled,
priority: e.priority,
timeout_ms: e.timeout_ms,
system_prompt: e.system_prompt.clone(),
})
.collect();
// 凭据复制:旧键 `translate-engine-*` → 新键 `ai-provider-*`。
// 复制失败只记日志(AI 侧不再回退读旧键,用户需在设置页重填一次)。
for e in &ai_engines {
let old = engine_secret_key(&e.id);
let new = crate::ai::provider_secret_key(&e.id);
let value = crate::secrets::read_or_empty(&old);
if value.trim().is_empty() {
continue;
}
if crate::secrets::read_or_empty(&new).trim().is_empty() {
if let Err(err) = crate::secrets::secret_write(&new, &value) {
crate::logger::log_warn(
"ai",
&format!(
"迁移引擎「{}」的密钥失败,需在 AI 服务中重新填写: {err}",
e.id
),
);
}
}
}
let default_id = translate.default_engine_id.clone();
let mut ai_settings = AiSettings {
version: 2,
providers,
default_provider_id: if default_id != "auto" && ai_engines.iter().any(|e| e.id == default_id)
{
default_id
} else {
"auto".to_string()
},
use_proxy: translate.use_proxy,
};
ai_settings.heal();
// translate 侧:移除 AI 引擎、写入场景参数;默认引擎指向已搬走的实例时改为「自动」
translate.engines = free_engines;
// 合并:已有 ai_params(重复迁移防御)+ 本次搬入的
for p in ai_params {
if !translate
.ai_params
.iter()
.any(|x| x.provider_id == p.provider_id)
{
translate.ai_params.push(p);
}
}
if translate.default_engine_id != "auto"
&& !translate
.engines
.iter()
.any(|e| e.id == translate.default_engine_id)
&& !translate
.ai_params
.iter()
.any(|p| p.provider_id == translate.default_engine_id)
{
translate.default_engine_id = "auto".to_string();
}
if let Err(err) = crate::ai::write_settings(data_dir, &ai_settings) {
crate::logger::log_error("ai", &format!("迁移写入 AI 设置失败: {err}"));
return;
}
match serde_json::to_string_pretty(&translate) {
Ok(json) => match write_translate_settings(data_dir, &json) {
Ok(()) => crate::logger::log_info(
"ai",
&format!(
"已从翻译设置迁移 {} 个 AI 引擎到主设置",
ai_settings.providers.len()
),
),
Err(err) => crate::logger::log_error("ai", &err),
},
Err(err) => crate::logger::log_error("ai", &format!("序列化翻译设置失败: {err}")),
}
}
/// 把 `ai/settings.json` 里残留的旧场景字段搬到 `translate.aiParams` 并两边落盘。
fn drain_legacy_params(data_dir: &Path) {
let Ok(raw) = std::fs::read_to_string(ai_settings_path(data_dir)) else {
return;
};
let Ok(mut settings) = serde_json::from_str::<AiSettings>(&raw) else {
return;
};
let mut moves: Vec<(String, i32, u64, String)> = Vec::new();
for p in &mut settings.providers {
if let Some((priority, timeout_ms, system_prompt)) = p.take_legacy() {
moves.push((p.id.clone(), priority, timeout_ms, system_prompt));
}
}
if moves.is_empty() {
return;
}
let translate_path = translate_settings_path(data_dir);
let mut translate = std::fs::read_to_string(&translate_path)
.ok()
.and_then(|s| serde_json::from_str::<TranslateSettings>(&s).ok())
.unwrap_or_default();
for (provider_id, priority, timeout_ms, system_prompt) in moves {
let entry = TranslateAiParams {
provider_id: provider_id.clone(),
// 旧字段的时代没有「翻译侧启用」这一层,默认视为启用
enabled: true,
priority,
timeout_ms,
system_prompt,
};
match translate
.ai_params
.iter_mut()
.find(|p| p.provider_id == provider_id)
{
Some(slot) => *slot = entry,
None => translate.ai_params.push(entry),
}
}
settings.version = 2;
if let Err(e) = crate::ai::write_settings(data_dir, &settings) {
crate::logger::log_error("ai", &format!("清理旧场景字段后保存失败: {e}"));
return;
}
match serde_json::to_string_pretty(&translate) {
Ok(json) => match write_translate_settings(data_dir, &json) {
Ok(()) => crate::logger::log_info("ai", "已将 AI 供应商上的旧场景参数迁到翻译设置"),
Err(e) => crate::logger::log_error("ai", &e),
},
Err(e) => crate::logger::log_error("ai", &format!("序列化翻译设置失败: {e}")),
}
}
/// 回写 translate 设置(启动阶段 TranslateManager 还没建,目录可能也不存在)。
fn write_translate_settings(data_dir: &Path, json: &str) -> Result<(), String> {
let root = data_dir.join("translate");
std::fs::create_dir_all(&root).map_err(|e| format!("创建翻译目录失败: {e}"))?;
std::fs::write(root.join("settings.json"), json)
.map_err(|e| format!("回写 translate/settings.json 失败: {e}"))
}
+158 -38
View File
@@ -29,31 +29,32 @@ mod capture;
mod commands;
mod engines;
mod history;
mod migrate;
mod ocr;
mod popup;
mod settings;
pub use commands::{
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,
translate_abort, translate_ai_engine_remove, translate_ai_params_save, 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,
};
pub use engines::{TranslateEngine, TranslateError, TranslateResult};
// 只再导出本模块内部(mod.rs / commands.rs / popup.rs)实际用到的类型。其余类型仍保留在
// `engines::` / `settings::` 下,等真正用到时再提升到此处——提前摆出一堆无人消费的再导出,
// 只会让「谁在用」更难判断。
pub use settings::TranslateSettings;
// 终端 AI 助手(terminal/assistant.rs)复用引擎配置与通用对话补全——
// 「现在真正用到了」,按上面的原则提升到此处。
pub use settings::TranslateEngineConfig;
pub use engines::ai::chat_once;
// TranslateEngineConfig / TranslateAiParams 供命令层、ai 迁移与前端类型共用。
pub use settings::{TranslateAiParams, TranslateEngineConfig};
// 启动阶段的一次性迁移(把旧版存在翻译设置里的 AI 引擎搬进主设置 → AI 服务)。
pub use migrate::migrate_legacy_ai_engines;
use engines::EngineRequest;
use std::path::PathBuf;
@@ -71,7 +72,7 @@ const PROXY_CACHE_TTL: Duration = Duration::from_millis(5000);
/// 引擎 API Key 的凭据键前缀(键名格式:`translate-engine-<engineId>`)。
const ENGINE_KEY_PREFIX: &str = "translate-engine-";
/// 某引擎实例的凭据键。
/// 某引擎实例的凭据键(free/cloud 源使用;AI 供应商用 `ai-provider-<id>`)。
pub fn engine_secret_key(engine_id: &str) -> String {
format!("{ENGINE_KEY_PREFIX}{engine_id}")
}
@@ -85,13 +86,53 @@ pub fn init_on_launch(app: &tauri::AppHandle) {
}
/// 读取某引擎实例的 API Key(未配置或读取失败 → 空串)。
///
/// AI 引擎(kind = "ai")的密钥在 `ai-provider-*`,走 [`crate::ai::provider_api_key`];
/// free/cloud 读本模块的 `translate-engine-*`。两条路径互不通气——AI 侧不认识旧键,
/// 密钥由 [`migrate_legacy_ai_engines`] 一次性复制过去。
pub fn engine_api_key(engine_id: &str) -> String {
engine_api_key_with_kind(engine_id, None)
}
/// 按 kind 读取密钥。`kind_hint` 为 Some("ai") 时走 AI 凭据键。
pub fn engine_api_key_with_kind(engine_id: &str, kind_hint: Option<&str>) -> String {
if engine_id.trim().is_empty() {
return String::new();
}
if kind_hint == Some("ai") {
return crate::ai::provider_api_key(engine_id);
}
crate::secrets::read_or_empty(&engine_secret_key(engine_id))
}
/// 把全局 AI 供应商转换为翻译引擎配置(kind = "ai")。
///
/// 连接与生成参数来自 AI 侧;**启用 / 优先级 / 超时 / 提示词覆盖**来自翻译设置的
/// [`TranslateAiParams`](场景参数归翻译管)。翻译候选与视觉直译都消费转换后的结果。
///
/// `enabled` 取两层开关的与:供应商自身关掉(AI 服务里停用)或翻译侧关掉,都不上场。
pub fn ai_provider_as_engine(
p: &crate::ai::AiProviderConfig,
params: &TranslateAiParams,
) -> TranslateEngineConfig {
TranslateEngineConfig {
id: p.id.clone(),
name: p.name.clone(),
kind: "ai".to_string(),
preset: p.preset.clone(),
enabled: p.enabled && params.enabled,
priority: params.priority,
base_url: p.base_url.clone(),
model: p.model.clone(),
temperature: p.temperature,
max_tokens: p.max_tokens,
timeout_ms: params.timeout_ms.max(1_000),
system_prompt: params.system_prompt.clone(),
extra_body: p.extra_body.clone(),
supports_vision: p.supports_vision,
}
}
struct SettingsCache {
read_at: Instant,
settings: TranslateSettings,
@@ -106,8 +147,10 @@ pub struct TranslateManager {
/// 直连客户端
client: reqwest::Client,
cache: Mutex<Option<SettingsCache>>,
/// 代理地址解析缓存:`(解析时刻, 结果)`;结果为 None 表示已开启但不可用
proxy_cache: Mutex<Option<(Instant, Option<String>)>>,
/// 代理地址解析缓存:`(解析时刻, 是否开启代理, 结果)`。
/// 必须把「是否开启」一并缓存:AI 引擎看 AI 服务的开关、free/cloud 看本模块开关,
/// 两个值不同却共用一份缓存时,先被解析的一方会把另一方带偏。
proxy_cache: Mutex<Option<(Instant, bool, Option<String>)>>,
/// 带代理的客户端缓存:`(代理地址, 客户端)`。与地址一一对应,地址变了就重建。
proxied_client: Mutex<Option<(String, reqwest::Client)>>,
/// 翻译历史。打开失败时为 None:历史是锦上添花,不值得为它让整个模块不可用。
@@ -162,7 +205,24 @@ impl TranslateManager {
.ok()
.and_then(|s| serde_json::from_str::<TranslateSettings>(&s).ok())
.unwrap_or_default();
let healed = settings.heal();
let mut healed = settings.heal();
// 默认引擎指向「本模块里没有、也已不在翻译候选里的 AI 供应商」→ 改为「自动」。
// 放在 Manager 而不是 settings::heal:那里拿不到 data_dir,读不了 AI 供应商。
// 判定必须连 ai_params 一起看:供应商在 AI 服务里存在、但被用户移出翻译候选时,
// 它同样不能再当默认引擎。
if settings.default_engine_id != "auto"
&& settings.engine(&settings.default_engine_id).is_none()
{
// 只有「已加入翻译候选、且供应商仍存在」的 AI 引擎才保留
let still_valid = settings.has_ai_engine(&settings.default_engine_id)
&& crate::ai::AiManager::load_settings_sync(&self.data_dir)
.provider(&settings.default_engine_id)
.is_some();
if !still_valid {
settings.default_engine_id = "auto".to_string();
healed = true;
}
}
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
@@ -233,14 +293,16 @@ impl TranslateManager {
.is_ok()
}
/// 解析当前应使用的代理地址(带 TTL 缓存)。未开启开关时返回 None。
async fn resolve_proxy_url(&self) -> Option<String> {
if !self.load_settings().use_proxy {
/// 解析当前应使用的代理地址(带 TTL 缓存)。`enabled` 为 false 时直接返回 None。
///
/// `enabled` 由调用方按引擎归属给出:AI 引擎取 AI 服务的开关,其余取本模块的开关。
async fn resolve_proxy_url(&self, enabled: bool) -> Option<String> {
if !enabled {
return None;
}
if let Ok(cache) = self.proxy_cache.lock() {
if let Some((at, url)) = cache.as_ref() {
if at.elapsed() < PROXY_CACHE_TTL {
if let Some((at, cached_enabled, url)) = cache.as_ref() {
if *cached_enabled == enabled && at.elapsed() < PROXY_CACHE_TTL {
return url.clone();
}
}
@@ -259,9 +321,9 @@ impl TranslateManager {
};
if let Ok(mut cache) = self.proxy_cache.lock() {
let previous = cache.as_ref().and_then(|(_, u)| u.clone());
let previous = cache.as_ref().and_then(|(_, _, u)| u.clone());
let changed = previous != resolved;
*cache = Some((Instant::now(), resolved.clone()));
*cache = Some((Instant::now(), enabled, resolved.clone()));
// 地址变了(或可用性变了)就丢弃旧客户端,否则会继续用已失效的代理
if changed {
if let Ok(mut client) = self.proxied_client.lock() {
@@ -275,8 +337,8 @@ impl TranslateManager {
/// 选择本次请求使用的 HTTP 客户端:开了代理且可用 → 走代理,否则直连。
/// 代理不可用时**静默回退直连**:让请求自己去失败,比在这里造一个错误更接近真相
/// (也许代理确实不通但目标站恰好可达)。
async fn select_client(&self) -> reqwest::Client {
let Some(url) = self.resolve_proxy_url().await else {
async fn select_client(&self, use_proxy: bool) -> reqwest::Client {
let Some(url) = self.resolve_proxy_url(use_proxy).await else {
return self.client.clone();
};
if let Ok(cache) = self.proxied_client.lock() {
@@ -309,13 +371,58 @@ impl TranslateManager {
// ===== 引擎 =====
/// 本模块自有引擎(free/cloud)+ **已加入翻译候选的**全局 AI 供应商
/// (转换为 kind = "ai"),按优先级升序。
///
/// 这是翻译候选的**唯一真源**:显式指定、自动降级、视觉直译都从这里取。
///
/// 两条筛选:
/// - AI 供应商必须先在翻译设置里「加入」(= `ai_params` 有记录)。主设置里配好的
/// 供应商不自动参与翻译,用户要哪几个就加哪几个;
/// - 历史遗留的 kind = "ai" 引擎(早期版本把 AI 存在翻译设置里)直接丢弃:
/// 它的连接配置已搬去 AI 服务、密钥也读不到,留着只会与 AI 供应商重复且删不掉。
///
/// **不过滤 enabled**——列表 UI 要能看到已禁用项;启用过滤发生在
/// [`Self::resolve_candidates`] 的 auto 分支。
pub fn all_engines(&self) -> Vec<TranslateEngineConfig> {
let settings = self.load_settings();
let ai = crate::ai::AiManager::load_settings_sync(&self.data_dir);
let mut list: Vec<TranslateEngineConfig> = settings
.engines
.iter()
.filter(|e| e.kind != "ai")
.cloned()
.collect();
list.extend(
ai.providers
.iter()
.filter(|p| settings.has_ai_engine(&p.id))
.map(|p| ai_provider_as_engine(p, &settings.ai_params_for(&p.id))),
);
list.sort_by_key(|e| e.priority);
list
}
/// 本次请求该不该走代理。
///
/// AI 引擎的连接配置归主设置(AI 服务)管,代理开关也跟着那边走;free/cloud 是
/// 本模块自己的源,用本模块的开关。两边开关同名不同域,混用会出现「终端里能通、
/// 翻译里不通(或反过来)」这种极难排查的现象。
fn proxy_enabled_for(&self, kind: &str) -> bool {
if kind == "ai" {
crate::ai::AiManager::load_settings_sync(&self.data_dir).use_proxy
} else {
self.load_settings().use_proxy
}
}
/// 按配置装配引擎实例(异步:需要先决定走不走代理)。
pub async fn build(
&self,
cfg: &TranslateEngineConfig,
) -> Result<Box<dyn TranslateEngine>, TranslateError> {
let templates = self.load_settings().prompt_templates;
let client = self.select_client().await;
let client = self.select_client(self.proxy_enabled_for(&cfg.kind)).await;
engines::build_engine(cfg, &templates, client)
}
@@ -329,36 +436,49 @@ impl TranslateManager {
engine_id: Option<&str>,
) -> Result<Vec<TranslateEngineConfig>, TranslateError> {
let settings = self.load_settings();
let all = self.all_engines();
let explicit = engine_id
.map(str::trim)
.filter(|s| !s.is_empty() && *s != "auto");
if let Some(id) = explicit {
return settings
.engine(id)
.cloned()
return all
.into_iter()
.find(|e| e.id == id)
.map(|cfg| vec![cfg])
.ok_or_else(|| TranslateError::config(format!("找不到引擎实例「{id}」")));
}
if settings.auto_fallback {
// 自动模式只尝试已启用的(free + AI 同一规则)
let list: Vec<TranslateEngineConfig> =
settings.auto_candidates().into_iter().cloned().collect();
all.into_iter().filter(|e| e.enabled).collect();
if list.is_empty() {
return Err(TranslateError::config(
"没有已启用的翻译引擎,请先在翻译设置中启用至少一个",
"没有可用的翻译引擎:请在主设置 → AI 服务中配置供应商,\
再到翻译设置里把它加入翻译候选(或启用免密钥/云引擎)",
));
}
return Ok(list);
}
// 未开启降级:只尝试默认引擎;默认引擎失效时回落到优先级最高的已启用实例
let preferred = settings
.engine(&settings.default_engine_id)
let preferred = all
.iter()
.find(|e| e.id == settings.default_engine_id && e.enabled)
.cloned()
.or_else(|| settings.auto_candidates().first().map(|c| (*c).clone()));
preferred.map(|cfg| vec![cfg]).ok_or_else(|| {
TranslateError::config("没有已启用的翻译引擎,请先在翻译设置中启用至少一个")
.or_else(|| {
all.into_iter()
.filter(|e| e.enabled)
.min_by_key(|e| e.priority)
});
preferred
.map(|cfg| vec![cfg])
.ok_or_else(|| {
TranslateError::config(
"没有可用的翻译引擎:请在主设置 → AI 服务中配置供应商,\
再到翻译设置里把它加入翻译候选,并启用至少一个引擎",
)
})
}
+90 -45
View File
@@ -68,6 +68,57 @@ impl PromptTemplates {
}
}
/// 全局 AI 供应商在**翻译场景**下的参数。
///
/// 与 `ai` 模块的分工:AI 侧只存连接与生成参数(Base URL / 模型 / 最大输出 / 上下文);
/// 优先级、超时、提示词覆盖是翻译自己的编排语义,留在本模块。
///
/// **列表即「已加入翻译候选的 AI 引擎」**:一条记录的存在就代表用户在主设置里选了这个
/// 供应商来翻译(见 `TranslateManager::all_engines`)。供应商本身仍只存在于 AI 服务里,
/// 这里只有 id 引用与场景参数——避免同一份连接配置出现两个真源。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct TranslateAiParams {
/// 对应全局 AI 供应商 id
pub provider_id: String,
/// 是否参与翻译候选(翻译侧开关)。
///
/// 与供应商自身的 `enabled` 是两层:那边是「这台机器是否允许用这个供应商」,
/// 这边是「它在翻译里是否上场」。生效值 = 两者与。
pub enabled: bool,
/// 优先级(数值越小越先尝试;自动降级按序)
pub priority: i32,
/// 该供应商在翻译请求中的超时(毫秒)
pub timeout_ms: u64,
/// 自定义 system prompt;**非空时覆盖翻译模板**
pub system_prompt: String,
}
impl Default for TranslateAiParams {
fn default() -> Self {
Self {
provider_id: String::new(),
enabled: true,
priority: 100,
timeout_ms: 30_000,
system_prompt: String::new(),
}
}
}
impl TranslateAiParams {
/// 按供应商 id 取参数(缺失时用默认值并带上 id)。
pub fn for_provider(list: &[Self], provider_id: &str) -> Self {
list.iter()
.find(|p| p.provider_id == provider_id)
.cloned()
.unwrap_or_else(|| Self {
provider_id: provider_id.to_string(),
..Self::default()
})
}
}
/// 单个翻译引擎实例的配置。
///
/// 「实例」而非「类型」:同一类型可以配置多份(例如官方 API 与本地 Ollama 并存),
@@ -129,31 +180,6 @@ impl Default for TranslateEngineConfig {
}
}
impl TranslateEngineConfig {
/// 内置 DeepSeek 预设:默认引擎。模型标识取现行名 `deepseek-flash`
/// (`deepseek-chat` / `deepseek-reasoner` 已于 2026-07-24 停用;`deepseek-v4-flash`
/// 等旧名虽仍被受理,但请求已被路由到 V4.1-Flash,不适合再写进默认配置)。
pub fn deepseek_default() -> Self {
Self {
id: "deepseek".to_string(),
name: "DeepSeek Flash".to_string(),
kind: "ai".to_string(),
preset: "deepseek".to_string(),
enabled: true,
priority: 10,
base_url: "https://api.deepseek.com".to_string(),
model: "deepseek-flash".to_string(),
temperature: 0.3,
max_tokens: 4096,
timeout_ms: 30_000,
// 翻译场景用非思考模式:不写 thinking / reasoning_effort,换低延迟低费用
system_prompt: String::new(),
extra_body: None,
supports_vision: false,
}
}
}
/// 划词翻译设置(P1 生效;结构在 P0 即定型,避免 P2 改数据结构)。
///
/// P2 重构说明:原「取词快捷键 Alt+T」「翻译剪贴板 Alt+Shift+T」已移除,
@@ -164,7 +190,7 @@ impl TranslateEngineConfig {
pub struct SelectionSettings {
/// 总开关:打开翻译面板时是否尝试读取当前划词作为候选
pub enabled: bool,
/// 打开翻译面板的全局快捷键(默认 Ctrl+2)
/// 打开翻译面板的全局快捷键(默认 Alt+F)
#[serde(default = "default_panel_shortcut")]
pub panel_shortcut: String,
/// 取词方式:
@@ -183,7 +209,7 @@ pub struct SelectionSettings {
}
fn default_panel_shortcut() -> String {
"Ctrl+2".to_string()
"Alt+F".to_string()
}
impl Default for SelectionSettings {
@@ -324,8 +350,10 @@ pub struct TranslateSettings {
/// **默认关闭**:自建 LibreTranslate 在境内、MyMemory 与 DeepSeek 均可直连,
/// 不需要代理;仅当翻译服务部署在境外或直连被拦截时由用户显式打开。
pub use_proxy: bool,
/// 引擎实例列表
/// 引擎实例列表(仅 free/cloud;AI 供应商在主设置,场景参数见 `ai_params`)
pub engines: Vec<TranslateEngineConfig>,
/// 全局 AI 供应商的翻译场景参数(优先级 / 超时 / 提示词覆盖)
pub ai_params: Vec<TranslateAiParams>,
pub selection: SelectionSettings,
pub popup: PopupSettings,
pub screenshot: ScreenshotSettings,
@@ -338,10 +366,13 @@ impl Default for TranslateSettings {
Self {
version: 1,
default_target: "zh-Hans".to_string(),
default_engine_id: "deepseek".to_string(),
// AI 引擎由主设置(ai 模块)统一管理;翻译侧默认只走「自动」,
// 候选 = 本模块 free/cloud 引擎 + 全局 AI 供应商。
default_engine_id: "auto".to_string(),
auto_fallback: true,
use_proxy: false,
engines: vec![TranslateEngineConfig::deepseek_default()],
engines: Vec::new(),
ai_params: Vec::new(),
selection: SelectionSettings::default(),
popup: PopupSettings::default(),
screenshot: ScreenshotSettings::default(),
@@ -357,21 +388,27 @@ impl TranslateSettings {
self.engines.iter().find(|e| e.id == id)
}
/// 参与「自动」模式的引擎,按优先级升序。
pub fn auto_candidates(&self) -> Vec<&TranslateEngineConfig> {
let mut list: Vec<&TranslateEngineConfig> = self.engines.iter().filter(|e| e.enabled).collect();
list.sort_by_key(|e| e.priority);
list
/// 全局 AI 供应商在翻译中的参数(缺失时默认 priority=100 / timeout=30s)。
pub fn ai_params_for(&self, provider_id: &str) -> TranslateAiParams {
TranslateAiParams::for_provider(&self.ai_params, provider_id)
}
/// 自愈:列表为空时补回 DeepSeek 默认实例;默认引擎 id 失效时回落到第一个可用实例。
/// 按 id 找 AI 场景参数(可变引用,供 upsert)。
pub fn ai_params_mut(&mut self, provider_id: &str) -> Option<&mut TranslateAiParams> {
self.ai_params.iter_mut().find(|p| p.provider_id == provider_id)
}
/// 该全局 AI 供应商是否已加入翻译候选(= `ai_params` 里有记录)。
pub fn has_ai_engine(&self, provider_id: &str) -> bool {
self.ai_params.iter().any(|p| p.provider_id == provider_id)
}
/// 自愈:**不再**向列表补 DeepSeek(AI 供应商归主设置管,列表为空是合法状态)。
/// 默认引擎 id 只做空值归一;指向已删除实例的校验由 TranslateManager 在能读到
/// 全局 AI 供应商时完成(否则会把合法的 AI 默认引擎误改成 "auto")。
/// 返回是否发生了变更(由调用方决定落盘)。
pub fn heal(&mut self) -> bool {
let mut changed = false;
if self.engines.is_empty() {
self.engines.push(TranslateEngineConfig::deepseek_default());
changed = true;
}
if self.default_target.trim().is_empty() {
self.default_target = "zh-Hans".to_string();
changed = true;
@@ -380,11 +417,6 @@ impl TranslateSettings {
self.default_engine_id = "auto".to_string();
changed = true;
}
if self.default_engine_id != "auto" && self.engine(&self.default_engine_id).is_none() {
// 指向的实例已被删除:不要静默改写成某个实例,改为「自动」更符合用户预期
self.default_engine_id = "auto".to_string();
changed = true;
}
// v1 → v2:取词方式默认值从 "compat" 改为 "smart"(UIA 直读已实现)。
// v1 里这个字段没有任何 UI 入口,用户不可能主动选过它,因此直接迁移是安全的;
// 迁移后用户再选 "compat" 会被原样保留(版本号已推进,不会再被改写)。
@@ -395,6 +427,19 @@ impl TranslateSettings {
self.version = 2;
changed = true;
}
// v2 → v3:翻译面板默认快捷键从 Ctrl+2 改为 Alt+F(把 Ctrl+数字 让给终端)。
// 仍等于旧默认值 = 用户没改过,直接迁移;改过或已清空的原样保留。
if self.version < 3 {
if self.selection
.panel_shortcut
.trim()
.eq_ignore_ascii_case("ctrl+2")
{
self.selection.panel_shortcut = default_panel_shortcut();
}
self.version = 3;
changed = true;
}
changed
}
}
+18
View File
@@ -3,6 +3,24 @@
//! 从 `clipboard::popup` 迁出,供剪贴板弹窗、快速面板、托盘菜单等多窗口模块统一引用,
//! 避免其他模块反向依赖剪贴板模块。
/// 设置进程的 AppUserModelID(AUMID)。
///
/// Windows 的系统媒体面板(SMTC)与任务栏都按 AUMID 反查应用显示名与图标:进程不设置时
/// 系统只能显示「未知应用」。这里传入安装包写进开始菜单快捷方式的同一个标识符
/// (即 Tauri 的 identifier),从而直接复用快捷方式里的名称与图标。
///
/// **必须在创建任何窗口之前调用**(Windows 在窗口创建时确定任务栏分组与身份)。
#[cfg(windows)]
pub fn set_app_user_model_id(app_id: &str) {
use windows_sys::Win32::UI::Shell::SetCurrentProcessExplicitAppUserModelID;
let wide: Vec<u16> = app_id.encode_utf16().chain(std::iter::once(0)).collect();
// SAFETY: wide 以 NUL 结尾,且在本调用期间保持存活
unsafe {
SetCurrentProcessExplicitAppUserModelID(wide.as_ptr());
}
}
/// 获取鼠标位置(屏幕坐标,物理像素)
#[cfg(windows)]
pub fn get_cursor_pos() -> Option<(i32, i32)> {
+1 -1
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "thing",
"version": "26.9.3",
"version": "26.9.4",
"identifier": "thing.lfeng.me",
"build": {
"beforeDevCommand": "bun run dev",
+1 -1
View File
@@ -16,7 +16,7 @@ const emit = defineEmits<{ select: [] }>()
<button
type="button"
class="flex w-full items-center gap-3 px-3 py-2 text-left transition-colors duration-150 outline-none focus-visible:ring-2 focus-visible:ring-ring/40 focus-visible:ring-inset"
:class="active ? 'bg-primary-soft' : 'hover:bg-hover'"
:class="active ? 'bg-row-selected' : 'hover:bg-row-hover'"
@click="emit('select')"
>
<span class="flex min-w-0 flex-1 flex-col gap-0.5">
+3 -3
View File
@@ -258,7 +258,7 @@ function toggleAt(index: number) {
v-for="row in visibleQueue"
:key="`${row.item.source}:${row.item.guid ?? row.index}`"
class="group flex items-center gap-3 rounded-md px-2 py-1.5 transition-colors"
:class="row.index === store.queueIndex && !isPreview ? 'bg-accent/60' : 'hover:bg-accent/40'"
:class="row.index === store.queueIndex && !isPreview ? 'bg-row-selected' : 'hover:bg-row-hover'"
>
<button
type="button"
@@ -277,7 +277,7 @@ function toggleAt(index: number) {
<div class="min-w-0 flex-1">
<div
class="truncate text-[13px]"
:class="row.index === store.queueIndex && !isPreview ? 'font-medium' : ''"
:class="row.index === store.queueIndex && !isPreview ? 'font-medium text-primary-soft-text' : ''"
>
{{ row.item.title }}
</div>
@@ -295,7 +295,7 @@ function toggleAt(index: number) {
<button
v-if="hasMoreQueue"
type="button"
class="mt-1 rounded-md py-2 text-[12px] text-muted-foreground hover:bg-accent/40"
class="mt-1 rounded-md py-2 text-[12px] text-muted-foreground hover:bg-row-hover"
@click="queueLimit += QUEUE_STEP"
>
显示更多({{ store.queue.length - queueLimit }})
+27
View File
@@ -0,0 +1,27 @@
<script lang="ts" setup>
import type { StepperRootEmits, StepperRootProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperRoot, useForwardPropsEmits } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperRootProps & { class?: HTMLAttributes["class"] }>()
const emits = defineEmits<StepperRootEmits>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardPropsEmits(delegatedProps, emits)
</script>
<template>
<StepperRoot
v-slot="slotProps"
:class="cn(
'flex gap-2',
props.class,
)"
v-bind="forwarded"
>
<slot v-bind="slotProps" />
</StepperRoot>
</template>
@@ -0,0 +1,19 @@
<script lang="ts" setup>
import type { StepperDescriptionProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperDescription, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperDescriptionProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperDescription v-slot="slotProps" v-bind="forwarded" :class="cn('text-xs text-muted-foreground', props.class)">
<slot v-bind="slotProps" />
</StepperDescription>
</template>
@@ -0,0 +1,32 @@
<script lang="ts" setup>
import type { StepperIndicatorProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperIndicator, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperIndicatorProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperIndicator
v-slot="slotProps"
v-bind="forwarded"
:class="cn(
'inline-flex items-center justify-center rounded-full text-muted-foreground/50 w-8 h-8',
// Disabled
'group-data-[disabled]:text-muted-foreground group-data-[disabled]:opacity-50',
// Active
'group-data-[state=active]:bg-primary group-data-[state=active]:text-primary-foreground',
// Completed
'group-data-[state=completed]:bg-accent group-data-[state=completed]:text-accent-foreground',
props.class,
)"
>
<slot v-bind="slotProps" />
</StepperIndicator>
</template>
+23
View File
@@ -0,0 +1,23 @@
<script lang="ts" setup>
import type { StepperItemProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperItem, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperItemProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperItem
v-slot="slotProps"
v-bind="forwarded"
:class="cn('flex items-center gap-2 group data-[disabled]:pointer-events-none', props.class)"
>
<slot v-bind="slotProps" />
</StepperItem>
</template>
@@ -0,0 +1,27 @@
<script lang="ts" setup>
import type { StepperSeparatorProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperSeparator, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperSeparatorProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperSeparator
v-bind="forwarded"
:class="cn(
'bg-muted',
// Disabled
'group-data-[disabled]:bg-muted group-data-[disabled]:opacity-50',
// Completed
'group-data-[state=completed]:bg-accent',
props.class,
)"
/>
</template>
@@ -0,0 +1,19 @@
<script lang="ts" setup>
import type { StepperTitleProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperTitle, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperTitleProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperTitle v-bind="forwarded" :class="cn('text-md font-semibold whitespace-nowrap', props.class)">
<slot />
</StepperTitle>
</template>
@@ -0,0 +1,22 @@
<script lang="ts" setup>
import type { StepperTriggerProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperTrigger, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperTriggerProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperTrigger
v-bind="forwarded"
:class="cn('p-1 flex flex-col items-center text-center gap-1 rounded-md', props.class)"
>
<slot />
</StepperTrigger>
</template>
+7
View File
@@ -0,0 +1,7 @@
export { default as Stepper } from "./Stepper.vue"
export { default as StepperDescription } from "./StepperDescription.vue"
export { default as StepperIndicator } from "./StepperIndicator.vue"
export { default as StepperItem } from "./StepperItem.vue"
export { default as StepperSeparator } from "./StepperSeparator.vue"
export { default as StepperTitle } from "./StepperTitle.vue"
export { default as StepperTrigger } from "./StepperTrigger.vue"
+707 -8
View File
@@ -267,6 +267,81 @@ export const commands = {
* 都会把已删除的连接从旧快照里写回来。
*/
musicSaveSettings: (settings: MusicSettings) => __TAURI_INVOKE<null>("music_save_settings", { settings }),
/**
* 开始播放一个音源。
*
* `source`:本地绝对路径,或飞牛流地址(形如
* `http://127.0.0.1:<port>/feiniu/stream?guid=...`,由前端按当前连接拼好 ——
* 鉴权留在原有代理里,引擎不重复实现)。
* `startSec`:起播位置,用于「恢复上次退出时的进度」。
*/
musicAudioPlay: (source: string, startSec: number | null) => __TAURI_INVOKE<null>("music_audio_play", { source, startSec }),
/** 暂停 / 恢复。瞬时生效(只改一个原子标志)。 */
musicAudioSetPlaying: (playing: boolean) => __TAURI_INVOKE<void>("music_audio_set_playing", { playing }),
/** 定位到指定秒。 */
musicAudioSeek: (sec: number | null) => __TAURI_INVOKE<void>("music_audio_seek", { sec }),
/** 停止播放并释放音频设备。 */
musicAudioStop: () => __TAURI_INVOKE<void>("music_audio_stop"),
/** 设置音量与静音(跨曲目沿用)。 */
musicAudioSetVolume: (volume: number | null, muted: boolean) => __TAURI_INVOKE<void>("music_audio_set_volume", { volume, muted }),
/** 读取播放状态快照(位置/缓冲/采样率/是否失败)。 */
musicAudioState: () => __TAURI_INVOKE<AudioState>("music_audio_state"),
remoteGetConfig: () => __TAURI_INVOKE<RemoteConfig>("remote_get_config"),
/** 开关(即时生效,§5.1)。 */
remoteSetEnabled: (enabled: boolean) => __TAURI_INVOKE<RemoteConfig>("remote_set_enabled", { enabled }),
remoteStatus: () => __TAURI_INVOKE<RemoteStatus>("remote_status"),
/** 生成配对码 + 二维码 payload(前端 `qrcode` 渲染,§5.3)。 */
remoteStartPairing: () => __TAURI_INVOKE<RemotePairingInfo>("remote_start_pairing"),
remoteCancelPairing: () => __TAURI_INVOKE<void>("remote_cancel_pairing"),
/** 设备列表(元数据 + 在线态;token 永不出现在这里)。 */
remoteListDevices: () => __TAURI_INVOKE<RemoteDeviceView[]>("remote_list_devices"),
/** 吊销设备(删表 + 删凭据;已建立的 WS 在下次重连时被拒)。 */
remoteRevokeDevice: (id: string) => __TAURI_INVOKE<null>("remote_revoke_device", { id }),
/**
* 前端发布 Thing 本机播放队列(手机端「播放队列 / 选歌」的数据源)。
*
* 队列活在前端 store(feiniuStore),Rust 只做快照转发;`items` 允许是完整队列
* 的一段(见 [`proto::QueueItem::index`]),`total` 恒为完整长度。
*/
remotePublishQueue: (items: QueueItem[], index: number, total: number) => __TAURI_INVOKE<void>("remote_publish_queue", { items, index, total }),
/**
* 启动一批本地解密任务。
*
* 两种输入方式(二选一,`folder` 优先):
* - `folder`:**文件夹批量**。递归扫描该目录下所有可解密的加密音乐
* (内容判定优先,见 `scan::route`),并按 `root` 还原相对目录结构。
* - `files`:显式文件列表(散选场景)。
*
* `in_place = true` 时产物与源文件同目录同名——文件夹批量推荐这样用,
* 符合"就地解出来"的直觉;`false` 则统一输出到 `out_dir`。
*
* 返回 `Ok(())` 表示任务已登记并开始执行;逐文件结果走事件。
*/
musicDecryptRun: (taskId: string, files: string[] | null, folder: string | null, root: string | null, outDir: string | null, inPlace: boolean | null) => __TAURI_INVOKE<null>("music_decrypt_run", { taskId, files, folder, root, outDir, inPlace }),
/**
* 请求取消一个解密任务。
*
* 队列级语义(与 `music_download_cancel` 一致):**当前文件会做完**,
* 剩余文件不再开始处理,随后发一个带 `cancelled` 计数的 `finished` 事件。
* 返回是否命中了一个在跑的任务(false 通常表示任务已结束)。
*/
musicDecryptCancel: (taskId: string) => __TAURI_INVOKE<boolean>("music_decrypt_cancel", { taskId }),
/**
* 扫描一个文件夹,返回可解密文件的数量与平台分布(**不解密**)。
*
* 给 UI 做预览:用户选完文件夹先看到"找到 N 个(网易云 x / QQ音乐 y)",
* 而不是直接开跑一个可能包含几千首的任务。
*/
musicDecryptScan: (folder: string, root: string | null) => __TAURI_INVOKE<ScanSummary>("music_decrypt_scan", { folder, root }),
/**
* 探测 QQ 音乐**在线取密钥**能力(新版 musicex 文件解密的前置条件)。
*
* 只读本机信息,不发网络请求:读 `QQMusicServiceConfig.ini` 的 `uin`,
* 再从运行中的 `QQMusic.exe` 内存里找 `authst`。
*
* `authst` **不会**返回给前端(只在后端用于调接口),前端拿到的只有 QQ 号与状态。
*/
musicDecryptQqStatus: () => __TAURI_INVOKE<QqOnlineStatus>("music_decrypt_qq_status"),
/** 禁用指定窗口(按 label 查找)的显示/隐藏过渡动画,消除覆盖层出现/消失时的缩放动画 */
screenshotDisableTransitions: (label: string) => __TAURI_INVOKE<null>("screenshot_disable_transitions", { label }),
/** 一次 IPC 完成指定窗口的显示与聚焦(截图覆盖层显示关键路径,减少串行往返) */
@@ -355,6 +430,37 @@ export const commands = {
screenshotLoadCache: (path: string) => __TAURI_INVOKE<string>("screenshot_load_cache", { path }),
/** 删除历史缓存文件(历史项移除/清空时调用,静默忽略不存在文件) */
screenshotDeleteCache: (path: string) => __TAURI_INVOKE<null>("screenshot_delete_cache", { path }),
/** 读取全局 AI 设置。 */
aiGetSettings: () => __TAURI_INVOKE<AiSettings_Serialize>("ai_get_settings"),
/** 保存全局 AI 设置(整体覆盖;供应商列表以传入为准)。 */
aiSaveSettings: (settings: AiSettings_Deserialize) => __TAURI_INVOKE<null>("ai_save_settings", { settings }),
/** 列出供应商视图(含密钥状态与可用性),保持配置中的顺序。 */
aiListProviders: () => __TAURI_INVOKE<AiProviderView_Serialize[]>("ai_list_providers"),
/**
* 新增或更新一个供应商(按 id upsert)。
*
* 校验 id:它会进入凭据键(`ai-provider-<id>`),限定为字母/数字/下划线/短横线。
*/
aiProviderSave: (config: AiProviderConfig_Deserialize) => __TAURI_INVOKE<null>("ai_provider_save", { config }),
/** 删除供应商(连同它在系统凭据管理器中的密钥)。 */
aiProviderDelete: (id: string) => __TAURI_INVOKE<null>("ai_provider_delete", { id }),
/** 写入供应商的 API Key(明文只在此处进入系统凭据管理器,永不回写配置文件)。 */
aiSecretSet: (id: string, apiKey: string) => __TAURI_INVOKE<null>("ai_secret_set", { id, apiKey }),
/** 清除供应商的 API Key。 */
aiSecretClear: (id: string) => __TAURI_INVOKE<null>("ai_secret_clear", { id }),
/**
* 连通性自检:用前端传入的草稿配置测试(**不落盘**)。
*
* `api_key` 是可选的「临时密钥」覆盖:设置页允许用户**填好 Key、还没保存**就先检查一次,
* 省掉「先保存再测试」的来回。它只用于这一次请求——不写凭据管理器、不落配置文件,
* 也不会被回传到前端;为空时退回凭据管理器里已保存的密钥。
*
* 之所以仍按 `config.id` 取已保存的密钥作为默认值:多数场景(改 Base URL / 换模型后复测)
* 用户并不想重新输入 Key。
*/
aiProviderTest: (config: AiProviderConfig_Deserialize, apiKey: string | null) => __TAURI_INVOKE<AiTestResult>("ai_provider_test", { config, apiKey }),
/** 拉取上游模型列表(按已保存的 id;密钥/地址取自磁盘上的配置与凭据库)。 */
aiProviderModels: (id: string) => __TAURI_INVOKE<string[]>("ai_provider_models", { id }),
/** 读取翻译设置 */
translateGetSettings: () => __TAURI_INVOKE<TranslateSettings>("translate_get_settings"),
/**
@@ -367,20 +473,35 @@ export const commands = {
translateSaveSettings: (settings: TranslateSettings) => __TAURI_INVOKE<null>("translate_save_settings", { settings }),
/** 按当前设置重新注册全局快捷键(设置页改动后或启动时调用) */
translateApplyShortcuts: () => __TAURI_INVOKE<null>("translate_apply_shortcuts"),
/** 列出引擎实例(含密钥状态与可用性) */
/**
* 列出引擎实例(含密钥状态与可用性)。
*
* 返回**本模块 free/cloud 引擎 + 全局 AI 供应商**(AI 转换为 kind = "ai"),
* 供工作台选择与「默认引擎」下拉使用。AI 的增删改走主设置 → AI 服务。
*/
translateEnginesList: () => __TAURI_INVOKE<EngineView[]>("translate_engines_list"),
/**
* 新增或更新一个引擎实例(按 id upsert)。
* 新增或更新一个**非 AI** 引擎实例(按 id upsert)。
*
* AI 引擎(kind = "ai")由主设置 → AI 服务管理,这里显式拒绝,
* 避免出现「翻译设置里改了一份、主设置里还是旧的」的双源分裂。
*
* 校验 id:它会进入凭据键(`translate-engine-<id>`),含特殊字符会让键名难以排查,
* 因此限定为字母/数字/下划线/短横线。
*/
translateEngineSave: (config: TranslateEngineConfig) => __TAURI_INVOKE<null>("translate_engine_save", { config }),
/** 删除引擎实例(连同它在系统凭据管理器中的密钥)。 */
/**
* 删除引擎实例(连同它在系统凭据管理器中的密钥)。
* AI 引擎请到主设置 → AI 服务删除。
*/
translateEngineDelete: (id: string) => __TAURI_INVOKE<null>("translate_engine_delete", { id }),
/** 写入引擎的 API Key(明文只在此处进入系统凭据管理器,永不回写配置文件)。 */
/**
* 写入引擎的 API Key(明文只在此处进入系统凭据管理器,永不回写配置文件)。
*
* AI 供应商的 Key 写 `ai-provider-*`;free/cloud 写 `translate-engine-*`。
*/
translateSecretSet: (id: string, apiKey: string) => __TAURI_INVOKE<null>("translate_secret_set", { id, apiKey }),
/** 清除引擎的 API Key */
/** 清除引擎的 API Key(按 kind 选凭据键,与 write 对称)。 */
translateSecretClear: (id: string) => __TAURI_INVOKE<null>("translate_secret_clear", { id }),
/**
* 连通性自检:用前端传入的配置测试(**不落盘**)。
@@ -393,7 +514,7 @@ export const commands = {
translateEngineTestConfig: (config: TranslateEngineConfig) => __TAURI_INVOKE<EngineTestResult>("translate_engine_test_config", { config }),
/**
* 拉取上游模型列表(应对「上游改名」导致预设失效的自救入口)。
* 免密钥源没有模型概念,返回空列表。
* 免密钥源没有模型概念,返回空列表。AI 供应商从全局列表按 id 查找。
*/
translateEngineModels: (id: string) => __TAURI_INVOKE<string[]>("translate_engine_models", { id }),
/**
@@ -507,6 +628,20 @@ export const commands = {
* 在翻译期间一直保持原样。回填前校验原窗口仍然存活,避免粘贴进毫不相干的窗口。
*/
translatePasteBack: (text: string, hwnd: number) => __TAURI_INVOKE<null>("translate_paste_back", { text, hwnd }),
/**
* 把某个全局 AI 供应商加入翻译候选,或更新它的**翻译场景参数**(启用 / 优先级 / 超时 / 提示词)。
*
* 连接配置(Base URL、模型、密钥)在主设置 → AI 服务;这里只写 translate 自己的编排语义。
* 首次调用即「加入」——`ai_params` 有记录就代表该供应商参与翻译候选。
*/
translateAiParamsSave: (params: TranslateAiParams) => __TAURI_INVOKE<null>("translate_ai_params_save", { params }),
/**
* 把某个全局 AI 供应商**移出翻译候选**(供应商本身与它的密钥都不动)。
*
* 只删 `ai_params` 里的这条记录。默认引擎指向它时改为「自动」——否则默认引擎会指向
* 一个已经不在候选里的 id,用户看到的是「设置对了但翻译报找不到引擎」。
*/
translateAiEngineRemove: (providerId: string) => __TAURI_INVOKE<null>("translate_ai_engine_remove", { providerId }),
/** 读取终端设置。 */
terminalGetSettings: () => __TAURI_INVOKE<TerminalSettings>("terminal_get_settings"),
/**
@@ -704,6 +839,87 @@ export const commands = {
* 多按一次回车的成本远低于一次误执行。
*/
terminalHistoryRun: (sessionId: string, command: string, submit: boolean | null) => __TAURI_INVOKE<ActionOutcome>("terminal_history_run", { sessionId, command, submit }),
/**
* 列出可用于命令生成的 AI 供应商(来自主设置 → AI 服务;按优先级排序)。
*
* 没有可用供应商时返回空列表——前端据此引导用户去主设置里配置,
* 而不是在点击「生成」后才报错。
*/
terminalAiEngines: () => __TAURI_INVOKE<AiEngineOption[]>("terminal_ai_engines"),
/**
* 根据意图生成命令建议。
*
* `context`:可选的终端最近输出/选中文本(前端从 xterm 缓冲取),
* 帮助模型理解「接着上一步做什么」。
*/
terminalAiSuggest: (engineId: string, intent: string, context: string) => __TAURI_INVOKE<CommandSuggestion[]>("terminal_ai_suggest", { engineId, intent, context }),
/**
* 环境总览:Node / dsh / 服务状态 + 模块设置(模块首屏一次拿全)。
*
* 声明为 `async`:Tauri 的**同步**命令在主线程执行,而本命令要跑
* `node --version` 子进程探测,放主线程会造成界面卡顿。
* (async 命令带 `State<'_>` 引用参数时必须返回 `Result`,故这里包一层 Ok。)
*/
dshEnvStatus: () => __TAURI_INVOKE<DshEnvStatus>("dsh_env_status"),
/** 重新探测 Node(系统 PATH + 托管目录)。同样因执行 `node --version` 而用 async。 */
dshNodeDetect: () => __TAURI_INVOKE<NodeStatus>("dsh_node_detect"),
/** 下载并安装便携 Node(`version` 为空 = 自动取满足要求的最新版)。 */
dshNodeInstall: (version: string | null) => __TAURI_INVOKE<NodeStatus>("dsh_node_install", { version }),
/** 安装 dsh(`version` 为空 = latest)。 */
dshInstall: (version: string | null) => __TAURI_INVOKE<DshInstallStatus>("dsh_install", { version }),
/** 更新 dsh 到 latest(更新前停止服务,避免文件被占用)。 */
dshUpdate: () => __TAURI_INVOKE<DshInstallStatus>("dsh_update"),
/** 卸载 dsh(停止服务并删除包目录;保留设置与 $DSH_HOME)。 */
dshUninstall: () => __TAURI_INVOKE<null>("dsh_uninstall"),
/** 取消进行中的下载 / 安装。 */
dshCancelInstall: () => __TAURI_INVOKE<void>("dsh_cancel_install"),
/** 查询 npm 上的可用版本。 */
dshCheckUpdate: () => __TAURI_INVOKE<DshUpdateInfo>("dsh_check_update"),
/**
* 读取「本次安装实际使用的 npm 源」及其来源。
*
* 设置为空时 npm 会用自己配置链里的源(含系统 Node 的 `~/.npmrc`),
* 这里把解析结果回给前端展示,让用户能看出「到底走的是哪个源」。
* async:内部要跑 `node <npm-cli.js> config get registry` 子进程。
*/
dshNpmRegistryInfo: () => __TAURI_INVOKE<DshNpmRegistryInfo>("dsh_npm_registry_info"),
dshGetSettings: () => __TAURI_INVOKE<DshSettings>("dsh_get_settings"),
/** 保存设置(即时生效;端口等改动在下次启动服务时生效)。 */
dshSaveSettings: (settings: DshSettings) => __TAURI_INVOKE<DshSettings>("dsh_save_settings", { settings }),
/**
* 注册(或切换)「打开 dsh 独立窗口」全局快捷键;传空字符串则注销。
*
* 按下时只 emit `dsh-open-window` 事件,**窗口由前端创建**:前端才持有带令牌的
* 启动地址,也能用 label 判重复用已开窗口(与截图模块「快捷键 → 事件 → 前端开窗」同构)。
*/
dshRegisterShortcut: (shortcut: string) => __TAURI_INVOKE<null>("dsh_register_shortcut", { shortcut }),
/** 注销「打开 dsh 独立窗口」全局快捷键。 */
dshUnregisterShortcut: () => __TAURI_INVOKE<null>("dsh_unregister_shortcut"),
/**
* 启动 dsh Web 服务。async:内部要 spawn 子进程 + 读凭据 + 写 settings.yaml,
* 同步命令会在主线程执行从而卡住界面。
*/
dshStart: () => __TAURI_INVOKE<DshServerStatus>("dsh_start"),
/** 停止 dsh Web 服务。 */
dshStop: () => __TAURI_INVOKE<DshServerStatus>("dsh_stop"),
/** 重启 dsh Web 服务。 */
dshRestart: () => __TAURI_INVOKE<DshServerStatus>("dsh_restart"),
/** 预览将写入 `$DSH_HOME/settings.yaml` 的内容(不含明文密钥)。 */
dshAiPreview: () => __TAURI_INVOKE<DshAiPreview>("dsh_ai_preview"),
/** 执行 AI 配置同步(合并写入 settings.yaml,写前备份)。 */
dshAiSync: () => __TAURI_INVOKE<DshAiPreview>("dsh_ai_sync"),
/** 读取服务日志尾部。 */
dshLogTail: (lines: number) => __TAURI_INVOKE<string>("dsh_log_tail", { lines }),
/**
* 读取 dsh 安装输出(npm 的 stdout/stderr 尾部)。
*
* 只存在内存里(每次安装开始时清空),供「安装引导 → dsh 本体」页临时展示,
* **不写应用日志、不落盘**。前端在安装进行中轮询这个命令。
*/
dshInstallLog: () => __TAURI_INVOKE<string>("dsh_install_log"),
dshLogClear: () => __TAURI_INVOKE<void>("dsh_log_clear"),
/** 在资源管理器中打开 dsh 模块目录。 */
dshOpenDir: () => __TAURI_INVOKE<null>("dsh_open_dir"),
};
/* Types */
@@ -719,6 +935,201 @@ export type ActionOutcome = {
message: string,
};
/** 可用于命令生成的供应商(已启用且配置了 Base URL)。 */
export type AiEngineOption = {
id: string,
name: string,
model: string,
};
/**
* AI 请求的错误分类。
*
* **本模块自带一份,不复用 `translate::ErrorKind`**:AI 服务是独立的底座,
* 不反向依赖任何业务模块(否则「谁依赖谁」会随功能增长变得无法收敛)。
* 变体名与 translate 的同名枚举刻意保持一致,前端可以共用一套提示文案;
* 只保留 AI 侧**真会产生的**分类(translate 的 unsupported / captcha 是翻译专属语义)。
* 将来若两者要做共享层,再把这个枚举上提合并。
*/
export type AiErrorKind =
/** 配置问题:Base URL / 模型名不对 */
"config" |
/** 认证问题:API Key 无效、无该模型权限、余额不足 */
"auth" |
/** 上游限流 */
"rateLimit" |
/** 网络不可达 / 上游服务端错误 */
"network" |
/** 超时 */
"timeout" |
/** 响应格式异常 */
"parse" |
/** 上游返回空内容 */
"empty" |
/** 其它未分类错误 */
"unknown";
/**
* 单个 AI 供应商实例(OpenAI 兼容端点)。
*
* 「实例」而非「类型」:同一厂商可配置多份(官方 API 与本地 Ollama 并存)。
* 翻译、终端助手等模块共用连接与生成参数;场景参数(优先级、超时、提示词)
* 由各模块自行维护。
*/
export type AiProviderConfig = AiProviderConfig_Serialize | AiProviderConfig_Deserialize;
/**
* 单个 AI 供应商实例(OpenAI 兼容端点)。
*
* 「实例」而非「类型」:同一厂商可配置多份(官方 API 与本地 Ollama 并存)。
* 翻译、终端助手等模块共用连接与生成参数;场景参数(优先级、超时、提示词)
* 由各模块自行维护。
*/
export type AiProviderConfig_Deserialize = {
/** 实例唯一标识(同时是凭据键的一部分,创建后不建议修改) */
id?: string,
/** 展示名称 */
name?: string,
/**
* 预设标识:"deepseek" | "openai" | "gemini" | "qwen" | "kimi" | "zhipu"
* | "doubao" | "mimo" | "mistral" | "groq" | "openrouter" | "siliconflow"
* | "ollama" | "lmstudio" | "custom" …
*/
preset?: string,
/** 是否启用(关闭后各模块不再把此供应商当候选) */
enabled?: boolean,
/** API 根地址(末尾可有可无 /,不可含 /chat/completions) */
baseUrl?: string,
/** 模型标识 */
model?: string,
/** 采样温度 */
temperature?: number | null,
/** 最大输出 tokens(completion 上限,对齐 Agent 常见的「回答长度」) */
maxTokens?: number,
/** 最大上下文窗口 tokens(模型可接受的输入+输出规模,供调用方截断与展示) */
maxContext?: number,
/** 额外请求体字段的 JSON 文本(thinking / enable_thinking 等非标准参数) */
extraBody?: string | null,
/** 是否支持图像输入(多模态能力声明;截图翻译「视觉直传」只发给勾选了此项的供应商) */
supportsVision?: boolean,
} & {
/** 旧:供应商级优先级(历史键 `priority`) */
legacyPriority?: number | null,
} | {
/** 旧:供应商级优先级(历史键 `priority`) */
priority?: number | null,
} & {
/** 旧:供应商级超时(历史键 `timeoutMs`) */
legacyTimeoutMs?: number | null,
} | {
/** 旧:供应商级超时(历史键 `timeoutMs`) */
timeoutMs?: number | null,
} & {
/** 旧:翻译 system prompt 覆盖(历史键 `systemPrompt`) */
legacySystemPrompt?: string | null,
} | {
/** 旧:翻译 system prompt 覆盖(历史键 `systemPrompt`) */
systemPrompt?: string | null,
};
/**
* 单个 AI 供应商实例(OpenAI 兼容端点)。
*
* 「实例」而非「类型」:同一厂商可配置多份(官方 API 与本地 Ollama 并存)。
* 翻译、终端助手等模块共用连接与生成参数;场景参数(优先级、超时、提示词)
* 由各模块自行维护。
*/
export type AiProviderConfig_Serialize = {
/** 实例唯一标识(同时是凭据键的一部分,创建后不建议修改) */
id: string,
/** 展示名称 */
name: string,
/**
* 预设标识:"deepseek" | "openai" | "gemini" | "qwen" | "kimi" | "zhipu"
* | "doubao" | "mimo" | "mistral" | "groq" | "openrouter" | "siliconflow"
* | "ollama" | "lmstudio" | "custom" …
*/
preset: string,
/** 是否启用(关闭后各模块不再把此供应商当候选) */
enabled: boolean,
/** API 根地址(末尾可有可无 /,不可含 /chat/completions) */
baseUrl: string,
/** 模型标识 */
model: string,
/** 采样温度 */
temperature: number | null,
/** 最大输出 tokens(completion 上限,对齐 Agent 常见的「回答长度」) */
maxTokens: number,
/** 最大上下文窗口 tokens(模型可接受的输入+输出规模,供调用方截断与展示) */
maxContext: number,
/** 额外请求体字段的 JSON 文本(thinking / enable_thinking 等非标准参数) */
extraBody: string | null,
/** 是否支持图像输入(多模态能力声明;截图翻译「视觉直传」只发给勾选了此项的供应商) */
supportsVision: boolean,
};
/** 供应商前端视图:配置 + 派生状态(密钥是否已配、是否可用)。 */
export type AiProviderView = AiProviderView_Serialize | AiProviderView_Deserialize;
/** 供应商前端视图:配置 + 派生状态(密钥是否已配、是否可用)。 */
export type AiProviderView_Deserialize = {
config: AiProviderConfig_Deserialize,
hasApiKey: boolean,
apiKeyMasked: string,
ready: boolean,
issue: string | null,
};
/** 供应商前端视图:配置 + 派生状态(密钥是否已配、是否可用)。 */
export type AiProviderView_Serialize = {
config: AiProviderConfig_Serialize,
hasApiKey: boolean,
apiKeyMasked: string,
ready: boolean,
issue: string | null,
};
/** 全局 AI 设置根结构。 */
export type AiSettings = AiSettings_Serialize | AiSettings_Deserialize;
/** 全局 AI 设置根结构。 */
export type AiSettings_Deserialize = {
/** 结构版本号:1 = 含供应商级场景参数;2 = 场景参数下沉到各模块 */
version?: number,
/** 供应商实例列表 */
providers?: AiProviderConfig_Deserialize[],
/** 默认供应商 id("auto" 表示不指定;主要给终端等简单消费方) */
defaultProviderId?: string,
/**
* AI 请求是否走代理模块(mihomo mixed 端口)。
* 默认关闭:DeepSeek 等境内可直连;境外服务由用户显式打开。
*/
useProxy?: boolean,
};
/** 全局 AI 设置根结构。 */
export type AiSettings_Serialize = {
/** 结构版本号:1 = 含供应商级场景参数;2 = 场景参数下沉到各模块 */
version: number,
/** 供应商实例列表 */
providers: AiProviderConfig_Serialize[],
/** 默认供应商 id("auto" 表示不指定;主要给终端等简单消费方) */
defaultProviderId: string,
/**
* AI 请求是否走代理模块(mihomo mixed 端口)。
* 默认关闭:DeepSeek 等境内可直连;境外服务由用户显式打开。
*/
useProxy: boolean,
};
export type AiTestResult = {
ok: boolean,
latencyMs: number,
message: string,
errorKind: AiErrorKind | null,
detail: string | null,
};
export type AppRecord = {
name: string,
path: string,
@@ -755,6 +1166,24 @@ export type ArchiveInfo = {
size: number,
};
/**
* 播放状态快照(返回前端)。进度用**拉取**而不是每帧推送:
* 高频 emit 既费 IPC,又会在拖动进度条时和本地状态打架。
*/
export type AudioState = {
/** 是否存在有效会话(false = 已停止/无曲目) */
active: boolean,
playing: boolean,
/** 当前播放位置(秒) */
positionSec: number | null,
/** 已解码待播的秒数 */
bufferedSec: number | null,
/** 源采样率(Hz),0 = 尚未探测出来 */
sampleRate: number,
finished: boolean,
failed: boolean,
};
/** BT 种子内文件条目(多文件任务用;阶段1下载全部文件,但保留列表供 UI 展示) */
export type BtFileInfo = {
/** 文件在种子内的索引 */
@@ -911,6 +1340,12 @@ export type CommandSnippet = {
createdAt?: number,
};
/** 一条命令建议。 */
export type CommandSuggestion = {
command: string,
description: string,
};
/** 自定义命令 */
export type CustomCommand = {
id: string,
@@ -997,6 +1432,136 @@ export type DownloaderSettings = {
btUseProxy?: boolean,
};
/** settings.yaml 同步预览。 */
export type DshAiPreview = {
/** 将被写入的 YAML 文本(密钥位置只有环境变量名) */
yaml: string,
providers: DshAiProvider[],
defaultProvider: string | null,
defaultModel: string | null,
settingsPath: string,
};
/** AI 供应商映射结果(预览用,不含明文密钥)。 */
export type DshAiProvider = {
/** Thing 侧供应商 id */
id: string,
name: string,
/** 写入 settings.yaml 的 apiKeyEnv 变量名 */
envName: string,
baseUrl: string,
model: string,
/** 凭据管理器中是否已配置密钥 */
hasKey: boolean,
};
/** 模块首屏环境总览。 */
export type DshEnvStatus = {
node: NodeStatus,
dsh: DshInstallStatus,
server: DshServerStatus,
settings: DshSettings,
};
/** dsh 本体安装状态。 */
export type DshInstallStatus = {
installed: boolean,
version: string | null,
/** bin 入口(dist/bin.js 绝对路径) */
entry: string | null,
/** 安装目录 */
dir: string,
};
/** npm 源信息(安装引导页展示「本次实际用哪个源」并提供快捷切换)。 */
export type DshNpmRegistryInfo = {
/** 本次安装/查询实际会使用的源(已去掉末尾 `/`) */
effective: string,
/** effective 的来源:setting(模块设置显式指定)| npm(npm 自身配置链)| fallback(默认官方源) */
source: string,
/**
* npm 自身解析出的源(环境变量 > 安装目录 .npmrc > 用户 ~/.npmrc > 内置),
* 未检测到 Node/npm 时为 None
*/
npmRegistry: string | null,
/** 模块设置里显式填写的值(空 = 未指定,交给 npm 解析) */
setting: string,
};
/** dsh 服务进程状态。 */
export type DshServerStatus = {
/** 进程存活 */
running: boolean,
/** HTTP 端口已可访问 */
ready: boolean,
pid: number | null,
port: number,
/** 规范地址(不含令牌,用于界面展示) */
url: string,
/**
* 带令牌的启动地址(**用于打开界面**)。
*
* dsh web 的浏览器鉴权是「进程级随机令牌 → 首次访问换 cookie」:
* 直接访问 [`Self::url`] 只会拿到 401。令牌每次启动都不同,只能从
* dsh 的输出里抓取,因此进程刚起来时这里可能为 None(等它打印)。
*/
launchUrl: string | null,
/** 启动时间(unix 秒) */
startedAt: number | null,
/** 启动失败原因(端口占用 / 进程立即退出等) */
error: string | null,
};
/**
* 模块设置(`{app_data}/dsh/settings.json`)。
*
* 独立文件,**不写** `thing_app_settings`(appStore 的 SETTINGS_VERSION 迁移会清空用户设置)。
*/
export type DshSettings = {
/** 结构版本号;变更时按版本校正字段 */
version?: number,
/** Node 来源偏好:auto(系统优先,缺失回落托管)| system | managed */
nodeSource?: string,
/** 指定下载的 Node 版本(空 = 自动取满足要求的最新版) */
managedNodeVersion?: string,
/** Node 分发包镜像前缀(空 = 官方 nodejs.org;国内可用 npmmirror) */
nodeMirror?: string,
/** npm registry(空 = 官方源) */
npmRegistry?: string,
/** 下载 Node / npm 安装是否走代理模块(mihomo mixed 端口) */
useProxy?: boolean,
/** Web UI 端口(dsh 的 `--port` 参数) */
port?: number,
/** 应用启动时自动拉起 dsh 服务 */
autoStart?: boolean,
/** 全局快捷键:打开 dsh Web 独立窗口(空 = 未启用) */
shortcut?: string,
/** $DSH_HOME 模式:managed({app_data}/dsh/home)| user(~/.dsh) */
dshHomeMode?: string,
/** 工作区目录(空 = {app_data}/dsh/workspace),即 dsh 进程的启动目录 */
workspace?: string,
/**
* dsh 本体的安装目录(npm `--prefix` 目标,即 node_modules 所在位置)。
* 空 = {app_data}/dsh。
* 只有 dsh 本体与它的 node_modules 跟随此设置;便携 Node、$DSH_HOME、
* 日志与模块设置仍固定在应用数据目录,避免自定义路径失效时连配置都读不到。
*/
installDir?: string,
/** 映射为 dsh 默认模型的 Thing AI 供应商 id */
providerId?: string,
/** 启动前自动同步 settings.yaml */
aiSync?: boolean,
};
/** dsh 版本更新信息。 */
export type DshUpdateInfo = {
current: string | null,
latest: string,
hasUpdate: boolean,
/** 可选版本(倒序,最多 20 个) */
versions: string[],
};
/** 重复类型 */
export type DuplicateKind =
/** 无重复 */
@@ -1409,6 +1974,28 @@ export type MusicSettings = {
feiniuLibraryNasPath?: string,
/** 下载完成后自动上传到飞牛曲库 */
feiniuAutoUpload?: boolean,
/** 手机互联:总开关(变更即时生效,MUSIC_REMOTE_PLAN §5.1) */
remoteEnabled?: boolean,
/** 手机互联:期望端口(0 = 默认 26124 起自动探测至 26139) */
remotePort?: number,
/** 本机标识(beacon / NowPlaying.deviceId 同源;首次启动自动生成) */
remoteDeviceId?: string,
/** 已配对设备表(仅元数据;token 在系统凭据管理器 `music-remote-token-*`) */
remoteDevices?: RemoteDeviceMeta[],
};
/** Node 运行环境状态。 */
export type NodeStatus = {
/** system | managed | none */
source: string,
/** node.exe 路径 */
path: string | null,
/** 版本号(如 v24.9.0) */
version: string | null,
/** 是否满足 dsh 的版本要求 */
satisfies: boolean,
/** 版本要求文案(供 UI 展示) */
required: string,
};
/** 划词结果悬浮窗外观(P1 生效)。 */
@@ -1497,6 +2084,35 @@ export type ProxyStatus = {
restartCount: number,
};
/** 在线能力状态(给 UI 状态卡用) */
export type QqOnlineStatus = {
/** QQMusic.exe 是否在运行 */
running: boolean,
/** 是否取到了 authst(= 已登录且能读到内存) */
loggedIn: boolean,
/** 本机读到的 QQ 号(仅用于展示;没有则为 None) */
uin: string | null,
/** 是否具备在线取 ekey 的能力 */
ready: boolean,
/** 给用户的一句话状态 */
message: string,
/** 需要用户照做的步骤(ready 时为一条"无需额外设置") */
steps: string[],
};
/**
* 播放队列条目(Thing 专属:本机播放器的队列,手机端可选歌)。
*
* `index` 是**在完整队列里的绝对下标**——下发时允许只带当前附近的一段
* (前端最多推 500 条,见 feiniuStore),手机端跳歌直接把 index 回传。
*/
export type QueueItem = {
index: number,
title: string,
artist: string,
durationSec: number | null,
};
/** 快速面板设置 */
export type QuickPanelSettings = {
/** 全局快捷键(如 "Alt+Space"),空字符串表示不注册。 */
@@ -1511,6 +2127,52 @@ export type QuickPanelSettings = {
customCommands?: CustomCommand[],
};
/** 远程配置(§5.1 命令 `remote_get_config` / `remote_set_enabled`)。 */
export type RemoteConfig = {
/** 开关(持久化) */
enabled: boolean,
/** 期望端口(0 = 默认 26124 起自动探测) */
port: number,
/** 服务是否在运行 */
running: boolean,
/** 实际监听端口(未运行为 0) */
runningPort: number,
/** 本机标识(beacon / NowPlaying.deviceId 同源) */
deviceId: string,
};
/** 设备元数据(settings.json 持久化;**token 不在此**,见键名约定)。 */
export type RemoteDeviceMeta = {
id: string,
name: string,
/** 最后一次成功连接(Unix 毫秒;0 = 从未连接) */
lastConnectedMs?: number,
};
/** 设备视图(settings 元数据 + 在线态)。 */
export type RemoteDeviceView = {
id: string,
name: string,
lastConnectedMs: number,
online: boolean,
};
/** 进行中的配对信息(二维码 payload 见计划 §3.3 扫码行)。 */
export type RemotePairingInfo = {
code: string,
/** `thingmusic://connect?ip=…&port=…&code=…` */
qrPayload: string,
secondsLeft: number,
};
/** 服务状态(`remote_status`)。 */
export type RemoteStatus = {
running: boolean,
port: number,
online: RemoteDeviceView[],
pairing: RemotePairingInfo | null,
};
export type RenameItem = {
path: string,
oldName: string,
@@ -1531,6 +2193,13 @@ export type RenameResult = {
error: string,
};
/** `music_decrypt_scan` 的返回(前端零手写类型) */
export type ScanSummary = {
total: number,
ncm: number,
qmc: number,
};
export type ScreenRect = {
x: number,
y: number,
@@ -1621,7 +2290,7 @@ export type Segment = {
export type SelectionSettings = {
/** 总开关:打开翻译面板时是否尝试读取当前划词作为候选 */
enabled?: boolean,
/** 打开翻译面板的全局快捷键(默认 Ctrl+2) */
/** 打开翻译面板的全局快捷键(默认 Alt+F) */
panelShortcut?: string,
/**
* 取词方式:
@@ -1992,6 +2661,34 @@ export type TrafficSnapshot = {
activeConnections: number,
};
/**
* 全局 AI 供应商在**翻译场景**下的参数。
*
* 与 `ai` 模块的分工:AI 侧只存连接与生成参数(Base URL / 模型 / 最大输出 / 上下文);
* 优先级、超时、提示词覆盖是翻译自己的编排语义,留在本模块。
*
* **列表即「已加入翻译候选的 AI 引擎」**:一条记录的存在就代表用户在主设置里选了这个
* 供应商来翻译(见 `TranslateManager::all_engines`)。供应商本身仍只存在于 AI 服务里,
* 这里只有 id 引用与场景参数——避免同一份连接配置出现两个真源。
*/
export type TranslateAiParams = {
/** 对应全局 AI 供应商 id */
providerId?: string,
/**
* 是否参与翻译候选(翻译侧开关)。
*
* 与供应商自身的 `enabled` 是两层:那边是「这台机器是否允许用这个供应商」,
* 这边是「它在翻译里是否上场」。生效值 = 两者与。
*/
enabled?: boolean,
/** 优先级(数值越小越先尝试;自动降级按序) */
priority?: number,
/** 该供应商在翻译请求中的超时(毫秒) */
timeoutMs?: number,
/** 自定义 system prompt;**非空时覆盖翻译模板** */
systemPrompt?: string,
};
/**
* 单个翻译引擎实例的配置。
*
@@ -2095,8 +2792,10 @@ export type TranslateSettings = {
* 不需要代理;仅当翻译服务部署在境外或直连被拦截时由用户显式打开。
*/
useProxy?: boolean,
/** 引擎实例列表 */
/** 引擎实例列表(仅 free/cloud;AI 供应商在主设置,场景参数见 `ai_params`) */
engines?: TranslateEngineConfig[],
/** 全局 AI 供应商的翻译场景参数(优先级 / 超时 / 提示词覆盖) */
aiParams?: TranslateAiParams[],
selection?: SelectionSettings,
popup?: PopupSettings,
screenshot?: ScreenshotSettings,
+24
View File
@@ -20,6 +20,13 @@ export const WINDOWS = {
translatePopup: 'translate-popup',
/** 单个终端独立窗口,实际 label = `terminal-window-<sessionId>` */
terminalWindow: 'terminal-window',
/**
* dsh 模块的 Web UI 独立窗口。
* 内容为远端 `http://127.0.0.1:<port>`,因此**不登记 capability**——
* 远端页面不应获得任何 Tauri 权限(Windows 平台上 label 未命中任何 capability
* 时,webview 仍可正常加载与交互,只是拿不到 IPC)。
*/
dshWeb: 'dsh-web',
} as const
/** Tauri 事件名(前端 emit / listen 与 Rust constants::events 对应) */
@@ -49,9 +56,13 @@ export const EVENTS = {
// 截图
screenshotBegin: 'screenshot-begin',
screenshotOverlayReady: 'screenshot-overlay-ready',
/** 覆盖层握手请求:主窗口每次发起截图前询问覆盖层是否已注册好 begin 监听(覆盖层以 screenshotOverlayReady 应答) */
screenshotOverlayPing: 'screenshot-overlay-ping',
screenshotShortcut: 'screenshot-shortcut',
screenshotPinShortcut: 'screenshot-pin-shortcut',
screenshotPinReady: 'screenshot-pin-ready',
/** 贴图窗口握手请求(同覆盖层):贴图窗口以 screenshotPinReady 应答 */
screenshotPinPing: 'screenshot-pin-ping',
screenshotPinShow: 'screenshot-pin-show',
screenshotExported: 'screenshot-exported',
/** 滚动截图会话:实时进度 { width, height, auto } */
@@ -64,6 +75,8 @@ export const EVENTS = {
scrollToEditor: 'screenshot-scroll-to-editor',
/** 常驻编辑器窗口挂载完成(store 等待后下发加载事件) */
screenshotEditorReady: 'screenshot-editor-ready',
/** 编辑器握手请求(同覆盖层):编辑器以 screenshotEditorReady 应答 */
screenshotEditorPing: 'screenshot-editor-ping',
/** 通知常驻编辑器窗口加载编辑器图片槽中的新图(raw IPC 取出) */
screenshotEditorLoad: 'screenshot-editor-load',
// 内核安装进度
@@ -116,6 +129,10 @@ export const EVENTS = {
monitorError: 'monitor-error',
monitorData: 'monitor-data',
monitorNetwork: 'monitor-network',
// 音乐:Rust 侧播放引擎(music/audio)。曲目自然播完(缓冲也放完)后发出,无负载
musicAudioEnded: 'music-audio-ended',
/** 音乐:Rust 侧播放失败(音源打不开 / 解码失败 / 输出设备异常),负载为错误文本 */
musicAudioError: 'music-audio-error',
// 其他
processStatusChanged: 'process-status-changed',
downloadAdded: 'download-added',
@@ -123,6 +140,13 @@ export const EVENTS = {
downloadRemoved: 'download-removed',
/** 浏览器扩展通过 HTTP API 新增下载(负载 { id },前端据以为该任务创建专属下载窗口) */
downloadExtensionAdded: 'download-extension-added',
// dsh 模块
/** 安装/下载进度(负载见 src/types/dsh.ts 的 DshInstallProgress) */
dshInstallProgress: 'dsh-install-progress',
/** 服务进程状态(负载见 src/types/dsh.ts 的 DshServerStatus) */
dshServerState: 'dsh-server-state',
/** 全局快捷键按下:打开 dsh 独立窗口(无负载) */
dshOpenWindow: 'dsh-open-window',
} as const
/** localStorage 存储键 */
+12 -6
View File
@@ -17,9 +17,12 @@
* SIGINT(中断当前命令),这是不可协商的——把它映射成「复制」会让所有用户
* 失去中断能力。因此复制粘贴用 `Ctrl+Shift+C/V`(Windows Terminal 惯例)。
*
* 2. **避开项目已有的全局快捷键**。`Ctrl+2` 已被翻译模块占用(取词翻译面板),
* 所以标签跳转用 `Alt+1..9` —— 在终端里 `Alt+数字` 通常不产生控制字符,
* 冲突面最小,且符合「切标签」的直觉。
* 2. **避开 `Ctrl+数字`**。项目里全局快捷键曾用过 `Ctrl+2`(翻译面板)与
* `Ctrl+3`(新建独立窗口),现已统一收进 `Alt+字母` 段;标签跳转用
* `Alt+1..9` —— 在终端里 `Alt+数字` 通常不产生控制字符,冲突面最小,
* 且符合「切标签」的直觉。
* 全局那几条都落在 `Alt+字母`(翻译面板 `Alt+F`、dsh `Alt+D`、
* 新建独立窗口 `Alt+T`),彼此不冲突,`Ctrl+数字` 整段留空。
*
* # 唯一一条「全局」动作:`newDetachedWindow`
*
@@ -157,10 +160,13 @@ export const TERMINAL_ACTIONS: TerminalAction[] = [
defaultKeys: 'Ctrl+0'
},
{
// id 保留 `toggleSftp` 不改名:它已写进用户设置与 Rust 侧的默认快捷键表
// (`heal()` 会剔除不在默认表内的 action),改名等于让所有人的这条绑定失效。
// 行为已随文件管理器的改版变化:现在打开的是模块的「文件」页(见 TerminalModule)。
id: 'toggleSftp',
label: '文件面板',
label: '文件管理器',
group: '视图',
description: '显示/隐藏当前 SSH 会话的文件管理面板(P1)',
description: '打开文件管理器(双栏:本地 / 已连接的 SSH 会话)',
defaultKeys: 'Ctrl+Shift+P'
},
{
@@ -196,7 +202,7 @@ export const TERMINAL_ACTIONS: TerminalAction[] = [
label: '新建独立窗口',
group: '会话',
description: '全局生效(任意界面按下):打开独立终端窗口并选择要启动的会话',
defaultKeys: 'Ctrl+3'
defaultKeys: 'Alt+T'
}
]
+7
View File
@@ -42,6 +42,7 @@ const standaloneWindowApps: Array<[hash: string, label: string, loader: () => Pr
['#translate-popup', '翻译悬浮窗', () => import('./modules/translate/TranslatePopup.vue')],
['#terminal-window', '终端独立窗口', () => import('./modules/terminal/TerminalWindow.vue')],
['#new-terminal-window', '新建终端窗口', () => import('./modules/terminal/NewTerminalWindow.vue')],
['#file-window', '文件管理器窗口', () => import('./modules/terminal/FileWindow.vue')],
]
const winHash = window.location.hash
@@ -118,6 +119,12 @@ if (matched) {
screenshotStore.initPinShortcutListener().catch(e => console.error('Screenshot pin shortcut listener init error:', e))
screenshotStore.initPinShortcutRegistration().catch(e => console.error('Screenshot pin shortcut registration init error:', e))
})
// dsh 模块:应用级初始化全局快捷键(注册 + 监听「打开独立窗口」事件)。
// 放这里而不是模块挂载时:快捷键要在任意模块下都能用,模块卸载不能把它带走。
void import('./stores/dshStore').then(({ useDshStore }) => {
useDshStore().initGlobalShortcut().catch(e => console.error('dsh shortcut init error:', e))
})
})
}
+2 -2
View File
@@ -415,7 +415,7 @@ onUnmounted(() => {
<Card
v-for="item in historyList"
:key="item.id"
class="group hover:shadow-md transition-shadow py-0"
class="group transition-[background-color,box-shadow] py-0 hover:bg-row-hover hover:shadow-md"
>
<CardContent class="flex items-center gap-3 px-3 py-2">
<component :is="kindIcon(item.kind)" class="size-4 text-muted-foreground shrink-0" />
@@ -465,7 +465,7 @@ onUnmounted(() => {
</Empty>
<div v-else class="space-y-1.5 px-3 pb-2">
<Card v-for="item in pinnedList" :key="item.id" class="group hover:shadow-md transition-shadow py-0">
<Card v-for="item in pinnedList" :key="item.id" class="group transition-[background-color,box-shadow] py-0 hover:bg-row-hover hover:shadow-md">
<CardContent class="flex items-center gap-3 px-3 py-2">
<component :is="kindIcon(item.kind)" class="size-4 text-primary shrink-0" />
<div class="flex-1 min-w-0 cursor-pointer" @click="openDetail(item)">
+9 -3
View File
@@ -630,13 +630,19 @@ onUnmounted(() => {
transition: box-shadow 0.2s, background-color 0.1s;
}
/* hover 使用 shadow(同主界面 hover:shadow-md),键盘选中保留轻微高亮 */
/* hover 用「主题色弱底 + 阴影」;键盘选中用 primary-soft 强底。
底色取 --row-hover(不透明)而不是半透明叠色 —— 弹窗根容器在 mica 下是透明的,
半透明色会和桌面壁纸混色。 */
.popup-item:hover {
background: var(--row-hover);
box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
}
.popup-item-selected {
background: var(--accent);
/* 选中态强度必须盖过 hover::hover 的特异性(0,2,0)高于单类(0,1,0),
不显式补 :hover 的话,悬停已选中项会退回更弱的行 hover 底 */
.popup-item-selected,
.popup-item-selected:hover {
background: var(--row-selected);
}
/* 类型 badge 配色(与主界面一致) */
+1 -1
View File
@@ -1713,7 +1713,7 @@ const toggleSortOrder = () => {
<label
v-for="f in btSelectTask.btFiles"
:key="f.index"
class="flex items-center gap-2 text-xs rounded px-1.5 py-1 hover:bg-muted cursor-pointer"
class="flex items-center gap-2 text-xs rounded px-1.5 py-1 hover:bg-row-hover cursor-pointer"
>
<input
type="checkbox"
+170
View File
@@ -0,0 +1,170 @@
<script setup lang="ts">
/**
* dsh 模块主页面(DeepSeek Harness 外壳)。
*
* 页面只承载「状态 + 配置 + 日志」,**不内嵌** dsh 的 Web UI:
* dsh 界面通过「独立窗口」(Tauri WebviewWindow 直接加载 http://127.0.0.1:<端口>)
* 或「浏览器打开」(系统默认浏览器)访问。
*
* 布局遵循项目规范:模块根 `min-h-full p-5`(滚动归属主滚动区),
* Tab 行不渲染(注册给 TitleBar 常驻切换器)。
*/
import { onMounted, onUnmounted, ref } from 'vue'
import {
ExternalLink,
Loader2,
Play,
RotateCw,
Square,
AppWindow,
FolderOpen
} from '@lucide/vue'
import { Tabs, TabsContent } from '@/components/ui/tabs'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { useModuleTabs } from '@/lib/use-module-tabs'
import { useDshStore } from '@/stores/dshStore'
import SetupStepper from './components/SetupStepper.vue'
import DshSettingsPanel from './components/DshSettingsPanel.vue'
import DshLogPanel from './components/DshLogPanel.vue'
const store = useDshStore()
const activeTab = ref('setup')
useModuleTabs(
'dsh',
activeTab,
[
{ value: 'setup', label: '状态' },
{ value: 'settings', label: '设置' },
{ value: 'logs', label: '日志' }
],
{ alwaysVisible: true }
)
onMounted(async () => {
await store.init()
})
onUnmounted(() => {
store.stopListeners()
})
</script>
<template>
<div class="min-h-full p-5">
<Tabs v-model="activeTab" class="flex min-h-full w-full flex-col">
<TabsContent value="setup" class="tab-animate">
<div class="flex flex-col gap-4">
<!-- 状态横幅:状态区 → 指标区 → 操作区(UI_DESIGN_SYSTEM §3.4) -->
<Card class="!py-0 !gap-0">
<CardContent class="flex flex-wrap items-center gap-x-6 gap-y-3 px-4 py-4">
<div class="flex items-center gap-2.5">
<span
v-if="!store.initialized"
class="flex items-center gap-1.5 text-[13px] text-muted-foreground"
>
<Loader2 class="size-3.5 animate-spin" />加载中
</span>
<template v-else>
<span
v-if="store.running"
class="flex items-center gap-1.5 text-[13px] text-success"
>
<span class="size-2 rounded-full bg-success status-dot-pulse" />运行中
</span>
<span
v-else
class="flex items-center gap-1.5 text-[13px] text-muted-foreground"
>
<span class="size-2 rounded-full bg-muted-foreground" />已停止
</span>
</template>
<span class="text-[13px] text-fg-secondary">DeepSeek Harness</span>
</div>
<div class="flex min-w-24 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">dsh</span>
<span
class="text-lg font-semibold tabular-nums"
:class="store.installed ? 'text-foreground' : 'text-danger'"
>{{ store.install?.version ?? '未安装' }}</span>
</div>
<div class="flex min-w-24 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">Node</span>
<span
class="text-lg font-semibold tabular-nums"
:class="store.nodeReady ? 'text-foreground' : 'text-danger'"
>{{ store.node?.version ?? '未检测到' }}</span>
</div>
<div class="flex min-w-40 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">服务地址</span>
<span class="truncate font-mono text-[13px] text-fg-secondary">{{ store.displayUrl }}</span>
</div>
<div class="ml-auto flex flex-wrap gap-2">
<Button
v-if="!store.running"
size="sm"
:disabled="!store.envReady || store.starting"
@click="store.start()"
>
<Loader2 v-if="store.starting" class="size-3.5 animate-spin" />
<Play v-else class="size-3.5" />启动
</Button>
<template v-else>
<Button size="sm" variant="outline" :disabled="store.starting" @click="store.restart()">
<Loader2 v-if="store.starting" class="size-3.5 animate-spin" />
<RotateCw v-else class="size-3.5" />重启
</Button>
<Button size="sm" variant="destructive" :disabled="store.stopping" @click="store.stop()">
<Loader2 v-if="store.stopping" class="size-3.5 animate-spin" />
<Square v-else class="size-3.5" />停止
</Button>
</template>
<Button size="sm" variant="outline" :disabled="!store.canOpen" @click="store.openWebWindow()">
<AppWindow class="size-3.5" />独立窗口
</Button>
<Button size="sm" variant="outline" :disabled="!store.canOpen" @click="store.openInBrowser()">
<ExternalLink class="size-3.5" />浏览器打开
</Button>
</div>
</CardContent>
</Card>
<!-- 服务启动失败的可见原因(否则只有日志里能看到) -->
<Card v-if="store.server?.error" class="!py-0 !gap-0">
<CardContent class="flex items-start gap-2 px-4 py-3">
<span class="text-[13px] text-danger">{{ store.server.error }}</span>
<Button class="ml-auto shrink-0" size="xs" variant="outline" @click="store.openDir()">
<FolderOpen class="size-3" />打开目录
</Button>
</CardContent>
</Card>
<!-- 已监听但还没打印带令牌的启动地址:此时打开界面只会拿到 401,故先等待 -->
<Card v-else-if="store.ready && !store.canOpen" class="!py-0 !gap-0">
<CardContent class="flex items-center gap-2 px-4 py-3">
<Loader2 class="size-3.5 shrink-0 animate-spin text-muted-foreground" />
<span class="text-[13px] text-fg-secondary">
等待 dsh 输出访问地址(浏览器鉴权令牌需要它换 cookie,稍候即可打开)
</span>
</CardContent>
</Card>
<SetupStepper />
</div>
</TabsContent>
<TabsContent value="settings" class="tab-animate">
<DshSettingsPanel />
</TabsContent>
<TabsContent value="logs" class="tab-animate">
<DshLogPanel />
</TabsContent>
</Tabs>
</div>
</template>
@@ -0,0 +1,54 @@
<script setup lang="ts">
/**
* dsh 服务日志面板:读取服务进程 stdout/stderr 的尾部输出。
*
* 日志在 Rust 侧同时写入 `{app_data}/dsh/logs/web.log` 与内存环形缓冲
* (最多 500 行),因此这里读到的是最近一段,不随运行时长无限增长。
* 读取时已过滤疑似密钥(`sk-` 形态)的行内片段。
*/
import { onMounted } from 'vue'
import { FolderOpen, RefreshCw, Trash2 } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { useDshStore } from '@/stores/dshStore'
const store = useDshStore()
onMounted(() => {
void store.loadLogs()
})
</script>
<template>
<div class="flex flex-col gap-3">
<div class="flex flex-wrap items-center gap-2">
<span class="text-[13px] font-medium text-foreground">服务日志</span>
<span class="text-xs text-muted-foreground">
{{ store.progress ? store.progress.message : '最近 300 行' }}
</span>
<div class="ml-auto flex gap-2">
<Button size="sm" variant="outline" :disabled="store.loadingLogs" @click="store.loadLogs()">
<RefreshCw class="size-3.5" :class="store.loadingLogs && 'animate-spin'" />刷新
</Button>
<Button size="sm" variant="outline" @click="store.openDir()">
<FolderOpen class="size-3.5" />打开目录
</Button>
<Button size="sm" variant="ghost" @click="store.clearLogs()">
<Trash2 class="size-3.5" />清空
</Button>
</div>
</div>
<Card class="!py-0 !gap-0">
<CardContent class="px-4 py-3">
<pre
v-if="store.logs.trim()"
class="max-h-[420px] overflow-auto whitespace-pre-wrap break-all font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ store.logs }}</pre>
<p v-else class="py-6 text-center text-xs text-muted-foreground">
暂无日志。启动服务后这里会显示 dsh 的输出。
</p>
</CardContent>
</Card>
</div>
</template>
@@ -0,0 +1,363 @@
<script setup lang="ts">
/**
* dsh 模块设置页。
*
* 版式与音乐模块设置页一致:**标题放在卡片内部**(Card → CardHeader/CardTitle +
* CardContent),卡片之间 `gap-4`;卡片内的一行行设置项复用业务组件 `SettingRow`
* (左标签+说明、右控件),用 1px 分隔线隔开。
*
* 约定:设置项改动**立即生效**(无保存按钮),端口与工作区在下次启动服务时生效。
* 成功提示省略,仅错误经 store 内的 `toast.error` 提示。
*/
import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue'
import { toast } from 'vue-sonner'
import { Cpu, FolderOpen, Keyboard, RefreshCw, Server, Sparkles, Zap } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
import { Switch } from '@/components/ui/switch'
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
import { SettingRow } from '@/components/common'
import { useDshStore } from '@/stores/dshStore'
import { useAiStore } from '@/stores/aiStore'
const store = useDshStore()
const aiStore = useAiStore()
const enabledProviders = computed(() => aiStore.providers.filter(p => p.config.enabled))
onMounted(async () => {
if (!store.initialized) await store.refresh()
await aiStore.init()
await store.loadAiPreview()
})
function onPortChange(e: Event) {
const raw = Number((e.target as HTMLInputElement).value)
if (!Number.isFinite(raw) || raw <= 0 || raw > 65535) {
store.refresh()
return
}
if (raw !== store.settings?.port) store.saveSettings({ port: Math.trunc(raw) })
}
function onTextChange(key: 'nodeMirror' | 'npmRegistry' | 'workspace' | 'installDir', e: Event) {
const value = (e.target as HTMLInputElement).value.trim()
store.saveSettings({ [key]: value })
}
// ===== 快捷键录入器(与 QuickPanelModule / ClipboardModule 同一模式) =====
const recording = ref(false)
const recorderRef = ref<HTMLDivElement | null>(null)
function displayShortcut(s: string): string {
if (!s) return ''
return s
.split('+')
.map(p => {
const t = p.trim()
if (!t) return ''
if (t.length === 1) return t.toUpperCase()
return t.charAt(0).toUpperCase() + t.slice(1)
})
.join(' + ')
}
function eventToShortcut(e: KeyboardEvent): string | null {
const mods: string[] = []
if (e.ctrlKey) mods.push('ctrl')
if (e.altKey) mods.push('alt')
if (e.shiftKey) mods.push('shift')
if (e.metaKey) mods.push('super')
let main = ''
const code = e.code || ''
if (/^Key[A-Z]$/.test(code)) main = code.slice(3).toLowerCase()
else if (/^Digit[0-9]$/.test(code)) main = code.slice(5)
else if (/^F([1-9]|1[0-2])$/.test(code)) main = code.toLowerCase()
else if (code === 'Space') main = 'space'
else if (code === 'PrintScreen') main = 'printscreen'
else if (code.startsWith('Numpad')) main = code.slice(6).toLowerCase()
else return null
const isFunctionKey = /^f([1-9]|1[0-2])$/.test(main) || main === 'printscreen'
if (mods.length === 0 && !isFunctionKey) return null
return [...mods, main].join('+')
}
function onRecordKey(e: KeyboardEvent) {
if (!recording.value) return
e.preventDefault()
e.stopPropagation()
if (e.key === 'Escape') {
recording.value = false
return
}
if (['Control', 'Alt', 'Shift', 'Meta'].includes(e.key)) return
const combo = eventToShortcut(e)
if (!combo) {
toast.warning('不支持的按键组合,请使用字母/数字/功能键 + 修饰键')
return
}
recording.value = false
// saveSettings 会顺带重新注册(注册失败时由 store 弹错误提示,如组合键被占用)
void store.saveSettings({ shortcut: combo }).then(() => {
if (store.settings?.shortcut === combo) {
toast.success(`快捷键已更新为 ${displayShortcut(combo)}`)
}
})
}
async function startRecord() {
recording.value = true
await nextTick()
recorderRef.value?.focus()
}
watch(recording, on => {
if (on) window.addEventListener('keydown', onRecordKey, true)
else window.removeEventListener('keydown', onRecordKey, true)
})
async function clearShortcut() {
await store.saveSettings({ shortcut: '' })
}
onUnmounted(() => {
window.removeEventListener('keydown', onRecordKey, true)
})
</script>
<template>
<div class="flex flex-col gap-4 pb-4">
<!-- 基础设置 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Zap class="size-4 text-primary" />
基础设置
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="随应用启动" description="应用启动且 dsh 已安装时自动拉起 Web 服务">
<Switch
:model-value="store.settings?.autoStart ?? false"
@update:model-value="v => store.saveSettings({ autoStart: v === true })"
/>
</SettingRow>
<SettingRow
label="打开独立窗口"
description="全局快捷键,在任意模块下都能唤出 dsh 界面;需至少一个修饰键 + 字母/数字/功能键"
>
<div class="flex items-center gap-2">
<div
ref="recorderRef"
class="hotkey-recorder"
:class="{ recording }"
tabindex="0"
@click="startRecord"
>
<template v-if="recording">按下快捷键…(Esc 取消)</template>
<template v-else-if="store.settings?.shortcut">
{{ displayShortcut(store.settings.shortcut) }}
</template>
<template v-else>未设置(点击录入)</template>
</div>
<Button
v-if="store.settings?.shortcut"
variant="ghost"
size="sm"
class="h-8 text-muted-foreground"
@click="clearShortcut"
>清除</Button>
</div>
</SettingRow>
</div>
</CardContent>
</Card>
<!-- 运行环境 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Cpu class="size-4 text-primary" />
运行环境
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
Node 的来源、镜像源与下载链路(dsh 要求 Node ^22.19 或 &gt;=24)
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow
label="Node 来源"
description="自动 = 系统 Node 满足要求就复用,否则回落托管版本"
control-width="wide"
>
<Select
:model-value="store.settings?.nodeSource ?? 'auto'"
@update:model-value="v => store.saveSettings({ nodeSource: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="auto">自动(系统优先)</SelectItem>
<SelectItem value="system">仅使用系统 Node</SelectItem>
<SelectItem value="managed">仅使用托管便携 Node</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow
label="Node 镜像源"
description="留空使用 nodejs.org;国内可填 https://npmmirror.com/mirrors/node"
control-width="wide"
>
<Input
:model-value="store.settings?.nodeMirror ?? ''"
placeholder="https://nodejs.org/dist"
@change="(e: Event) => onTextChange('nodeMirror', e)"
/>
</SettingRow>
<SettingRow
label="npm 源"
description="留空 = 跟随 npm 自身配置(环境变量 → 安装目录 .npmrc → 用户 ~/.npmrc),系统 Node 已设的镜像会被沿用;国内镜像可在安装引导页用下拉快速选择"
control-width="wide"
>
<Input
:model-value="store.settings?.npmRegistry ?? ''"
placeholder="留空 = 跟随 npm 配置"
@change="(e: Event) => onTextChange('npmRegistry', e)"
/>
</SettingRow>
<SettingRow label="下载走代理" description="使用代理模块(mihomo)的混合端口;内核未运行时自动直连">
<Switch
:model-value="store.settings?.useProxy ?? true"
@update:model-value="v => store.saveSettings({ useProxy: v === true })"
/>
</SettingRow>
</div>
</CardContent>
</Card>
<!-- 服务 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Server class="size-4 text-primary" />
服务
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
监听端口、安装位置与工作区(端口与工作区改动在下次启动服务时生效)
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="端口" description="dsh 的 --port 参数;被占用时启动会直接报错" control-width="wide">
<Input
type="number"
min="1"
max="65535"
:model-value="store.settings?.port ?? 3080"
@change="onPortChange"
/>
</SettingRow>
<SettingRow
label="dsh 安装目录"
description="npm 安装目标(node_modules 所在位置),必须是绝对路径;留空 = 模块目录。改到新目录后需重新安装,原目录不会自动清理"
control-width="wide"
>
<Input
:model-value="store.settings?.installDir ?? ''"
placeholder="留空 = 应用数据目录下的 dsh"
@change="(e: Event) => onTextChange('installDir', e)"
/>
</SettingRow>
<SettingRow label="工作区" description="dsh 进程的启动目录,也是默认 workspace;留空使用模块目录下的 workspace" control-width="wide">
<Input
:model-value="store.settings?.workspace ?? ''"
placeholder="留空 = 模块目录下的 workspace"
@change="(e: Event) => onTextChange('workspace', e)"
/>
</SettingRow>
</div>
</CardContent>
</Card>
<!-- AI 装载 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Sparkles class="size-4 text-primary" />
AI 装载
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
把主设置「AI 服务」里的供应商映射进 dsh;密钥不落盘,改为启动时以环境变量注入
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow
label="dsh 主目录"
description="托管 = 模块目录(卸载即清理);用户目录 = ~/.dsh(与命令行 dsh 共享会话)"
control-width="wide"
>
<Select
:model-value="store.settings?.dshHomeMode ?? 'managed'"
@update:model-value="v => store.saveSettings({ dshHomeMode: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="managed">模块独立目录</SelectItem>
<SelectItem value="user">用户目录(~/.dsh)</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="默认供应商" description="写入 agent-default-model,作为 dsh 的默认模型来源" control-width="wide">
<Select
:model-value="store.settings?.providerId ?? ''"
@update:model-value="v => store.saveSettings({ providerId: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue placeholder="选择供应商" /></SelectTrigger>
<SelectContent>
<SelectItem v-for="p in enabledProviders" :key="p.config.id" :value="p.config.id">
{{ p.config.name || p.config.id }}
</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="默认模型" description="来自所选供应商的模型标识" control-width="wide">
<span class="block truncate text-right font-mono text-xs text-fg-secondary">
{{ store.preview?.defaultModel ?? '—' }}
</span>
</SettingRow>
<SettingRow label="启动前自动同步" description="每次启动服务前合并写入 settings.yaml(写前备份 .bak)">
<Switch
:model-value="store.settings?.aiSync ?? true"
@update:model-value="v => store.saveSettings({ aiSync: v === true })"
/>
</SettingRow>
</div>
</CardContent>
</Card>
<div class="flex flex-wrap items-center gap-2">
<Button size="sm" variant="outline" @click="store.openDir()">
<FolderOpen class="size-3.5" />打开模块目录
</Button>
<Button size="sm" variant="ghost" @click="store.refresh()">
<RefreshCw class="size-3.5" />刷新状态
</Button>
<span class="flex items-center gap-1.5 text-xs text-muted-foreground">
<Keyboard class="size-3" />
settings.yaml:{{ store.preview?.settingsPath ?? '—' }}
</span>
</div>
</div>
</template>
+491
View File
@@ -0,0 +1,491 @@
<script setup lang="ts">
/**
* 安装引导步骤条:Node 运行环境 → dsh 本体 → AI 通道。
*
* 步骤条用项目已有的 `ui/stepper`(reka-ui 封装,此前无模块使用)。
* 进度条用 `ui/progress`,**必须传 `:model-value`**(reka-ui ProgressRoot 没有
* `:value`,传错不报错但指示条永远停在 0)。
*
* npm 安装阶段没有百分比(npm 不输出),此时 `percent === 0`,用不确定态动画条
* 表达「正在进行」,不伪造百分比。
*/
import { computed, onMounted, ref, watch } from 'vue'
import {
Check,
Download,
FolderOpen,
Loader2,
RefreshCw,
Play,
Sparkles,
Terminal,
X
} from '@lucide/vue'
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import {
Stepper,
StepperDescription,
StepperIndicator,
StepperItem,
StepperSeparator,
StepperTitle,
StepperTrigger
} from '@/components/ui/stepper'
import { Button } from '@/components/ui/button'
import { Progress } from '@/components/ui/progress'
import { Switch } from '@/components/ui/switch'
import { Badge } from '@/components/ui/badge'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Card, CardContent } from '@/components/ui/card'
import { SettingGroup, SettingRow } from '@/components/common'
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
import { createLogger } from '@/lib/logger'
import { useDshStore } from '@/stores/dshStore'
import { useAiStore } from '@/stores/aiStore'
const logger = createLogger('dsh')
const store = useDshStore()
const aiStore = useAiStore()
const steps = [
{ value: 'node', title: 'Node 运行环境', description: 'dsh 要求 ^22.19 或 >=24' },
{ value: 'dsh', title: 'dsh 本体', description: '本地安装,可锁版本与更新' },
{ value: 'ai', title: 'AI 通道', description: '复用设置里的供应商与密钥' }
]
/** 当前步骤跟随环境状态自动推进(已完成的步骤不再回退) */
const step = ref(0)
const maxStepReached = ref(0)
watch(
() => store.setupStep,
value => {
if (value > maxStepReached.value) {
maxStepReached.value = value
step.value = value
}
},
{ immediate: true }
)
const installProgressText = computed(() => store.progress?.message ?? '')
/** 不确定进度(npm 无百分比输出) */
const indeterminate = computed(() => !!store.progress && store.progress.percent === 0)
const progressPercent = computed(() => store.progress?.percent ?? 0)
/**
* 安装输出面板的显示开关。
*
* 日志只在内存里(Rust 缓冲 + 本页展示,不进应用日志),因此这里也做成
* 「临时」的:一次安装结束后仍留在页面上供排查,用户可手动隐藏;
* 发起新安装时重新展开。
*/
const logHidden = ref(false)
const hasInstallLog = computed(() => store.installLog.trim().length > 0)
const showInstallLog = computed(() => hasInstallLog.value && !logHidden.value)
watch(
() => store.installing,
value => {
if (value) logHidden.value = false
}
)
/**
* npm 源下拉选项(地址均为实测可用)。
*
* 「跟随 npm 配置」对应存储值空串 = 不传 `--registry`,让 npm 走自己的配置链
* (环境变量 > 安装目录 .npmrc > 用户 ~/.npmrc > 内置)——「系统 Node 以前配过的
* 镜像」正是靠这一项被沿用。
*
* 注意:reka-ui 的 SelectItem **不允许空字符串 value**(会 throw),
* 因此这里用哨兵值 `__npm__` 代表「跟随」,读写设置时再与空串互换。
*/
const FOLLOW_NPM = '__npm__'
const REGISTRY_PRESETS = [
{ label: '跟随 npm 配置(推荐,沿用系统 Node 已设的镜像)', value: FOLLOW_NPM },
{ label: 'npm 官方源(registry.npmjs.org)', value: 'https://registry.npmjs.org' },
{ label: 'npmmirror(阿里)', value: 'https://registry.npmmirror.com' },
{ label: '腾讯云', value: 'https://mirrors.cloud.tencent.com/npm' },
{ label: '华为云', value: 'https://mirrors.huaweicloud.com/repository/npm' }
]
/** 当前存的若是自定义地址,补一条选项,避免下拉显示空白 */
const registryOptions = computed(() => {
const current = store.settings?.npmRegistry ?? ''
if (!current || REGISTRY_PRESETS.some(p => p.value === current)) return REGISTRY_PRESETS
return [...REGISTRY_PRESETS, { label: `自定义:${current}`, value: current }]
})
const registrySelectValue = computed(() => store.settings?.npmRegistry || FOLLOW_NPM)
function onRegistryChange(v: unknown) {
const value = String(v)
store.saveSettings({ npmRegistry: value === FOLLOW_NPM ? '' : value })
}
/** 来源说明(让用户一眼看出到底走的哪个源) */
const registrySourceText = computed(() => {
const info = store.registryInfo
if (!info) return ''
if (info.source === 'setting') return '模块设置指定'
if (info.source === 'npm') return 'npm 配置链(含系统 Node 的 ~/.npmrc)'
return '默认官方源(未检测到 npm 配置)'
})
onMounted(async () => {
await aiStore.init()
await store.loadAiPreview()
})
async function handleInstallNode() {
await store.installNode()
}
/** 安装目录改动手工输入(Rust 侧校验绝对路径,非法会 toast) */
function onInstallDirChange(e: Event) {
const value = (e.target as HTMLInputElement).value.trim()
if (value === (store.settings?.installDir ?? '')) return
store.saveSettings({ installDir: value })
}
/** 目录选择器选安装目录(返回的一定是绝对路径) */
async function pickInstallDir() {
try {
const picked = await openDialog({ directory: true, multiple: false, title: '选择 dsh 安装目录' })
if (typeof picked === 'string') store.saveSettings({ installDir: picked })
} catch (e) {
logger.error('选择安装目录失败: ' + e)
}
}
</script>
<template>
<div class="flex flex-col gap-4">
<Stepper
:model-value="step"
class="w-full flex-col gap-3 sm:flex-row sm:items-center"
@update:model-value="v => (step = Number(v))"
>
<StepperItem
v-for="(item, index) in steps"
:key="item.value"
:step="index"
class="flex w-full items-center gap-2"
>
<StepperTrigger class="flex-row items-center gap-2.5 rounded-md p-1">
<StepperIndicator class="size-7 bg-muted text-xs">
<Check v-if="index < step" class="size-3.5" />
<span v-else>{{ index + 1 }}</span>
</StepperIndicator>
<div class="flex flex-col items-start text-left">
<StepperTitle class="text-[13px]">{{ item.title }}</StepperTitle>
<StepperDescription>{{ item.description }}</StepperDescription>
</div>
</StepperTrigger>
<StepperSeparator
v-if="index < steps.length - 1"
class="mx-1 h-px flex-1 shrink-0"
/>
</StepperItem>
</Stepper>
<!-- 步骤 1:Node -->
<Card v-if="step === 0" class="!py-0 !gap-0">
<CardContent class="flex flex-col gap-3 px-4 py-4">
<div class="flex items-start justify-between gap-4">
<div class="flex min-w-0 flex-col gap-1">
<span class="text-[13px] font-medium text-foreground">Node 运行环境</span>
<span class="text-xs text-muted-foreground">
当前策略:{{ store.settings?.nodeSource === 'managed' ? '始终使用托管便携 Node' : store.settings?.nodeSource === 'system' ? '仅使用系统 Node' : '优先复用系统 Node,缺失才下载' }}
</span>
</div>
<Badge v-if="store.nodeReady" variant="outline" class="shrink-0">已满足</Badge>
<Badge v-else variant="destructive" class="shrink-0">不满足</Badge>
</div>
<dl class="flex flex-col gap-1 text-xs">
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">来源</dt>
<dd class="text-foreground">
{{ store.node?.source === 'managed' ? '模块托管' : store.node?.source === 'system' ? '系统 PATH' : '未找到' }}
</dd>
</div>
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">版本</dt>
<dd class="font-mono text-foreground">{{ store.node?.version ?? '—' }}</dd>
</div>
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">要求</dt>
<dd class="font-mono text-foreground">{{ store.node?.required }}</dd>
</div>
<div v-if="store.node?.path" class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">路径</dt>
<dd class="min-w-0 break-all font-mono text-fg-secondary">{{ store.node.path }}</dd>
</div>
</dl>
<div v-if="store.installing" class="flex flex-col gap-2">
<div
v-if="indeterminate"
class="relative h-2 w-full overflow-hidden rounded-full bg-primary/20"
>
<div class="progress-indeterminate bg-primary absolute inset-y-0 w-1/3 rounded-full" />
</div>
<Progress v-else :model-value="progressPercent" />
<span class="text-xs text-muted-foreground">{{ installProgressText }}</span>
</div>
<div class="flex gap-2">
<Button v-if="!store.nodeReady" size="sm" :disabled="store.installing" @click="handleInstallNode">
<Loader2 v-if="store.installing" class="size-3.5 animate-spin" />
<Download v-else class="size-3.5" />下载便携 Node
</Button>
<Button v-else size="sm" disabled>
<Check class="size-3.5" />环境就绪
</Button>
<Button v-if="store.installing" size="sm" variant="outline" @click="store.cancelInstall()">
<X class="size-3.5" />取消
</Button>
<Button size="sm" variant="ghost" :disabled="store.installing" @click="store.detectNode()">
<RefreshCw class="size-3.5" />重新检测
</Button>
</div>
</CardContent>
</Card>
<!-- 步骤 2:dsh -->
<Card v-else-if="step === 1" class="!py-0 !gap-0">
<CardContent class="flex flex-col gap-3 px-4 py-4">
<div class="flex items-start justify-between gap-4">
<div class="flex min-w-0 flex-col gap-1">
<span class="text-[13px] font-medium text-foreground">dsh 本体</span>
<span class="text-xs text-muted-foreground">
用当前 Node 自带的 npm 安装到指定目录(默认应用数据目录),更新与卸载可回滚
</span>
</div>
<Badge v-if="store.installed" variant="outline" class="shrink-0">已安装</Badge>
<Badge v-else variant="destructive" class="shrink-0">未安装</Badge>
</div>
<dl class="flex flex-col gap-1 text-xs">
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">版本</dt>
<dd class="font-mono text-foreground">{{ store.install?.version ?? '—' }}</dd>
</div>
<div v-if="store.updateInfo" class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">最新版本</dt>
<dd class="flex items-center gap-2 font-mono text-foreground">
{{ store.updateInfo.latest }}
<span v-if="store.updateInfo.hasUpdate" class="text-[11px] text-warning">可更新</span>
<Check v-else class="size-3 text-success" />
</dd>
</div>
</dl>
<!-- 安装目录:可直接改 + 目录选择器(设置页同一项,两处联动) -->
<div class="flex flex-col gap-2 rounded-lg border border-border p-3">
<div class="flex flex-wrap items-center gap-2">
<span class="text-xs font-medium text-foreground">安装目录</span>
<span class="text-[11px] text-muted-foreground">
dsh 本体(node_modules)装到哪,必须是绝对路径;改到新目录后需重新安装
</span>
</div>
<div class="flex w-full gap-2 sm:max-w-96">
<Input
:model-value="store.settings?.installDir ?? ''"
placeholder="留空 = 应用数据目录下的 dsh"
@change="onInstallDirChange"
/>
<Button size="sm" variant="outline" class="shrink-0" @click="pickInstallDir">
<FolderOpen class="size-3.5" />浏览
</Button>
</div>
<span class="text-[11px] text-muted-foreground">
实际使用
<span class="font-mono text-fg-secondary">{{ store.install?.dir }}</span>
<template v-if="store.settings?.installDir">(已自定义)</template>
<template v-else>(模块目录,未自定义)</template>
</span>
</div>
<!-- 下载源:看清本次安装走哪个 npm 源,并可一键切到国内镜像 -->
<div class="flex flex-col gap-1.5 rounded-lg border border-border p-3">
<div class="flex flex-wrap items-center gap-2">
<span class="text-xs font-medium text-foreground">下载源</span>
<span class="text-[11px] text-muted-foreground">npm 依赖从哪个源拉取</span>
<Select
class="w-full sm:ml-auto sm:w-80"
:model-value="registrySelectValue"
@update:model-value="onRegistryChange"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem v-for="opt in registryOptions" :key="opt.value" :value="opt.value">
{{ opt.label }}
</SelectItem>
</SelectContent>
</Select>
</div>
<span class="text-[11px] text-muted-foreground">
本次将使用
<span class="font-mono text-fg-secondary">{{ store.registryInfo?.effective ?? '检测中...' }}</span>
<template v-if="registrySourceText">({{ registrySourceText }})</template>
</span>
<span
v-if="store.registryInfo?.npmRegistry && store.registryInfo.source === 'setting'"
class="text-[11px] text-muted-foreground"
>
系统 npm 当前配置:<span class="font-mono">{{ store.registryInfo.npmRegistry }}</span>
</span>
</div>
<div v-if="store.installing" class="flex flex-col gap-2">
<div
v-if="indeterminate"
class="relative h-2 w-full overflow-hidden rounded-full bg-primary/20"
>
<div class="progress-indeterminate bg-primary absolute inset-y-0 w-1/3 rounded-full" />
</div>
<Progress v-else :model-value="progressPercent" />
<span class="text-xs text-muted-foreground">{{ installProgressText }}</span>
</div>
<div class="flex flex-wrap gap-2">
<Button v-if="!store.installed" size="sm" :disabled="store.installing" @click="store.installDsh()">
<Loader2 v-if="store.installing" class="size-3.5 animate-spin" />
<Download v-else class="size-3.5" />安装 dsh
</Button>
<Button v-else size="sm" variant="outline" :disabled="store.installing" @click="store.updateDsh()">
<Loader2 v-if="store.installing" class="size-3.5 animate-spin" />
<Download v-else class="size-3.5" />更新到最新
</Button>
<Button size="sm" variant="ghost" :disabled="store.checkingUpdate || store.installing" @click="store.checkUpdate()">
<Loader2 v-if="store.checkingUpdate" class="size-3.5 animate-spin" />
<RefreshCw v-else class="size-3.5" />检查更新
</Button>
<Button v-if="store.installing" size="sm" variant="outline" @click="store.cancelInstall()">
<X class="size-3.5" />取消
</Button>
<Button v-if="store.installed && !store.installing" size="sm" variant="ghost" @click="store.uninstallDsh()">
卸载
</Button>
</div>
<!-- 安装输出:只在内存里,临时展示;不进应用日志 -->
<div v-if="showInstallLog" class="flex flex-col gap-2">
<div class="flex items-center gap-2">
<Terminal class="size-3.5 text-muted-foreground" />
<span class="text-xs font-medium text-foreground">安装输出</span>
<span class="text-[11px] text-muted-foreground">仅本页临时显示,不写入应用日志</span>
<Button class="ml-auto" size="xs" variant="ghost" @click="logHidden = true">
隐藏
</Button>
</div>
<ScrollArea class="h-56 rounded-lg border border-border bg-card">
<pre
class="px-3 py-2.5 whitespace-pre-wrap break-all font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ store.installLog }}</pre>
</ScrollArea>
</div>
</CardContent>
</Card>
<!-- 步骤 3:AI 通道 -->
<Card v-else class="!py-0 !gap-0">
<CardContent class="flex flex-col gap-3 px-4 py-4">
<div class="flex items-start justify-between gap-4">
<div class="flex min-w-0 flex-col gap-1">
<span class="text-[13px] font-medium text-foreground">AI 通道</span>
<span class="text-xs text-muted-foreground">
把主设置「AI 服务」里已启用的供应商写入 dsh 的 settings.yaml;
密钥不落盘,改为启动时以环境变量注入(来自系统凭据管理器)
</span>
</div>
<Badge v-if="store.preview?.providers.length" variant="outline" class="shrink-0">
{{ store.preview.providers.length }} 个供应商
</Badge>
<Badge v-else variant="destructive" class="shrink-0">无可用供应商</Badge>
</div>
<SettingGroup title="默认模型" description="选择 dsh 默认使用哪个供应商(在 dsh 内仍可切换)">
<SettingRow label="默认供应商" description="取自设置 → AI 服务中已启用的供应商" control-width="wide">
<Select
:model-value="store.settings?.providerId ?? ''"
@update:model-value="v => store.saveSettings({ providerId: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue placeholder="选择供应商" /></SelectTrigger>
<SelectContent>
<SelectItem
v-for="p in aiStore.providers.filter(x => x.config.enabled)"
:key="p.config.id"
:value="p.config.id"
>
{{ p.config.name || p.config.id }}
</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="同步 settings.yaml" description="启动服务前自动同步一次;关闭后可手动同步">
<Switch
:model-value="store.settings?.aiSync ?? true"
@update:model-value="v => store.saveSettings({ aiSync: v === true })"
/>
</SettingRow>
</SettingGroup>
<div v-if="store.preview" class="flex flex-col gap-2">
<div class="flex flex-wrap gap-2">
<Badge
v-for="p in store.preview.providers"
:key="p.id"
:variant="p.hasKey ? 'outline' : 'destructive'"
>
{{ p.name || p.id }} · {{ p.hasKey ? '已配置密钥' : '缺密钥' }}
</Badge>
</div>
<ScrollArea class="h-56 rounded-lg border border-border bg-card">
<pre
class="px-3 py-2.5 font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ store.preview.yaml }}</pre>
</ScrollArea>
</div>
<div class="flex flex-wrap gap-2">
<Button size="sm" variant="outline" @click="store.syncAi()">
<Sparkles class="size-3.5" />同步 AI 配置
</Button>
<Button size="sm" variant="ghost" @click="store.loadAiPreview()">
<RefreshCw class="size-3.5" />刷新预览
</Button>
<Button size="sm" :disabled="!store.running" @click="store.restart()">
<Play class="size-3.5" />重启服务生效
</Button>
</div>
</CardContent>
</Card>
</div>
</template>
<style scoped>
/*
* 不确定进度条(npm 安装无百分比输出时的表达)。
* 项目没有「indeterminate Progress」组件,这里用一条循环平移的色块代替,
* 避免伪造百分比数字。
*/
.progress-indeterminate {
animation: dsh-indeterminate 1.2s ease-in-out infinite;
}
@keyframes dsh-indeterminate {
0% {
left: -33%;
}
100% {
left: 100%;
}
}
</style>
+72
View File
@@ -0,0 +1,72 @@
import type { ModuleConfig } from '@/types/module'
import type { SearchIndexItem } from '@/stores/searchIndex'
const searchItems: SearchIndexItem[] = [
{
title: 'DeepSeek Harness',
description: '安装、更新与启动 dsh,管理 Node 运行环境与 AI 通道',
keywords: ['dsh', 'deepseek', 'harness', 'agent', '智能体', '外壳', '安装'],
tab: 'setup'
},
{
title: '安装 dsh 环境',
description: '按步骤引导安装 Node 运行环境与 dsh 本体',
keywords: ['安装', 'install', 'node', '环境', '引导', 'stepper', '更新'],
tab: 'setup'
},
{
title: 'dsh 设置',
description: '端口、工作区、Node 来源、镜像源与自动启动',
keywords: ['设置', 'setting', '端口', 'port', '工作区', 'workspace', '镜像'],
tab: 'settings'
},
{
title: 'dsh AI 通道',
description: '把设置里的 AI 供应商(含 DeepSeek API Key)同步给 dsh',
keywords: ['ai', 'api key', 'deepseek', '供应商', 'provider', '模型', 'model'],
tab: 'settings'
},
{
title: 'dsh 运行日志',
description: '查看 dsh 服务的输出日志',
keywords: ['日志', 'log', '输出', '排查', 'debug'],
tab: 'logs'
}
]
export const moduleConfig: ModuleConfig = {
id: 'dsh',
name: 'DeepSeek Harness',
icon: 'dsh',
description: 'DeepSeek Harness(dsh)外壳:环境安装引导、版本更新与 Web 服务生命周期管理',
category: 'tool',
defaultEnabled: true,
loader: () => import('./DshModule.vue'),
searchItems,
lifecycle: {
// 模块启用:恢复全局快捷键(应用启动时由 main.ts 注册;这里覆盖「先禁用再启用」)
onEnable: async () => {
try {
const { useDshStore } = await import('@/stores/dshStore')
await useDshStore().registerShortcut()
} catch (e) {
console.error('[dsh] onEnable 注册快捷键失败:', e)
}
},
// 模块禁用:停服务 + 注销快捷键(服务停了快捷键也没意义,且组合键不该被占着)
onDisable: async () => {
// 动态导入避免 index.ts 直接依赖 store(会形成循环依赖,参见 terminal / music 的处理)
try {
const { useDshStore } = await import('@/stores/dshStore')
const store = useDshStore()
if (store.running) await store.stop()
await store.unregisterShortcut()
store.stopListeners()
} catch (e) {
console.error('[dsh] onDisable 停止服务失败:', e)
}
}
},
// 排在开发工具之后:音乐 / 代理 / 下载 / 终端 / 翻译 / 监控 / 截图 / 剪贴板 / 快捷面板 / 开发工具 / dsh
order: 110
}
+4 -2
View File
@@ -10,7 +10,8 @@ import {
Wrench,
Music,
Languages,
SquareTerminal
SquareTerminal,
Bot
} from '@lucide/vue'
/**
@@ -31,7 +32,8 @@ export const moduleIconMap: Record<string, Component> = {
devtools: Wrench,
music: Music,
translate: Languages,
terminal: SquareTerminal
terminal: SquareTerminal,
dsh: Bot
}
/** 获取模块图标组件,未找到时回退到 Settings 图标 */
Loaded 100 of 154 files, more files were not shown because too many files have changed in this diff. Show more