357 lines
17 KiB
Rust
357 lines
17 KiB
Rust
//! 审批门控逻辑。
|
||
//!
|
||
//! 审批策略(方案 B:Persona 维度 + 扩展点):
|
||
//! - reviewer/analyst 人设的工具调用全 auto(只读/分析,审批无意义)
|
||
//! - 其他人设走现有 auto_exec_mode 三档
|
||
//! - Phase 2 扩展点:可在 should_auto_for_persona 内加工具维度 if 分支
|
||
|
||
use std::sync::Arc;
|
||
|
||
use tauri::{AppHandle, Emitter, Manager};
|
||
use tokio::sync::Mutex;
|
||
|
||
use df_ai::ai_tools::{AiToolRegistry, RiskLevel};
|
||
use df_ai::provider::ChatMessage;
|
||
use df_storage::crud::AiToolExecutionRepo;
|
||
use df_storage::db::Database;
|
||
|
||
use super::cache::{find_cached_high_risk_result, pending_placeholder_for};
|
||
use super::diff::build_write_file_diff;
|
||
use super::reason::build_approval_reason;
|
||
use super::record::audit_tool_call;
|
||
use super::super::{AiChatEvent, AiSession, ApprovalKind, PendingApproval, ToolCallDraft, is_destructive_command, trust_key_for, TrustKey};
|
||
|
||
/// 按 risk_level + auto_exec_mode 判定是否自动执行。
|
||
///
|
||
/// F-#97 自动执行范围三档（2026-06-22）：low/medium/all，默认 low。
|
||
/// - low：仅 Low 自动（等价旧行为）
|
||
/// - medium：Low+Medium 自动
|
||
/// - all：全自动无审批（完全 AI 接管）
|
||
///
|
||
/// C-260627：patch_file 小改动（≤5 行）特例自动放行，不阻塞 AI 工作流。
|
||
pub(super) fn classify_risk_and_auto(
|
||
risk_level: RiskLevel,
|
||
auto_exec_mode: &str,
|
||
tool_name: &str,
|
||
args: &serde_json::Value,
|
||
) -> bool {
|
||
let _ = args; // 预留扩展点(未来可加路径白名单/文件类型等维度)
|
||
// patch_file 是 AI 编码主力工具,改文件是 AI Coding 的工作常态。
|
||
// 原本“小改动(≤5 行)豁免、大改动审批”的设计在实际使用中频繁打断 AI 工作流
|
||
// (AI 改文件往往远超 5 行),且文件已写入会落 audit 表可追溯,审批价值低。
|
||
// 决策:patch_file 全档位自动放行(low/medium/all 均不审批),与 read_file 同级处理。
|
||
if tool_name == "patch_file" {
|
||
return true;
|
||
}
|
||
match risk_level {
|
||
RiskLevel::Low => true,
|
||
RiskLevel::Medium => auto_exec_mode == "medium" || auto_exec_mode == "all",
|
||
RiskLevel::High => auto_exec_mode == "all",
|
||
}
|
||
}
|
||
|
||
/// 审批策略方案 B:Persona 维度判定。
|
||
///
|
||
/// 在 classify_risk_and_auto 之上叠加人设维度:
|
||
/// - reviewer/analyst 人设:工具白名单已限制为只读,全部 auto(审批纯浪费)
|
||
/// - 其他人设:走 classify_risk_and_auto 原逻辑
|
||
///
|
||
/// Phase 2 扩展点:在此函数内加工具维度 if 分支,例如:
|
||
/// ```ignore
|
||
/// if persona_id == "coder" && tool_name == "write_file" {
|
||
/// if let Some(path) = args.get("path").and_then(|v| v.as_str()) {
|
||
/// if path.ends_with(".md") { return true; } // 写文档 auto
|
||
/// }
|
||
/// }
|
||
/// ```
|
||
#[allow(dead_code)] // 接线到 process_tool_calls 需要 SubTask 携带 persona_id,后续批次接入
|
||
pub(super) fn should_auto_for_persona(
|
||
persona_id: Option<&str>,
|
||
risk_level: RiskLevel,
|
||
auto_exec_mode: &str,
|
||
tool_name: &str,
|
||
args: &serde_json::Value,
|
||
) -> bool {
|
||
// 人设维度:reviewer/analyst 全 auto
|
||
match persona_id {
|
||
Some("reviewer") | Some("analyst") => {
|
||
tracing::debug!(
|
||
persona = ?persona_id,
|
||
tool = %tool_name,
|
||
"[POLICY-B] 只读人设全 auto"
|
||
);
|
||
return true;
|
||
}
|
||
_ => {}
|
||
}
|
||
// 兜底:现有三档 + patch_file 特例
|
||
classify_risk_and_auto(risk_level, auto_exec_mode, tool_name, args)
|
||
}
|
||
|
||
/// 检查会话信任命中。
|
||
///
|
||
/// 首批信任工具：write_file / run_command。同会话已批准过同工具+同目录 →
|
||
/// `TrustKey` 命中，返回 `Some(TrustKey)`；否则返回 `None`（走原审批流程）。
|
||
///
|
||
/// 签名改 `session_arc: &Arc<Mutex<AiSession>>`,内部短 lock 读
|
||
/// `session_trust` 后立即 drop,信任查询不持锁,与 process_tool_calls 持锁 await 反模式解耦。
|
||
pub(super) async fn check_trust_hits(
|
||
draft: &ToolCallDraft,
|
||
args: &serde_json::Value,
|
||
session_arc: &Arc<Mutex<AiSession>>,
|
||
conv_id: &str,
|
||
) -> Option<TrustKey> {
|
||
let key = trust_key_for(&draft.name, args)?;
|
||
// 安全门控（run_command 会话信任按目录不按命令的补丁）：
|
||
// run_command 的信任 key 只用 working_dir，一次批准 → 同目录任意命令 auto。
|
||
// 破坏性命令（rm/del/format/... 不可逆）绝不 auto 放行，即使同目录已批准过，
|
||
// 也必须每轮走正常审批。命中黑名单直接返 None，让流程继续走 pending 审批。
|
||
if matches!(key, TrustKey::Execute { .. }) {
|
||
if let Some(cmd) = args.get("command").and_then(|v| v.as_str()) {
|
||
if is_destructive_command(cmd) {
|
||
tracing::info!(
|
||
tool = %draft.name,
|
||
new_tool_call_id = %draft.id,
|
||
"[会话信任] 命中破坏性命令黑名单，跳过 auto 放行（走正常审批）"
|
||
);
|
||
return None;
|
||
}
|
||
}
|
||
}
|
||
// 短 lock 读 session_trust(仅 contains 判定,无 await,纳秒级),命中即返 key
|
||
let hit = {
|
||
let session = session_arc.lock().await;
|
||
session.conv_read(conv_id)
|
||
.map(|c| c.session_trust.contains(&key))
|
||
.unwrap_or(false)
|
||
};
|
||
if hit { Some(key) } else { None }
|
||
}
|
||
|
||
/// 插入 pending 审批：生成 diff → 重试检测 → insert PendingApproval + 占位 tool_result
|
||
/// → 拼 reason + emit AiApprovalRequired + 审计落 pending 纪录。
|
||
///
|
||
/// **注意**：调用方应在调用前先 +=1 `pending_count`（保持与原 `handle_approval_tool`
|
||
/// 行为一致——重试 skip 分支也在 `pending_count += 1` 之后返回）。
|
||
///
|
||
/// 签名改 `session_arc: &Arc<Mutex<AiSession>>`,所有慢操作
|
||
/// (build_write_file_diff/detect_retry_count/build_approval_reason/audit_tool_call)
|
||
/// 在锁外 await,仅 `pending_approvals.insert` + `messages.push` 两处纯写改短 lock 段。
|
||
pub(super) async fn insert_pending_approval(
|
||
draft: ToolCallDraft,
|
||
args: serde_json::Value,
|
||
risk_level: RiskLevel,
|
||
session_arc: &Arc<Mutex<AiSession>>,
|
||
conv_id: &str,
|
||
audit_repo: &AiToolExecutionRepo,
|
||
app_handle: &AppHandle,
|
||
db: &Arc<Database>,
|
||
current_message_id: Option<&str>,
|
||
) {
|
||
// （路径 B）：write_file 挂起审批前预读旧文件生成 diff。
|
||
// 仅 write_file（覆盖整文件，有完整新旧内容可对比）；其他工具 diff=None。
|
||
// 旧文件不存在（新建）→ diff=None，前端回退显新 content。
|
||
// 读失败不阻断审批（容错：文件无读权限等极端情况降级为无 diff 预览）。
|
||
let approval_diff: Option<String> = if draft.name == "write_file" {
|
||
build_write_file_diff(&args).await
|
||
} else {
|
||
None
|
||
};
|
||
|
||
// (容错/恢复，开关 df-ai-approval-retry)：同 tc_id 重试检测。
|
||
// 与 High risk 的 find_cached_high_risk_result 互补：去重按 (tool_name,args) 匹配
|
||
// （High only），本 guard 按 tc_id 匹配（覆盖 Med + High 残留场景）。
|
||
// 同 tc_id 已有审计落定记录 → retry_count≥1，跳过审批 + emit Completed，断死循环。
|
||
// 兜底：flag 关或无审计记录 → retry_count=0，等价原行为。
|
||
let retry_count = detect_retry_count(audit_repo, &draft.id).await;
|
||
if retry_count >= 1 {
|
||
let skip_msg = format!(
|
||
"已跳过重试（同 tool_call_id={} 此前已审批执行过，防 LLM 死循环重试同卡死工具）",
|
||
draft.id
|
||
);
|
||
// 短 lock 段:push tool_result(纯写,无 await)
|
||
{
|
||
let mut session = session_arc.lock().await;
|
||
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &skip_msg));
|
||
}
|
||
// L3 emit 双写：重试 guard 跳过 emit Completed 双路发布。
|
||
let ev = AiChatEvent::AiToolCallCompleted {
|
||
id: draft.id.clone(),
|
||
result: serde_json::Value::String(skip_msg.clone()),
|
||
conversation_id: Some(conv_id.to_string()),
|
||
};
|
||
let _ = app_handle.emit("ai-chat-event", ev.clone());
|
||
let _ = app_handle.state::<crate::state::AppState>().ai_event_bus.publish_event(ev);
|
||
audit_tool_call(audit_repo, conv_id, &draft.id, &draft.name, &draft.args, "skipped_retry", risk_level, Some(skip_msg), Some("auto_retry_guard"), current_message_id).await;
|
||
return;
|
||
}
|
||
|
||
// 短 lock 段:纯写 pending_approvals.insert + 占位 tool_result push
|
||
{
|
||
let mut session = session_arc.lock().await;
|
||
session.pending_approvals.insert(draft.id.clone(), PendingApproval {
|
||
tool_call_id: draft.id.clone(),
|
||
tool_name: draft.name.clone(),
|
||
arguments: args.clone(),
|
||
conversation_id: Some(conv_id.to_string()),
|
||
recovered: false,
|
||
// 普通风险审批标 kind=Risk{diff}（下沉原 diff 字段）。
|
||
kind: ApprovalKind::Risk { diff: approval_diff.clone() },
|
||
retry_count,
|
||
created_at: Some(std::time::SystemTime::now()),
|
||
});
|
||
// 占位带 __PENDING__:tc_id 标记，供 sanitize 豁免保留 + 出口断言自愈（防 400 orphan）
|
||
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &pending_placeholder_for(&draft.id)));
|
||
}
|
||
// 慢操作锁外:拼 reason(DB 读)+ emit + 审计落 pending 纪录(DB 写)
|
||
let reason = build_approval_reason(&draft.name, &args, risk_level, db).await;
|
||
// L3 emit 双写：Med/High 风险审批挂起 AiApprovalRequired 双路发布（tunnel 透传 miniapp 弹审批窗）。
|
||
let ev = AiChatEvent::AiApprovalRequired {
|
||
id: draft.id.clone(),
|
||
name: draft.name.clone(),
|
||
args: args.clone(),
|
||
reason,
|
||
diff: approval_diff,
|
||
conversation_id: Some(conv_id.to_string()),
|
||
};
|
||
let _ = app_handle.emit("ai-chat-event", ev.clone());
|
||
let _ = app_handle.state::<crate::state::AppState>().ai_event_bus.publish_event(ev);
|
||
audit_tool_call(audit_repo, conv_id, &draft.id, &draft.name, &draft.args, "pending", risk_level, None, None, current_message_id).await;
|
||
}
|
||
|
||
/// (容错/恢复，开关 `df-ai-approval-retry`)：查审计表推算同 tc_id 重试计数。
|
||
///
|
||
/// 返回语义：
|
||
/// - 0：审计表无该 tc_id 落定记录（或仅 pending），属首次审批执行，正常挂起。
|
||
/// - ≥1：审计表已有该 tc_id 的落定记录（executed/failed/rejected/skipped_retry），即该
|
||
/// tc_id 此前已被审批执行过一次，LLM 又用同 id 重试 → 调用方据 ≥1 跳过执行 + emit Completed，
|
||
/// 断「超时/权限错→LLM 死循环重试同 id→重新挂起→用户被迫二次授权」循环。
|
||
///
|
||
/// 实现：查 `find_by_tool_call_id`，status 为 pending 视为"尚未落定"（返 0，首次挂起审批的
|
||
/// 正常态）；其余落定状态返 1。retry_count 当前仅取 0/1（断路器语义：第二次即跳过），
|
||
/// 字段类型 u32 留给未来"允许多次重试"扩展（配置上限阈值）。
|
||
///
|
||
/// 兜底/回退：flag 关（文档标记）或审计查询失败 → 返 0，等价原行为（单次审批执行，无重试防护）。
|
||
pub(super) async fn detect_retry_count(audit_repo: &AiToolExecutionRepo, tc_id: &str) -> u32 {
|
||
// 审计查询失败不阻断主流程（DB 故障等降级为无重试防护，返回 0 走原审批流程）
|
||
let rec = match audit_repo.find_by_tool_call_id(tc_id).await {
|
||
Ok(opt) => match opt {
|
||
Some(r) => r,
|
||
None => return 0, // 无记录 = 首次
|
||
},
|
||
Err(e) => {
|
||
tracing::warn!("[approval-retry] 查审计表 tc_id={} 失败（降级无重试防护）: {}", tc_id, e);
|
||
return 0;
|
||
}
|
||
};
|
||
// pending = 首次挂起审批（尚未落定）；其余落定状态 = 已执行过 → 计 1 次重试
|
||
if rec.status == "pending" {
|
||
0
|
||
} else {
|
||
1
|
||
}
|
||
}
|
||
|
||
/// 对单条工具调用执行审批门控决策：
|
||
///
|
||
/// 1. 按 `auto_exec_mode`（low/medium/all） + `risk_level` + `patch_file` 小改动特例
|
||
/// 判定是否应自动执行（`classify_risk_and_auto`）。若是 → 推入 `low_risk` 返回。
|
||
/// 2. 否则走审批分支：会话信任（`check_trust_hits`）→ 高危去重缓存 → 重试 guard →
|
||
/// `insert_pending_approval`（write_file diff + 挂起 + emit + 审计落 pending 记录）。
|
||
///
|
||
/// 签名改 `session_arc: &Arc<Mutex<AiSession>>`,所有 session 访问
|
||
/// 都改短 lock 段(check_trust_hits/find_cached_high_risk_result 内部短 lock,命中后 push
|
||
/// tool_result 短 lock 段)。慢操作(audit_tool_call/find_cached_high_risk_result 的 DB 查)
|
||
/// 全在锁外 await,根治 process_tool_calls 持 session lock 期间 await 慢操作死锁反模式。
|
||
pub(super) async fn handle_approval_tool(
|
||
draft: ToolCallDraft,
|
||
args: serde_json::Value,
|
||
risk_level: RiskLevel,
|
||
auto_exec_mode: &str,
|
||
session_arc: &Arc<Mutex<AiSession>>,
|
||
conv_id: &str,
|
||
_tools_arc: &Arc<AiToolRegistry>,
|
||
audit_repo: &AiToolExecutionRepo,
|
||
app_handle: &AppHandle,
|
||
db: &Arc<Database>,
|
||
low_risk: &mut Vec<(ToolCallDraft, serde_json::Value, RiskLevel)>,
|
||
trust_hits: &mut Vec<(ToolCallDraft, serde_json::Value, String, RiskLevel)>,
|
||
pending_count: &mut usize,
|
||
current_message_id: Option<&str>,
|
||
) {
|
||
// ── Step 1: 自动执行判定 ──
|
||
if classify_risk_and_auto(risk_level, auto_exec_mode, &draft.name, &args) {
|
||
low_risk.push((draft, args, risk_level));
|
||
return;
|
||
}
|
||
|
||
// ── Step 2: 会话信任检查 ──
|
||
// 会话级信任（Session Trust）：首批 write_file / run_command，
|
||
// 同会话已批准过同工具+同目录 → TrustKey 命中 → 自动放行（跳过 pending + 二次确认）。
|
||
// 命中后走与去重命中相似的「直接执行 + Completed + 审计 decided_by=auto_trust」路径，
|
||
// 但与 F-05 不同：F-05 复用缓存 tool_result 跳过执行；trust 放行**真实执行工具**
|
||
// （用户信任同目录同类操作，但仍要看每次的真实结果）。
|
||
if let Some(key) = check_trust_hits(&draft, &args, session_arc, conv_id).await {
|
||
let dir_label = match &key {
|
||
TrustKey::Write { dir } | TrustKey::Execute { dir } => dir.clone(),
|
||
};
|
||
tracing::info!(
|
||
tool = %draft.name,
|
||
dir = %dir_label,
|
||
new_tool_call_id = %draft.id,
|
||
"[会话信任] 命中: 同会话已批准同类操作，自动放行（跳过审批+二次确认）"
|
||
);
|
||
// emit 轻量 toast 事件（前端 AiChat.vue 显示"🔓 自动放行: tool(dir)"）
|
||
// L3 emit 双写：会话信任自动放行 toast 双路发布（tunnel 透传 miniapp 即时反馈）。
|
||
let ev = AiChatEvent::AiToolAutoApproved {
|
||
id: draft.id.clone(),
|
||
tool: draft.name.clone(),
|
||
dir: dir_label.clone(),
|
||
conversation_id: Some(conv_id.to_string()),
|
||
};
|
||
let _ = app_handle.emit("ai-chat-event", ev.clone());
|
||
let _ = app_handle.state::<crate::state::AppState>().ai_event_bus.publish_event(ev);
|
||
// 收集后循环外 spawn 执行，对齐 Low risk 不持锁（原注释 L593 声称"锁外"但代码持锁，
|
||
// run_command 慢命令会阻塞同会话所有触 state.ai_session 的 IPC，CR-51 修此）
|
||
trust_hits.push((draft, args, dir_label, risk_level));
|
||
return;
|
||
}
|
||
|
||
// ── Step 3: F-05 高危去重缓存（仅 High） ──
|
||
if matches!(risk_level, RiskLevel::High) {
|
||
// find_cached_high_risk_result 内部短 lock 读 messages + 锁外 await DB 查 status,
|
||
// 返回 (cached_content, status) 时不持锁
|
||
if let Some((cached, status)) = find_cached_high_risk_result(session_arc, conv_id, audit_repo, &draft.name, &args).await {
|
||
// 命中：把缓存结果作为新 tool_call_id 的 tool_result 回传，跳过审批
|
||
tracing::info!(
|
||
tool = %draft.name,
|
||
new_tool_call_id = %draft.id,
|
||
"[F-05] 高危工具去重命中:LLM 重试同命令，复用缓存结果跳过审批（断循环）"
|
||
);
|
||
// 短 lock 段:push tool_result(纯写,无 await)
|
||
{
|
||
let mut session = session_arc.lock().await;
|
||
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &cached));
|
||
}
|
||
// L3 emit 双写：高危去重命中复用缓存 emit Completed 双路发布。
|
||
let ev = AiChatEvent::AiToolCallCompleted {
|
||
id: draft.id.clone(),
|
||
result: serde_json::Value::String(cached.clone()),
|
||
conversation_id: Some(conv_id.to_string()),
|
||
};
|
||
let _ = app_handle.emit("ai-chat-event", ev.clone());
|
||
let _ = app_handle.state::<crate::state::AppState>().ai_event_bus.publish_event(ev);
|
||
// 审计：去重命中记一条（status 透传缓存来源 completed/rejected/failed，SW-260618-16；decided_by=auto_dedup），不进 pending
|
||
audit_tool_call(audit_repo, conv_id, &draft.id, &draft.name, &draft.args, &status, risk_level, Some(cached), Some("auto_dedup"), current_message_id).await;
|
||
return;
|
||
}
|
||
}
|
||
|
||
// ── Step 4: 插入 pending 审批 ──
|
||
*pending_count += 1;
|
||
insert_pending_approval(
|
||
draft, args, risk_level, session_arc, conv_id, audit_repo, app_handle, db,
|
||
current_message_id,
|
||
).await;
|
||
}
|