From 06461df91bda8e440c6714c062d74a62cebedab1 Mon Sep 17 00:00:00 2001 From: AskaEth Date: Tue, 3 Nov 2026 22:57:07 +0800 Subject: [PATCH] =?UTF-8?q?fix(presenter):=20M103=20r1=20=E2=80=94?= =?UTF-8?q?=E2=80=94=20=E8=84=B1=E6=95=8F=E9=97=B8=E9=97=A8=E8=A1=A5?= =?UTF-8?q?=E5=AE=88=E5=8D=AB=EF=BC=8CP2=20=E4=BA=94=E6=9D=A1=E5=B8=A6?= =?UTF-8?q?=E8=B5=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit P1（守卫缺失，产品代码本来是对的）： - 新增 agent/tests_red_line.rs：MessageAppended（绕过 agent_submit）、 ToolCallFinished（name+summary）、非 JWT 形状的 details（键名 / 嵌套 / 数组 / 值随 path 敏感）各一条；变异 A/H/C2 复跑确认变红 - tests.rs 拆出红线组（547 → 334 行，单文件 ≤400） P2： - scrub_details 补「值随 path 敏感」规则（对齐 agent::redact::redact_args） - scrub_text 补短 Bearer 掩码（对齐 agent::redact::mask_bearer） - pending_confirm_forces_busy_without_yolo 先 finish_stream 再断言（不再空过）， 变异 F 现在两条测试同时变红 - MessageDelta 越界下标 debug_assert；ToolCallFinished 没有 pending 时忽略， 不再改写已收敛的历史条目 - Presenter::state_mut() 收窄成 #[cfg(test)]，换成 navigate/back/toggle_ai/ prefs_mut/agent_set_yolo/agent_set_draft 等窄入口 - agent_submit 成功后立刻 begin_turn() 置忙，事件投影完 settle_streaming() 重算， 异步后端空窗不会再让用户点两次发送 - 补测：begin_turn 置忙、静默后端不留假忙、工具收尾不覆盖历史 --- crates/presenter/src/agent.rs | 55 ++++- crates/presenter/src/agent/rail.rs | 110 +++++++-- crates/presenter/src/agent/tests.rs | 133 +++++------ crates/presenter/src/agent/tests_red_line.rs | 230 +++++++++++++++++++ crates/presenter/src/state_tests.rs | 3 + 5 files changed, 435 insertions(+), 96 deletions(-) create mode 100644 crates/presenter/src/agent/tests_red_line.rs diff --git a/crates/presenter/src/agent.rs b/crates/presenter/src/agent.rs index 3231e0c..514de91 100644 --- a/crates/presenter/src/agent.rs +++ b/crates/presenter/src/agent.rs @@ -37,16 +37,21 @@ //! - 流式时序：端口是同步返回事件分片的（便于单测），真实实现是异步推流。 use crate::dto::{AppEvent, Sensitivity}; +use crate::prefs::UiPrefs; +use crate::router::Route; use crate::state::AppState; -use rail::scrub_text; pub mod mock; pub mod rail; +use rail::scrub_text; pub use rail::AgentRail; #[cfg(test)] mod tests; +#[cfg(test)] +#[path = "agent/tests_red_line.rs"] +mod tests_red_line; /// 裁决记录上限（只留最近若干条；权威审计不在这里）。 pub const MAX_AUDIT_ENTRIES: usize = 256; @@ -147,11 +152,49 @@ impl Presenter { &self.state } - /// 可写状态（导航、偏好、其它页面事件；agent 相关动作请走本类的方法）。 + /// 可写状态——**只在测试构建里存在**。 + /// + /// 非测试代码没有这个后门：`AppState::ai` 的字段全是 pub，返回 `&mut AppState` 就等于 + /// 让调用方绕开 [`AgentRail::ingest`] 的脱敏与 `busy` 不变量。需要写状态时走下面这些 + /// 窄入口（prefs / 导航 / rail 的那几个字段），rail 的内容一律走四个契约方法。 + #[cfg(test)] pub fn state_mut(&mut self) -> &mut AppState { &mut self.state } + /// 导航（一级页替换、子页压栈；去 AI 独立页会展开栏并清未读）。 + pub fn navigate(&mut self, route: Route) { + self.state.navigate(route); + } + + /// 回退一层（子页面）；已在根页面时返回 `false`。 + pub fn back(&mut self) -> bool { + self.state.back() + } + + /// 折叠/展开 AI 栏（独立页形态下等价于收回侧栏；展开时清未读）。 + pub fn toggle_ai(&mut self) { + self.state.toggle_ai(); + } + + /// UI 偏好（主题、磁贴尺寸、栏折叠位…）。**不含** rail 字段。 + pub fn prefs_mut(&mut self) -> &mut UiPrefs { + &mut self.state.prefs + } + + /// YOLO 开关（设置 → AI 的那一项）。 + /// + /// 只翻开关不裁决：若此刻正有待确认请求，调用方仍要走一次 + /// [`Presenter::agent_confirm`]（YOLO 下它会自动放行并记审计）。 + pub fn agent_set_yolo(&mut self, on: bool) { + self.state.ai.yolo = on; + } + + /// 输入框草稿（用户打字时同步进来，切形态不丢）。 + pub fn agent_set_draft(&mut self, text: String) { + self.state.ai.draft = text; + } + /// 喂一条事件（纯转发给 [`AppState::apply`]）。 pub fn apply(&mut self, event: AppEvent) { self.state.apply(event); @@ -168,8 +211,10 @@ impl Presenter { /// 拒绝的三种情形都不改状态（草稿保留，用户能接着改）： /// 空文本、上一轮还在跑、有写操作待确认。 /// - /// 成功时清空草稿并顺序投影后端返回的事件分片。用户气泡**由事件产生** - /// （不在本地乐观回显，见 `lib.rs` §3）。 + /// 成功时清空草稿、立刻把 `busy` 置真（**然后**才投影后端返回的事件分片），最后按消息 + /// 重算一次 `streaming`——异步后端在「提交成功 → 第一个事件到达」之间的空窗因此不会 + /// 让用户再点一次发送（那会产生两条 user 消息、两轮回复）。 + /// 用户气泡**由事件产生**（不在本地乐观回显，见 `lib.rs` §3）。 pub fn agent_submit(&mut self, text: String) -> Result<(), String> { let trimmed = text.trim(); if trimmed.is_empty() { @@ -190,9 +235,11 @@ impl Presenter { .map_err(|error| scrub_text(&error))?; self.state.ai.draft.clear(); self.state.ai.error = None; + self.state.ai.begin_turn(); for event in events { self.state.apply(event); } + self.state.ai.settle_streaming(); Ok(()) } diff --git a/crates/presenter/src/agent/rail.rs b/crates/presenter/src/agent/rail.rs index 06af545..a927a43 100644 --- a/crates/presenter/src/agent/rail.rs +++ b/crates/presenter/src/agent/rail.rs @@ -26,7 +26,14 @@ //! [`scrub_text`] / [`scrub_details`]。凭据字段（`token` / `refresh_token` / `password` / //! `access_token` …）不该出现在事件里（AGENTS §6：AI 永不接触账户凭据），这里的脱敏是 //! **第二道**防线：万一实现方把 JWT 塞进了工具摘要或错误文案，rail 上也不会出现原文。 -//! 复用 `unlucky_core::launch::redact`（M40 上提的「带点 token」规则），不另写一套正则。 +//! +//! 规则来源（刻意不另写一套正则）： +//! - 内容侧：复用 `unlucky_core::launch::redact`（M40 上提的「带点 token」+ ≥64 不透明串）； +//! - 上下文侧：照 `unlucky_agent::redact` 补两条——`Bearer <短令牌>` 掩码、 +//! `{"path": 敏感键}` 时 `value`/`old`/`new` 一并掩码（`set_config` 的 details 正是它）。 +//! +//! 键名名单与 `unlucky_agent::redact::is_sensitive_key` **当前逐字相同**；差异在上下文规则 +//! 上（agent 侧多一条 path 规则，presenter 已补齐，见上）。漂移风险记在 M103 报告里。 //! //! # 3. 刻意不做的事 //! @@ -63,27 +70,39 @@ pub fn is_sensitive_key(key: &str) -> bool { .any(|needle| lower.contains(needle)) } -/// 文本脱敏：JWT 形状（带点 token）/ ≥64 不透明串由 core 的规则打码。 +/// 文本脱敏：内容规则三件套。 /// -/// 不登记主目录（rail 不持有数据根）：`` 掩码是 host 侧的职责。 +/// 1. JWT 形状（带点 token）/ ≥64 不透明串 —— 复用 core 的 `Redactor`（M40 上提的那份）； +/// 2. `Bearer` 后面的短令牌 —— core 没有这条，照 `unlucky_agent::redact::mask_bearer` 补； +/// 3. 主目录不登记：rail 不持有数据根，`` 掩码是 host 侧的职责。 #[must_use] pub fn scrub_text(text: &str) -> String { - Redactor::new().scrub(text).into_owned() + mask_bearer(&Redactor::new().scrub(text)) } -/// 结构化细节脱敏：先按键名掩码，再按内容掩码（两道都要，见模块文档 §2）。 +/// 结构化细节脱敏：按**键名**、按**值随 path 敏感**、按内容三道（见模块文档 §2）。 +/// +/// 同样对齐 `unlucky_agent::redact::redact_args` 的两条上下文规则：键名命中即掩码， +/// 以及 `{"path": "ai.api_key", "old": …, "new": …}` 这种「值随路径敏感」的形状 +/// （`set_config` 的 details 正是它）——否则 API key 会原样躺在确认弹窗的 diff 里。 #[must_use] pub fn scrub_details(value: &Value) -> Value { match value { Value::Object(map) => { + let sensitive_path = map + .get("path") + .and_then(Value::as_str) + .is_some_and(is_sensitive_key); let mut out = Map::with_capacity(map.len()); for (key, child) in map { - let masked = if is_sensitive_key(key) { + let masked = is_sensitive_key(key) + || (sensitive_path && matches!(key.as_str(), "value" | "old" | "new")); + let child = if masked { Value::String(TOKEN_PLACEHOLDER.to_string()) } else { scrub_details(child) }; - out.insert(key.clone(), masked); + out.insert(key.clone(), child); } Value::Object(out) } @@ -93,6 +112,38 @@ pub fn scrub_details(value: &Value) -> Value { } } +/// `Bearer` 之后的分隔符（令牌到此为止）。 +const BEARER_STOPS: [char; 8] = [' ', '\t', '\n', '\r', '"', '\'', ',', ';']; + +/// `Bearer ` → `Bearer `。 +/// +/// core 的 `Redactor` 只认「点号 token / ≥64 不透明串」，短令牌（`Bearer abcdef123456`） +/// 会原样放过——这条规则照 `unlucky_agent::redact::mask_bearer` 补上。幂等：已经是 +/// `` 的再跑一遍结果不变。 +fn mask_bearer(text: &str) -> String { + const MARKER: &str = "Bearer "; + let mut out = String::with_capacity(text.len()); + let mut cursor = 0usize; + while let Some(position) = text[cursor..].find(MARKER) { + let token_start = cursor + position + MARKER.len(); + let token_end = bearer_token_end(text, token_start); + out.push_str(&text[cursor..token_start]); + if token_end > token_start { + out.push_str(TOKEN_PLACEHOLDER); + } + cursor = token_end; + } + out.push_str(&text[cursor..]); + out +} + +/// 从 `from` 起取到下一个分隔符为止（令牌的右边界）。 +fn bearer_token_end(text: &str, from: usize) -> usize { + text[from..] + .find(BEARER_STOPS) + .map_or(text.len(), |offset| from + offset) +} + /// AI 助手栏视图模型（UI 壳只读它，不自己攒会话状态）。 #[derive(Debug, Clone, PartialEq)] pub struct AgentRail { @@ -144,7 +195,22 @@ impl AgentRail { for message in &mut self.messages { message.streaming = false; } - self.streaming = false; + self.settle_streaming(); + } + + /// 提交成功、后端还没回事件时先把「一轮在跑」点亮。 + /// + /// 异步后端在「提交成功 → 第一个事件到达」之间有空窗；不先置忙的话用户能再点一次发送， + /// 于是两条 user 消息、两轮回复并行。反正事件流收敛时会用 + /// [`AgentRail::settle_streaming`] 按消息重算，不会留下假忙。 + pub fn begin_turn(&mut self) { + self.streaming = true; + self.sync_busy(); + } + + /// 按消息重算 `streaming`（有任一条还在流式即为真）并同步 `busy`。 + pub fn settle_streaming(&mut self) { + self.streaming = self.messages.iter().any(|message| message.streaming); self.sync_busy(); } @@ -182,8 +248,15 @@ impl AgentRail { AgentEvent::MessageDelta { index, delta } => { // 只追加正文，不动流式标记：迟到的尾增量（`Failed` 之后）不该把 // 「一轮在跑」重新点亮，否则输入框会一直禁用。 - if let Some(message) = self.messages.get_mut(*index) { - message.text.push_str(&scrub_text(delta)); + match self.messages.get_mut(*index) { + Some(message) => message.text.push_str(&scrub_text(delta)), + // 分片乱序/重放时正文会无声消失（用户只看到半截话）：开发期吵起来， + // 发布期宁可丢这一片也不去猜该拼到哪条上。 + None => debug_assert!( + false, + "MessageDelta 指向不存在的消息下标 {index}（会话 {} 条）", + self.messages.len() + ), } self.sync_busy(); false @@ -193,8 +266,7 @@ impl AgentRail { message.streaming = false; } // 以消息为准重算：并发工具条目没收敛时 `streaming` 不能提前熄 - self.streaming = self.messages.iter().any(|message| message.streaming); - self.sync_busy(); + self.settle_streaming(); false } AgentEvent::ToolCallStarted { name, summary } => { @@ -217,18 +289,13 @@ impl AgentRail { AgentEvent::ToolCallFinished { name, ok, summary } => { let name = scrub_text(name); let summary = scrub_text(summary); - // 优先收敛「还没结束的同名调用」（并发同名工具时按最近一条）， - // 找不到再退回最近一条同名条目（重放/重复结束事件）。 + // 只收敛「还在跑的同名调用」。找不到就**忽略**，绝不退回改写已收敛的旧条目 + // ——那会把历史结果覆盖掉（重放、重复结束事件、丢过 ToolCallStarted 都会命中）。 let pending = self .messages .iter() .rposition(|message| message.streaming && tool_named(message, &name)); - let target = pending.or_else(|| { - self.messages - .iter() - .rposition(|message| tool_named(message, &name)) - }); - if let Some(index) = target { + if let Some(index) = pending { let message = &mut self.messages[index]; message.streaming = false; message.text.clone_from(&summary); @@ -237,8 +304,7 @@ impl AgentRail { tool.summary = summary; } } - self.streaming = self.messages.iter().any(|message| message.streaming); - self.sync_busy(); + self.settle_streaming(); false } AgentEvent::Failed { message } => { diff --git a/crates/presenter/src/agent/tests.rs b/crates/presenter/src/agent/tests.rs index 9de30a1..6dccdaf 100644 --- a/crates/presenter/src/agent/tests.rs +++ b/crates/presenter/src/agent/tests.rs @@ -1,18 +1,15 @@ //! `agent` 模块的单元测试：四条路径（正常问答 / 流式中途出错 / 需确认的写操作 / 未读计数）+ -//! 红线（凭据形状的串不得进 rail）+ YOLO 语义 + 提交前置条件。 +//! YOLO 语义 + 提交前置条件 + 投影健壮性。 //! +//! 红线（凭据形状的串不得进 rail）单列在 `agent/tests_red_line.rs`（单文件 ≤400 行）。 //! 断言口径照 M103 的要求写清「抓得住什么 / 抓不住什么」：这些测试盯的是**投影与裁决**， //! 不盯真实模型的措辞、真实时序与网络错误——那些要接 rig 之后跑回放回归。 use super::mock::{MockAgentTransport, Script}; use super::{AgentTransport, ConfirmVerdict, Presenter}; -use crate::agent::rail::scrub_text; use crate::agent::AgentRail; use crate::dto::{AgentEvent, AppEvent, ChatMessage, ChatRole, ConfirmRequest, Sensitivity}; -/// 真实形状的 JWT（header.payload.signature，三段各 ≥8）。 -const JWT: &str = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.c2lnbmF0dXJlLXZhbHVlLXRoYXQtaXMtbG9uZy1lbm91Z2g"; - fn presenter(script: Script) -> Presenter { Presenter::new(Box::new(MockAgentTransport::new(script))) } @@ -172,65 +169,68 @@ fn pending_confirm_forces_busy_without_yolo() { presenter .agent_submit("并发调小点".to_string()) .expect("提交应当成功"); + assert!(presenter.agent_rail().confirm.is_some()); + // 先把流式标记清干净：否则 `busy` 可能只是「streaming 顺手置真」， + // 这条测试就钉不住「待确认算忙」这条规则（r1 P2-2：变异掉 `confirm.is_some()` + // 之后这里必须变红）。 + presenter.state_mut().ai.finish_stream(); let rail = presenter.agent_rail(); - assert!(rail.confirm.is_some()); + assert!(!rail.streaming, "此刻没有流式消息在跑"); assert!(rail.busy, "非 YOLO 下待确认必须算忙，UI 靠它禁用输入"); } -// ───────────────────── 红线：凭据形状的串 ───────────────────── - #[test] -fn jwt_shaped_text_never_reaches_the_rail() { - let mut presenter = presenter(Script::Qa); - // 五个入口各注入一次：用户提交、增量、工具摘要、错误、确认请求细节 - presenter - .agent_submit(format!("我的 token 是 {JWT}")) - .expect("提交应当成功"); - presenter.apply(AppEvent::Agent(AgentEvent::MessageDelta { - index: 1, - delta: format!("顺手贴一个 {JWT}"), - })); - presenter.apply(AppEvent::Agent(AgentEvent::ToolCallStarted { - name: "read_game_log".to_string(), - summary: format!("Authorization: Bearer {JWT}"), - })); - presenter.apply(AppEvent::Agent(AgentEvent::Failed { - message: format!("401: access_token={JWT}"), - })); - presenter.apply(AppEvent::Agent(AgentEvent::ConfirmRequested { - request: ConfirmRequest { - id: "req-jwt".to_string(), - tool: "set_config".to_string(), - summary: format!("把 access_token 改成 {JWT}"), - details: serde_json::json!({ "access_token": JWT, "note": JWT }), - sensitivity: Sensitivity::High, - }, - })); +fn begin_turn_marks_busy_before_any_event_arrives() { + // 提交成功到第一个事件之间异步后端有空窗：这段时间必须已经算忙， + // 否则用户能再点一次发送（两条 user 消息、两轮回复）。 + let mut rail = AgentRail::new(); + rail.begin_turn(); + assert!(rail.busy && rail.streaming); - let rail = presenter.agent_rail(); - let text = rail_text(rail); - assert!( - !text.contains("eyJhbGci"), - "rail 上不得出现 JWT 原文：{text}" - ); - assert!( - text.contains(""), - "应当被脱敏成占位符：{text}" - ); - // 凭据键名的值整段打码（不只是靠内容规则） - let details = &rail.confirm.as_ref().expect("确认请求仍在").details; - assert_eq!(details["access_token"], ""); - assert!(!details["note"] - .as_str() - .unwrap_or_default() - .contains("eyJhbGci")); + // 空事件流也不会把输入框永久锁死：收敛时按消息重算 + rail.settle_streaming(); + assert!(!rail.busy && !rail.streaming); } #[test] -fn scrub_text_is_idempotent_on_already_redacted_text() { - let once = scrub_text(JWT); - assert_eq!(scrub_text(&once), once); +fn submit_with_a_silent_backend_does_not_leave_the_shell_busy() { + let mut presenter = Presenter::new(Box::new(SilentTransport)); + presenter + .agent_submit("在吗".to_string()) + .expect("提交应当成功"); + assert!( + !presenter.agent_rail().busy, + "后端一个事件都没回，输入框必须重新可用" + ); +} + +/// 工具收尾事件早于开始事件（或重复投递）：不许覆盖已收敛的历史条目（r1 P2-3）。 +#[test] +fn tool_call_finished_without_a_pending_call_never_rewrites_history() { + let mut presenter = presenter(Script::Qa); + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallStarted { + name: "set_config".to_string(), + summary: "修改 download.concurrency".to_string(), + })); + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallFinished { + name: "set_config".to_string(), + ok: true, + summary: "并发已改成 16".to_string(), + })); + // 重放 / 乱序：没有 pending 的收尾事件只能被忽略 + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallFinished { + name: "set_config".to_string(), + ok: false, + summary: "另一次失败".to_string(), + })); + + let tool = presenter.agent_rail().messages[0] + .tool + .as_ref() + .expect("工具条目"); + assert_eq!(tool.summary, "并发已改成 16", "历史条目被改写了"); + assert!(tool.ok); } // ─────────────────────── 提交前置条件 ─────────────────────── @@ -320,22 +320,15 @@ impl AgentTransport for BrokenTransport { } } -/// 把 rail 上所有对用户可见的文本拼起来（红线断言用）。 -fn rail_text(rail: &AgentRail) -> String { - let mut out = String::new(); - for message in &rail.messages { - out.push_str(&message.text); - if let Some(tool) = &message.tool { - out.push_str(&tool.name); - out.push_str(&tool.summary); - } +/// 收下输入但一个事件都不回的后端（异步推流的极端形态：这一拍还没到）。 +struct SilentTransport; + +impl AgentTransport for SilentTransport { + fn submit(&mut self, _text: &str, _history: &AgentRail) -> Result, String> { + Ok(Vec::new()) } - out.push_str(rail.error.as_deref().unwrap_or_default()); - out.push_str(&rail.endpoint_label); - if let Some(confirm) = &rail.confirm { - out.push_str(&confirm.tool); - out.push_str(&confirm.summary); - out.push_str(&confirm.details.to_string()); + + fn confirm(&mut self, _request_id: &str, _accept: bool) -> Vec { + Vec::new() } - out } diff --git a/crates/presenter/src/agent/tests_red_line.rs b/crates/presenter/src/agent/tests_red_line.rs new file mode 100644 index 0000000..89c2a7f --- /dev/null +++ b/crates/presenter/src/agent/tests_red_line.rs @@ -0,0 +1,230 @@ +//! 红线测试：凭据形状的串不得进 [`crate::agent::AgentRail`]。 +//! +//! 与 `agent/tests.rs` 同源、拆文件只为守「单文件 ≤400 行」。这一组测试的目标是**守住闸门**： +//! 每条入口各自注入，任何一条把脱敏摘掉都必须变红（r1 复审发现三条入口是假绿，故单列一文件， +//! 改动这里时请照 r1 的做法逐入口造变异自证）。 +//! +//! 注入的凭据形状两类： +//! - JWT（`header.payload.signature`，靠 core `Redactor` 的「带点 token」规则拦）； +//! - 非 JWT 形状（`{"password":"hunter2"}`、短 `Bearer abcdef123456`，靠键名与 Bearer 规则拦）。 + +use super::mock::{MockAgentTransport, Script}; +use super::Presenter; +use crate::agent::rail::scrub_text; +use crate::agent::AgentRail; +use crate::dto::{AgentEvent, AppEvent, ChatMessage, ChatRole, ConfirmRequest, Sensitivity}; + +/// 真实形状的 JWT（header.payload.signature，三段各 ≥8）。 +const JWT: &str = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.c2lnbmF0dXJlLXZhbHVlLXRoYXQtaXMtbG9uZy1lbm91Z2g"; + +fn presenter(script: Script) -> Presenter { + Presenter::new(Box::new(MockAgentTransport::new(script))) +} + +#[test] +fn jwt_shaped_text_never_reaches_the_rail() { + let mut presenter = presenter(Script::Qa); + // 五个入口各注入一次：用户提交、增量、工具摘要、错误、确认请求细节 + presenter + .agent_submit(format!("我的 token 是 {JWT}")) + .expect("提交应当成功"); + presenter.apply(AppEvent::Agent(AgentEvent::MessageDelta { + index: 1, + delta: format!("顺手贴一个 {JWT}"), + })); + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallStarted { + name: "read_game_log".to_string(), + summary: format!("Authorization: Bearer {JWT}"), + })); + presenter.apply(AppEvent::Agent(AgentEvent::Failed { + message: format!("401: access_token={JWT}"), + })); + presenter.apply(AppEvent::Agent(AgentEvent::ConfirmRequested { + request: ConfirmRequest { + id: "req-jwt".to_string(), + tool: "set_config".to_string(), + summary: format!("把 access_token 改成 {JWT}"), + details: serde_json::json!({ "access_token": JWT, "note": JWT }), + sensitivity: Sensitivity::High, + }, + })); + + let rail = presenter.agent_rail(); + let text = rail_text(rail); + assert!( + !text.contains("eyJhbGci"), + "rail 上不得出现 JWT 原文：{text}" + ); + assert!( + text.contains(""), + "应当被脱敏成占位符：{text}" + ); + // 凭据键名的值整段打码（不只是靠内容规则） + let details = &rail.confirm.as_ref().expect("确认请求仍在").details; + assert_eq!(details["access_token"], ""); + assert!(!details["note"] + .as_str() + .unwrap_or_default() + .contains("eyJhbGci")); +} + +/// 上一条测试里 `MessageAppended` 走的是 `agent_submit`（已先 scrub），踩不到 rail 自己的 +/// `scrub_message`。这条**绕过 submit** 直接投递，钉住那条入口（r1 P1 变异 A）。 +#[test] +fn message_appended_from_the_backend_is_scrubbed_inside_the_rail() { + let mut presenter = presenter(Script::Qa); + presenter.apply(AppEvent::Agent(AgentEvent::MessageAppended( + ChatMessage::user(format!("access_token={JWT}")), + ))); + presenter.apply(AppEvent::Agent(AgentEvent::MessageAppended(ChatMessage { + role: ChatRole::Assistant, + text: format!("听到你贴了 {JWT}"), + tool: None, + streaming: false, + }))); + presenter.apply(AppEvent::Agent(AgentEvent::MessageAppended( + ChatMessage::system(format!("refresh_token={JWT}")), + ))); + + let text = rail_text(presenter.agent_rail()); + assert!( + !text.contains("eyJhbGci"), + "MessageAppended 入口未脱敏：{text}" + ); + assert_eq!( + presenter.agent_rail().messages.len(), + 3, + "三条消息都要在（脱敏不等于丢消息）" + ); +} + +/// 工具**收尾**事件（`ToolCallFinished`）同样带 name + summary，必须过闸门（r1 P1 变异 C2）。 +/// +/// 两边用同一个「名字里带 JWT」的工具名：脱敏后仍然相等，所以**只要有一侧没脱敏**， +/// 名字就对不上（条目收敛不了、`ok` 仍是 false），断言会红。 +#[test] +fn tool_call_finished_summary_is_scrubbed_inside_the_rail() { + let mut presenter = presenter(Script::Qa); + let name = format!("set_config_{JWT}"); + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallStarted { + name: name.clone(), + summary: "修改 download.concurrency".to_string(), + })); + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallFinished { + name, + ok: true, + summary: format!("写进去了：Authorization: Bearer {JWT}"), + })); + + let text = rail_text(presenter.agent_rail()); + assert!( + !text.contains("eyJhbGci"), + "ToolCallFinished 入口未脱敏：{text}" + ); + let tool = presenter.agent_rail().messages[0] + .tool + .as_ref() + .expect("工具条目"); + assert!(tool.ok, "结论位要照实写"); + assert!(!tool.name.contains("eyJhbGci"), "工具名也要过闸门"); +} + +/// 非 JWT 形状的凭据（`{"password":"hunter2"}`）只能靠**键名**规则拦（r1 P1 变异 H）。 +/// +/// 同时钉住「值随 path 敏感」这条上下文规则（`set_config` 的 details 形状）。 +#[test] +fn sensitive_keys_in_confirm_details_are_masked_without_jwt_shape() { + let mut presenter = presenter(Script::Qa); + presenter.apply(AppEvent::Agent(AgentEvent::ConfirmRequested { + request: ConfirmRequest { + id: "req-keys".to_string(), + tool: "set_config".to_string(), + summary: "改几个设置".to_string(), + details: serde_json::json!({ + "password": "hunter2", + "api_key": "short-key-123", + "nested": { "refresh_token": "rt-1" }, + "list": [{ "token": "xyz" }], + "plain": "nothing here", + "path": "ai.api_key", + "old": "", + "new": "sk-proj-abcdefghijklmnop", + }), + sensitivity: Sensitivity::High, + }, + })); + + let details = &presenter + .agent_rail() + .confirm + .as_ref() + .expect("确认请求") + .details; + let placeholder = serde_json::json!(""); + // 键名命中：对象 / 嵌套 / 数组各一 + assert_eq!(details["password"], placeholder); + assert_eq!(details["api_key"], placeholder); + assert_eq!(details["nested"]["refresh_token"], placeholder); + assert_eq!(details["list"][0]["token"], placeholder); + // 值随 path 敏感：old/new 一并掩码（不然 API key 就躺在确认弹窗的 diff 里） + assert_eq!(details["new"], placeholder); + assert_eq!(details["old"], placeholder); + // 无关键原样保留（审计要看得出改的是什么） + assert_eq!(details["plain"], serde_json::json!("nothing here")); + assert_eq!(details["path"], serde_json::json!("ai.api_key")); + + let text = rail_text(presenter.agent_rail()); + for leak in [ + "hunter2", + "short-key-123", + "rt-1", + "xyz", + "sk-proj-abcdefghijklmnop", + ] { + assert!(!text.contains(leak), "凭据泄漏到 rail：{leak} / {text}"); + } +} + +/// 短 `Bearer` 令牌不是 JWT 形状，core 的 `Redactor` 会放过它（r1 P2-1）。 +#[test] +fn short_bearer_token_is_masked() { + let mut presenter = presenter(Script::Qa); + presenter.apply(AppEvent::Agent(AgentEvent::ToolCallStarted { + name: "read_game_log".to_string(), + summary: "Authorization: Bearer abcdef123456".to_string(), + })); + let text = rail_text(presenter.agent_rail()); + assert!( + !text.contains("abcdef123456"), + "短 Bearer 令牌要掩码：{text}" + ); + assert!(text.contains("Bearer "), "{text}"); +} + +#[test] +fn scrub_text_is_idempotent_on_already_redacted_text() { + let once = scrub_text(JWT); + assert_eq!(scrub_text(&once), once); + let bearer = scrub_text("Authorization: Bearer abcdef123456"); + assert_eq!(scrub_text(&bearer), bearer); +} + +/// 把 rail 上所有对用户可见的文本拼起来（红线断言用）。 +fn rail_text(rail: &AgentRail) -> String { + let mut out = String::new(); + for message in &rail.messages { + out.push_str(&message.text); + if let Some(tool) = &message.tool { + out.push_str(&tool.name); + out.push_str(&tool.summary); + } + } + out.push_str(rail.error.as_deref().unwrap_or_default()); + out.push_str(&rail.endpoint_label); + if let Some(confirm) = &rail.confirm { + out.push_str(&confirm.tool); + out.push_str(&confirm.summary); + out.push_str(&confirm.details.to_string()); + } + out +} diff --git a/crates/presenter/src/state_tests.rs b/crates/presenter/src/state_tests.rs index 7d589fb..e1a4358 100644 --- a/crates/presenter/src/state_tests.rs +++ b/crates/presenter/src/state_tests.rs @@ -270,6 +270,9 @@ fn failed_event_settles_streaming_and_keeps_the_evidence() { #[test] fn confirm_request_keeps_the_shell_busy_until_it_resolves() { + // 分工：这条钉 state 层的「待确认 ⇒ busy」与 `ConfirmResolved` 收敛； + // presenter 层的同名守卫是 `agent::tests::pending_confirm_forces_busy_without_yolo` + // （r1 P2-2：那条曾因 ToolCallStarted 顺手置真而空过，已改成先 finish_stream 再断言）。 let mut state = AppState::new(); state.apply(AppEvent::Agent(AgentEvent::ConfirmRequested { request: confirm_request("req-1"),