fix(desktop): align browser sessions with agent metadata

This commit is contained in:
xiaomakuaiz committed 2026-07-23 07:57:00 +00:00
1 parent 715db22bc6
commit a602b11401
9 files changed
+150 -94

No files matched your search

+1 -1
Submodule agent updated: eeff4ef8f2...d30f69d928.
+6 -7
View File
@@ -144,14 +144,13 @@ Op/Ev/错误码、proto:1、20s ping。
- 9 个 browser_* 工具经壳内 MCP streamable-http server 暴露给引擎
(Bearer 鉴权;手写最小面:POST json 应答/通知 202/GET 405)。
- **会话隔离并发**:每条 MCP transport 经 `initialize` 取得独立
`Mcp-Session-Id` 并拥有独立 `BrowserSession`。同一 transport 内串行保护
current tab/ref 表,不同 transport 可并行进入扩展桥;实现只依赖标准 MCP
会话头,不要求 Agent 私有 `_meta`。当前 Agent 的子任务共享父 transport,
因而共享父浏览器现场并按序执行;不同顶层任务各自建 transport,可并行。
`Mcp-Session-Id`;Agent 的 `tools/call._meta` 再携带实际 `session_id` 与
`work_dir`。两级 key 为父任务和共享 transport 的子 Agent 分配独立
`BrowserSession`。同一现场串行保护 current tab/ref,不同现场可并行。
`tabId → owner` 路由保证事件只投给所属任务;普通选择不能抢占其他任务的
tab,只有用户显式 handoff 才转交。MCP 标准调用不含 cwd:唯一活跃
workspace 可确定时落截图;无法确定时只跳过本地副本、不拒绝操作,图片
仍作为 MCP image 返回模型。
tab,只有用户显式 handoff 才转交。截图按 `work_dir` 精确落盘;旧 Agent
缺少元数据时回退唯一活跃 workspace,无法确定只跳过本地副本、不拒绝
操作,图片仍作为 MCP image 返回模型。
- 错误码→中文可行动文案是产品契约(模型行为依赖),改动需过 e2e 断言。
## 引擎监督
+3 -3
View File
@@ -46,6 +46,6 @@ make windows # NSIS 安装包(在 Windows 上执行;或走 CI)
`../browser-extension/` 随包分发(设置页引导加载);扩展经
`ws://127.0.0.1:{7440-7449}/ext` 连壳内桥,配对码在设置页展示。
browser_* 工具经壳内 MCP server 暴露给引擎;每条 MCP transport 有独立
浏览器现场和标签页归属,不同 transport 可并行,同一 transport 内按调用
顺序执行。该隔离只依赖标准 `Mcp-Session-Id`,不修改 Agent。
browser_* 工具经壳内 MCP server 暴露给引擎;`Mcp-Session-Id` 与 Agent
调用 `_meta.session_id` 共同标识浏览器现场,父任务/子 Agent 可并行且标签页
归属隔离,同一现场内按调用顺序执行。
+60 -27
View File
@@ -8,9 +8,9 @@
// 鉴权:随机 Bearer token,经 mcp.json 内置条目的 headers 下发给引擎——
// MCP 面能驱动用户浏览器,不能对本机任意进程裸奔。
//
// 并发模型:每条 MCP protocol session 拥有独立 BrowserSession;同一
// transport 内工具串行(共享 current tab/ref 表),不同 transport 可并行。
// Desktop 不依赖 Agent 私有字段,只使用标准 Mcp-Session-Id。
// 并发模型:Mcp-Session-Id 隔离 transport,tools/call._meta.session_id 再
// 隔离共用 transport 的父/子 Agent;每个 context 独享 BrowserSession。
// 同一 context 内串行保护 current tab/ref,不同 context 可并行。
use std::collections::HashMap;
use std::io::{Read as _, Write as _};
@@ -24,9 +24,15 @@ use serde_json::{json, Value};
use super::ops::tool_metas;
use super::session::{BrowserSession, BrowserSessions};
#[derive(Clone, Default)]
pub struct CallScope {
pub session_id: Option<String>,
pub work_dir: Option<String>,
}
/// 解析/校验调用工作区。None 只跳过截图落盘,不影响浏览器操作;owner
/// 隔离由标准 MCP protocol session 完成,不再拿工作区充当并发锁。
pub type WorkdirFn = Arc<dyn Fn() -> Result<Option<String>, String> + Send + Sync>;
/// 隔离由 MCP protocol session + Agent session id 完成,不拿工作区充当锁。
pub type WorkdirFn = Arc<dyn Fn(&CallScope) -> Result<Option<String>, String> + Send + Sync>;
#[derive(Clone)]
pub struct McpSessions(Arc<McpSessionsInner>);
@@ -38,7 +44,7 @@ struct McpSessionsInner {
struct McpClientSession {
closed: AtomicBool,
context: Arc<McpCallContext>,
contexts: StdMutex<HashMap<String, Arc<McpCallContext>>>,
}
struct McpCallContext {
@@ -47,9 +53,11 @@ struct McpCallContext {
}
impl McpClientSession {
fn close_context(&self) -> Arc<McpCallContext> {
fn drain_contexts(&self) -> Vec<Arc<McpCallContext>> {
// 先封门再等 contexts 锁:已进临界区的创建会被随后 drain,尚未进入
// 的创建会看到 closed。DELETE/reset 后不会晚生幽灵 context。
self.closed.store(true, Ordering::Release);
self.context.clone()
self.contexts.lock().unwrap().drain().map(|(_, context)| context).collect()
}
}
@@ -63,15 +71,11 @@ impl McpSessions {
fn create(&self) -> Result<String, String> {
let id = new_token()?;
let context = Arc::new(McpCallContext {
browser: self.0.browser.get_or_create(&id),
call_mu: tokio::sync::Mutex::new(()),
});
self.0.clients.lock().unwrap().insert(
id.clone(),
Arc::new(McpClientSession {
closed: AtomicBool::new(false),
context,
contexts: StdMutex::new(HashMap::new()),
}),
);
Ok(id)
@@ -81,22 +85,36 @@ impl McpSessions {
self.0.clients.lock().unwrap().contains_key(id)
}
fn context(&self, protocol_id: &str) -> Option<Arc<McpCallContext>> {
fn context(&self, protocol_id: &str, agent_id: Option<&str>) -> Option<Arc<McpCallContext>> {
let client = self.0.clients.lock().unwrap().get(protocol_id).cloned()?;
let key = agent_id.filter(|id| !id.is_empty()).unwrap_or("root");
let mut contexts = client.contexts.lock().unwrap();
if client.closed.load(Ordering::Acquire) {
return None;
}
Some(client.context.clone())
Some(
contexts
.entry(key.to_string())
.or_insert_with(|| {
let owner = format!("{protocol_id}:{key}");
Arc::new(McpCallContext {
browser: self.0.browser.get_or_create(&owner),
call_mu: tokio::sync::Mutex::new(()),
})
})
.clone(),
)
}
async fn remove(&self, id: &str) -> bool {
let client = self.0.clients.lock().unwrap().remove(id);
let Some(client) = client else { return false };
let context = client.close_context();
// DELETE 可与最后一个 tools/call 同时到达。先从协议注册表摘除,
// 再等调用锁,确保不会在旧调用仍操作 tab 时 detach。
let _guard = context.call_mu.lock().await;
context.browser.close().await;
for context in client.drain_contexts() {
// DELETE 可与最后一个 tools/call 同时到达。先从协议注册表摘除,
// 再等 context 调用锁,确保不会在旧调用仍操作 tab 时 detach。
let _guard = context.call_mu.lock().await;
context.browser.close().await;
}
true
}
@@ -109,9 +127,10 @@ impl McpSessions {
std::mem::take(&mut *clients).into_values().collect::<Vec<_>>()
};
for client in clients {
let context = client.close_context();
let _guard = context.call_mu.lock().await;
context.browser.close().await;
for context in client.drain_contexts() {
let _guard = context.call_mu.lock().await;
context.browser.close().await;
}
}
}
}
@@ -281,13 +300,14 @@ async fn dispatch(
"tools/call" => {
let name = params.get("name").and_then(|v| v.as_str()).unwrap_or("").to_string();
let args = params.get("arguments").cloned().unwrap_or(json!({}));
let scope = call_scope(&params);
let context = sessions
.context(protocol_id)
.context(protocol_id, scope.session_id.as_deref())
.ok_or_else(|| (-32001, "MCP 会话已关闭".to_string()))?;
// 同一 protocol session 的 current-tab/ref 状态串行;不同
// transport 没有共享可变现场,可并行进入扩展桥。
// 同一 Agent context 的 current-tab/ref 状态串行;不同 context
// 没有共享可变现场,可并行进入扩展桥。
let _g = context.call_mu.lock().await;
let out = match workdir() {
let out = match workdir(&scope) {
Err(e) => Err(e),
Ok(owner_workdir) => tokio::time::timeout(
std::time::Duration::from_secs(180),
@@ -311,6 +331,19 @@ async fn dispatch(
}
}
fn call_scope(params: &Value) -> CallScope {
let meta = params.get("_meta");
let value = |key: &str| meta.and_then(|value| value.get(key)).and_then(Value::as_str);
CallScope {
session_id: value("session_id")
.map(str::trim)
.filter(|value| !value.is_empty())
.map(str::to_string),
// work_dir 是文件系统值,不裁剪合法的首尾空格。
work_dir: value("work_dir").filter(|value| !value.is_empty()).map(str::to_string),
}
}
/// 工具分派:名称/入参形态对齐 ops.rs 的 tool_metas(即 Go tools.go)。
async fn call_tool(
sess: &BrowserSession,
+16 -7
View File
@@ -12,9 +12,9 @@
// mcp.rs MCP streamable-http server:配对后把工具暴露给 ohmyagent
// (Bearer 鉴权,URL+token 经 mcp.json 内置条目物化下发)
//
// MCP initialize 为每条客户端 transport 分配协议会话;每个 protocol
// session 各自拥有 BrowserSession,允许不同任务并行,同时隔离 current
// tab/ref 表。只依赖标准 Mcp-Session-Id,不要求 Agent 私有扩展。
// MCP initialize 为每条客户端 transport 分配协议会话;Agent 在 tools/call
// `_meta` 携带实际 session_id/work_dir。两级 key 各自拥有 BrowserSession,
// 允许父任务与子 Agent 并行,同时隔离 current tab/ref 与截图落盘路径。
pub mod bridge;
pub mod cdp;
@@ -70,17 +70,26 @@ pub fn init(app: &AppHandle) {
};
let b = bridge::ExtBridge::new(7440, &data_dir);
let mcp_sessions = mcp::McpSessions::new(b.clone());
// MCP 标准请求不携带调用方 cwd。唯一活跃工作区可确定时为截图落盘;
// 多任务并发时只跳过本地副本,图片仍通过 MCP 返回,不阻断浏览器操作。
// 新 Agent 直接在 tools/call._meta 携带实际 work_dir;兼容旧 Agent 时
// 回退 session id/唯一活跃工作区。无法确定只跳过落盘,不阻断操作。
let app2 = app.clone();
let wd: mcp::WorkdirFn = std::sync::Arc::new(move || {
let wd: mcp::WorkdirFn = std::sync::Arc::new(move |scope| {
let Some(host) = app2.try_state::<crate::driver::DriverHost>() else {
return Err("桌面驱动尚未初始化,无法确定浏览器操作归属".into());
};
let driver = host
.get()
.map_err(|e| format!("无法确定浏览器操作归属:{e}"))?;
Ok(driver.single_running_workdir())
Ok(scope
.work_dir
.clone()
.or_else(|| {
scope
.session_id
.as_deref()
.and_then(|id| driver.browser_workdir_for(id))
})
.or_else(|| driver.single_running_workdir()))
});
match mcp::serve(mcp_sessions.clone(), wd) {
Ok((url, token)) => {
+6 -5
View File
@@ -1,4 +1,5 @@
// 浏览器会话现场:每个 MCP protocol session 独立持有当前标签页、ref 表、事件旁白
// 浏览器会话现场:每个 MCP protocol + Agent session context 独立持有当前
// 标签页、ref 表、事件旁白
// 与 CDP 交互原语;BrowserSessions 负责 tab → owner 事件路由。
// 契约对齐 agent/internal/browser/session.go(语义逐字移植)。
//
@@ -33,9 +34,9 @@ use super::refs::{err_ref_stale, RefTable};
#[derive(Clone)]
pub struct BrowserSession(pub(crate) Arc<SessInner>);
/// 进程内浏览器现场注册表。每条 MCP protocol session 取一个
/// BrowserSession;不同 owner 可并行操作各自标签页,同一 owner 内由 MCP
/// 层串行,避免 ref/current-tab 状态互踩。
/// 进程内浏览器现场注册表。每个 MCP protocol + Agent session context 取
/// 一个 BrowserSession;不同 owner 可并行操作各自标签页,同一 owner 内由
/// MCP 层串行,避免 ref/current-tab 状态互踩。
#[derive(Clone)]
pub struct BrowserSessions(Arc<BrowserSessionsInner>);
@@ -203,7 +204,7 @@ impl SessState {
impl BrowserSession {
/// 单现场兼容构造器(测试/独立使用)。生产 MCP 复用一个
/// BrowserSessions,并按 MCP 协议会话创建 owner。
/// BrowserSessions,并按 MCP 协议会话/Agent session 创建 owner。
#[cfg(test)]
pub fn new(bridge: ExtBridge) -> Self {
BrowserSessions::new(bridge).get_or_create("default")
+42 -40
View File
@@ -194,13 +194,13 @@ async fn mcp_smoke_initialize_list_call() {
let b = ExtBridge::new(27460, &dir);
// 不 spawn 桥监听:MCP 面不依赖扩展在线
let sessions = mcp::McpSessions::new(b);
let workdir_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let workdir_calls2 = workdir_calls.clone();
let scopes: std::sync::Arc<std::sync::Mutex<Vec<mcp::CallScope>>> = Default::default();
let scopes2 = scopes.clone();
let (url, token) = mcp::serve(
sessions,
std::sync::Arc::new(move || {
workdir_calls2.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
Ok(None)
std::sync::Arc::new(move |scope| {
scopes2.lock().unwrap().push(scope.clone());
Ok(scope.work_dir.clone())
}),
)
.expect("MCP 启动");
@@ -295,11 +295,25 @@ async fn mcp_smoke_initialize_list_call() {
.await;
assert!(resp.contains(r#""isError":true"#), "应 isError: {resp}");
assert!(resp.contains("当前没有活动标签页"), "缺可行动文案: {resp}");
assert_eq!(
workdir_calls.load(std::sync::atomic::Ordering::SeqCst),
1,
"标准 tools/call 应经过 Desktop 工作区解析"
);
// 新 Agent 发送顶层 _meta.session_id/work_dir;Desktop 必须按实际字段
// 消费,不能沿用旧草案里的 namespace 或 cwd 拼写。
let resp = post(
json!({ "jsonrpc": "2.0", "id": 4, "method": "tools/call",
"params": { "name": "browser_snapshot", "arguments": {}, "_meta": {
"session_id": "agent-child", "work_dir": "/workspace/child"
} } }),
Some(token.clone()),
Some(session.clone()),
)
.await;
assert!(resp.contains(r#""isError":true"#));
{
let seen = scopes.lock().unwrap();
let scope = seen.last().expect("workdir resolver 应收到 scope");
assert_eq!(scope.session_id.as_deref(), Some("agent-child"));
assert_eq!(scope.work_dir.as_deref(), Some("/workspace/child"));
}
// 通知 → 202
let resp = post(
@@ -332,10 +346,10 @@ async fn mcp_smoke_initialize_list_call() {
assert!(resp.starts_with("HTTP/1.1 404"), "已删除会话必须失效: {resp}");
}
/// 不同 MCP transport 必须真正并行,不能只做到状态分表后仍被一个全局
/// mutex 串行。隔离只依赖标准 Mcp-Session-Id,不要求 Agent 私有元数据。
/// 父/子 Agent 共用一个 MCP transport;不同 _meta.session_id 必须真正并行,
/// 不能只做到状态分表后仍被 transport 级全局 mutex 串行。
#[tokio::test(flavor = "multi_thread")]
async fn mcp_protocol_sessions_execute_in_parallel() {
async fn mcp_agent_contexts_execute_in_parallel() {
let dir = tmp_dir("mcp-parallel");
let sessions = mcp::McpSessions::new(ExtBridge::new(27465, &dir));
let gate = std::sync::Arc::new((
@@ -347,7 +361,7 @@ async fn mcp_protocol_sessions_execute_in_parallel() {
let timed_out2 = timed_out.clone();
let (url, token) = mcp::serve(
sessions,
std::sync::Arc::new(move || {
std::sync::Arc::new(move |_| {
let (lock, ready) = &*gate2;
let mut entered = lock.lock().unwrap();
*entered += 1;
@@ -382,59 +396,47 @@ async fn mcp_protocol_sessions_execute_in_parallel() {
String::from_utf8_lossy(&buf).into_owned()
}
let init_one = post(
let init = post(
&addr,
&token,
None,
json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {} }),
)
.await;
let session_one = init_one
let session = init
.lines()
.find_map(|line| line.strip_prefix("Mcp-Session-Id: "))
.map(str::trim)
.expect("initialize 应返回 session id")
.to_string();
let init_two = post(
&addr,
&token,
None,
json!({ "jsonrpc": "2.0", "id": 2, "method": "initialize", "params": {} }),
)
.await;
let session_two = init_two
.lines()
.find_map(|line| line.strip_prefix("Mcp-Session-Id: "))
.map(str::trim)
.expect("第二个 initialize 应返回 session id")
.to_string();
assert_ne!(session_one, session_two);
let one = post(
&addr,
&token,
Some(&session_one),
json!({ "jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {
"name": "browser_snapshot", "arguments": {}
Some(&session),
json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {
"name": "browser_snapshot", "arguments": {},
"_meta": { "session_id": "agent-one", "work_dir": "/workspace/one" }
} }),
);
let two = post(
&addr,
&token,
Some(&session_two),
json!({ "jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {
"name": "browser_snapshot", "arguments": {}
Some(&session),
json!({ "jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {
"name": "browser_snapshot", "arguments": {},
"_meta": { "session_id": "agent-two", "work_dir": "/workspace/two" }
} }),
);
let (one, two) = tokio::time::timeout(Duration::from_secs(5), async {
tokio::join!(one, two)
})
.await
.expect("不同 MCP protocol session 不应互相阻塞");
.expect("不同 Agent context 不应互相阻塞");
assert!(one.contains(r#""isError":true"#) && two.contains(r#""isError":true"#));
assert_eq!(*gate.0.lock().unwrap(), 2, "两个 protocol session 都应进入 resolver");
assert_eq!(*gate.0.lock().unwrap(), 2, "两个 Agent context 都应进入 resolver");
assert!(
!timed_out.load(std::sync::atomic::Ordering::SeqCst),
"两个 MCP protocol session 被全局锁串行了"
"两个 Agent context 被 transport 级锁串行了"
);
}
@@ -446,7 +448,7 @@ async fn mcp_gosdk_wire_shape() {
let dir = tmp_dir("mcp-wire");
let b = ExtBridge::new(27470, &dir);
let sessions = mcp::McpSessions::new(b);
let (url, token) = mcp::serve(sessions, std::sync::Arc::new(|| Ok(None))).expect("MCP 启动");
let (url, token) = mcp::serve(sessions, std::sync::Arc::new(|_| Ok(None))).expect("MCP 启动");
let addr = url.strip_prefix("http://").unwrap().split('/').next().unwrap().to_string();
async fn raw(addr: &str, req: String) -> String {
+3 -1
View File
@@ -489,7 +489,7 @@ fn concurrent_sidecar_updates_do_not_lose_fields() {
}
#[test]
fn browser_workdir_fallback_does_not_reject_concurrency() {
fn browser_context_resolves_explicit_sessions_without_rejecting_concurrency() {
let inner = bare_inner("browser-owner");
let mut one = bare_session("s1");
one.workdir = "/workspace/one".into();
@@ -501,6 +501,8 @@ fn browser_workdir_fallback_does_not_reject_concurrency() {
sessions.insert("s2".into(), two);
}
let driver = OhmyDriver(inner.clone());
assert_eq!(driver.browser_workdir_for("s1").as_deref(), Some("/workspace/one"));
assert_eq!(driver.browser_workdir_for("s2").as_deref(), Some("/workspace/two"));
assert_eq!(driver.single_running_workdir(), None, "多任务时仅停用旧式落盘兜底");
inner.sess.sessions.lock().unwrap().get_mut("s2").unwrap().running = false;
+13 -3
View File
@@ -738,9 +738,19 @@ impl OhmyDriver {
Ok(())
}
/// MCP 标准工具调用不带 cwd;仅在唯一 owner 可确定时返回截图落盘路径。
/// 多 owner 时只跳过落盘,浏览器现场仍由 MCP session 隔离并正常并发,
/// 绝不因工作区不明确而拒绝工具调用。
/// 按 Agent/壳 session id 精确查工作区。新 MCP 调用同时显式携带
/// work_dir;本方法用于兼容元数据缺失或旧 Agent。
pub fn browser_workdir_for(&self, id: &str) -> Option<String> {
let sessions = self.0.sess.sessions.lock().unwrap();
sessions
.get(id)
.or_else(|| sessions.values().find(|session| session.engine_id == id))
.map(|session| session.workdir.clone())
.filter(|workdir| !workdir.is_empty())
}
/// 旧 Agent 没有 MCP 调用元数据时的截图落盘兜底:仅在唯一 owner 可
/// 确定时返回路径。多 owner 时只跳过落盘,浏览器现场仍正常并发。
pub fn single_running_workdir(&self) -> Option<String> {
// 显式后台 Agent 只转发 tool/error 心跳,纯文本任务可能从未物化
// child SessionState;background_agents 才是其存活/父归属真值。