fix(agents): an MCP server switched off for a Claude session stays off (#3742)

Switching a server off in the session's MCP picker only left it out of the servers passed to the session, so a server Claude Code also loads from its own configuration kept running. The session parameters now name the servers switched off (_meta.openidea.mcpServersOff) and the Claude Code session denies their tools with --disallowedTools mcp__<server>.
This commit is contained in:
l0ng-ai
2026-11-16 18:51:59 +08:00
committed by GitHub
parent c1bec5182c
commit fd8f8d6dd0
4 changed files with 76 additions and 14 deletions
+24 -3
View File
@@ -1143,7 +1143,11 @@ impl AgentManager {
.peer
.request(
"session/fork",
json!({ "sessionId": live.session, "cwd": cwd_s, "mcpServers": mcp_servers }),
{
let mut params = session_params(&cwd_s, &mcp_servers, &mcp_overrides);
params["sessionId"] = json!(live.session);
params
},
None,
)
.await
@@ -2316,7 +2320,8 @@ impl Task {
let mut session = None;
if let (Some(id), true) = (saved, can_load) {
self.replaying.store(true, Ordering::Release);
let params = json!({ "sessionId": &id, "cwd": &cwd_s, "mcpServers": &mcp_servers });
let mut params = session_params(&cwd_s, &mcp_servers, &mcp_overrides);
params["sessionId"] = json!(&id);
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
tokio::time::sleep(REPLAY_GRACE).await;
self.replaying.store(false, Ordering::Release);
@@ -2329,7 +2334,7 @@ impl Task {
let (session_id, result) = match session {
Some(s) => s,
None => {
let params = json!({ "cwd": &cwd_s, "mcpServers": &mcp_servers });
let params = session_params(&cwd_s, &mcp_servers, &mcp_overrides);
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
@@ -3265,6 +3270,22 @@ fn turn_starts(entries: &[AgentEntry]) -> Vec<usize> {
.collect()
}
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
/// servers, and the ones switched off for this session, so an agent that also loads its own
/// configuration (Claude Code) can keep a same-named server of it off too.
fn session_params(cwd: &str, servers: &[Value], overrides: &BTreeMap<String, bool>) -> Value {
let off: Vec<&str> = overrides
.iter()
.filter(|(name, on)| !**on && name.as_str() != mcp::BUILTIN_MCP_NAME)
.map(|(name, _)| name.as_str())
.collect();
let mut params = json!({ "cwd": cwd, "mcpServers": servers });
if !off.is_empty() {
params["_meta"] = json!({ "openidea": { "mcpServersOff": off } });
}
params
}
fn is_false(b: &bool) -> bool {
!*b
}
+31 -11
View File
@@ -170,6 +170,8 @@ struct Session {
id: String,
cwd: PathBuf,
mcp_config: Option<tempfile::TempPath>,
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
mcp_off: Vec<String>,
shim: Weak<Shim>,
st: Mutex<State>,
/// Serializes (re)starting the process.
@@ -344,9 +346,10 @@ impl Shim {
cwd: PathBuf,
start: Start,
pending: bool,
mcp_config: Option<String>,
params: &Value,
) -> Arc<Session> {
let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
let mcp_off = mcp_off(params);
let mcp_config = mcp_config(params).and_then(|json| match write_mcp_config(&json) {
Ok(path) => Some(path),
Err(e) => {
tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
@@ -356,6 +359,7 @@ impl Shim {
let session = Arc::new(Session {
id: id.to_owned(),
mcp_config,
mcp_off,
shim: Arc::downgrade(self),
st: Mutex::new(State {
proc: None,
@@ -411,13 +415,8 @@ impl Shim {
}
"session/new" => {
let id = new_uuid(false);
let session = self.add_session(
&id,
self.cwd_of(&params),
Start::New { id: id.clone() },
false,
mcp_config(&params),
);
let session =
self.add_session(&id, self.cwd_of(&params), Start::New { id: id.clone() }, false, &params);
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
session.announce_commands();
Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
@@ -433,7 +432,7 @@ impl Shim {
None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
};
let chain = self.base_chain(&cwd, &start).map_err(internal)?;
let session = self.add_session(id, cwd, start, pending, mcp_config(&params));
let session = self.add_session(id, cwd, start, pending, &params);
rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
if method == "session/load" {
session.replay(&chain);
@@ -459,7 +458,7 @@ impl Shim {
(start, st.settings.clone())
};
self.save_pending(&id, Some(&start));
let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(&params));
let session = self.add_session(&id, source.cwd.clone(), start, true, &params);
session.st.lock().settings = settings;
let options = session.st.lock().settings.options();
Ok(json!({ "sessionId": id, "configOptions": options }))
@@ -666,6 +665,9 @@ impl Session {
if let Some(config) = &self.mcp_config {
args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
}
if !self.mcp_off.is_empty() {
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
}
args.extend(start.args());
let launch =
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
@@ -1497,6 +1499,24 @@ fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
Ok(file.into_temp_path())
}
/// The servers switched off for the session (`_meta.openidea.mcpServersOff`) as Claude Code
/// permission rules that deny all of a server's tools (`mcp__<server>`), so a server of
/// Claude Code's own configuration stays off too.
fn mcp_off(params: &Value) -> Vec<String> {
params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.map(|name| {
let name: String =
name.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' || c == '-' { c } else { '_' }).collect();
format!("mcp__{name}")
})
.collect()
}
/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
fn mcp_config(params: &Value) -> Option<String> {
let servers = params.get("mcpServers")?.as_array()?;
@@ -1243,6 +1243,13 @@ async fn skipped_questions_have_no_answers() {
assert_eq!(cancelled, None);
}
#[test]
fn servers_switched_off_become_disallowed_tools() {
assert!(mcp_off(&json!({})).is_empty());
let off = mcp_off(&json!({ "_meta": { "openidea": { "mcpServersOff": ["github", "my server.v2"] } } }));
assert_eq!(off, ["mcp__github", "mcp__my_server_v2"]);
}
#[test]
fn mcp_servers_become_an_mcp_config() {
assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
+14
View File
@@ -4238,3 +4238,17 @@ done
);
mgr.shutdown();
}
#[test]
fn session_params_name_the_servers_switched_off() {
let overrides = BTreeMap::from([
("github".to_owned(), false),
("docs".to_owned(), true),
(mcp::BUILTIN_MCP_NAME.to_owned(), false),
]);
let params = session_params("/p", &[json!({ "name": "docs" })], &overrides);
assert_eq!(params["cwd"], "/p");
assert_eq!(params["mcpServers"][0]["name"], "docs");
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
assert!(session_params("/p", &[], &BTreeMap::new()).get("_meta").is_none());
}