feat(ai): 凭据库 scope 化——per-provider DPAPI 密钥隔离（v0.11.6 M1）

Author: Aparencia

app/src-tauri/src/ai_credentials.rs

@@ -1,9 +1,13 @@
-//! AI 密钥凭据存储（REQ-138，v0.8.0 M1 使能层）。
+//! AI 密钥凭据存储（REQ-138，v0.8.0 M1 使能层；v0.11.6 M1 scope 化）。
 //!
 //! @ai-context: 安全红线（AGENTS.md §4）：密钥不落 SQLite/明文文件——
 //!              Windows 用 DPAPI CryptProtectData 加密后写入数据目录
 //!              ai_credentials.bin（当前用户作用域，管理员与其他用户不可解；
 //!              CRYPTPROTECT_UI_FORBIDDEN 禁弹窗，服务化场景不卡 UI）。
+//! @ai-context: scope 化（v0.11.6 M1）：默认条目 scope="default" 保持旧文件名
+//!              ai_credentials.bin 向后兼容（已存用户凭据不失效）；per-provider
+//!              隔离用 "provider:<id>" → ai_credentials_<safe_id>.bin，各自独立
+//!              DPAPI 加密。scope 字符白名单：字母/数字/-/_，其余映射为 '_'。
 //! @ai-context: keyring crate spike 因本机 TLS 拦截（crates.io 新依赖下载
 //!              失败）跳过，直接走 v0.8.0 规划裁决的 DPAPI 直写 fallback
 //!              路径（裁决见 ADR-016）；环境变量 SILICONFLOW_API_KEY 保留
@@ -14,11 +18,12 @@
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 
-/// 凭据存储抽象（测试注入内存桩；平台存储 Windows=DPAPI）。
+/// 凭据存储抽象（scope：默认条目 "default" 或 per-provider "provider:<id>"；
+/// 测试注入内存桩；平台存储 Windows=DPAPI 加密文件）。
 pub trait CredentialStore: Send + Sync {
-    fn save_key(&self, api_key: &str) -> Result<(), String>;
-    fn load_key(&self) -> Result<Option<String>, String>;
-    fn clear_key(&self) -> Result<(), String>;
+    fn save_key(&self, scope: &str, api_key: &str) -> Result<(), String>;
+    fn load_key(&self, scope: &str) -> Result<Option<String>, String>;
+    fn clear_key(&self, scope: &str) -> Result<(), String>;
 }
 
 /// 平台存储构造（Windows=DPAPI 加密文件；非 Windows 内存存储 + 告警——
@@ -49,19 +54,34 @@ pub struct DpapiCredentialStore {
     path: PathBuf,
 }
 
+#[cfg(target_os = "windows")]
+impl DpapiCredentialStore {
+    /// scope → 凭据文件路径（default=旧文件名兼容；provider:<id> 按 id 隔离）
+    fn scoped_path(&self, scope: &str) -> PathBuf {
+        if scope == "default" {
+            return self.path.clone();
+        }
+        let safe: String = scope
+            .chars()
+            .map(|c| if c.is_alphanumeric() || c == '-' || c == '_' { c } else { '_' })
+            .collect();
+        self.path.with_file_name(format!("ai_credentials_{}.bin", safe))
+    }
+}
+
 #[cfg(target_os = "windows")]
 impl CredentialStore for DpapiCredentialStore {
-    fn save_key(&self, api_key: &str) -> Result<(), String> {
+    fn save_key(&self, scope: &str, api_key: &str) -> Result<(), String> {
         if api_key.trim().is_empty() {
             return Err("密钥不能为空".to_string());
         }
         let encrypted = dpapi_protect(api_key.as_bytes())?;
-        std::fs::write(&self.path, encrypted)
+        std::fs::write(self.scoped_path(scope), encrypted)
             .map_err(|e| format!("写入凭据文件失败: {}", e))
     }
 
-    fn load_key(&self) -> Result<Option<String>, String> {
-        let raw = match std::fs::read(&self.path) {
+    fn load_key(&self, scope: &str) -> Result<Option<String>, String> {
+        let raw = match std::fs::read(self.scoped_path(scope)) {
             Ok(b) => b,
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
             Err(e) => return Err(format!("读取凭据文件失败: {}", e)),
@@ -74,8 +94,8 @@ impl CredentialStore for DpapiCredentialStore {
         Ok(Some(key))
     }
 
-    fn clear_key(&self) -> Result<(), String> {
-        match std::fs::remove_file(&self.path) {
+    fn clear_key(&self, scope: &str) -> Result<(), String> {
+        match std::fs::remove_file(self.scoped_path(scope)) {
             Ok(()) => Ok(()),
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
             Err(e) => Err(format!("删除凭据文件失败: {}", e)),
@@ -151,24 +171,30 @@ fn dpapi_unprotect(blob: &[u8]) -> Result<Vec<u8>, String> {
 #[allow(dead_code)]
 #[derive(Default)]
 pub struct MemoryCredentialStore {
-    inner: Mutex<Option<String>>,
+    inner: Mutex<std::collections::HashMap<String, String>>,
 }
 
 impl CredentialStore for MemoryCredentialStore {
-    fn save_key(&self, api_key: &str) -> Result<(), String> {
+    fn save_key(&self, scope: &str, api_key: &str) -> Result<(), String> {
         if api_key.trim().is_empty() {
             return Err("密钥不能为空".to_string());
         }
-        *self.inner.lock().map_err(|_| "凭据锁中毒".to_string())? = Some(api_key.to_string());
+        self.inner
+            .lock()
+            .map_err(|_| "凭据锁中毒".to_string())?
+            .insert(scope.to_string(), api_key.to_string());
         Ok(())
     }
 
-    fn load_key(&self) -> Result<Option<String>, String> {
-        Ok(self.inner.lock().map_err(|_| "凭据锁中毒".to_string())?.clone())
+    fn load_key(&self, scope: &str) -> Result<Option<String>, String> {
+        Ok(self.inner.lock().map_err(|_| "凭据锁中毒".to_string())?.get(scope).cloned())
     }
 
-    fn clear_key(&self) -> Result<(), String> {
-        *self.inner.lock().map_err(|_| "凭据锁中毒".to_string())? = None;
+    fn clear_key(&self, scope: &str) -> Result<(), String> {
+        self.inner
+            .lock()
+            .map_err(|_| "凭据锁中毒".to_string())?
+            .remove(scope);
         Ok(())
     }
 }

app/src-tauri/src/ai_credentials_tests.rs

@@ -7,43 +7,58 @@ fn store() -> MemoryCredentialStore {
     MemoryCredentialStore::default()
 }
 
+/// 默认 scope（与 command 层调用一致——旧测试全部走 "default" 条目）。
+const DEFAULT_SCOPE: &str = "default";
+
 #[test]
 fn roundtrip_save_load() {
     let s = store();
-    s.save_key("sk-test-123").expect("保存成功");
-    assert_eq!(s.load_key().expect("读取成功").as_deref(), Some("sk-test-123"));
+    s.save_key(DEFAULT_SCOPE, "sk-test-123").expect("保存成功");
+    assert_eq!(s.load_key(DEFAULT_SCOPE).expect("读取成功").as_deref(), Some("sk-test-123"));
 }
 
 #[test]
 fn load_empty_is_none() {
     // 未保存 → None（与 DPAPI 文件不存在语义一致）
     let s = store();
-    assert_eq!(s.load_key().expect("读取成功"), None);
+    assert_eq!(s.load_key(DEFAULT_SCOPE).expect("读取成功"), None);
 }
 
 #[test]
 fn clear_removes_key() {
     let s = store();
-    s.save_key("sk-abc").expect("保存成功");
-    s.clear_key().expect("清除成功");
-    assert_eq!(s.load_key().expect("读取成功"), None);
+    s.save_key(DEFAULT_SCOPE, "sk-abc").expect("保存成功");
+    s.clear_key(DEFAULT_SCOPE).expect("清除成功");
+    assert_eq!(s.load_key(DEFAULT_SCOPE).expect("读取成功"), None);
     // 幂等：重复清除不报错（文件不存在视为已清除）
-    s.clear_key().expect("重复清除成功");
+    s.clear_key(DEFAULT_SCOPE).expect("重复清除成功");
 }
 
 #[test]
 fn empty_key_rejected() {
     // 空/空白密钥拒绝保存（防御：不写坏凭据）
     let s = store();
-    assert!(s.save_key("").is_err());
-    assert!(s.save_key("   ").is_err());
-    assert_eq!(s.load_key().expect("读取成功"), None);
+    assert!(s.save_key(DEFAULT_SCOPE, "").is_err());
+    assert!(s.save_key(DEFAULT_SCOPE, "   ").is_err());
+    assert_eq!(s.load_key(DEFAULT_SCOPE).expect("读取成功"), None);
 }
 
 #[test]
 fn save_overwrites_previous() {
     let s = store();
-    s.save_key("sk-old").expect("保存成功");
-    s.save_key("sk-new").expect("覆盖保存成功");
-    assert_eq!(s.load_key().expect("读取成功").as_deref(), Some("sk-new"));
+    s.save_key(DEFAULT_SCOPE, "sk-old").expect("保存成功");
+    s.save_key(DEFAULT_SCOPE, "sk-new").expect("覆盖保存成功");
+    assert_eq!(s.load_key(DEFAULT_SCOPE).expect("读取成功").as_deref(), Some("sk-new"));
+}
+
+#[test]
+fn scoped_store_isolates_keys_by_scope() {
+    let store = crate::ai_credentials::MemoryCredentialStore::default();
+    store.save_key("default", "sk-a").unwrap();
+    store.save_key("provider:p1", "sk-b").unwrap();
+    assert_eq!(store.load_key("default").unwrap().as_deref(), Some("sk-a"));
+    assert_eq!(store.load_key("provider:p1").unwrap().as_deref(), Some("sk-b"));
+    store.clear_key("provider:p1").unwrap();
+    assert_eq!(store.load_key("provider:p1").unwrap(), None);
+    assert_eq!(store.load_key("default").unwrap().as_deref(), Some("sk-a"));
 }

app/src-tauri/src/ai_refine_task.rs

@@ -191,7 +191,7 @@ fn run_refine_task_inner(
         .map_err(|e| AiTaskFailure::Other(e.to_string()))?
         .clone();
     let env_key = std::env::var("SILICONFLOW_API_KEY").ok().filter(|k| !k.is_empty());
-    let stored_key = st.ai_credentials.load_key().ok().flatten();
+    let stored_key = st.ai_credentials.load_key("default").ok().flatten();
     // 密钥来源诊断（脱敏：只打长度+前 6 字符；真机 unauthorized 排查 2026-08-21）
     eprintln!(
         "[refine-task] task={} key: env={} stored={}",

app/src-tauri/src/commands_ai_enrich.rs

@@ -85,7 +85,7 @@ pub async fn ai_enrich_start(
     let mock = std::env::var(MOCK_ENV).map(|v| v == "1").unwrap_or(false);
     if !mock {
         let env_key = std::env::var("SILICONFLOW_API_KEY").ok().filter(|k| !k.is_empty());
-        let stored = st.ai_credentials.load_key()?;
+        let stored = st.ai_credentials.load_key("default")?;
         if env_key.is_none() && stored.is_none() {
             return Err("未配置 API 密钥（设置页保存密钥或配置环境变量 SILICONFLOW_API_KEY）".to_string());
         }
@@ -274,7 +274,7 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
             None => String::new(),
         };
         let settings = st.ai_settings.lock().map_err(|e| AiTaskFailure::Other(e.to_string()))?.clone();
-        let client = AiClient::from_settings(&settings, st.ai_credentials.load_key().ok().flatten());
+        let client = AiClient::from_settings(&settings, st.ai_credentials.load_key("default").ok().flatten());
         let adapter = AiNoteEnrichAdapter::new(client.clone());
         let mock_adapter = AiMockAdapter;
         // 切片（长笔记按章节切——REQ-145 基建复用；锚点跨片=全局章节标题）

app/src-tauri/src/commands_ai_refine.rs

@@ -134,7 +134,7 @@ pub async fn ai_refine_start(
     // ② 密钥解析（env > 凭据库）；非 mock 且无密钥 → 明确错误（不创建任务）
     if !mock {
         let env_key = std::env::var("SILICONFLOW_API_KEY").ok().filter(|k| !k.is_empty());
-        let stored = st.ai_credentials.load_key()?;
+        let stored = st.ai_credentials.load_key("default")?;
         if env_key.is_none() && stored.is_none() {
             return Err("未配置 API 密钥（设置页保存密钥或配置环境变量 SILICONFLOW_API_KEY）".to_string());
         }
@@ -493,7 +493,7 @@ pub(crate) fn ensure_balance_for(st: &AppState, chars: usize, model: &str) -> Re
     let api_key = std::env::var("SILICONFLOW_API_KEY")
         .ok()
         .filter(|k| !k.is_empty())
-        .or(st.ai_credentials.load_key().ok().flatten())
+        .or(st.ai_credentials.load_key("default").ok().flatten())
         .unwrap_or_default();
     if api_key.is_empty() {
         return Err("未配置 API 密钥（设置页保存密钥或配置环境变量 SILICONFLOW_API_KEY）".to_string());

app/src-tauri/src/commands_ai_settings.rs

@@ -48,7 +48,7 @@ pub struct BalanceView {
 pub fn ai_get_settings(state: State<'_, AppState>) -> Result<AiSettingsView, String> {
     let s = snapshot_settings(&state)?;
     let env_key = env_api_key();
-    let stored = state.ai_credentials.load_key()?;
+    let stored = state.ai_credentials.load_key("default")?;
     let (has_key, key_source) = if env_key.is_some() {
         (true, "env".to_string())
     } else if stored.is_some() {
@@ -78,13 +78,13 @@ pub fn ai_save_key(state: State<'_, AppState>, api_key: String) -> Result<(), St
     if key.chars().count() > API_KEY_MAX_CHARS {
         return Err(format!("密钥超长（上限 {} 字符）", API_KEY_MAX_CHARS));
     }
-    state.ai_credentials.save_key(&key)
+    state.ai_credentials.save_key("default", &key)
 }
 
 /// 清除凭据库密钥（文件不存在视为已清除——幂等）。
 #[tauri::command]
 pub fn ai_clear_key(state: State<'_, AppState>) -> Result<(), String> {
-    state.ai_credentials.clear_key()
+    state.ai_credentials.clear_key("default")
 }
 
 /// 更新 AI 设置（白名单校验后持久化；command 层锁内 read-modify-write）。
@@ -216,7 +216,7 @@ fn snapshot_settings(state: &AppState) -> Result<AiSettings, String> {
 fn balance_adapter(state: &AppState) -> Result<AiBalanceAdapter, String> {
     let s = snapshot_settings(state)?;
     let api_key = env_api_key()
-        .or(state.ai_credentials.load_key()?)
+        .or(state.ai_credentials.load_key("default")?)
         .unwrap_or_default();
     let cfg = crate::ai_client::AiClient::from_settings(&s, Some(api_key)).config;
     Ok(AiBalanceAdapter {