дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-20 16:39:31 +02:00
Порівняти коміти
73
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
9b4358f046 | ||
|
|
8daaef38d9 | ||
|
|
efd4e454ee | ||
|
|
0379c37a49 | ||
|
|
98da80b2b3 | ||
|
|
5c2e7ff92a | ||
|
|
e86a853048 | ||
|
|
fd8f0eb99c | ||
|
|
121e1fa535 | ||
|
|
5859cf9f5b | ||
|
|
21b187f2d5 | ||
|
|
121d7edc15 | ||
|
|
b9256a7260 | ||
|
|
47b4cb55ba | ||
|
|
da1bcd67cd | ||
|
|
67a4797cf4 | ||
|
|
39523bc419 | ||
|
|
639c76d54c | ||
|
|
d5f29ea256 | ||
|
|
f9455549a7 | ||
|
|
dd14e8b040 | ||
|
|
efce16d45d | ||
|
|
977ce62bf0 | ||
|
|
479123dcf3 | ||
|
|
09301ca12d | ||
|
|
485c1ac40b | ||
|
|
6d756ec472 | ||
|
|
8b427bcedd | ||
|
|
966963c8b6 | ||
|
|
ead8dc507b | ||
|
|
f5db9714d6 | ||
|
|
f90eca0777 | ||
|
|
485a7edc4e | ||
|
|
786de5f5e8 | ||
|
|
ac08cd85b2 | ||
|
|
0c8d45154f | ||
|
|
7eb186ae8a | ||
|
|
31bb1cb797 | ||
|
|
1ba6a6247c | ||
|
|
fa74f6e8e4 | ||
|
|
5c321f02e4 | ||
|
|
00871ab971 | ||
|
|
5aba5e0629 | ||
|
|
eec447872c | ||
|
|
98418d727b | ||
|
|
2265497b18 | ||
|
|
7f33640895 | ||
|
|
a57e12dbc5 | ||
|
|
b3f8cec272 | ||
|
|
e44e389571 | ||
|
|
0cf0e93d92 | ||
|
|
c7ad3459c4 | ||
|
|
af281341b1 | ||
|
|
313a5f3a14 | ||
|
|
18cd2ef63b | ||
|
|
4fc55f7520 | ||
|
|
795413c366 | ||
|
|
dd3c9c7b0a | ||
|
|
361ca01cc0 | ||
|
|
1b9c330613 | ||
|
|
2d7bb56a8d | ||
|
|
2c8a029939 | ||
|
|
6e2c19846c | ||
|
|
6c2ae13387 | ||
|
|
34cb4ad5e0 | ||
|
|
d080ca28f8 | ||
|
|
22a5e4c9e6 | ||
|
|
e93ac42489 | ||
|
|
ae604b7933 | ||
|
|
bd27eb5474 | ||
|
|
15fcf4f2c1 | ||
|
|
65415a03bd | ||
|
|
58585e1064 |
No files matched your search
Створено
@@ -4660,6 +4660,7 @@ dependencies = [
|
||||
name = "ide-lsp"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4943,6 +4944,7 @@ dependencies = [
|
||||
"portable-pty",
|
||||
"serde",
|
||||
"specta",
|
||||
"tokio",
|
||||
"tracing",
|
||||
]
|
||||
|
||||
|
||||
@@ -256,6 +256,38 @@ impl AgentCatalogs {
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub(super) async fn load_levels(
|
||||
self: &Arc<Self>,
|
||||
shared: &Arc<Shared>,
|
||||
provider: &str,
|
||||
model: &str,
|
||||
) -> Result<Vec<AgentConfigOption>, String> {
|
||||
if let Some(levels) = self.levels(shared, provider, model) {
|
||||
return Ok(levels);
|
||||
}
|
||||
let unavailable = || "The agent did not report settings for the selected model".to_owned();
|
||||
let spec = shared.spec(provider).ok_or_else(unavailable)?;
|
||||
let (_, flight) = self.request(shared, spec, false, Some(model));
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.levels(shared, provider, model).ok_or_else(|| {
|
||||
let state = self.state.lock();
|
||||
state
|
||||
.entries
|
||||
.get(&Self::key(shared, provider))
|
||||
.and_then(|entry| {
|
||||
entry.model_failures.get(model).map(|failure| &failure.error).or(entry.error.as_ref())
|
||||
})
|
||||
.cloned()
|
||||
.unwrap_or_else(unavailable)
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
|
||||
@@ -323,6 +323,36 @@ async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
|
||||
switch_chat_model(ChatSwitch::Idle).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_effort_is_discovered_persisted_and_applied_before_the_first_reply() {
|
||||
switch_chat_model(ChatSwitch::Uncached).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_with_no_effort_can_be_selected() {
|
||||
switch_chat_model(ChatSwitch::NoEffort).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_settings_failure_leaves_the_chat_unchanged() {
|
||||
switch_chat_model(ChatSwitch::DiscoveryFails).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_withdrawn_effort_prevents_sending() {
|
||||
switch_chat_model(ChatSwitch::EffortUnavailable).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_rejected_effort_prevents_sending() {
|
||||
switch_chat_model(ChatSwitch::EffortRejected).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
|
||||
switch_chat_model(ChatSwitch::Superseded).await;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ChatSwitch {
|
||||
Live,
|
||||
@@ -330,6 +360,12 @@ enum ChatSwitch {
|
||||
ResumeFails,
|
||||
Unavailable,
|
||||
Idle,
|
||||
Uncached,
|
||||
NoEffort,
|
||||
DiscoveryFails,
|
||||
EffortUnavailable,
|
||||
EffortRejected,
|
||||
Superseded,
|
||||
}
|
||||
|
||||
async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
@@ -376,7 +412,21 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
}
|
||||
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
|
||||
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
|
||||
if matches!(scenario, ChatSwitch::Idle) {
|
||||
let offline = matches!(scenario, ChatSwitch::Idle | ChatSwitch::Uncached | ChatSwitch::Superseded);
|
||||
let missing_settings = matches!(
|
||||
scenario,
|
||||
ChatSwitch::Uncached | ChatSwitch::NoEffort | ChatSwitch::DiscoveryFails | ChatSwitch::Superseded
|
||||
);
|
||||
let no_effort = matches!(scenario, ChatSwitch::NoEffort);
|
||||
let effort_error = match scenario {
|
||||
ChatSwitch::EffortUnavailable => Some("no longer offers effort value thorough"),
|
||||
ChatSwitch::EffortRejected => Some("effort rejected by the agent"),
|
||||
_ => None,
|
||||
};
|
||||
let choose_effort = matches!(scenario, ChatSwitch::Uncached) || effort_error.is_some();
|
||||
let (catalog_models, catalog_effort): (&[&str], &[&str]) =
|
||||
if missing_settings { (&["old", "new"], &["low", "high"]) } else { (&["new", "old"], &["quick", "thorough"]) };
|
||||
if offline {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
}
|
||||
@@ -385,41 +435,122 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
|
||||
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
|
||||
next.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert_eq!(model_values(&catalog), catalog_models);
|
||||
if missing_settings {
|
||||
assert!(!catalog.thought_levels.contains_key("new"));
|
||||
}
|
||||
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
|
||||
|
||||
let live = matches!(scenario, ChatSwitch::Live);
|
||||
let offline = matches!(scenario, ChatSwitch::Idle);
|
||||
let resumed_launch = if missing_settings { 3 } else { 2 };
|
||||
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
|
||||
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
{
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
}
|
||||
}
|
||||
if missing_settings {
|
||||
let discovery = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((discovery.launch, discovery.method.as_str()), (2, "session/new"));
|
||||
discovery.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
|
||||
let set = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!(set.params, json!({"sessionId": "discovery-only", "configId": "model", "value": "new"}));
|
||||
assert_eq!(set.method, "session/set_config_option");
|
||||
assert!(
|
||||
manager
|
||||
.prompt(&task.id, AgentPrompt { text: "too early".into(), ..Default::default() }, false)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
if matches!(scenario, ChatSwitch::DiscoveryFails) {
|
||||
set.reply.send(Err("Sign in required".into())).unwrap();
|
||||
let error = switching.await.unwrap_err().to_string();
|
||||
assert!(error.contains("Sign in required"), "{error}");
|
||||
assert_eq!(manager.subscribe(Arc::new(|_| {})).remove(0).config, before_config);
|
||||
assert!(harness.pending.try_recv().is_err());
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
if matches!(scenario, ChatSwitch::Superseded) {
|
||||
manager.set_config(&task.id, "model", "old".into()).await.unwrap();
|
||||
set.reply.send(Ok(response(&["new", "old"], &["quick", "thorough"]))).unwrap();
|
||||
switching.await.unwrap();
|
||||
let task = manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("low"));
|
||||
assert!(harness.pending.try_recv().is_err());
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
let levels: &[&str] = if no_effort { &[] } else { &["quick", "thorough"] };
|
||||
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
|
||||
}
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not reopen the chat or send: {request:?}"),
|
||||
}
|
||||
}
|
||||
// A fallback selection settles without waiting for a new process.
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not open another session: {request:?}"),
|
||||
}
|
||||
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
|
||||
if matches!(scenario, ChatSwitch::Uncached) {
|
||||
let update = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
if let AgentEvent::Task { task: update } = events.recv().await.unwrap()
|
||||
&& update.id == task.id
|
||||
{
|
||||
break update;
|
||||
}
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let effort = update.config.iter().find(|o| o.id == "effort").unwrap();
|
||||
assert_eq!(effort.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["quick", "thorough"]);
|
||||
}
|
||||
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
|
||||
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
|
||||
let effort =
|
||||
|task: &crate::AgentTask| task.config.iter().find(|o| o.id == "effort").and_then(|o| o.current.clone());
|
||||
assert_eq!(
|
||||
effort(¤t).as_deref(),
|
||||
if live {
|
||||
Some("session-only")
|
||||
} else if no_effort {
|
||||
None
|
||||
} else {
|
||||
Some("quick")
|
||||
},
|
||||
"the new model's effort must be available before sending"
|
||||
);
|
||||
if choose_effort {
|
||||
assert!(manager.set_config(&task.id, "effort", "high".into()).await.is_err());
|
||||
manager.set_config(&task.id, "effort", "thorough".into()).await.unwrap();
|
||||
assert_eq!(effort(&snapshot(&manager)).as_deref(), Some("thorough"));
|
||||
if matches!(scenario, ChatSwitch::Uncached) {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let restored = snapshot(&manager);
|
||||
assert_eq!(restored.id, task.id);
|
||||
assert_eq!(effort(&restored).as_deref(), Some("thorough"));
|
||||
}
|
||||
}
|
||||
|
||||
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
|
||||
if !live {
|
||||
let load = harness.next().await;
|
||||
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
|
||||
assert_eq!((load.launch, load.method.as_str()), (resumed_launch, "session/load"));
|
||||
assert_eq!(load.params["sessionId"], "saved-chat");
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
@@ -447,6 +578,7 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
let task = snapshot(&manager);
|
||||
assert_eq!(task.model.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
assert_eq!(effort(&task).as_deref(), Some("low"));
|
||||
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
|
||||
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
|
||||
@@ -472,24 +604,60 @@ async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
return;
|
||||
}
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
|
||||
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
let levels: &[&str] = match scenario {
|
||||
ChatSwitch::NoEffort => &[],
|
||||
ChatSwitch::EffortUnavailable => &["session-only", "quick"],
|
||||
_ if choose_effort => &["session-only", "thorough"],
|
||||
_ => &["session-only"],
|
||||
};
|
||||
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
|
||||
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
if choose_effort && !matches!(scenario, ChatSwitch::EffortUnavailable) {
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "effort", "value": "thorough"}));
|
||||
let reply = if effort_error.is_some() {
|
||||
Err("effort rejected by the agent".into())
|
||||
} else {
|
||||
Ok(response(&["new", "old"], &["thorough", "session-only"]))
|
||||
};
|
||||
set.reply.send(reply).unwrap();
|
||||
}
|
||||
if let Some(expected) = effort_error {
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("old"));
|
||||
assert_eq!(effort(¤t).as_deref(), Some("low"));
|
||||
assert!(current.error.as_deref().unwrap().contains(expected), "{:?}", current.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send using a fallback effort");
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
}
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
|
||||
(if live { 0 } else { resumed_launch }, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("new"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
|
||||
assert_eq!(
|
||||
effort(¤t).as_deref(),
|
||||
if choose_effort {
|
||||
Some("thorough")
|
||||
} else if no_effort {
|
||||
None
|
||||
} else {
|
||||
Some("session-only")
|
||||
}
|
||||
);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
|
||||
manager.shutdown();
|
||||
}
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
use crate::model::{
|
||||
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
|
||||
AgentModelPricing, AgentUsage,
|
||||
AgentModelPricing, AgentTokens, AgentUsage,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
@@ -272,6 +272,18 @@ pub(crate) fn usage_of(update: &Value) -> Option<AgentUsage> {
|
||||
Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)?, cost })
|
||||
}
|
||||
|
||||
/// The `usage` of a `session/prompt` result: `{ inputTokens, cachedReadTokens, outputTokens }`.
|
||||
pub(crate) fn tokens_of(result: &Value) -> Option<AgentTokens> {
|
||||
let usage = result.get("usage")?;
|
||||
let tokens = |key: &str| usage.get(key).and_then(Value::as_u64).map_or(0, |n| u32::try_from(n).unwrap_or(u32::MAX));
|
||||
let tokens = AgentTokens {
|
||||
input: tokens("inputTokens"),
|
||||
cached: tokens("cachedReadTokens"),
|
||||
output: tokens("outputTokens"),
|
||||
};
|
||||
(tokens != AgentTokens::default()).then_some(tokens)
|
||||
}
|
||||
|
||||
/// The usage-limit windows a [`crate::LIMITS_UPDATE`] carries; malformed entries are skipped.
|
||||
pub(crate) fn limits_of(update: &Value) -> Vec<AgentLimit> {
|
||||
let limits = update.get("limits").and_then(Value::as_array).into_iter().flatten();
|
||||
@@ -368,6 +380,15 @@ mod tests {
|
||||
c.iter().map(|o| (o.id.as_str(), o.current.as_deref())).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hermes_prompt_result_reports_the_turns_tokens() {
|
||||
let result = json!({"stopReason": "end_turn", "usage": {"cachedReadTokens": 51306, "inputTokens": 77284,
|
||||
"outputTokens": 509, "thoughtTokens": 0, "totalTokens": 77793}});
|
||||
assert_eq!(tokens_of(&result), Some(AgentTokens { input: 77284, cached: 51306, output: 509 }));
|
||||
assert_eq!(tokens_of(&json!({"stopReason": "end_turn"})), None);
|
||||
assert_eq!(tokens_of(&json!({"usage": {}})), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_options_win_over_the_older_fields() {
|
||||
let r = json!({
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
//! Hermes Agent profiles on disk: `default` is the Hermes home itself, the others are
|
||||
//! `<home>/profiles/<name>` directories holding one of Hermes' identity files.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
|
||||
const PROFILE_FILES: &[&str] = &["config.yaml", ".env", "SOUL.md", "profile.yaml", "auth.json", "state.db"];
|
||||
|
||||
/// Hermes' home directory (`~/.hermes`; `%LOCALAPPDATA%\hermes` on Windows).
|
||||
pub fn root(home: Option<&Path>) -> Option<PathBuf> {
|
||||
#[cfg(windows)]
|
||||
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
|
||||
return Some(PathBuf::from(local).join("hermes"));
|
||||
}
|
||||
home.map(|h| h.join(".hermes"))
|
||||
}
|
||||
|
||||
/// The profile names under `root`: `default` first, then the others by name; none without `root`.
|
||||
pub fn profiles(root: &Path) -> Vec<String> {
|
||||
if !root.is_dir() {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut named: Vec<String> = std::fs::read_dir(root.join("profiles"))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.filter(|e| PROFILE_FILES.iter().any(|f| e.path().join(f).exists()))
|
||||
.filter_map(|e| e.file_name().to_str().map(str::to_owned))
|
||||
.filter(|name| name != "default")
|
||||
.collect();
|
||||
named.sort();
|
||||
std::iter::once("default".to_owned()).chain(named).collect()
|
||||
}
|
||||
|
||||
/// A profile and the name Hermes shows for it (`hermes profile list`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Type)]
|
||||
pub struct HermesProfile {
|
||||
/// What `hermes -p` takes; `default` is the Hermes home itself.
|
||||
pub name: String,
|
||||
/// `display_name` from the profile's `profile.yaml`, else the name.
|
||||
pub label: String,
|
||||
}
|
||||
|
||||
/// [`profiles`] with the names Hermes shows for them.
|
||||
pub fn labeled_profiles(root: &Path) -> Vec<HermesProfile> {
|
||||
profiles(root)
|
||||
.into_iter()
|
||||
.map(|name| {
|
||||
let home = if name == "default" { root.to_path_buf() } else { root.join("profiles").join(&name) };
|
||||
let label = display_name(&home).unwrap_or_else(|| name.clone());
|
||||
HermesProfile { name, label }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The top-level `display_name:` of `<home>/profile.yaml`, the only key read (no YAML parser).
|
||||
fn display_name(home: &Path) -> Option<String> {
|
||||
let text = std::fs::read_to_string(home.join("profile.yaml")).ok()?;
|
||||
let value = text.lines().find_map(|l| l.strip_prefix("display_name:"))?;
|
||||
let value = value.trim().trim_matches(['"', '\'']).trim();
|
||||
(!value.is_empty()).then(|| value.to_owned())
|
||||
}
|
||||
|
||||
/// The home of the profile an agent id stands for: `hermes` and `hermes-default` are the
|
||||
/// default profile, `hermes-<slug>` the profile whose name slugifies to `<slug>`.
|
||||
pub fn profile_home(root: &Path, provider: &str) -> Option<PathBuf> {
|
||||
let slug = match provider {
|
||||
"hermes" | "hermes-default" => return Some(root.to_path_buf()),
|
||||
_ => provider.strip_prefix("hermes-")?,
|
||||
};
|
||||
profiles(root).into_iter().find(|p| crate::provider::slugify_id(p) == slug).map(|p| root.join("profiles").join(p))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn lists_default_and_profiles_with_an_identity_file() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
assert!(profiles(&dir.path().join("missing")).is_empty());
|
||||
let root = dir.path().join(".hermes");
|
||||
std::fs::create_dir_all(root.join("profiles/empty")).unwrap();
|
||||
assert_eq!(profiles(&root), ["default"]);
|
||||
for (name, file) in [("work", "config.yaml"), ("Dom 2", "SOUL.md"), ("db", "state.db")] {
|
||||
std::fs::create_dir_all(root.join("profiles").join(name)).unwrap();
|
||||
std::fs::write(root.join("profiles").join(name).join(file), "").unwrap();
|
||||
}
|
||||
std::fs::write(root.join("profiles/stray.yaml"), "").unwrap();
|
||||
assert_eq!(profiles(&root), ["default", "Dom 2", "db", "work"]);
|
||||
assert_eq!(profile_home(&root, "hermes"), Some(root.clone()));
|
||||
assert_eq!(profile_home(&root, "hermes-dom-2"), Some(root.join("profiles/Dom 2")));
|
||||
assert_eq!(profile_home(&root, "hermes-empty"), None);
|
||||
assert_eq!(profile_home(&root, "claude"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn labels_profiles_with_their_display_name() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().join(".hermes");
|
||||
std::fs::create_dir_all(root.join("profiles/work")).unwrap();
|
||||
std::fs::write(root.join("profile.yaml"), "description: mine\ndisplay_name: \"qb\"\n").unwrap();
|
||||
std::fs::write(root.join("profiles/work/profile.yaml"), "ui_meta:\n display_name: nested\n").unwrap();
|
||||
let label = |name: &str, label: &str| HermesProfile { name: name.into(), label: label.into() };
|
||||
assert_eq!(labeled_profiles(&root), [label("default", "qb"), label("work", "work")]);
|
||||
std::fs::remove_file(root.join("profile.yaml")).unwrap();
|
||||
assert_eq!(labeled_profiles(&root)[0], label("default", "default"));
|
||||
}
|
||||
}
|
||||
+343
-116
@@ -14,6 +14,7 @@ mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
mod external;
|
||||
pub mod hermes;
|
||||
pub mod mcp;
|
||||
mod model;
|
||||
mod native;
|
||||
@@ -357,9 +358,11 @@ struct TaskFile {
|
||||
/// Settings the user chose, re-applied to every new or reloaded session.
|
||||
#[serde(default)]
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
/// Pending model option id in task files saved before pending settings were stored separately.
|
||||
#[serde(default, skip_serializing)]
|
||||
pending_model: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pending_switch: Option<PendingModel>,
|
||||
/// In the project's own checkout: files already changed when the task started.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
before: BTreeMap<String, worktree::Stamp>,
|
||||
@@ -384,6 +387,26 @@ struct TaskFile {
|
||||
title_renamed: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct PendingModel {
|
||||
model: AgentConfigChoice,
|
||||
candidate: Option<AgentConfigValue>,
|
||||
options: Vec<AgentConfigOption>,
|
||||
choices: Vec<AgentConfigChoice>,
|
||||
}
|
||||
|
||||
impl PendingModel {
|
||||
fn apply(&self, wanted: &mut Vec<AgentConfigChoice>, confirmed: &[AgentConfigOption]) {
|
||||
wanted.retain(|choice| {
|
||||
choice.id != self.model.id
|
||||
&& !self.options.iter().any(|o| o.id == choice.id)
|
||||
&& !confirmed.iter().any(|o| o.id == choice.id && config::is_per_model_option(o))
|
||||
});
|
||||
wanted.push(self.model.clone());
|
||||
wanted.extend(self.choices.iter().cloned());
|
||||
}
|
||||
}
|
||||
|
||||
/// The changed files of a checkout, stamped.
|
||||
type Snapshot = BTreeMap<String, worktree::Stamp>;
|
||||
|
||||
@@ -392,8 +415,9 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
pending_model: Option<String>,
|
||||
pending_model: Option<PendingModel>,
|
||||
model_choice: u64,
|
||||
discovering_model: Option<u64>,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
@@ -415,23 +439,43 @@ struct TaskState {
|
||||
}
|
||||
|
||||
impl TaskState {
|
||||
fn pending_model(&self) -> Option<&AgentConfigChoice> {
|
||||
let id = self.pending_model.as_deref()?;
|
||||
self.wanted.iter().find(|c| c.id == id)
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> AgentTask {
|
||||
let mut task = self.task.clone();
|
||||
if let Some(choice) = self.pending_model()
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
|
||||
if let Some(pending) = &self.pending_model
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == pending.model.id)
|
||||
{
|
||||
model.current = Some(choice.value.clone());
|
||||
model.current = Some(pending.model.value.clone());
|
||||
if let Some(candidate) = &pending.candidate
|
||||
&& !model.values.iter().any(|v| v.value == candidate.value)
|
||||
{
|
||||
model.values.push(candidate.clone());
|
||||
}
|
||||
task.config.retain(|o| !config::is_per_model_option(o));
|
||||
task.config.extend(pending.options.iter().cloned().map(|mut option| {
|
||||
if let Some(choice) = pending.choices.iter().find(|choice| choice.id == option.id) {
|
||||
option.current = Some(choice.value.clone());
|
||||
}
|
||||
option
|
||||
}));
|
||||
}
|
||||
task
|
||||
}
|
||||
}
|
||||
|
||||
struct DiscoveringModel<'a> {
|
||||
state: &'a Mutex<TaskState>,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
impl Drop for DiscoveringModel<'_> {
|
||||
fn drop(&mut self) {
|
||||
let mut s = self.state.lock();
|
||||
if s.discovering_model == Some(self.generation) {
|
||||
s.discovering_model = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A running agent and its session.
|
||||
#[derive(Clone)]
|
||||
struct Live {
|
||||
@@ -666,7 +710,8 @@ impl AgentManager {
|
||||
|
||||
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
|
||||
/// in the project: what the agent offered last time there, unadvertised builtins,
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed.
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed (for Hermes,
|
||||
/// its profile's skills).
|
||||
pub async fn commands(&self, provider: &str, task: Option<&str>) -> IdeResult<Vec<AgentCommand>> {
|
||||
let (provider, offered, cwd) = match task {
|
||||
Some(id) => {
|
||||
@@ -700,10 +745,18 @@ impl AgentManager {
|
||||
offered.push(command);
|
||||
}
|
||||
}
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
if provider == "hermes" || provider.starts_with("hermes-") {
|
||||
let found = blocking(move || {
|
||||
let profile = hermes::root(home.as_deref()).and_then(|root| hermes::profile_home(&root, &provider));
|
||||
Ok(profile.map(|p| skills::hermes(&p)).unwrap_or_default())
|
||||
})
|
||||
.await?;
|
||||
return Ok(skills::merge(offered, found));
|
||||
}
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
return Ok(offered);
|
||||
}
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
let found = blocking(move || Ok(skills::discover(&cwd, home.as_deref()))).await?;
|
||||
Ok(skills::merge(offered, found))
|
||||
}
|
||||
@@ -789,6 +842,7 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -796,6 +850,7 @@ impl AgentManager {
|
||||
entries: Vec::new(),
|
||||
wanted: Vec::new(),
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before: BTreeMap::new(),
|
||||
saved: None,
|
||||
touched: Some(BTreeSet::new()),
|
||||
@@ -905,6 +960,7 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -912,6 +968,7 @@ impl AgentManager {
|
||||
entries: Vec::new(),
|
||||
wanted: req.config,
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before,
|
||||
saved,
|
||||
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
|
||||
@@ -949,6 +1006,9 @@ impl AgentManager {
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
if s.discovering_model.is_some() {
|
||||
return Err(IdeError::unavailable("Model settings are still loading"));
|
||||
}
|
||||
if s.busy {
|
||||
let item = AgentQueued { id: uuid::Uuid::new_v4().simple().to_string(), prompt };
|
||||
if now {
|
||||
@@ -1068,6 +1128,24 @@ impl AgentManager {
|
||||
let task = self.task(id)?;
|
||||
let (target, change) = {
|
||||
let mut s = task.state.lock();
|
||||
let busy = s.busy;
|
||||
let archived = s.task.status == AgentStatus::Archived;
|
||||
if let Some(pending) = &mut s.pending_model
|
||||
&& let Some(target) = pending.options.iter().find(|o| o.id == option)
|
||||
{
|
||||
if archived || busy {
|
||||
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
|
||||
}
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
pending.choices.retain(|c| c.id != option);
|
||||
pending.choices.push(AgentConfigChoice { id: option.to_owned(), value });
|
||||
drop(s);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
@@ -1075,6 +1153,9 @@ impl AgentManager {
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if s.pending_model.is_some() && config::is_per_model_option(&target) {
|
||||
return Err(IdeError::invalid("This setting is not available on the selected model"));
|
||||
}
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
@@ -1083,8 +1164,12 @@ impl AgentManager {
|
||||
} else {
|
||||
let switching_model = target.category.as_deref() == Some("model");
|
||||
if switching_model {
|
||||
if s.pending_model.is_some() && s.busy {
|
||||
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
|
||||
}
|
||||
s.model_choice += 1;
|
||||
s.pending_model = None;
|
||||
s.discovering_model = None;
|
||||
}
|
||||
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
|
||||
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
|
||||
@@ -1116,33 +1201,19 @@ impl AgentManager {
|
||||
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
|
||||
{
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
let mut error = None;
|
||||
if levels.is_none()
|
||||
&& let Some(spec) = self.shared.spec(&provider)
|
||||
{
|
||||
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
|
||||
error = catalog.error;
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
}
|
||||
let levels = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
|
||||
// Another selection may have superseded this discovery while it was waiting.
|
||||
if task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
let Some(levels) = levels else {
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::unavailable(
|
||||
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
|
||||
));
|
||||
let levels = match levels {
|
||||
Ok(levels) => levels,
|
||||
Err(error) => {
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::unavailable(error));
|
||||
}
|
||||
};
|
||||
let mut s = task.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
@@ -1257,6 +1328,7 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
stats: Box::default(),
|
||||
..s.task.clone()
|
||||
};
|
||||
TaskFile {
|
||||
@@ -1265,6 +1337,7 @@ impl AgentManager {
|
||||
entries,
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
@@ -1310,6 +1383,8 @@ impl AgentManager {
|
||||
};
|
||||
s.session_id = None;
|
||||
s.pending_model = None;
|
||||
s.model_choice += 1;
|
||||
s.discovering_model = None;
|
||||
s.conversation = Conversation::default();
|
||||
// The fresh session reports its own usage; nothing carries over.
|
||||
s.task.usage = None;
|
||||
@@ -1908,6 +1983,24 @@ impl Task {
|
||||
let mut task = file.task;
|
||||
config::add_client_options(&task.provider, &mut task.config);
|
||||
let conversation = Conversation::restore(file.entries, file.subagents);
|
||||
let mut wanted = file.wanted;
|
||||
let pending_model = file.pending_switch.or_else(|| {
|
||||
let id = file.pending_model?;
|
||||
let index = wanted.iter().position(|choice| choice.id == id)?;
|
||||
let model = wanted.remove(index);
|
||||
if let Some(value) = task.model.clone() {
|
||||
wanted.push(AgentConfigChoice { id, value });
|
||||
}
|
||||
let catalog = shared.paths.catalogs.cached(&shared, &task.provider);
|
||||
let candidate = catalog
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.category.as_deref() == Some("model"))
|
||||
.and_then(|o| o.values.iter().find(|v| v.value == model.value))
|
||||
.cloned();
|
||||
let options = catalog.thought_levels.get(&model.value).cloned().unwrap_or_default();
|
||||
Some(PendingModel { model, candidate, options, choices: Vec::new() })
|
||||
});
|
||||
Arc::new(Self {
|
||||
id: task.id.clone(),
|
||||
shared,
|
||||
@@ -1915,9 +2008,10 @@ impl Task {
|
||||
task,
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
pending_model: file.pending_model,
|
||||
wanted,
|
||||
pending_model,
|
||||
model_choice: 0,
|
||||
discovering_model: None,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
@@ -2111,7 +2205,8 @@ impl Task {
|
||||
session_id: s.session_id.clone(),
|
||||
entries: s.conversation.main.entries.clone(),
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: s.pending_model.clone(),
|
||||
pending_model: None,
|
||||
pending_switch: s.pending_model.clone(),
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
@@ -2264,13 +2359,18 @@ impl Task {
|
||||
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
|
||||
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
|
||||
})?;
|
||||
let model_choice = {
|
||||
let selection = {
|
||||
let mut s = self.state.lock();
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
s.model_choice += 1;
|
||||
s.model_choice
|
||||
s.discovering_model = Some(s.model_choice);
|
||||
DiscoveringModel { state: &self.state, generation: s.model_choice }
|
||||
};
|
||||
let model_choice = selection.generation;
|
||||
// A prompt starting during the switch must not grab the peer we're about to recycle.
|
||||
let _connecting = self.connecting.lock().await;
|
||||
let connecting = self.connecting.lock().await;
|
||||
{
|
||||
let s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
@@ -2293,16 +2393,16 @@ impl Task {
|
||||
Ok(None)
|
||||
};
|
||||
|
||||
let accepted = {
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let pending = match result {
|
||||
Ok(Some(reply)) => {
|
||||
let refused = match result {
|
||||
Ok(Some(reply)) => {
|
||||
let (config, model) = {
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut s.task.config, options);
|
||||
} else if s.task.model.as_deref() != Some(value.as_str()) {
|
||||
@@ -2321,36 +2421,66 @@ impl Task {
|
||||
model.current = Some(value.clone());
|
||||
s.task.model = Some(value.clone());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
false
|
||||
}
|
||||
refused => {
|
||||
if s.session_id.is_none()
|
||||
|| live.as_ref().is_some_and(|l| !l.resumable)
|
||||
|| self.start_fresh.load(Ordering::Acquire)
|
||||
{
|
||||
return Err(IdeError::unavailable(
|
||||
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
|
||||
));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
true
|
||||
}
|
||||
};
|
||||
s.wanted.retain(|c| c.id != target.id);
|
||||
s.pending_model = pending.then(|| target.id.clone());
|
||||
s.wanted.push(AgentConfigChoice { id: target.id, value });
|
||||
(!pending).then(|| {
|
||||
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
|
||||
(s.task.config.clone(), model)
|
||||
})
|
||||
s.pending_model = None;
|
||||
s.wanted.retain(|c| c.id != target.id);
|
||||
s.wanted.push(AgentConfigChoice { id: target.id, value });
|
||||
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
|
||||
(s.task.config.clone(), model)
|
||||
};
|
||||
self.shared.remember(&provider, Some(&config), None, model.as_deref());
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
refused => refused,
|
||||
};
|
||||
if let Some((config, model)) = accepted {
|
||||
self.shared.remember(&provider, Some(&config), None, model.as_deref());
|
||||
} else {
|
||||
self.recycle_resumable_session();
|
||||
{
|
||||
let s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.session_id.is_none()
|
||||
|| live.as_ref().is_some_and(|l| !l.resumable)
|
||||
|| self.start_fresh.load(Ordering::Acquire)
|
||||
{
|
||||
return Err(IdeError::unavailable(
|
||||
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
|
||||
));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
}
|
||||
// Catalog discovery never owns the chat session. Let a newer model choice supersede it.
|
||||
drop(connecting);
|
||||
let options = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
|
||||
let _connecting = self.connecting.lock().await;
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
let options = options.map_err(IdeError::unavailable)?;
|
||||
let choices = s
|
||||
.pending_model
|
||||
.take()
|
||||
.filter(|pending| pending.model.value == value)
|
||||
.map(|pending| pending.choices)
|
||||
.unwrap_or_default();
|
||||
s.pending_model = Some(PendingModel {
|
||||
model: AgentConfigChoice { id: target.id, value },
|
||||
candidate: Some(candidate),
|
||||
options,
|
||||
choices,
|
||||
});
|
||||
}
|
||||
self.recycle_resumable_session();
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
Ok(())
|
||||
@@ -2536,7 +2666,13 @@ impl Task {
|
||||
.await;
|
||||
}
|
||||
match result {
|
||||
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
|
||||
Ok(v) => {
|
||||
if let Some(tokens) = config::tokens_of(&v) {
|
||||
self.state.lock().task.stats.tokens = Some(tokens);
|
||||
self.emit_task();
|
||||
}
|
||||
Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned())
|
||||
}
|
||||
Err(e) => Err(self.failure(e)),
|
||||
}
|
||||
}
|
||||
@@ -2612,10 +2748,9 @@ impl Task {
|
||||
}
|
||||
let (provider_id, cwd, saved, pending) = {
|
||||
let s = self.state.lock();
|
||||
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), s.pending_model.clone())
|
||||
};
|
||||
let pending_model = pending.as_ref().map(|(choice, _)| choice);
|
||||
let pending_model = pending.as_ref();
|
||||
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
@@ -2641,22 +2776,12 @@ impl Task {
|
||||
let live = match opened {
|
||||
Ok(live) => live,
|
||||
Err(err) => {
|
||||
if let Some((choice, previous)) = pending {
|
||||
let mut s = self.state.lock();
|
||||
if s.pending_model() == Some(&choice) {
|
||||
s.pending_model = None;
|
||||
s.wanted.retain(|c| c.id != choice.id);
|
||||
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
|
||||
model.current.clone_from(&previous);
|
||||
}
|
||||
s.task.model.clone_from(&previous);
|
||||
if let Some(value) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: choice.id, value });
|
||||
}
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
let mut s = self.state.lock();
|
||||
if pending.is_some() && s.pending_model == pending {
|
||||
s.pending_model = None;
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
return Err(err.message);
|
||||
}
|
||||
@@ -2671,7 +2796,7 @@ impl Task {
|
||||
spec: provider::ProviderSpec,
|
||||
cwd: &Path,
|
||||
saved: Option<String>,
|
||||
pending_model: Option<&AgentConfigChoice>,
|
||||
pending_model: Option<&PendingModel>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
@@ -2697,14 +2822,15 @@ impl Task {
|
||||
}
|
||||
});
|
||||
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
|
||||
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
|
||||
let client = Client::new(self, saved.as_deref().filter(|_| pending_model.is_some()));
|
||||
let handler = acp::Dialect::wrap(client.clone());
|
||||
let raw_peer =
|
||||
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
|
||||
(self.shared.connector)(&spec, cwd, handler.clone(), on_stderr).map_err(|e| SessionOpenError {
|
||||
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
|
||||
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
|
||||
})?;
|
||||
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
|
||||
let peer = acp::Conn::new(raw_peer, client);
|
||||
let peer = acp::Conn::new(raw_peer, handler);
|
||||
|
||||
let init = peer.initialize(&client_info()).await.map_err(|e| {
|
||||
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
|
||||
@@ -2803,7 +2929,13 @@ impl Task {
|
||||
|
||||
// The session's settings, then the user's choices on top.
|
||||
// A session that reports none keeps the last known ones, but what is set is unknown.
|
||||
let reported = config::options_of(&result);
|
||||
let mut reported = config::options_of(&result);
|
||||
if let Some(update) = client.take_opening_config()
|
||||
&& let Some(config) = update.get("configOptions")
|
||||
&& reported.iter().all(|o| o.category.as_deref() != Some("model"))
|
||||
{
|
||||
config::merge_update(&mut reported, config);
|
||||
}
|
||||
let known = !reported.is_empty();
|
||||
if known {
|
||||
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
|
||||
@@ -2811,19 +2943,33 @@ impl Task {
|
||||
let (mut options, mut wanted) = {
|
||||
let s = self.state.lock();
|
||||
let options = if known { reported } else { s.task.config.clone() };
|
||||
let wanted = s.wanted.clone();
|
||||
let mut wanted = s.wanted.clone();
|
||||
if let Some(pending) = pending_model {
|
||||
pending.apply(&mut wanted, &s.task.config);
|
||||
}
|
||||
(options, wanted)
|
||||
};
|
||||
config::add_client_options(provider_id, &mut options);
|
||||
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
|
||||
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
|
||||
Some(o) if o.category.as_deref() == Some("model") => 0,
|
||||
Some(o) if config::is_per_model_option(o) => 2,
|
||||
_ => 1,
|
||||
wanted.sort_by_key(|c| {
|
||||
if let Some(pending) = pending_model {
|
||||
if c == &pending.model {
|
||||
return 0;
|
||||
}
|
||||
if pending.choices.contains(c) {
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
match options.iter().find(|o| o.id == c.id) {
|
||||
Some(o) if o.category.as_deref() == Some("model") => 0,
|
||||
Some(o) if config::is_per_model_option(o) => 2,
|
||||
_ => 1,
|
||||
}
|
||||
});
|
||||
let mut model_options = known;
|
||||
for choice in &wanted {
|
||||
let pending = pending_model == Some(choice);
|
||||
let pending = pending_model.is_some_and(|p| &p.model == choice);
|
||||
let explicit = pending_model.is_some_and(|p| p.choices.contains(choice));
|
||||
if pending
|
||||
&& !options.iter().any(|o| {
|
||||
o.id == choice.id
|
||||
@@ -2836,6 +2982,19 @@ impl Task {
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if explicit
|
||||
&& (!model_options
|
||||
|| !options.iter().any(|o| {
|
||||
o.id == choice.id
|
||||
&& config::is_per_model_option(o)
|
||||
&& o.values.iter().any(|v| v.value == choice.value)
|
||||
}))
|
||||
{
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The selected model no longer offers {} value {}.", choice.id, choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
|
||||
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
|
||||
if o.id == config::CURSOR_APPROVAL {
|
||||
@@ -2847,7 +3006,7 @@ impl Task {
|
||||
if config::is_per_model_option(&o) && !model_options {
|
||||
continue;
|
||||
}
|
||||
let already = known && o.current.as_deref() == Some(choice.value.as_str());
|
||||
let already = (known || explicit) && o.current.as_deref() == Some(choice.value.as_str());
|
||||
if already || !o.values.iter().any(|v| v.value == choice.value) {
|
||||
continue;
|
||||
}
|
||||
@@ -2856,14 +3015,30 @@ impl Task {
|
||||
params["sessionId"] = json!(session_id);
|
||||
match peer.request::<_, Value>(method, params, None).await {
|
||||
Ok(reply) => {
|
||||
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
|
||||
let observed = client.take_opening_config();
|
||||
let report =
|
||||
if reply.get("configOptions").is_some() { &reply } else { observed.as_ref().unwrap_or(&reply) };
|
||||
if pending && !config::accepts_model(report, &o.id, &choice.value) {
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The reloaded session did not switch to model {}.", choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if let Some(fresh) = reply.get("configOptions") {
|
||||
if let Some(fresh) = report.get("configOptions") {
|
||||
config::merge_update(&mut options, fresh);
|
||||
if explicit
|
||||
&& !options.iter().any(|option| {
|
||||
option.id == choice.id && option.current.as_deref() == Some(choice.value.as_str())
|
||||
})
|
||||
{
|
||||
return Err(SessionOpenError {
|
||||
message: format!(
|
||||
"The selected model did not accept {} value {}.",
|
||||
choice.id, choice.value
|
||||
),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
model_options = true;
|
||||
} else if o.category.as_deref() == Some("model") {
|
||||
if o.current.as_deref() != Some(choice.value.as_str()) {
|
||||
@@ -2875,7 +3050,7 @@ impl Task {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
}
|
||||
Err(e) if pending => {
|
||||
Err(e) if pending || explicit => {
|
||||
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
|
||||
}
|
||||
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
|
||||
@@ -2885,6 +3060,16 @@ impl Task {
|
||||
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if let Some(pending) = pending_model {
|
||||
if s.pending_model.as_ref() != Some(pending) {
|
||||
return Err(SessionOpenError {
|
||||
message: "The pending model settings changed while reopening the session.".into(),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
let TaskState { task, wanted, .. } = &mut *s;
|
||||
pending.apply(wanted, &task.config);
|
||||
}
|
||||
s.task.model = model_of(&options).or(s.task.model.take());
|
||||
s.task.config = options;
|
||||
s.pending_model = None;
|
||||
@@ -2894,6 +3079,7 @@ impl Task {
|
||||
// The (re)started process runs nothing yet: whatever it reports next is all of it.
|
||||
s.background_tasks = Vec::new();
|
||||
s.task.background.clear();
|
||||
*client.opening_config.lock() = None;
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
@@ -3020,6 +3206,17 @@ impl Task {
|
||||
return;
|
||||
}
|
||||
if kind == "session_info_update" {
|
||||
let depth = update.pointer("/_meta/hermes/sessionProvenance/compressionDepth").and_then(Value::as_u64);
|
||||
if let Some(depth) = depth.and_then(|d| u32::try_from(d).ok()) {
|
||||
let changed = {
|
||||
let mut s = self.state.lock();
|
||||
std::mem::replace(&mut s.task.stats.compressions, depth) != depth
|
||||
};
|
||||
if changed {
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
// The agent's own title for the session replaces the first line of the prompt,
|
||||
// unless the user named the task.
|
||||
let title = update.get("title").and_then(Value::as_str).map(str::trim).filter(|t| !t.is_empty());
|
||||
@@ -3361,6 +3558,28 @@ impl Task {
|
||||
/// Answers the agent's requests on behalf of one task.
|
||||
struct Client {
|
||||
task: Weak<Task>,
|
||||
opening_config: Mutex<Option<OpeningConfig>>,
|
||||
}
|
||||
|
||||
/// Config replays belong to the candidate connection until its model and settings are confirmed.
|
||||
struct OpeningConfig {
|
||||
session: String,
|
||||
options: Option<Value>,
|
||||
}
|
||||
|
||||
impl Client {
|
||||
fn new(task: &Arc<Task>, opening_session: Option<&str>) -> Arc<Self> {
|
||||
Arc::new(Self {
|
||||
task: Arc::downgrade(task),
|
||||
opening_config: Mutex::new(
|
||||
opening_session.map(|id| OpeningConfig { session: id.to_owned(), options: None }),
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
fn take_opening_config(&self) -> Option<Value> {
|
||||
self.opening_config.lock().as_mut()?.options.take()
|
||||
}
|
||||
}
|
||||
|
||||
impl Handler for Client {
|
||||
@@ -3377,6 +3596,14 @@ impl Handler for Client {
|
||||
if method == "session/update"
|
||||
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
|
||||
{
|
||||
if update.get("sessionUpdate").and_then(Value::as_str) == Some("config_option_update")
|
||||
&& let Some(opening) = self.opening_config.lock().as_mut()
|
||||
{
|
||||
if params.get("sessionId").and_then(Value::as_str) == Some(opening.session.as_str()) {
|
||||
opening.options = Some(update.clone());
|
||||
}
|
||||
return;
|
||||
}
|
||||
task.on_update(params.get("sessionId").and_then(Value::as_str), update);
|
||||
}
|
||||
}
|
||||
@@ -3841,7 +4068,7 @@ fn entry_event(
|
||||
entry: &AgentEntry,
|
||||
) -> AgentEvent {
|
||||
let text = match entry {
|
||||
AgentEntry::Agent { text } | AgentEntry::Thought { text } => Some(text),
|
||||
AgentEntry::Agent { text } | AgentEntry::Thought { text, .. } => Some(text),
|
||||
_ => None,
|
||||
};
|
||||
let Some(text) = text else {
|
||||
|
||||
@@ -108,6 +108,29 @@ pub struct AgentTask {
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
/// Token counts of the last turn and context compressions, when the agent reports them.
|
||||
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
|
||||
#[serde(default)]
|
||||
pub stats: Box<AgentSessionStats>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentSessionStats {
|
||||
/// The last turn's tokens (`session/prompt` result `usage`).
|
||||
#[serde(default)]
|
||||
pub tokens: Option<AgentTokens>,
|
||||
/// How many times the agent compressed the conversation (Hermes `compressionDepth`).
|
||||
#[serde(default)]
|
||||
pub compressions: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentTokens {
|
||||
pub input: u32,
|
||||
pub cached: u32,
|
||||
pub output: u32,
|
||||
}
|
||||
|
||||
/// A task the agent runs in the background while the conversation goes on.
|
||||
@@ -479,6 +502,9 @@ pub enum AgentEntry {
|
||||
},
|
||||
Thought {
|
||||
text: String,
|
||||
/// When the reasoning started (ms since the epoch); `None` in tasks saved before.
|
||||
#[serde(default)]
|
||||
started_ms: Option<f64>,
|
||||
},
|
||||
Tool {
|
||||
id: String,
|
||||
@@ -490,6 +516,11 @@ pub enum AgentEntry {
|
||||
/// Text the tool reported (command output…), truncated.
|
||||
output: Option<String>,
|
||||
diffs: Vec<AgentToolDiff>,
|
||||
/// When the call started and ended (ms since the epoch); `None` in tasks saved before.
|
||||
#[serde(default)]
|
||||
started_ms: Option<f64>,
|
||||
#[serde(default)]
|
||||
ended_ms: Option<f64>,
|
||||
},
|
||||
Plan {
|
||||
items: Vec<AgentPlanItem>,
|
||||
|
||||
@@ -82,6 +82,7 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
|
||||
("kiro", "Kiro", Driver::Acp, &["kiro-cli", "acp"], "Run `kiro-cli login` in a terminal."),
|
||||
("vibe", "Mistral Vibe", Driver::Acp, &["vibe-acp"], "Run `vibe` in a terminal and sign in."),
|
||||
("omp", "OMP", Driver::Acp, &["omp", "acp"], "Run `omp` in a terminal and sign in."),
|
||||
("hermes", "Hermes Agent", Driver::Acp, &["hermes", "acp"], "Run `hermes model` in a terminal."),
|
||||
];
|
||||
|
||||
fn builtins() -> Vec<ProviderSpec> {
|
||||
@@ -503,7 +504,7 @@ fn validated_custom_id(id: &str) -> IdeResult<String> {
|
||||
}
|
||||
|
||||
/// Turns an `acp.json` server name into a file-stem id (`"My Agent!"` → `"my-agent"`).
|
||||
fn slugify_id(name: &str) -> String {
|
||||
pub(crate) fn slugify_id(name: &str) -> String {
|
||||
let mut id = String::with_capacity(name.len());
|
||||
for c in name.chars() {
|
||||
if c.is_ascii_alphanumeric() {
|
||||
@@ -716,6 +717,15 @@ mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn hermes_is_built_in_over_acp() {
|
||||
let spec = builtin_spec("hermes").unwrap();
|
||||
assert_eq!(spec.driver, Driver::Acp);
|
||||
let info = describe(&spec);
|
||||
assert_eq!((info.name.as_str(), info.command.as_str()), ("Hermes Agent", "hermes acp"));
|
||||
assert_eq!(info.login_hint.as_deref(), Some("Run `hermes model` in a terminal."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qoder_global_and_cn_editions_are_both_built_in() {
|
||||
let info = |id: &str| describe(&load(None, None).into_iter().find(|s| s.id == id).unwrap());
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Claude Code's slash commands on disk, for completion before (or without) a session:
|
||||
//! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`.
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`; and
|
||||
//! the skills of a Hermes profile (`<profile>/skills`).
|
||||
|
||||
use crate::{AgentCommand, AgentCommandSource};
|
||||
use std::collections::HashSet;
|
||||
@@ -34,6 +35,19 @@ pub(crate) fn discover(cwd: &Path, home: Option<&Path>) -> Vec<AgentCommand> {
|
||||
out
|
||||
}
|
||||
|
||||
/// The skills of a Hermes profile: `<profile>/skills/<skill>` and `<profile>/skills/<category>/<skill>`;
|
||||
/// the first of a name wins.
|
||||
pub(crate) fn hermes(profile: &Path) -> Vec<AgentCommand> {
|
||||
let root = profile.join("skills");
|
||||
let mut found = skills(&root);
|
||||
for category in sorted(&root).into_iter().filter(|p| !p.join("SKILL.md").exists()) {
|
||||
found.extend(skills(&category));
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
found.retain(|c| seen.insert(c.name.clone()));
|
||||
found
|
||||
}
|
||||
|
||||
/// `first` (the agent's own list) plus the commands of `more` it lacks.
|
||||
pub(crate) fn merge(first: Vec<AgentCommand>, more: Vec<AgentCommand>) -> Vec<AgentCommand> {
|
||||
let mut out = first;
|
||||
@@ -256,6 +270,24 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hermes_skills_flat_and_in_categories() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let profile = tmp.path();
|
||||
assert!(hermes(profile).is_empty());
|
||||
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan", "skills/empty"] {
|
||||
std::fs::create_dir_all(profile.join(dir)).unwrap();
|
||||
}
|
||||
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan"] {
|
||||
std::fs::write(profile.join(dir).join("SKILL.md"), "---\ndescription: d\n---\n").unwrap();
|
||||
}
|
||||
let names: Vec<_> = hermes(profile).into_iter().map(|c| (c.name, c.source)).collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
[("plan".to_owned(), AgentCommandSource::Skill), ("review".to_owned(), AgentCommandSource::Skill)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_without_claude_dirs() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -909,6 +909,27 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
mgr3.shutdown();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hermes_profiles_complete_their_own_skills() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let skill = |dir: &str, name: &str| {
|
||||
let dir = tmp.path().join(dir).join(name);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("SKILL.md"), format!("---\nname: {name}\ndescription: d\n---\n")).unwrap();
|
||||
};
|
||||
skill(".hermes/skills", "plan");
|
||||
skill(".hermes/profiles/dom/skills/home", "lights");
|
||||
std::fs::write(tmp.path().join(".hermes/profiles/dom/config.yaml"), "").unwrap();
|
||||
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), Arc::new(FakeAgent::default()));
|
||||
let names = |c: Vec<AgentCommand>| c.into_iter().map(|c| c.name).collect::<Vec<_>>();
|
||||
assert!(names(mgr.commands("hermes", None).await.unwrap()).contains(&"plan".to_owned()));
|
||||
let dom = names(mgr.commands("hermes-dom", None).await.unwrap());
|
||||
assert!(dom.contains(&"lights".to_owned()) && !dom.contains(&"plan".to_owned()));
|
||||
assert!(!names(mgr.commands("claude", None).await.unwrap()).contains(&"plan".to_owned()));
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1877,6 +1898,32 @@ async fn real_claude_task_in_a_worktree() {
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hermes_session_info_names_the_task_and_counts_compressions() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
// "again" ends the turn at once; the default prompt waits for a permission answer.
|
||||
.create(NewAgentTask { prompt: text("again"), provider: "claude".into(), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
let info = |title: &str, depth: u32| {
|
||||
json!({"sessionUpdate": "session_info_update", "title": title, "updatedAt": "2026-11-18T18:35:32.068362+00:00",
|
||||
"_meta": {"hermes": {"sessionProvenance": {"sessionKind": "root", "parentHermesSessionId": null,
|
||||
"compressionDepth": depth}}}})
|
||||
};
|
||||
handle.on_update(None, &info("Make a 3-step plan and carry it out: 1) list the…", 0));
|
||||
handle.on_update(None, &info("List files and edit notes.txt", 0));
|
||||
let t = handle.state.lock().task.clone();
|
||||
assert_eq!(t.title, "List files and edit notes.txt", "the agent's latest title wins");
|
||||
assert_eq!(t.stats.compressions, 0);
|
||||
handle.on_update(None, &info("List files and edit notes.txt", 2));
|
||||
assert_eq!(handle.state.lock().task.stats.compressions, 2);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1935,7 +1982,7 @@ async fn startup_warnings_survive_replay_and_restart_without_failing_the_task()
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
handle.replaying.store(true, Ordering::Release);
|
||||
handle.turn_started.store(false, Ordering::Release);
|
||||
let client = Client { task: Arc::downgrade(&handle) };
|
||||
let client = Client::new(&handle, None);
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
|
||||
client.on_notification(WARNING_NOTIFICATION, json!({}));
|
||||
@@ -3531,11 +3578,13 @@ fn streamed_text_is_sent_as_appends() {
|
||||
);
|
||||
let replaced = entry_event("t", &mut streamed, None, 3, &agent("Other"));
|
||||
assert!(matches!(replaced, AgentEvent::Entry { .. }), "text that doesn't extend the sent text is sent whole");
|
||||
let thought = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm…".into() });
|
||||
let thought = AgentEntry::Thought { text: "hmm…".into(), started_ms: None };
|
||||
let thought = entry_event("t", &mut streamed, None, 4, &thought);
|
||||
assert!(matches!(thought, AgentEvent::Entry { index: 4, .. }), "a new message starts whole");
|
||||
let tool = AgentEntry::Error { message: "x".into() };
|
||||
entry_event("t", &mut streamed, None, 4, &tool);
|
||||
let again = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm… ok".into() });
|
||||
let again = AgentEntry::Thought { text: "hmm… ok".into(), started_ms: None };
|
||||
let again = entry_event("t", &mut streamed, None, 4, &again);
|
||||
assert!(matches!(again, AgentEvent::Entry { .. }), "an entry replaced by another kind forgets its text");
|
||||
|
||||
let long = "é".repeat(5000);
|
||||
|
||||
@@ -85,6 +85,8 @@ impl Timeline {
|
||||
locations: locations(update.get("locations")),
|
||||
output: None,
|
||||
diffs: Vec::new(),
|
||||
started_ms: Some(crate::now_ms()),
|
||||
ended_ms: None,
|
||||
};
|
||||
let index = match self.tools.get(&id) {
|
||||
Some(&i) => {
|
||||
@@ -134,17 +136,22 @@ impl Timeline {
|
||||
fn append_text(&mut self, thought: bool, text: &str) -> usize {
|
||||
match self.entries.last_mut() {
|
||||
Some(AgentEntry::Agent { text: t }) if !thought => t.push_str(text),
|
||||
Some(AgentEntry::Thought { text: t }) if thought => t.push_str(text),
|
||||
Some(AgentEntry::Thought { text: t, .. }) if thought => t.push_str(text),
|
||||
_ => {
|
||||
let text = text.to_owned();
|
||||
return self.push(if thought { AgentEntry::Thought { text } } else { AgentEntry::Agent { text } });
|
||||
return self.push(if thought {
|
||||
AgentEntry::Thought { text, started_ms: Some(crate::now_ms()) }
|
||||
} else {
|
||||
AgentEntry::Agent { text }
|
||||
});
|
||||
}
|
||||
}
|
||||
self.entries.len() - 1
|
||||
}
|
||||
|
||||
fn merge_tool(&mut self, index: usize, update: &Value) {
|
||||
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, .. } = &mut self.entries[index]
|
||||
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, ended_ms, .. } =
|
||||
&mut self.entries[index]
|
||||
else {
|
||||
return;
|
||||
};
|
||||
@@ -156,6 +163,9 @@ impl Timeline {
|
||||
}
|
||||
if let Some(s) = tool_status(update.get("status")) {
|
||||
*status = s;
|
||||
if matches!(s, AgentToolStatus::Completed | AgentToolStatus::Failed) && ended_ms.is_none() {
|
||||
*ended_ms = Some(crate::now_ms());
|
||||
}
|
||||
}
|
||||
if update.get("locations").is_some_and(Value::is_array) {
|
||||
*locs = locations(update.get("locations"));
|
||||
@@ -183,6 +193,11 @@ impl Timeline {
|
||||
}
|
||||
}
|
||||
if !text.is_empty() {
|
||||
// The command a call announced (`$ cmd`) stays above the result that replaces it.
|
||||
let command = output.as_deref().and_then(|o| o.lines().next()).filter(|l| l.starts_with("$ "));
|
||||
if let Some(command) = command.filter(|c| !text.starts_with(c)) {
|
||||
text = format!("{command}\n{text}");
|
||||
}
|
||||
*output = Some(tail(text));
|
||||
}
|
||||
if !new_diffs.is_empty() {
|
||||
@@ -432,11 +447,14 @@ mod tests {
|
||||
assert_eq!(t.apply(&chunk("lo")).changed, vec![0]);
|
||||
t.apply(&json!({"sessionUpdate": "agent_thought_chunk", "content": {"type": "text", "text": "hmm"}}));
|
||||
t.apply(&chunk("again"));
|
||||
// The thought's start is the clock's: it is there, and the rest compares exactly.
|
||||
let AgentEntry::Thought { started_ms, .. } = &mut t.entries[1] else { panic!("{:?}", t.entries) };
|
||||
assert!(started_ms.take().is_some());
|
||||
assert_eq!(
|
||||
t.entries,
|
||||
vec![
|
||||
AgentEntry::Agent { text: "Hello".into() },
|
||||
AgentEntry::Thought { text: "hmm".into() },
|
||||
AgentEntry::Thought { text: "hmm".into(), started_ms: None },
|
||||
AgentEntry::Agent { text: "again".into() },
|
||||
]
|
||||
);
|
||||
@@ -528,6 +546,25 @@ mod tests {
|
||||
assert!(matches!(t.entries[2], AgentEntry::User { done_ms: None, .. }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hermes_terminal_call_keeps_its_command_and_times() {
|
||||
let text = |t: &str| serde_json::json!([{"type": "content", "content": {"type": "text", "text": t}}]);
|
||||
let mut t = Timeline::default();
|
||||
t.apply(&serde_json::json!({"sessionUpdate": "tool_call", "toolCallId": "tc-0b98b5e30a28",
|
||||
"kind": "execute", "title": "terminal: echo ok + 2 commands", "locations": [],
|
||||
"content": text("$ echo ok >> notes.txt && wc -l notes.txt")}));
|
||||
let AgentEntry::Tool { started_ms, ended_ms, .. } = &t.entries[0] else { panic!() };
|
||||
assert!(started_ms.is_some() && ended_ms.is_none());
|
||||
t.apply(&serde_json::json!({"sessionUpdate": "tool_call_update", "toolCallId": "tc-0b98b5e30a28",
|
||||
"kind": "execute", "status": "completed",
|
||||
"content": text("terminal result\n- **output:** 3 notes.txt\n- **exit_code:** 0")}));
|
||||
let AgentEntry::Tool { output, status, ended_ms, .. } = &t.entries[0] else { panic!() };
|
||||
assert_eq!(*status, AgentToolStatus::Completed);
|
||||
assert!(ended_ms.is_some());
|
||||
let expected = "$ echo ok >> notes.txt && wc -l notes.txt\nterminal result\n- **output:** 3 notes.txt\n";
|
||||
assert_eq!(output.as_deref(), Some(format!("{expected}- **exit_code:** 0").as_str()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn long_output_keeps_its_tail() {
|
||||
let s = tail("é".repeat(MAX_OUTPUT));
|
||||
|
||||
@@ -236,10 +236,9 @@ fn classpath(
|
||||
}
|
||||
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
|
||||
let top_dir = subdir(root, &target.top.dir);
|
||||
let status = ProcCommand::new(&target.top.command)
|
||||
.args(&args)
|
||||
.envs(&target.top.env)
|
||||
.current_dir(&top_dir)
|
||||
let mut command = ProcCommand::new(&target.top.command);
|
||||
command.args(&args).envs(&target.top.env).current_dir(&top_dir);
|
||||
let status = ide_core::process::prepare(&mut command)
|
||||
.output()
|
||||
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
|
||||
if !status.status.success() {
|
||||
|
||||
@@ -36,6 +36,8 @@ pub enum IdeEvent {
|
||||
},
|
||||
/// Project window membership or selection changed.
|
||||
WindowGroupsChanged,
|
||||
/// A project was loaded or unloaded for the MCP server without a window of its own.
|
||||
McpBackgroundProjectsChanged,
|
||||
/// A window entered or left full screen, itself or as a member of a full-screen window group.
|
||||
WindowFullscreenChanged,
|
||||
/// This remote window's connection to its host ended on its own (network loss, the host or
|
||||
@@ -87,6 +89,8 @@ pub enum IdeEvent {
|
||||
DocDirty {
|
||||
doc: DocId,
|
||||
dirty: bool,
|
||||
/// Text version when this transition occurred, including when it was saved.
|
||||
version: u32,
|
||||
},
|
||||
/// A complete workspace edit can be undone as one operation.
|
||||
WorkspaceEditApplied {
|
||||
|
||||
@@ -34,6 +34,8 @@ pub struct Settings {
|
||||
pub project_structure: ProjectStructureSettings,
|
||||
/// Version Control (Git, Commit, Confirmation, Issue Navigation).
|
||||
pub vcs: VcsSettings,
|
||||
/// Build, Execution, Deployment › Compiler (Build tool window).
|
||||
pub build: BuildSettings,
|
||||
/// Build, Execution, Deployment › Console.
|
||||
pub console: ConsoleSettings,
|
||||
pub debugger: DebuggerSettings,
|
||||
@@ -317,6 +319,20 @@ pub enum NewTaskApprovals {
|
||||
Ask,
|
||||
}
|
||||
|
||||
/// Which folders without an open window the MCP server still serves tools for.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum McpBackgroundProjects {
|
||||
/// Only projects open in a window.
|
||||
#[default]
|
||||
Off,
|
||||
/// Also folders the user trusts: trusted projects, recent projects and the repositories inside
|
||||
/// trusted locations.
|
||||
Trusted,
|
||||
/// Only the folders in [`McpServerSettings::background_project_paths`] (and below them).
|
||||
Listed,
|
||||
}
|
||||
|
||||
/// Agents › MCP Server: agents use the IDE's built-in tools.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -341,6 +357,21 @@ pub struct McpServerSettings {
|
||||
/// Keep the bearer token across runs (in the app data, readable by this user only) rather than
|
||||
/// make a new one each run.
|
||||
pub fixed_token: bool,
|
||||
/// Serve tools for folders that have no open window (see [`McpBackgroundProjects`]); the
|
||||
/// project loads when an agent first asks for it.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = McpBackgroundProjects)]
|
||||
pub background_projects: McpBackgroundProjects,
|
||||
/// The folders [`McpBackgroundProjects::Listed`] serves, and the ones `Trusted` serves even
|
||||
/// when untrusted.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = Vec<String>)]
|
||||
pub background_project_paths: Vec<String>,
|
||||
/// Minutes a background project may go without a tool call before it is unloaded, at most
|
||||
/// 1440; 0 keeps it until the IDE quits.
|
||||
pub background_idle_minutes: u32,
|
||||
/// Background projects loaded at once, 1 to 32; the least recently used one makes room.
|
||||
pub background_project_limit: u32,
|
||||
}
|
||||
|
||||
/// The default of [`McpServerSettings::port`].
|
||||
@@ -359,6 +390,10 @@ impl Default for McpServerSettings {
|
||||
fixed_port: true,
|
||||
port: DEFAULT_MCP_PORT,
|
||||
fixed_token: false,
|
||||
background_projects: McpBackgroundProjects::Off,
|
||||
background_project_paths: Vec::new(),
|
||||
background_idle_minutes: 30,
|
||||
background_project_limit: 8,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -508,6 +543,7 @@ impl Default for Settings {
|
||||
languages: LanguagesSettings::default(),
|
||||
project_structure: ProjectStructureSettings::default(),
|
||||
vcs: VcsSettings::default(),
|
||||
build: BuildSettings::default(),
|
||||
console: ConsoleSettings::default(),
|
||||
debugger: DebuggerSettings::default(),
|
||||
run: RunSettings::default(),
|
||||
@@ -1194,11 +1230,31 @@ pub struct ArduinoSettings {
|
||||
}
|
||||
|
||||
/// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct MarkdownSettings {
|
||||
/// Preview (and notebook Markdown cell) font size in px; unset follows the editor font size.
|
||||
pub preview_font_size: Option<u32>,
|
||||
/// "Detect commands that can be run right from Markdown files": gutter run icons on
|
||||
/// shell code blocks and on command lines in code blocks.
|
||||
pub run_commands: bool,
|
||||
/// Where those commands run; unset asks when the project and the file's folder differ.
|
||||
pub command_directory: Option<MarkdownCommandDirectory>,
|
||||
}
|
||||
|
||||
impl Default for MarkdownSettings {
|
||||
fn default() -> Self {
|
||||
Self { preview_font_size: None, run_commands: true, command_directory: None }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum MarkdownCommandDirectory {
|
||||
/// The project's root folder.
|
||||
Project,
|
||||
/// The Markdown file's parent folder.
|
||||
File,
|
||||
}
|
||||
|
||||
impl LanguagesSettings {
|
||||
@@ -2117,6 +2173,63 @@ mod tests {
|
||||
let restored: Settings = serde_json::from_value(value).unwrap();
|
||||
assert_eq!(restored, settings);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn background_projects_default_to_off_with_no_paths_30_idle_minutes_and_a_limit_of_8() {
|
||||
for settings in [Settings::default(), serde_json::from_str(r#"{"mcpServer":{"enabled":true}}"#).unwrap()] {
|
||||
let mcp = settings.mcp_server;
|
||||
assert_eq!(mcp.background_projects, McpBackgroundProjects::Off);
|
||||
assert!(mcp.background_project_paths.is_empty());
|
||||
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (30, 8));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_bad_background_mode_or_path_list_reads_as_its_default_and_keeps_the_rest() {
|
||||
for (key, bad) in
|
||||
[("backgroundProjects", serde_json::json!("bogus")), ("backgroundProjectPaths", serde_json::json!(5))]
|
||||
{
|
||||
let mut json = serde_json::json!({
|
||||
"appearance": { "theme": "solarized-dark" },
|
||||
"mcpServer": {
|
||||
"enabled": true,
|
||||
"port": 7000,
|
||||
"backgroundProjects": "listed",
|
||||
"backgroundProjectPaths": ["/projects/inventory"],
|
||||
"backgroundIdleMinutes": 10,
|
||||
"backgroundProjectLimit": 3,
|
||||
},
|
||||
});
|
||||
json["mcpServer"][key] = bad;
|
||||
let settings: Settings = serde_json::from_value(json).unwrap_or_else(|e| panic!("{key}: {e}"));
|
||||
let mcp = settings.mcp_server;
|
||||
let (mode, paths) = if key == "backgroundProjects" {
|
||||
(McpBackgroundProjects::Off, vec!["/projects/inventory".to_owned()])
|
||||
} else {
|
||||
(McpBackgroundProjects::Listed, Vec::new())
|
||||
};
|
||||
assert_eq!((mcp.background_projects, mcp.background_project_paths), (mode, paths), "{key}");
|
||||
assert_eq!((mcp.enabled, mcp.port), (true, 7000), "{key}");
|
||||
assert_eq!((mcp.background_idle_minutes, mcp.background_project_limit), (10, 3), "{key}");
|
||||
assert_eq!(settings.appearance.theme, "solarized-dark", "{key}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn background_project_settings_round_trip() {
|
||||
for mode in [McpBackgroundProjects::Off, McpBackgroundProjects::Trusted, McpBackgroundProjects::Listed] {
|
||||
let mut settings = Settings::default();
|
||||
settings.mcp_server.background_projects = mode;
|
||||
settings.mcp_server.background_project_paths =
|
||||
vec!["/projects/inventory".into(), "/projects/billing".into()];
|
||||
settings.mcp_server.background_idle_minutes = 0;
|
||||
settings.mcp_server.background_project_limit = 32;
|
||||
let json = serde_json::to_string(&settings).unwrap();
|
||||
assert!(json.contains(r#""backgroundProjects":""#), "{json}");
|
||||
let restored: Settings = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(restored.mcp_server, settings.mcp_server);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -170,6 +170,12 @@ pub struct CommitSettings {
|
||||
pub double_click_opens_diff: Option<bool>,
|
||||
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
|
||||
pub agent_instructions: String,
|
||||
/// The coding agent Generate Commit Message with Agent uses; empty follows the latest task's agent.
|
||||
pub agent: String,
|
||||
/// That agent's model for commit messages; empty keeps the model the agent would use.
|
||||
pub agent_model: String,
|
||||
/// That model's thinking level for commit messages; empty keeps the agent's.
|
||||
pub agent_effort: String,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
@@ -192,6 +198,9 @@ impl Default for CommitSettings {
|
||||
disabled_plugin_checks: Vec::new(),
|
||||
double_click_opens_diff: None,
|
||||
agent_instructions: String::new(),
|
||||
agent: String::new(),
|
||||
agent_model: String::new(),
|
||||
agent_effort: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -308,6 +317,23 @@ pub struct SqlResolutionScope {
|
||||
pub schema: String,
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Compiler (Build tool window behaviour).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct BuildSettings {
|
||||
/// When to open the Build tool window: `always` | `onError` | `never`.
|
||||
pub open_tool_window: String,
|
||||
/// When to focus the Build tool window: `always` | `onError` | `never`.
|
||||
pub focus_tool_window: String,
|
||||
}
|
||||
|
||||
impl Default for BuildSettings {
|
||||
fn default() -> Self {
|
||||
// Builds open the tool window without taking focus.
|
||||
Self { open_tool_window: "always".into(), focus_tool_window: "never".into() }
|
||||
}
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Console.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
|
||||
@@ -68,10 +68,16 @@ pub enum Incoming {
|
||||
Closed,
|
||||
}
|
||||
|
||||
/// Bounded outgoing queue: an adapter that stops reading its input holds back `send`
|
||||
/// instead of the IDE accumulating unbounded messages. The incoming queue stays unbounded:
|
||||
/// the event loop awaits requests while handling events (`stopped` restores breakpoints), so
|
||||
/// a reader parked on a full queue would never read the response that loop waits for.
|
||||
const OUT_CAPACITY: usize = 256;
|
||||
|
||||
type Pending = HashMap<i64, (String, oneshot::Sender<Result<Value, DapError>>)>;
|
||||
|
||||
struct Inner {
|
||||
out: mpsc::UnboundedSender<Vec<u8>>,
|
||||
out: mpsc::Sender<Vec<u8>>,
|
||||
pending: Mutex<Pending>,
|
||||
seq: AtomicI64,
|
||||
closed: AtomicBool,
|
||||
@@ -114,7 +120,7 @@ impl Connection {
|
||||
R: AsyncRead + Unpin + Send + 'static,
|
||||
W: AsyncWrite + Unpin + Send + 'static,
|
||||
{
|
||||
let (out_tx, mut out_rx) = mpsc::unbounded_channel::<Vec<u8>>();
|
||||
let (out_tx, mut out_rx) = mpsc::channel::<Vec<u8>>(OUT_CAPACITY);
|
||||
let (in_tx, in_rx) = mpsc::unbounded_channel();
|
||||
let inner = Arc::new(Inner {
|
||||
out: out_tx,
|
||||
@@ -183,17 +189,17 @@ impl Connection {
|
||||
self.inner.closed.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
fn send(&self, value: &Value) -> Result<(), DapError> {
|
||||
async fn send(&self, value: &Value) -> Result<(), DapError> {
|
||||
if self.is_closed() {
|
||||
return Err(DapError::Closed);
|
||||
}
|
||||
let body = serde_json::to_vec(value).map_err(|e| DapError::Protocol(e.to_string()))?;
|
||||
tracing::trace!(target: "ide_dap::wire", "--> {}", String::from_utf8_lossy(&body));
|
||||
self.inner.out.send(body).map_err(|_| DapError::Closed)
|
||||
self.inner.out.send(body).await.map_err(|_| DapError::Closed)
|
||||
}
|
||||
|
||||
/// Sends a request and returns a receiver for its response body, without waiting.
|
||||
pub fn send_request(
|
||||
pub async fn send_request(
|
||||
&self,
|
||||
command: &str,
|
||||
arguments: Value,
|
||||
@@ -205,7 +211,7 @@ impl Connection {
|
||||
if !arguments.is_null() {
|
||||
msg["arguments"] = arguments;
|
||||
}
|
||||
if let Err(e) = self.send(&msg) {
|
||||
if let Err(e) = self.send(&msg).await {
|
||||
self.inner.pending.lock().remove(&seq);
|
||||
return Err(e);
|
||||
}
|
||||
@@ -214,7 +220,7 @@ impl Connection {
|
||||
|
||||
/// Sends a request and waits for the response body (`null` when absent).
|
||||
pub async fn request(&self, command: &str, arguments: Value) -> Result<Value, DapError> {
|
||||
let rx = self.send_request(command, arguments)?;
|
||||
let rx = self.send_request(command, arguments).await?;
|
||||
rx.await.unwrap_or(Err(DapError::Closed))
|
||||
}
|
||||
|
||||
@@ -226,7 +232,12 @@ impl Connection {
|
||||
}
|
||||
|
||||
/// Answers a reverse request.
|
||||
pub fn respond(&self, request_seq: i64, command: &str, result: Result<Value, String>) -> Result<(), DapError> {
|
||||
pub async fn respond(
|
||||
&self,
|
||||
request_seq: i64,
|
||||
command: &str,
|
||||
result: Result<Value, String>,
|
||||
) -> Result<(), DapError> {
|
||||
let seq = self.inner.seq.fetch_add(1, Ordering::Relaxed);
|
||||
let mut msg = json!({
|
||||
"seq": seq,
|
||||
@@ -240,7 +251,7 @@ impl Connection {
|
||||
Ok(_) => {}
|
||||
Err(message) => msg["message"] = Value::String(message),
|
||||
}
|
||||
self.send(&msg)
|
||||
self.send(&msg).await
|
||||
}
|
||||
}
|
||||
|
||||
@@ -319,6 +330,62 @@ fn error_message(msg: &Value) -> String {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_handler_awaiting_a_request_still_gets_its_response_behind_an_event_burst() {
|
||||
// The event loop handles `stopped` by sending `setBreakpoints` and awaiting the reply
|
||||
// while the adapter keeps printing: the reply arrives behind thousands of events.
|
||||
let (client_in, mut adapter_out) = tokio::io::duplex(64 * 1024);
|
||||
let (client_out, adapter_in) = tokio::io::duplex(64 * 1024);
|
||||
let (conn, mut incoming) = Connection::start(client_in, client_out);
|
||||
let adapter = tokio::spawn(async move {
|
||||
let event =
|
||||
|seq: i64, event: &str| json!({"seq": seq, "type": "event", "event": event, "body": {"output": "x"}});
|
||||
framing::write_message(&mut adapter_out, event(0, "stopped").to_string().as_bytes()).await.unwrap();
|
||||
for i in 1..=5000 {
|
||||
framing::write_message(&mut adapter_out, event(i, "output").to_string().as_bytes()).await.unwrap();
|
||||
}
|
||||
let mut requests = BufReader::new(adapter_in);
|
||||
let request = framing::read_message(&mut requests).await.unwrap().unwrap();
|
||||
let request: Value = serde_json::from_slice(&request).unwrap();
|
||||
let response = json!({"seq": 5001, "type": "response", "request_seq": request["seq"], "success": true, "command": request["command"], "body": {"breakpoints": []}});
|
||||
framing::write_message(&mut adapter_out, response.to_string().as_bytes()).await.unwrap();
|
||||
adapter_out
|
||||
});
|
||||
let Some(Incoming::Event { event, .. }) = incoming.recv().await else { panic!("no event") };
|
||||
assert_eq!(event, "stopped");
|
||||
let reply = tokio::time::timeout(Duration::from_secs(10), conn.request("setBreakpoints", json!({})))
|
||||
.await
|
||||
.expect("the reader stalled behind the events")
|
||||
.unwrap();
|
||||
assert_eq!(reply, json!({"breakpoints": []}));
|
||||
let _ = adapter.await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn outgoing_commands_are_backpressured_when_the_adapter_is_slow() {
|
||||
let (writer, _unread_peer) = tokio::io::duplex(32 * 1024);
|
||||
let (reader, _idle_peer) = tokio::io::duplex(32 * 1024);
|
||||
// Nobody reads the writer's pipe, so it fills and the writer task stalls.
|
||||
let (conn, _incoming) = Connection::start(reader, writer);
|
||||
let producer_conn = conn.clone();
|
||||
let sent = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
let count = sent.clone();
|
||||
let producer = tokio::spawn(async move {
|
||||
for i in 0..2000 {
|
||||
let body = json!({"seq": i, "type": "event", "event": "output", "body": {"output": "x"}});
|
||||
if producer_conn.send(&body).await.is_err() {
|
||||
break;
|
||||
}
|
||||
count.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
});
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
assert!(sent.load(Ordering::Relaxed) < 2000);
|
||||
// The bounded queue held `send` back; closing cancels the writer task.
|
||||
conn.close();
|
||||
producer.abort();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_output_events_with_non_utf8_text() {
|
||||
// "中文" in GBK inside an output event, as netcoredbg sends it on a Chinese Windows.
|
||||
|
||||
@@ -1144,7 +1144,7 @@ impl DebugManager {
|
||||
let mut launch = if launch_in_config {
|
||||
None
|
||||
} else {
|
||||
let reply = s.conn.send_request(request, arguments.clone())?;
|
||||
let reply = s.conn.send_request(request, arguments.clone()).await?;
|
||||
Some(Box::pin(async move { reply.await.unwrap_or(Err(DapError::Closed)) }))
|
||||
};
|
||||
let mut initialized = s.initialized.subscribe();
|
||||
@@ -1222,7 +1222,7 @@ impl DebugManager {
|
||||
}
|
||||
if s.supports("supportsConfigurationDoneRequest") {
|
||||
if s.adapter == kotlin::ADAPTER {
|
||||
drop(s.conn.send_request("configurationDone", json!({}))?);
|
||||
drop(s.conn.send_request("configurationDone", json!({})).await?);
|
||||
} else {
|
||||
s.conn.request_timeout("configurationDone", Value::Null, REQUEST_TIMEOUT).await?;
|
||||
}
|
||||
@@ -1236,7 +1236,7 @@ impl DebugManager {
|
||||
}
|
||||
None => {
|
||||
// GDB 15: the breakpoints are in, so its `run` cannot miss them.
|
||||
let reply = s.conn.send_request(request, arguments)?;
|
||||
let reply = s.conn.send_request(request, arguments).await?;
|
||||
reply.await.unwrap_or(Err(DapError::Closed))?;
|
||||
}
|
||||
}
|
||||
@@ -1246,7 +1246,7 @@ impl DebugManager {
|
||||
// never answered), and the page is already loading: its document and first scripts
|
||||
// are not in the list.
|
||||
if js_debug::is_page(s) {
|
||||
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments())?;
|
||||
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments()).await?;
|
||||
let session = s.clone();
|
||||
// Not waited for here: the page runs on. A refusal is told to the Network view,
|
||||
// which would otherwise wait for requests that never come.
|
||||
|
||||
@@ -924,7 +924,11 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
|
||||
match command {
|
||||
"runInTerminal" => {
|
||||
let result = run_in_terminal(s, &args);
|
||||
let _ = s.conn.respond(seq, command, result);
|
||||
let conn = s.conn.clone();
|
||||
let command = command.to_owned();
|
||||
tokio::spawn(async move {
|
||||
let _ = conn.respond(seq, &command, result).await;
|
||||
});
|
||||
}
|
||||
"startDebugging" => {
|
||||
let mgr = mgr.clone();
|
||||
@@ -933,11 +937,15 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
|
||||
let request = args.get("request").and_then(Value::as_str).unwrap_or("launch").to_owned();
|
||||
let configuration = args.get("configuration").cloned().unwrap_or_else(|| json!({}));
|
||||
let result = mgr.start_child(&s, request, configuration).await;
|
||||
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message));
|
||||
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message)).await;
|
||||
});
|
||||
}
|
||||
_ => {
|
||||
let _ = s.conn.respond(seq, command, Err(format!("unsupported reverse request {command}")));
|
||||
let conn = s.conn.clone();
|
||||
let command = command.to_owned();
|
||||
tokio::spawn(async move {
|
||||
let _ = conn.respond(seq, &command, Err(format!("unsupported reverse request {command}"))).await;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
|
||||
|
||||
pub const MANIFEST_FILE: &str = "plugin.toml";
|
||||
/// The plugin API (engine) version this host implements.
|
||||
pub const ENGINE_VERSION: &str = "1.13.0";
|
||||
pub const ENGINE_VERSION: &str = "1.14.0";
|
||||
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
|
||||
pub const LEGACY_API: &str = "0.1";
|
||||
/// Marketplace categories, in the order they are shown.
|
||||
|
||||
@@ -98,6 +98,7 @@ async fn run(base: PathBuf) -> i32 {
|
||||
}));
|
||||
// A stable path for `--mcp-stdio` client configurations across server upgrades.
|
||||
host.mcp.set_stdio_link(base.join("bin").join("openidea-server"));
|
||||
host.mcp_background.serve_none();
|
||||
host.mcp.apply(&host);
|
||||
// The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
|
||||
let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
|
||||
|
||||
@@ -69,6 +69,8 @@ pub struct Host {
|
||||
pub mcp_requests: mcp::Requests,
|
||||
/// Commands agents run in the Run tool window (`run_command`).
|
||||
pub mcp_agent_runs: mcp::AgentRuns,
|
||||
/// Projects the MCP server serves without a window.
|
||||
pub mcp_background: mcp::BackgroundProjects,
|
||||
pub(crate) agent_catalogs: Arc<ide_agent::AgentCatalogs>,
|
||||
pub trust: trust::TrustStore,
|
||||
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
|
||||
@@ -125,10 +127,16 @@ pub struct Host {
|
||||
const EXIT_SHUTDOWN_WAIT: std::time::Duration = std::time::Duration::from_secs(10);
|
||||
|
||||
impl Host {
|
||||
/// Windows whose current project has this root.
|
||||
/// Windows whose current project has this root. A project served without a window
|
||||
/// has none.
|
||||
pub(crate) fn windows_for_root(&self, root: &std::path::Path) -> Vec<String> {
|
||||
let mut windows: Vec<_> =
|
||||
self.projects.read().iter().filter(|(_, p)| p.root == root).map(|(w, _)| w.clone()).collect();
|
||||
let mut windows: Vec<_> = self
|
||||
.projects
|
||||
.read()
|
||||
.iter()
|
||||
.filter(|(w, p)| p.root == root && !mcp::BackgroundProjects::is_key(w))
|
||||
.map(|(w, _)| w.clone())
|
||||
.collect();
|
||||
windows.sort();
|
||||
windows
|
||||
}
|
||||
@@ -159,6 +167,7 @@ impl Host {
|
||||
mcp_reports: Default::default(),
|
||||
mcp_requests: Default::default(),
|
||||
mcp_agent_runs: Default::default(),
|
||||
mcp_background: Default::default(),
|
||||
agent_catalogs: Arc::default(),
|
||||
trust: trust::TrustStore::load(&config_dir, &data_dir),
|
||||
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
|
||||
@@ -322,9 +331,18 @@ impl Host {
|
||||
}
|
||||
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
|
||||
project.plugin_diagnostics.close();
|
||||
// A project served without a window shares its files with a window whose root lies
|
||||
// around or below its own: their diagnostics stay.
|
||||
let background = mcp::BackgroundProjects::is_key(window);
|
||||
let shared = background
|
||||
&& self.projects.read().values().any(|other| {
|
||||
!other.light && (other.root.starts_with(&project.root) || project.root.starts_with(&other.root))
|
||||
});
|
||||
// The producers will re-report when a project reopens; until then the snapshot
|
||||
// must not answer for files whose project is gone.
|
||||
self.diagnostics.forget_root(&project.root);
|
||||
if !shared {
|
||||
self.diagnostics.forget_root(&project.root);
|
||||
}
|
||||
if let Some(plugins) = plugins::editor_plugin_host() {
|
||||
plugins.invalidate_client_navigation(&project.root, Some(window), None);
|
||||
plugins.set_active_file(window, None);
|
||||
@@ -355,7 +373,8 @@ impl Host {
|
||||
vec![project.notebooks.clone()],
|
||||
project.kotlin_bridge.iter().cloned().collect(),
|
||||
Some(project.lsp.clone()),
|
||||
Some((self.debugger.clone(), window.to_owned(), project.root.clone())),
|
||||
// Debug sessions under the root belong to windows: a project served without one starts none.
|
||||
Some((self.debugger.clone(), window.to_owned(), (!background).then(|| project.root.clone()))),
|
||||
Some(project),
|
||||
))
|
||||
}
|
||||
@@ -368,7 +387,7 @@ impl Host {
|
||||
notebooks: Vec<Arc<notebook::NotebookService>>,
|
||||
bridges: Vec<Arc<kotlin_bridge::KotlinBridge>>,
|
||||
lsp: Option<Arc<ide_lsp::LspManager>>,
|
||||
debug: Option<(Arc<ide_dap::DebugManager>, String, std::path::PathBuf)>,
|
||||
debug: Option<(Arc<ide_dap::DebugManager>, String, Option<std::path::PathBuf>)>,
|
||||
retired: Option<Arc<Project>>,
|
||||
) -> std::thread::JoinHandle<()> {
|
||||
for bridge in &bridges {
|
||||
@@ -395,7 +414,9 @@ impl Host {
|
||||
}
|
||||
if let Some((debug, key, root)) = debug {
|
||||
debug.stop_key(&key).await;
|
||||
debug.stop_under(&root).await;
|
||||
if let Some(root) = root {
|
||||
debug.stop_under(&root).await;
|
||||
}
|
||||
}
|
||||
});
|
||||
if let Some(retired) = retired {
|
||||
@@ -414,17 +435,22 @@ impl Host {
|
||||
}
|
||||
|
||||
fn wait_blocking(&self, shutdown: std::thread::JoinHandle<()>) {
|
||||
let wait = move || {
|
||||
Self::in_place(move || {
|
||||
if let Err(error) = shutdown.join() {
|
||||
tracing::error!("project shutdown thread failed: {error:?}");
|
||||
}
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/// Runs blocking work on this thread. On a worker of a multi-thread runtime the
|
||||
/// runtime is told first, so the worker's other tasks move to another thread.
|
||||
pub(crate) fn in_place<T>(work: impl FnOnce() -> T) -> T {
|
||||
if tokio::runtime::Handle::try_current()
|
||||
.is_ok_and(|handle| handle.runtime_flavor() == tokio::runtime::RuntimeFlavor::MultiThread)
|
||||
{
|
||||
tokio::task::block_in_place(wait);
|
||||
tokio::task::block_in_place(work)
|
||||
} else {
|
||||
wait();
|
||||
work()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,498 @@
|
||||
//! Projects the MCP server serves without a window ("background projects"): opened by a
|
||||
//! client's first tool call under the key `mcp:<root>` in the host's projects, held by the
|
||||
//! calls and runs in flight, unloaded when idle or when the limit needs room, and closed
|
||||
//! when a window opens the same root or the settings and trust decisions stop serving it.
|
||||
|
||||
mod policy;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use crate::{Host, Project};
|
||||
use ide_core::settings::McpBackgroundProjects;
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use parking_lot::{Mutex, RwLock};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
/// Starts the key of every background project; window labels never contain `:`.
|
||||
const KEY_PREFIX: &str = "mcp:";
|
||||
/// `mcpServer.backgroundIdleMinutes` counts up to a day.
|
||||
const MAX_IDLE_MINUTES: u32 = 24 * 60;
|
||||
/// `mcpServer.backgroundProjectLimit` stays within these bounds.
|
||||
const MIN_PROJECTS: u32 = 1;
|
||||
const MAX_PROJECTS: u32 = 32;
|
||||
/// How often idle projects are looked for.
|
||||
const SWEEP_EVERY: Duration = Duration::from_secs(30);
|
||||
|
||||
/// A project served without a window, as the IDE lists it.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpBackgroundProject {
|
||||
pub root: IpcPath,
|
||||
/// Seconds since its last tool call began or ended.
|
||||
pub idle_seconds: u32,
|
||||
/// Seconds until it is unloaded for being idle. Absent while something keeps it open
|
||||
/// and when idle projects are never unloaded.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
#[specta(optional)]
|
||||
pub unloads_in_seconds: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
#[specta(optional)]
|
||||
pub kept_open_by: Option<McpBackgroundHold>,
|
||||
}
|
||||
|
||||
/// What keeps an idle background project loaded.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum McpBackgroundHold {
|
||||
/// A tool call is in flight.
|
||||
Request,
|
||||
/// A run it started is alive; `name` is the first one's.
|
||||
Run { name: String },
|
||||
}
|
||||
|
||||
type Observer = Arc<dyn Fn() + Send + Sync>;
|
||||
|
||||
/// The background projects of one [`Host`].
|
||||
#[derive(Default)]
|
||||
pub struct BackgroundProjects {
|
||||
/// Serializes opens and unloads, and is held across the open itself. Taken before
|
||||
/// `state`, never with it held.
|
||||
gate: Mutex<()>,
|
||||
state: Mutex<State>,
|
||||
observer: RwLock<Option<Observer>>,
|
||||
/// Set by [`BackgroundProjects::serve_none`].
|
||||
serves_none: AtomicBool,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct State {
|
||||
entries: HashMap<PathBuf, Arc<Entry>>,
|
||||
/// Windows that are opening a root right now, counted per root.
|
||||
claims: HashMap<PathBuf, usize>,
|
||||
/// The root a background open under way is opening; the gate allows one at a time.
|
||||
opening: Option<PathBuf>,
|
||||
}
|
||||
|
||||
/// Marks the root of the open under way in [`State::opening`] until that open is over.
|
||||
struct Opening<'a>(&'a BackgroundProjects);
|
||||
|
||||
impl Drop for Opening<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.state.lock().opening = None;
|
||||
}
|
||||
}
|
||||
|
||||
struct Entry {
|
||||
/// Tool calls running in the project.
|
||||
in_flight: AtomicUsize,
|
||||
/// When a call last reached the project or left it.
|
||||
last_used: Mutex<Instant>,
|
||||
}
|
||||
|
||||
/// Keeps a background project loaded while a tool call runs in it.
|
||||
pub(crate) struct ActivityGuard(Arc<Entry>);
|
||||
|
||||
/// What answers a tool call: the window label or background key, the project, and the
|
||||
/// call's guard when the project is served in the background.
|
||||
pub(crate) type Served = (String, Arc<Project>, Option<ActivityGuard>);
|
||||
|
||||
impl Drop for ActivityGuard {
|
||||
fn drop(&mut self) {
|
||||
// The time first: a sweep that sees no call in flight then sees a fresh time.
|
||||
*self.0.last_used.lock() = Instant::now();
|
||||
self.0.in_flight.fetch_sub(1, Ordering::AcqRel);
|
||||
}
|
||||
}
|
||||
|
||||
/// A window is opening the root: no background project of it is opened meanwhile.
|
||||
pub(crate) struct Claim<'a> {
|
||||
owner: &'a BackgroundProjects,
|
||||
root: PathBuf,
|
||||
}
|
||||
|
||||
impl Drop for Claim<'_> {
|
||||
fn drop(&mut self) {
|
||||
let mut state = self.owner.state.lock();
|
||||
if let Some(count) = state.claims.get_mut(&self.root) {
|
||||
*count -= 1;
|
||||
if *count == 0 {
|
||||
state.claims.remove(&self.root);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// When [`BackgroundProjects::remove`] unloads a project.
|
||||
#[derive(Clone, Copy)]
|
||||
enum Only {
|
||||
Always,
|
||||
/// No call or run holds it.
|
||||
Unheld,
|
||||
/// Nothing holds it and it has been idle for the configured time at this moment.
|
||||
Idle(Instant),
|
||||
}
|
||||
|
||||
/// The inputs of [`policy::resolve`] at one moment.
|
||||
struct Policy {
|
||||
mode: McpBackgroundProjects,
|
||||
listed: Vec<PathBuf>,
|
||||
decisions: crate::trust::TrustDecisions,
|
||||
recents: Vec<PathBuf>,
|
||||
home: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl Policy {
|
||||
/// `None` when the MCP server or its background projects are off, and when the trust
|
||||
/// decisions cannot be read.
|
||||
fn current(host: &Host) -> Option<Self> {
|
||||
let settings = host.global_settings.effective().mcp_server;
|
||||
// Without the server no client is served, a request it accepted before it stopped included.
|
||||
if !settings.enabled || host.mcp_background.serves_none.load(Ordering::Relaxed) {
|
||||
return None;
|
||||
}
|
||||
let mode = settings.background_projects;
|
||||
let by_trust = match mode {
|
||||
McpBackgroundProjects::Off => return None,
|
||||
McpBackgroundProjects::Trusted => true,
|
||||
McpBackgroundProjects::Listed => false,
|
||||
};
|
||||
let recents = if by_trust { ide_workspace::RecentProjects::load(&host.config_dir).paths() } else { Vec::new() };
|
||||
Some(Self {
|
||||
mode,
|
||||
listed: settings.background_project_paths.iter().map(PathBuf::from).collect(),
|
||||
decisions: host.trust.decisions().ok()?,
|
||||
recents,
|
||||
home: dirs::home_dir(),
|
||||
})
|
||||
}
|
||||
|
||||
fn resolve(&self, path: &Path) -> Option<PathBuf> {
|
||||
policy::resolve(self.mode, &self.listed, &self.decisions, &self.recents, self.home.as_deref(), path)
|
||||
}
|
||||
}
|
||||
|
||||
/// The root of the project that serves `path` in the background under the current
|
||||
/// settings and trust decisions. Opens nothing.
|
||||
pub(crate) fn serving_root(host: &Host, path: &Path) -> Option<PathBuf> {
|
||||
Policy::current(host)?.resolve(path)
|
||||
}
|
||||
|
||||
/// How long a project may stay idle; `None` when `minutes` is 0 (never unloaded).
|
||||
fn idle_limit(minutes: u32) -> Option<Duration> {
|
||||
(minutes > 0).then(|| Duration::from_secs(u64::from(minutes.min(MAX_IDLE_MINUTES)) * 60))
|
||||
}
|
||||
|
||||
fn project_limit(limit: u32) -> usize {
|
||||
limit.clamp(MIN_PROJECTS, MAX_PROJECTS) as usize
|
||||
}
|
||||
|
||||
fn whole_seconds(time: Duration) -> u32 {
|
||||
u32::try_from(time.as_secs()).unwrap_or(u32::MAX)
|
||||
}
|
||||
|
||||
/// What keeps the project at `root` loaded, a call before a run.
|
||||
fn hold(host: &Host, root: &Path, entry: &Entry) -> Option<McpBackgroundHold> {
|
||||
if entry.in_flight.load(Ordering::Acquire) > 0 {
|
||||
return Some(McpBackgroundHold::Request);
|
||||
}
|
||||
host.processes.running_in(root).into_iter().next().map(|run| McpBackgroundHold::Run { name: run.name })
|
||||
}
|
||||
|
||||
impl BackgroundProjects {
|
||||
/// The key of the background project at `root` in the host's projects.
|
||||
pub fn key(root: &Path) -> String {
|
||||
format!("{KEY_PREFIX}{}", root.display())
|
||||
}
|
||||
|
||||
/// Serves no project in the background, whatever the settings say: the remote server,
|
||||
/// which exists for its window's project and holds no trust decisions of its own.
|
||||
pub fn serve_none(&self) {
|
||||
self.serves_none.store(true, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
/// Whether `window` is the key of a background project and not a window's label.
|
||||
pub fn is_key(window: &str) -> bool {
|
||||
window.starts_with(KEY_PREFIX)
|
||||
}
|
||||
|
||||
/// The loaded background project at `root`. Leaves its idle time alone.
|
||||
pub(crate) fn project(&self, host: &Host, root: &Path) -> Option<Arc<Project>> {
|
||||
self.state.lock().entries.contains_key(root).then(|| host.project(&Self::key(root)).ok()).flatten()
|
||||
}
|
||||
|
||||
/// The project that answers a tool call for `root`, opened now unless it is loaded: its
|
||||
/// key, the project and the guard of the call, which counts as in flight from here on,
|
||||
/// so nothing unloads the project before the call runs. A window that opened the root
|
||||
/// meanwhile answers instead, with its label and no guard. Refused while a window is
|
||||
/// opening the root, when the settings and trust decisions do not serve it, and when
|
||||
/// the limit is reached with every loaded project held.
|
||||
pub(crate) fn open(&self, host: &Host, root: &Path) -> IdeResult<Served> {
|
||||
let key = Self::key(root);
|
||||
// Without the gate, which the open of another root may hold for seconds.
|
||||
if let Some((project, call)) = self.reach(host, root, &key) {
|
||||
return Ok((key, project, Some(call)));
|
||||
}
|
||||
let mut changed = false;
|
||||
let opened = {
|
||||
let _gate = self.gate.lock();
|
||||
self.open_gated(host, root, &key, &mut changed)
|
||||
};
|
||||
if changed {
|
||||
self.notify();
|
||||
}
|
||||
opened
|
||||
}
|
||||
|
||||
/// The loaded project at `root`, with a call entered in it.
|
||||
fn reach(&self, host: &Host, root: &Path, key: &str) -> Option<(Arc<Project>, ActivityGuard)> {
|
||||
let call = {
|
||||
// Under `state`, so an unload either sees the call or has removed the entry.
|
||||
let state = self.state.lock();
|
||||
let entry = state.entries.get(root)?.clone();
|
||||
entry.in_flight.fetch_add(1, Ordering::AcqRel);
|
||||
*entry.last_used.lock() = Instant::now();
|
||||
ActivityGuard(entry)
|
||||
};
|
||||
// A project closed behind its entry drops the guard here; the gated open replaces both.
|
||||
host.project(key).ok().map(|project| (project, call))
|
||||
}
|
||||
|
||||
fn open_gated(&self, host: &Host, root: &Path, key: &str, changed: &mut bool) -> IdeResult<Served> {
|
||||
// Another call opened it while this one waited for the gate.
|
||||
if let Some((project, call)) = self.reach(host, root, key) {
|
||||
return Ok((key.to_owned(), project, Some(call)));
|
||||
}
|
||||
if let Some((window, project)) = host.window_project(root) {
|
||||
return Ok((window, project, None));
|
||||
}
|
||||
let _opening = {
|
||||
let mut state = self.state.lock();
|
||||
if state.claims.contains_key(root) {
|
||||
return Err(IdeError::unavailable(format!("{} is opening in a window; retry", root.display())));
|
||||
}
|
||||
// An entry whose project was closed behind its back would count against the limit.
|
||||
*changed |= state.entries.remove(root).is_some();
|
||||
// In the same step as the look at the claims: a window that claims the root from
|
||||
// here on sees this open and waits for it.
|
||||
state.opening = Some(root.to_path_buf());
|
||||
Opening(self)
|
||||
};
|
||||
if serving_root(host, root).as_deref() != Some(root) {
|
||||
return Err(IdeError::unavailable(format!("{} is not served in the background", root.display())));
|
||||
}
|
||||
let limit = project_limit(host.global_settings.effective().mcp_server.background_project_limit);
|
||||
while self.state.lock().entries.len() >= limit {
|
||||
let Some(idle) = self.longest_idle(host) else {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"the limit of {limit} background projects is reached and all are busy"
|
||||
)));
|
||||
};
|
||||
// A call that entered it meanwhile keeps it; the loop then looks again.
|
||||
*changed |= self.remove(host, &idle, Only::Unheld);
|
||||
}
|
||||
let project = host.open_project(key, root)?;
|
||||
// Entered from the start: the next open cannot evict it before this call runs.
|
||||
let entry = Arc::new(Entry { in_flight: AtomicUsize::new(1), last_used: Mutex::new(Instant::now()) });
|
||||
self.state.lock().entries.insert(root.to_path_buf(), entry.clone());
|
||||
if let Some(plugins) = host.plugin_host() {
|
||||
plugins.reopen_client(key);
|
||||
}
|
||||
*changed = true;
|
||||
Ok((key.to_owned(), project, Some(ActivityGuard(entry))))
|
||||
}
|
||||
|
||||
/// Unloads the background project at `root` and stops what it started; its workers
|
||||
/// finish shutting down in the background. It waits for a background open that is under
|
||||
/// way, so call it from a blocking context. With `only_if_idle`, a project that a call
|
||||
/// or a run holds, or that is not idle for the configured time at that moment, stays.
|
||||
/// `false` when nothing was unloaded, an unknown root included.
|
||||
pub fn detach(&self, host: &Host, root: &Path, only_if_idle: Option<Instant>) -> bool {
|
||||
let removed = {
|
||||
let _gate = self.gate.lock();
|
||||
self.remove(host, root, only_if_idle.map_or(Only::Always, Only::Idle))
|
||||
};
|
||||
if removed {
|
||||
self.notify();
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
/// The single way a background project closes. The caller holds the gate.
|
||||
fn remove(&self, host: &Host, root: &Path, only: Only) -> bool {
|
||||
// Before `state`: the runs have a lock of their own.
|
||||
let running = !host.processes.running_in(root).is_empty();
|
||||
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
|
||||
{
|
||||
let mut state = self.state.lock();
|
||||
let Some(entry) = state.entries.get(root) else { return false };
|
||||
let held = running || entry.in_flight.load(Ordering::Acquire) > 0;
|
||||
let idle = |now: Instant| {
|
||||
may_idle.is_some_and(|limit| now.saturating_duration_since(*entry.last_used.lock()) >= limit)
|
||||
};
|
||||
let stays = match only {
|
||||
Only::Always => false,
|
||||
Only::Unheld => held,
|
||||
Only::Idle(now) => held || !idle(now),
|
||||
};
|
||||
if stays {
|
||||
return false;
|
||||
}
|
||||
state.entries.remove(root);
|
||||
}
|
||||
let key = Self::key(root);
|
||||
if let Some(plugins) = host.plugin_host() {
|
||||
plugins.forget_client(&key);
|
||||
}
|
||||
host.close_project_detached(&key);
|
||||
true
|
||||
}
|
||||
|
||||
/// The projects no call or run holds that have been idle for the configured time at `now`.
|
||||
pub(crate) fn sweep_candidates(&self, host: &Host, now: Instant) -> Vec<PathBuf> {
|
||||
let minutes = host.global_settings.effective().mcp_server.background_idle_minutes;
|
||||
let Some(limit) = idle_limit(minutes) else { return Vec::new() };
|
||||
let idle = |entry: &Entry| now.saturating_duration_since(*entry.last_used.lock()) >= limit;
|
||||
let entries = self.entries().into_iter();
|
||||
entries.filter(|(root, entry)| idle(entry) && hold(host, root, entry).is_none()).map(|(root, _)| root).collect()
|
||||
}
|
||||
|
||||
/// Unloads the projects that are idle at `now`; each is checked again as it is unloaded.
|
||||
pub(crate) fn sweep(&self, host: &Host, now: Instant) {
|
||||
for root in self.sweep_candidates(host, now) {
|
||||
self.detach(host, &root, Some(now));
|
||||
}
|
||||
}
|
||||
|
||||
/// A window is about to open `root`: unloads the root's background project and keeps
|
||||
/// another from opening until the claim drops. It waits for a background open only when
|
||||
/// the root is loaded or is the one being opened; a window on any other folder goes on
|
||||
/// at once.
|
||||
pub(crate) fn claim(&self, host: &Host, root: &Path) -> Claim<'_> {
|
||||
let contested = {
|
||||
let mut state = self.state.lock();
|
||||
// From here no background open of the root gets past its look at the claims.
|
||||
*state.claims.entry(root.to_path_buf()).or_default() += 1;
|
||||
state.entries.contains_key(root) || state.opening.as_deref() == Some(root)
|
||||
};
|
||||
let claim = Claim { owner: self, root: root.to_path_buf() };
|
||||
if contested {
|
||||
let removed = {
|
||||
let _gate = self.gate.lock();
|
||||
self.remove(host, root, Only::Always)
|
||||
};
|
||||
if removed {
|
||||
self.notify();
|
||||
}
|
||||
}
|
||||
claim
|
||||
}
|
||||
|
||||
/// Waits for a background open that is under way. After it, the project that open
|
||||
/// read its settings and trust for is registered, and an open that starts later reads
|
||||
/// what is stored now.
|
||||
pub(crate) fn wait_for_open(&self) {
|
||||
drop(self.gate.lock());
|
||||
}
|
||||
|
||||
/// The loaded background projects at `now`, sorted by root.
|
||||
pub fn snapshot(&self, host: &Host, now: Instant) -> Vec<McpBackgroundProject> {
|
||||
let may_idle = idle_limit(host.global_settings.effective().mcp_server.background_idle_minutes);
|
||||
let mut projects: Vec<_> = self
|
||||
.entries()
|
||||
.into_iter()
|
||||
.map(|(root, entry)| {
|
||||
let idle = now.saturating_duration_since(*entry.last_used.lock());
|
||||
let kept_open_by = hold(host, &root, &entry);
|
||||
let unloads_in = may_idle.filter(|_| kept_open_by.is_none()).map(|limit| limit.saturating_sub(idle));
|
||||
McpBackgroundProject {
|
||||
root: root.into(),
|
||||
idle_seconds: whole_seconds(idle),
|
||||
unloads_in_seconds: unloads_in.map(whole_seconds),
|
||||
kept_open_by,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
projects.sort_by(|a, b| a.root.cmp(&b.root));
|
||||
projects
|
||||
}
|
||||
|
||||
fn entries(&self) -> Vec<(PathBuf, Arc<Entry>)> {
|
||||
self.state.lock().entries.iter().map(|(root, entry)| (root.clone(), entry.clone())).collect()
|
||||
}
|
||||
|
||||
/// The project nothing holds that was used the longest ago.
|
||||
fn longest_idle(&self, host: &Host) -> Option<PathBuf> {
|
||||
let unheld = self.entries().into_iter().filter(|(root, entry)| hold(host, root, entry).is_none());
|
||||
unheld.min_by_key(|(_, entry)| *entry.last_used.lock()).map(|(root, _)| root)
|
||||
}
|
||||
|
||||
/// Tells the observer that the loaded projects changed. Never called with a lock of
|
||||
/// this type held.
|
||||
fn notify(&self) {
|
||||
let observer = self.observer.read().clone();
|
||||
if let Some(observer) = observer {
|
||||
observer();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Host {
|
||||
/// The window, and its project, that has `root` open as a project (not in LightEdit).
|
||||
fn window_project(&self, root: &Path) -> Option<(String, Arc<Project>)> {
|
||||
let projects = self.projects.read();
|
||||
let windows = projects.iter().filter(|(w, p)| !BackgroundProjects::is_key(w) && !p.light && p.root == root);
|
||||
windows.min_by_key(|(w, _)| w.as_str()).map(|(w, p)| (w.clone(), p.clone()))
|
||||
}
|
||||
|
||||
/// Unloads the background projects the settings and trust decisions no longer serve:
|
||||
/// all of them when the MCP server is off, otherwise each whose root no longer serves
|
||||
/// itself. Call it after either changes, from a blocking context: it reads the recent
|
||||
/// projects and waits for a background open that is under way.
|
||||
pub fn apply_background_policy(&self) {
|
||||
// First: a project that is being opened under the old settings has no entry yet.
|
||||
self.mcp_background.wait_for_open();
|
||||
let roots: Vec<PathBuf> = self.mcp_background.entries().into_iter().map(|(root, _)| root).collect();
|
||||
if roots.is_empty() {
|
||||
return;
|
||||
}
|
||||
let policy = Policy::current(self);
|
||||
for root in roots {
|
||||
if policy.as_ref().and_then(|policy| policy.resolve(&root)).as_deref() != Some(&root) {
|
||||
self.mcp_background.detach(self, &root, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts the timer that unloads idle background projects for as long as the host lives.
|
||||
pub fn start_background_sweeper(self: &Arc<Self>) {
|
||||
let host = Arc::downgrade(self);
|
||||
self.runtime.spawn(async move {
|
||||
let mut tick = tokio::time::interval(SWEEP_EVERY);
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
tick.tick().await;
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let Some(host) = host.upgrade() else { break };
|
||||
// The timer's clock, so a sweep and its tick agree on the time.
|
||||
let now = tokio::time::Instant::now().into_std();
|
||||
// An unload waits for the gate, which an open in flight holds: off the async workers.
|
||||
let sweep = tokio::task::spawn_blocking(move || host.mcp_background.sweep(&host, now));
|
||||
if let Err(error) = sweep.await {
|
||||
tracing::warn!(%error, "sweeping idle background projects failed");
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Sets what is told when a background project is opened or unloaded. It runs on the
|
||||
/// thread that made the change, outside the locks of the background projects.
|
||||
pub fn set_background_projects_observer(&self, observer: Arc<dyn Fn() + Send + Sync>) {
|
||||
*self.mcp_background.observer.write() = Some(observer);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
//! Which folder serves a client's path as a background project: a pure function of the
|
||||
//! setting, the listed folders, the trust decisions, the recent projects and the project
|
||||
//! markers on disk.
|
||||
|
||||
use crate::trust::TrustDecisions;
|
||||
use ide_core::settings::McpBackgroundProjects;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// The root of the background project that serves `path`: the innermost of the `listed`
|
||||
/// folders containing it and, in `Trusted` mode, of the trusted projects, the trusted recent
|
||||
/// projects and the nearest trusted folder with a project marker. `None` when the mode is
|
||||
/// `Off`, when `path` is relative or missing, and when no folder qualifies. Listed and
|
||||
/// recent folders that are gone or not absolute paths are skipped.
|
||||
pub(crate) fn resolve(
|
||||
mode: McpBackgroundProjects,
|
||||
listed: &[PathBuf],
|
||||
decisions: &TrustDecisions,
|
||||
recents: &[PathBuf],
|
||||
home: Option<&Path>,
|
||||
path: &Path,
|
||||
) -> Option<PathBuf> {
|
||||
let by_trust = match mode {
|
||||
McpBackgroundProjects::Off => return None,
|
||||
McpBackgroundProjects::Trusted => true,
|
||||
McpBackgroundProjects::Listed => false,
|
||||
};
|
||||
if !path.is_absolute() {
|
||||
return None;
|
||||
}
|
||||
let path = dunce::canonicalize(path).ok()?;
|
||||
// A relative entry would be read against the working directory, which says nothing
|
||||
// about the user's folders (`/` for an app started from the Finder).
|
||||
let existing = |entry: &PathBuf| entry.is_absolute().then(|| dunce::canonicalize(entry).ok()).flatten();
|
||||
// A listed folder serves its subtree whether or not it is trusted: it opens restricted then.
|
||||
let mut candidates: Vec<PathBuf> = listed.iter().filter_map(existing).collect();
|
||||
if by_trust {
|
||||
candidates.extend(decisions.projects.iter().filter(|p| trusted_here(decisions, p)).cloned());
|
||||
// Remote projects are recorded as locations (`ssh://…`), not as folders of this machine.
|
||||
let local = recents.iter().filter(|p| !p.to_string_lossy().contains("://"));
|
||||
candidates.extend(local.filter_map(existing).filter(|p| trusted_here(decisions, p)));
|
||||
let home = home.map(|h| dunce::canonicalize(h).unwrap_or_else(|_| h.to_path_buf()));
|
||||
// A trusted location and the home folder hold projects; neither is one.
|
||||
candidates
|
||||
.extend(marker_root(&path).filter(|a| {
|
||||
trusted_here(decisions, a) && !decisions.locations.contains(a) && home.as_ref() != Some(a)
|
||||
}));
|
||||
}
|
||||
innermost(&candidates, &path).cloned()
|
||||
}
|
||||
|
||||
/// The entry with the most components among those of `entries` that contain `path`.
|
||||
fn innermost<'a>(entries: impl IntoIterator<Item = &'a PathBuf>, path: &Path) -> Option<&'a PathBuf> {
|
||||
entries.into_iter().filter(|entry| path.starts_with(entry)).max_by_key(|entry| entry.components().count())
|
||||
}
|
||||
|
||||
/// Whether the decisions trust a project at `root`: its innermost grant (the project itself
|
||||
/// or a trusted location around it) lies deeper than every restricted folder around it, so a
|
||||
/// restricted folder vetoes everything below it short of a grant made further down.
|
||||
fn trusted_here(decisions: &TrustDecisions, root: &Path) -> bool {
|
||||
let own = decisions.projects.iter().filter(|project| *project == root);
|
||||
let Some(grant) = innermost(own.chain(&decisions.locations), root) else { return false };
|
||||
innermost(&decisions.restricted, root).is_none_or(|veto| veto.components().count() < grant.components().count())
|
||||
}
|
||||
|
||||
/// The first ancestor of `path`, itself included, that looks like a project: it holds an
|
||||
/// `.openidea` folder, or a `.git` or `.jj` entry (a linked worktree's `.git` is a file).
|
||||
fn marker_root(path: &Path) -> Option<PathBuf> {
|
||||
let marked = |dir: &&Path| dir.join(".openidea").is_dir() || dir.join(".git").exists() || dir.join(".jj").exists();
|
||||
path.ancestors().find(marked).map(Path::to_path_buf)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use McpBackgroundProjects::{Listed, Off, Trusted};
|
||||
|
||||
type Folders = &'static [&'static str];
|
||||
/// What is asked, the mode, the listed folders, the trusted projects, the trusted
|
||||
/// locations, the restricted folders, the recent projects, the path and the root that
|
||||
/// serves it; folders are relative to the tree.
|
||||
type Case = (
|
||||
&'static str,
|
||||
McpBackgroundProjects,
|
||||
Folders,
|
||||
Folders,
|
||||
Folders,
|
||||
Folders,
|
||||
Folders,
|
||||
&'static str,
|
||||
Option<&'static str>,
|
||||
);
|
||||
|
||||
/// `code/` with projects of every marker kind, and `home/` standing in for the user's home.
|
||||
fn tree() -> (tempfile::TempDir, PathBuf) {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
for dir in [
|
||||
"code/app/.git",
|
||||
"code/app/src",
|
||||
"code/app/.wt/feature/src",
|
||||
"code/lib/.jj",
|
||||
"code/tool/.openidea",
|
||||
"code/tool/sub",
|
||||
"code/plain/src",
|
||||
"code/vendor/dep/.git",
|
||||
"home/.openidea",
|
||||
"home/notes",
|
||||
"home/work/.git",
|
||||
] {
|
||||
std::fs::create_dir_all(base.join(dir)).unwrap();
|
||||
}
|
||||
// A linked worktree's `.git` is a file.
|
||||
std::fs::write(base.join("code/app/.wt/feature/.git"), "gitdir: ../../.git/worktrees/feature\n").unwrap();
|
||||
// A file named like the settings folder is no marker.
|
||||
std::fs::write(base.join("code/plain/.openidea"), "").unwrap();
|
||||
(tmp, base)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_innermost_folder_the_policy_allows_serves_a_path() {
|
||||
let (_tmp, base) = tree();
|
||||
let paths = |names: &[&str]| names.iter().map(|n| base.join(n)).collect::<Vec<_>>();
|
||||
#[rustfmt::skip]
|
||||
let cases: &[Case] = &[
|
||||
("off serves nothing", Off, &["code/app"], &["code/app"], &["code"], &[], &["code/app"], "code/app/src", None),
|
||||
("a listed folder, trusted or not", Listed, &["code/app"], &[], &[], &[], &[], "code/app/src", Some("code/app")),
|
||||
("a listed folder itself", Listed, &["code/app"], &[], &[], &[], &[], "code/app", Some("code/app")),
|
||||
("listed mode ignores trust", Listed, &[], &["code/app"], &["code"], &[], &["code/app"], "code/app/src", None),
|
||||
("a sibling of a listed folder", Listed, &["code/app"], &[], &[], &[], &[], "code/lib", None),
|
||||
("a listed folder that is gone", Listed, &["code/gone", "code/app"], &[], &[], &[], &[], "code/app/src", Some("code/app")),
|
||||
("a trusted project", Trusted, &[], &["code/plain"], &[], &[], &[], "code/plain/src", Some("code/plain")),
|
||||
("a recent project in a trusted location", Trusted, &[], &[], &["code"], &[], &["code/plain"], "code/plain/src", Some("code/plain")),
|
||||
("a recent project nobody trusted", Trusted, &[], &[], &[], &[], &["code/plain"], "code/plain/src", None),
|
||||
("a recent project that was restricted", Trusted, &[], &[], &["code"], &["code/plain"], &["code/plain"], "code/plain/src", None),
|
||||
("a recent project that is gone", Trusted, &[], &[], &["code"], &[], &["code/gone"], "code/plain/src", None),
|
||||
("a .git folder", Trusted, &[], &[], &["code"], &[], &[], "code/app/src", Some("code/app")),
|
||||
("a .git file", Trusted, &[], &[], &["code"], &[], &[], "code/app/.wt/feature/src", Some("code/app/.wt/feature")),
|
||||
("a .jj folder, from the root itself", Trusted, &[], &[], &["code"], &[], &[], "code/lib", Some("code/lib")),
|
||||
("an .openidea folder", Trusted, &[], &[], &["code"], &[], &[], "code/tool/sub", Some("code/tool")),
|
||||
("an .openidea file is no marker", Trusted, &[], &[], &["code"], &[], &[], "code/plain/src", None),
|
||||
("a marker nobody trusted", Trusted, &[], &[], &[], &[], &[], "code/app/src", None),
|
||||
("the walk stops at the first marker", Trusted, &[], &[], &["code"], &["code/app/.wt/feature"], &[], "code/app/.wt/feature/src", None),
|
||||
("a worktree in a trusted location inside a trusted project", Trusted, &[], &["code/app"], &["code/app/.wt"], &[], &[], "code/app/.wt/feature/src", Some("code/app/.wt/feature")),
|
||||
("an untrusted worktree inside a trusted project", Trusted, &[], &["code/app"], &[], &[], &[], "code/app/.wt/feature/src", Some("code/app")),
|
||||
("a trusted child of a listed untrusted parent", Trusted, &["code"], &["code/plain"], &[], &[], &[], "code/plain/src", Some("code/plain")),
|
||||
("the listed parent for the rest of it", Trusted, &["code"], &["code/plain"], &[], &[], &[], "code/tool/sub", Some("code")),
|
||||
("a marker under a restricted folder", Trusted, &[], &[], &["code"], &["code/vendor"], &[], "code/vendor/dep", None),
|
||||
("a deeper grant under a restricted folder", Trusted, &[], &["code/vendor/dep"], &["code"], &["code/vendor"], &[], "code/vendor/dep", Some("code/vendor/dep")),
|
||||
("a restricted trusted location", Trusted, &[], &[], &["code"], &["code"], &[], "code/app/src", None),
|
||||
("a trusted location is no project", Trusted, &[], &[], &["code/app"], &[], &[], "code/app/src", None),
|
||||
("the home folder is no project", Trusted, &[], &[], &[""], &[], &[], "home/notes", None),
|
||||
("a repository in the home folder", Trusted, &[], &[], &[""], &[], &[], "home/work", Some("home/work")),
|
||||
("a missing path", Listed, &["code/app"], &[], &[], &[], &[], "code/app/missing", None),
|
||||
];
|
||||
for (what, mode, listed, projects, locations, restricted, recents, path, expected) in cases {
|
||||
let decisions = TrustDecisions {
|
||||
projects: paths(projects),
|
||||
locations: paths(locations),
|
||||
restricted: paths(restricted),
|
||||
};
|
||||
let home = base.join("home");
|
||||
let found = resolve(*mode, &paths(listed), &decisions, &paths(recents), Some(&home), &base.join(path));
|
||||
assert_eq!(found, expected.map(|root| base.join(root)), "{what}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_relative_path_is_served_by_nothing() {
|
||||
let (_tmp, base) = tree();
|
||||
let listed = [base.join("code/app"), PathBuf::from("code/app"), PathBuf::from(".")];
|
||||
let none = TrustDecisions::default();
|
||||
for path in ["code/app/src", ".", "src"] {
|
||||
assert_eq!(resolve(Listed, &listed, &none, &[], None, Path::new(path)), None, "{path}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_relative_list_or_recent_entry_serves_nothing() {
|
||||
// Read against the working directory, `.` would serve whatever folder the app was started from.
|
||||
let here = dunce::canonicalize(std::env::current_dir().unwrap()).unwrap();
|
||||
let around = TrustDecisions { locations: vec![here.parent().unwrap().to_path_buf()], ..Default::default() };
|
||||
let none = TrustDecisions::default();
|
||||
let (dot, absolute): (&[PathBuf], &[PathBuf]) = (&[PathBuf::from(".")], std::slice::from_ref(&here));
|
||||
for (what, mode, listed, decisions, recents, expected) in [
|
||||
("a listed `.`", Listed, dot, &none, &[][..], None),
|
||||
("a listed `.` with trusted projects served", Trusted, dot, &none, &[][..], None),
|
||||
("a recent `.`", Trusted, &[][..], &around, dot, None),
|
||||
("the same folder listed by its full path", Listed, absolute, &none, &[][..], Some(&here)),
|
||||
("the same folder recent by its full path", Trusted, &[][..], &around, absolute, Some(&here)),
|
||||
] {
|
||||
assert_eq!(resolve(mode, listed, decisions, recents, None, &here).as_ref(), expected, "{what}");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_folder_reached_through_a_link_is_the_folder_itself() {
|
||||
let (_tmp, base) = tree();
|
||||
std::os::unix::fs::symlink(base.join("code"), base.join("link")).unwrap();
|
||||
let none = TrustDecisions::default();
|
||||
// Listed by the link, asked for by the real path, and the other way round (`/tmp` and `/private/tmp`).
|
||||
for (listed, path) in [("link/app", "code/app/src"), ("code/app", "link/app/src"), ("link/app", "link/app")] {
|
||||
let found = resolve(Listed, &[base.join(listed)], &none, &[], None, &base.join(path));
|
||||
assert_eq!(found, Some(base.join("code/app")), "{listed} for {path}");
|
||||
}
|
||||
let trusted = TrustDecisions { locations: vec![base.join("code")], ..Default::default() };
|
||||
let recent = [base.join("link/plain")];
|
||||
assert_eq!(
|
||||
resolve(Trusted, &[], &trusted, &recent, None, &base.join("link/plain/src")),
|
||||
Some(base.join("code/plain"))
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_remote_recent_project_is_skipped_even_when_its_text_names_a_local_folder() {
|
||||
let (_tmp, base) = tree();
|
||||
// `<base>/ssh://box/app` reads as the local folder `<base>/ssh:/box/app`.
|
||||
std::fs::create_dir_all(base.join("ssh:/box/app/src")).unwrap();
|
||||
let recent = [PathBuf::from(format!("{}/ssh://box/app", base.display()))];
|
||||
let trusted = TrustDecisions { locations: vec![base.clone()], ..Default::default() };
|
||||
assert_eq!(resolve(Trusted, &[], &trusted, &recent, None, &base.join("ssh:/box/app/src")), None);
|
||||
let local = [base.join("ssh:/box/app")];
|
||||
assert_eq!(
|
||||
resolve(Trusted, &[], &trusted, &local, None, &base.join("ssh:/box/app/src")),
|
||||
Some(base.join("ssh:/box/app"))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,792 @@
|
||||
use super::*;
|
||||
use crate::HostConfig;
|
||||
use ide_workspace::SettingsScope;
|
||||
use serde_json::json;
|
||||
|
||||
const MINUTE: Duration = Duration::from_secs(60);
|
||||
const SECOND: Duration = Duration::from_secs(1);
|
||||
|
||||
/// A host with the MCP server on that serves the folders `inventory`, `billing` and
|
||||
/// `orders` as listed background projects; no window is open.
|
||||
struct Fixture {
|
||||
host: Arc<Host>,
|
||||
base: PathBuf,
|
||||
syntax: Arc<std::sync::OnceLock<Arc<ide_language::Syntax>>>,
|
||||
_tmp: tempfile::TempDir,
|
||||
}
|
||||
|
||||
/// The grammars' warm-up, held unfinished as at start-up until this is dropped. Every open
|
||||
/// waits for it after it has read the settings and the trust decision, before it registers
|
||||
/// its project.
|
||||
struct WarmUp(#[expect(dead_code, reason = "dropping it ends the warm-up")] std::sync::mpsc::Sender<()>);
|
||||
|
||||
/// Returns once `done` holds; no later than half a minute from now.
|
||||
fn wait_until(what: &str, done: impl Fn() -> bool) {
|
||||
let deadline = Instant::now() + 30 * SECOND;
|
||||
while !done() {
|
||||
assert!(Instant::now() < deadline, "{what}");
|
||||
std::thread::yield_now();
|
||||
}
|
||||
}
|
||||
|
||||
/// Long enough to tell work that waits from work that has finished.
|
||||
const A_MOMENT: Duration = Duration::from_millis(300);
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
for name in ["inventory", "billing", "orders"] {
|
||||
std::fs::create_dir_all(base.join(name).join("parts")).unwrap();
|
||||
std::fs::write(base.join(name).join("notes.txt"), "stock\n").unwrap();
|
||||
}
|
||||
let syntax: Arc<std::sync::OnceLock<Arc<ide_language::Syntax>>> = Arc::default();
|
||||
let host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("local"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: syntax.clone(),
|
||||
sink_for: Box::new(|_| Arc::new(|_| {})),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
}));
|
||||
let fixture = Self { host, base, syntax, _tmp: tmp };
|
||||
fixture.set("enabled", json!(true));
|
||||
fixture.set("backgroundProjects", json!("listed"));
|
||||
fixture.list(&["inventory", "billing", "orders"]);
|
||||
fixture
|
||||
}
|
||||
|
||||
fn set(&self, key: &str, value: serde_json::Value) {
|
||||
self.host.global_settings.set(SettingsScope::Global, &format!("mcpServer.{key}"), value).unwrap();
|
||||
}
|
||||
|
||||
fn list(&self, names: &[&str]) {
|
||||
self.set("backgroundProjectPaths", json!(names.iter().map(|name| self.root(name)).collect::<Vec<_>>()));
|
||||
}
|
||||
|
||||
fn root(&self, name: &str) -> PathBuf {
|
||||
self.base.join(name)
|
||||
}
|
||||
|
||||
fn background(&self) -> &BackgroundProjects {
|
||||
&self.host.mcp_background
|
||||
}
|
||||
|
||||
fn open(&self, name: &str) -> Arc<Project> {
|
||||
self.background().open(&self.host, &self.root(name)).expect("the project is served").1
|
||||
}
|
||||
|
||||
/// A tool call that reached the project `name` and has not ended yet.
|
||||
fn call(&self, name: &str) -> ActivityGuard {
|
||||
let (_, _, call) = self.background().open(&self.host, &self.root(name)).expect("the project is served");
|
||||
call.expect("in the background")
|
||||
}
|
||||
|
||||
fn hold_warm_up(&self) -> WarmUp {
|
||||
let (started, holding) = std::sync::mpsc::channel();
|
||||
let (finish, finished) = std::sync::mpsc::channel::<()>();
|
||||
let syntax = self.syntax.clone();
|
||||
std::thread::spawn(move || {
|
||||
syntax.get_or_init(|| {
|
||||
// Both ends hang up when the test is over.
|
||||
let _ = started.send(());
|
||||
let _ = finished.recv();
|
||||
Arc::new(ide_language::Syntax::new())
|
||||
});
|
||||
});
|
||||
holding.recv_timeout(30 * SECOND).expect("the warm-up starts");
|
||||
WarmUp(finish)
|
||||
}
|
||||
|
||||
/// A client's first call for `name` on another thread, once its open is under way.
|
||||
fn open_in_flight(&self, name: &str) -> tokio::task::JoinHandle<Arc<Project>> {
|
||||
let (host, root) = (self.host.clone(), self.root(name));
|
||||
let open = tokio::task::spawn_blocking(move || host.mcp_background.open(&host, &root).expect("served").1);
|
||||
wait_until("the open is under way", || self.background().gate.is_locked());
|
||||
open
|
||||
}
|
||||
|
||||
/// Whether an open has read its settings and trust decision: Local History, which it
|
||||
/// creates next, is there.
|
||||
fn an_open_has_read_its_decisions(&self) -> bool {
|
||||
std::fs::read_dir(self.base.join("data/history")).is_ok_and(|mut entries| entries.next().is_some())
|
||||
}
|
||||
|
||||
fn refused(&self, name: &str) -> String {
|
||||
self.background().open(&self.host, &self.root(name)).err().expect("the open is refused").message
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> Vec<McpBackgroundProject> {
|
||||
self.background().snapshot(&self.host, Instant::now())
|
||||
}
|
||||
|
||||
/// The folder names of the loaded projects, sorted.
|
||||
fn loaded(&self) -> Vec<String> {
|
||||
let name = |project: McpBackgroundProject| project.root.0.file_name().unwrap().to_string_lossy().into_owned();
|
||||
self.snapshot().into_iter().map(name).collect()
|
||||
}
|
||||
|
||||
fn held_by(&self, name: &str) -> Option<McpBackgroundHold> {
|
||||
let root = self.root(name);
|
||||
self.snapshot().into_iter().find(|project| project.root.0 == root).unwrap().kept_open_by
|
||||
}
|
||||
|
||||
fn used(&self, name: &str) -> Instant {
|
||||
*self.background().state.lock().entries[&self.root(name)].last_used.lock()
|
||||
}
|
||||
|
||||
fn claims(&self, name: &str) -> usize {
|
||||
self.background().state.lock().claims.get(&self.root(name)).copied().unwrap_or(0)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
// Waits for each shutdown, so nothing still works in the folder when it is deleted.
|
||||
for (root, _) in self.background().entries() {
|
||||
self.host.close_project(&BackgroundProjects::key(&root));
|
||||
}
|
||||
self.host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns once the clock reads later than `time`, so the next reading is strictly after it.
|
||||
fn tick_past(time: Instant) {
|
||||
while Instant::now() <= time {
|
||||
std::hint::spin_loop();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_first_call_opens_a_project_under_its_key_and_the_next_one_reuses_it() {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let (key, project, _) = f.background().open(&f.host, &root).unwrap();
|
||||
assert_eq!(key, format!("mcp:{}", root.display()));
|
||||
assert!(BackgroundProjects::is_key(&key));
|
||||
assert!(!BackgroundProjects::is_key("main") && !BackgroundProjects::is_key("settings-main"));
|
||||
assert_eq!(project.root, root);
|
||||
assert!(Arc::ptr_eq(&f.host.project(&key).unwrap(), &project));
|
||||
assert!(!project.is_trusted(), "a listed folder nobody trusted opens in Restricted Mode");
|
||||
let (_, again, _) = f.background().open(&f.host, &root).unwrap();
|
||||
assert!(Arc::ptr_eq(&again, &project));
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_root_the_settings_do_not_serve_is_refused_and_nothing_opens() {
|
||||
let f = Fixture::new();
|
||||
f.list(&["billing"]);
|
||||
let root = f.root("inventory");
|
||||
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
|
||||
// A folder inside a served root is not a root itself.
|
||||
assert!(f.refused("billing/parts").contains("is not served in the background"));
|
||||
f.set("backgroundProjects", json!("off"));
|
||||
assert!(f.refused("billing").contains("is not served in the background"));
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.projects().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_in_flight_holds_the_project_and_its_end_restarts_the_idle_time() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let opened = f.used("inventory");
|
||||
tick_past(opened);
|
||||
let call = f.call("inventory");
|
||||
let entered = f.used("inventory");
|
||||
assert!(entered > opened, "entering counts as use");
|
||||
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Request));
|
||||
// Held: no idle time unloads it.
|
||||
let days_later = entered + 2 * 24 * 60 * MINUTE;
|
||||
assert!(f.background().sweep_candidates(&f.host, days_later).is_empty());
|
||||
assert!(!f.background().detach(&f.host, &root, Some(days_later)));
|
||||
tick_past(entered);
|
||||
drop(call);
|
||||
let left = f.used("inventory");
|
||||
assert!(left > entered, "the end of the call restarts the idle time");
|
||||
assert_eq!(f.held_by("inventory"), None);
|
||||
assert!(f.background().sweep_candidates(&f.host, left + 30 * MINUTE - SECOND).is_empty());
|
||||
assert_eq!(f.background().sweep_candidates(&f.host, left + 30 * MINUTE), [root]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_that_outlives_its_project_leaves_the_reopened_project_alone() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let outlived = f.call("inventory");
|
||||
assert!(f.background().detach(&f.host, &root, None), "an unload by hand does not wait for the call");
|
||||
f.open("inventory");
|
||||
let current = f.call("inventory");
|
||||
drop(outlived);
|
||||
assert_eq!(
|
||||
f.held_by("inventory"),
|
||||
Some(McpBackgroundHold::Request),
|
||||
"the call in the reopened project still counts"
|
||||
);
|
||||
drop(current);
|
||||
assert_eq!(f.held_by("inventory"), None);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn an_idle_project_is_unloaded_exactly_when_its_idle_time_is_up() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let used = f.used("inventory");
|
||||
f.background().sweep(&f.host, used + 30 * MINUTE - SECOND);
|
||||
assert_eq!(f.loaded(), ["inventory"], "one second short");
|
||||
f.set("backgroundIdleMinutes", json!(0));
|
||||
f.background().sweep(&f.host, used + 365 * 24 * 60 * MINUTE);
|
||||
assert_eq!(f.loaded(), ["inventory"], "0 never unloads");
|
||||
// More than a day counts as a day.
|
||||
f.set("backgroundIdleMinutes", json!(5000));
|
||||
f.background().sweep(&f.host, used + 1440 * MINUTE - SECOND);
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
f.background().sweep(&f.host, used + 1440 * MINUTE);
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.project(&BackgroundProjects::key(&f.root("inventory"))).is_err());
|
||||
|
||||
f.set("backgroundIdleMinutes", json!(30));
|
||||
f.open("inventory");
|
||||
f.background().sweep(&f.host, f.used("inventory") + 30 * MINUTE);
|
||||
assert!(f.loaded().is_empty(), "exactly at the limit");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_that_arrives_between_the_sweep_and_the_unload_keeps_the_project() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let now = f.used("inventory") + 30 * MINUTE;
|
||||
assert_eq!(f.background().sweep_candidates(&f.host, now), std::slice::from_ref(&root));
|
||||
let call = f.call("inventory");
|
||||
assert!(!f.background().detach(&f.host, &root, Some(now)), "held by the call");
|
||||
drop(call);
|
||||
assert!(!f.background().detach(&f.host, &root, Some(now)), "used since the sweep looked");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_live_run_holds_the_project_and_an_unload_by_hand_stops_it() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
let root = f.root("inventory");
|
||||
let (exits, exited) = std::sync::mpsc::channel();
|
||||
let exits = Mutex::new(exits);
|
||||
let sink: ide_core::SharedSink = Arc::new(move |event: ide_core::IdeEvent| {
|
||||
if let ide_core::IdeEvent::RunExited { run, .. } = event {
|
||||
// The receiver is gone once the test has seen the exit.
|
||||
let _ = exits.lock().send(run);
|
||||
}
|
||||
});
|
||||
let config = ide_run::RunConfig {
|
||||
id: "serve".into(),
|
||||
name: "serve stock".into(),
|
||||
kind: "shell".into(),
|
||||
command: "sleep 30".into(),
|
||||
args: Vec::new(),
|
||||
cwd: None,
|
||||
env: Default::default(),
|
||||
detected: false,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
};
|
||||
let run = f.host.processes.start(&root, &config, &Default::default(), sink, Box::new(|_| {})).unwrap();
|
||||
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Run { name: "serve stock".into() }));
|
||||
assert_eq!(f.snapshot()[0].unloads_in_seconds, None);
|
||||
let days_later = f.used("inventory") + 2 * 24 * 60 * MINUTE;
|
||||
assert!(f.background().sweep_candidates(&f.host, days_later).is_empty());
|
||||
assert!(!f.background().detach(&f.host, &root, Some(days_later)));
|
||||
// The limit does not unload it either.
|
||||
f.set("backgroundProjectLimit", json!(1));
|
||||
assert_eq!(f.refused("billing"), "the limit of 1 background projects is reached and all are busy");
|
||||
|
||||
assert!(f.background().detach(&f.host, &root, None));
|
||||
assert_eq!(exited.recv_timeout(Duration::from_secs(30)).unwrap(), run.id);
|
||||
assert!(f.host.processes.running_in(&root).is_empty());
|
||||
assert!(!f.background().detach(&f.host, &root, None), "already unloaded");
|
||||
assert!(!f.background().detach(&f.host, &f.root("billing"), None), "never loaded");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_limit_unloads_the_project_used_longest_ago_and_refuses_when_all_are_held() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundProjectLimit", json!(2));
|
||||
f.open("inventory");
|
||||
tick_past(f.used("inventory"));
|
||||
f.open("billing");
|
||||
// A call in `inventory` makes `billing` the one used longest ago.
|
||||
tick_past(f.used("billing"));
|
||||
drop(f.call("inventory"));
|
||||
f.open("orders");
|
||||
assert_eq!(f.loaded(), ["inventory", "orders"]);
|
||||
assert!(f.host.project(&BackgroundProjects::key(&f.root("billing"))).is_err());
|
||||
|
||||
let in_inventory = f.call("inventory");
|
||||
let in_orders = f.call("orders");
|
||||
assert_eq!(f.refused("billing"), "the limit of 2 background projects is reached and all are busy");
|
||||
assert_eq!(f.loaded(), ["inventory", "orders"]);
|
||||
// A loaded project answers at the limit.
|
||||
f.open("inventory");
|
||||
drop(in_orders);
|
||||
f.open("billing");
|
||||
assert_eq!(f.loaded(), ["billing", "inventory"]);
|
||||
// A lowered limit is reached by the next open.
|
||||
drop(in_inventory);
|
||||
f.set("backgroundProjectLimit", json!(0));
|
||||
f.open("orders");
|
||||
assert_eq!(f.loaded(), ["orders"], "0 serves one project");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_project_whose_call_has_not_started_running_is_not_evicted_for_another_client() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundProjectLimit", json!(1));
|
||||
// The open hands the call over already counted: nothing unloads the project before it runs.
|
||||
let call = f.call("inventory");
|
||||
assert_eq!(f.refused("billing"), "the limit of 1 background projects is reached and all are busy");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
assert_eq!(f.held_by("inventory"), Some(McpBackgroundHold::Request));
|
||||
drop(call);
|
||||
f.open("billing");
|
||||
assert_eq!(f.loaded(), ["billing"], "with the call over, the other client's project takes the place");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
||||
async fn a_trust_refresh_leaves_its_runtime_worker_to_other_tasks_while_it_unloads_projects() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.set("backgroundProjects", json!("off"));
|
||||
// The observer runs inside the policy step: holding it there holds the step.
|
||||
let (inside, entered) = std::sync::mpsc::channel();
|
||||
let (release, released) = std::sync::mpsc::channel::<()>();
|
||||
let released = Mutex::new(Some(released));
|
||||
f.host.set_background_projects_observer(Arc::new(move || {
|
||||
if let Some(released) = released.lock().take() {
|
||||
// Both ends hang up when the test is over.
|
||||
let _ = inside.send(());
|
||||
let _ = released.recv();
|
||||
}
|
||||
}));
|
||||
let host = f.host.clone();
|
||||
let refresh = tokio::spawn(async move { host.refresh_project_trust().await });
|
||||
// Waits on this thread, which is none of the runtime's: its timers stand while the worker is held.
|
||||
entered.recv_timeout(30 * SECOND).expect("the policy step unloads the project");
|
||||
// The runtime's only worker is inside the step; a task spawned now still runs.
|
||||
let (ran, other) = std::sync::mpsc::channel();
|
||||
tokio::spawn(async move {
|
||||
// The test may have given up waiting.
|
||||
let _ = ran.send(());
|
||||
});
|
||||
other.recv_timeout(10 * SECOND).expect("another task runs meanwhile");
|
||||
drop(release);
|
||||
refresh.await.unwrap().unwrap();
|
||||
assert!(f.loaded().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_limit_and_the_idle_time_stay_within_their_bounds() {
|
||||
for (setting, limit) in [(0, 1), (1, 1), (8, 8), (32, 32), (99, 32), (u32::MAX, 32)] {
|
||||
assert_eq!(project_limit(setting), limit, "{setting}");
|
||||
}
|
||||
let day = 24 * 60 * MINUTE;
|
||||
for (minutes, limit) in [
|
||||
(0, None),
|
||||
(1, Some(MINUTE)),
|
||||
(30, Some(30 * MINUTE)),
|
||||
(1440, Some(day)),
|
||||
(5000, Some(day)),
|
||||
(u32::MAX, Some(day)),
|
||||
] {
|
||||
assert_eq!(idle_limit(minutes), limit, "{minutes}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_that_opens_the_root_takes_it_over_and_gives_it_back_when_it_closes() {
|
||||
let f = Fixture::new();
|
||||
let background = f.open("inventory");
|
||||
f.open("billing");
|
||||
let root = f.root("inventory");
|
||||
let key = BackgroundProjects::key(&root);
|
||||
let window = f.host.open_project("main", &root).unwrap();
|
||||
assert!(!Arc::ptr_eq(&window, &background));
|
||||
assert!(f.host.project(&key).is_err());
|
||||
assert_eq!(f.loaded(), ["billing"], "the other project is left alone");
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
// A call for the root reaches the window now.
|
||||
let (label, project, call) = f.background().open(&f.host, &root).unwrap();
|
||||
assert_eq!(label, "main");
|
||||
assert!(call.is_none(), "a window is not held by calls");
|
||||
assert!(Arc::ptr_eq(&project, &window));
|
||||
assert_eq!(f.loaded(), ["billing"]);
|
||||
|
||||
f.host.close_project("main");
|
||||
assert_eq!(f.background().open(&f.host, &root).unwrap().0, key);
|
||||
assert_eq!(f.loaded(), ["billing", "inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_background_open_is_refused_until_every_window_opening_the_root_is_done() {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let first = f.background().claim(&f.host, &root);
|
||||
let second = f.background().claim(&f.host, &root);
|
||||
let refusal = format!("{} is opening in a window; retry", root.display());
|
||||
assert_eq!(f.refused("inventory"), refusal);
|
||||
drop(first);
|
||||
assert_eq!(f.refused("inventory"), refusal, "the second window is still opening it");
|
||||
f.open("billing");
|
||||
drop(second);
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
f.open("inventory");
|
||||
assert_eq!(f.loaded(), ["billing", "inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_open_that_fails_releases_the_root() {
|
||||
let f = Fixture::new();
|
||||
// Local History cannot be created, which fails the open after the window claimed the root.
|
||||
let history = f.base.join("data/history");
|
||||
std::fs::create_dir_all(history.parent().unwrap()).unwrap();
|
||||
std::fs::write(&history, "").unwrap();
|
||||
assert!(f.host.open_project("main", &f.root("inventory")).is_err());
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
std::fs::remove_file(&history).unwrap();
|
||||
f.open("inventory");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn revoked_trust_unloads_a_project_served_for_its_trust_and_restricts_a_listed_one() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundProjects", json!("trusted"));
|
||||
f.list(&["billing"]);
|
||||
for name in ["inventory", "billing"] {
|
||||
f.host.trust.decide(&f.root(name), true, false).unwrap();
|
||||
}
|
||||
let inventory = f.open("inventory");
|
||||
let billing = f.open("billing");
|
||||
assert!(inventory.is_trusted() && billing.is_trusted());
|
||||
for name in ["inventory", "billing"] {
|
||||
f.host.set_project_trust(&f.root(name), false, false).await.unwrap();
|
||||
}
|
||||
assert_eq!(f.loaded(), ["billing"]);
|
||||
assert!(!billing.is_trusted(), "the listed project stays, in Restricted Mode");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_folder_taken_off_the_list_is_unloaded_and_the_others_stay() {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.open("billing");
|
||||
f.list(&["billing", "orders"]);
|
||||
f.host.apply_background_policy();
|
||||
assert_eq!(f.loaded(), ["billing"]);
|
||||
f.host.apply_background_policy();
|
||||
assert_eq!(f.loaded(), ["billing"], "nothing more to unload");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn turning_background_projects_or_the_server_off_unloads_every_project() {
|
||||
for (key, value) in [("backgroundProjects", json!("off")), ("enabled", json!(false))] {
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.open("billing");
|
||||
f.set(key, value);
|
||||
f.host.apply_background_policy();
|
||||
assert!(f.loaded().is_empty(), "{key}");
|
||||
assert!(f.host.projects().is_empty(), "{key}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_observer_hears_of_every_open_unload_and_eviction_outside_the_locks() {
|
||||
let f = Fixture::new();
|
||||
let heard = Arc::new(AtomicUsize::new(0));
|
||||
let locked = Arc::new(AtomicUsize::new(0));
|
||||
let (count, under_lock, host) = (heard.clone(), locked.clone(), Arc::downgrade(&f.host));
|
||||
f.host.set_background_projects_observer(Arc::new(move || {
|
||||
count.fetch_add(1, Ordering::AcqRel);
|
||||
let host = host.upgrade().unwrap();
|
||||
let background = &host.mcp_background;
|
||||
if background.gate.try_lock().is_none() || background.state.try_lock().is_none() {
|
||||
under_lock.fetch_add(1, Ordering::AcqRel);
|
||||
}
|
||||
}));
|
||||
let heard = || heard.load(Ordering::Acquire);
|
||||
let root = f.root("inventory");
|
||||
f.open("inventory");
|
||||
assert_eq!(heard(), 1, "an open");
|
||||
f.open("inventory");
|
||||
assert_eq!(heard(), 1, "a loaded project is reused silently");
|
||||
assert!(f.background().detach(&f.host, &root, None));
|
||||
assert_eq!(heard(), 2, "an unload");
|
||||
assert!(!f.background().detach(&f.host, &root, None));
|
||||
f.list(&["inventory", "billing"]);
|
||||
assert!(f.refused("orders").contains("not served"));
|
||||
assert_eq!(heard(), 2, "nothing changed");
|
||||
f.set("backgroundProjectLimit", json!(1));
|
||||
f.open("inventory");
|
||||
f.open("billing");
|
||||
assert_eq!(heard(), 4, "an open, then an eviction with its open");
|
||||
f.background().sweep(&f.host, f.used("billing") + 30 * MINUTE);
|
||||
assert_eq!(heard(), 5, "an idle unload");
|
||||
f.open("billing");
|
||||
f.host.open_project("main", &f.root("billing")).unwrap();
|
||||
assert_eq!(heard(), 7, "an open, then a window taking the root over");
|
||||
assert_eq!(locked.load(Ordering::Acquire), 0);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_background_project_is_not_a_window_of_its_root() {
|
||||
use crate::plugins::{HostWorkspace, PluginWorkspace};
|
||||
let f = Fixture::new();
|
||||
f.open("inventory");
|
||||
f.host.open_project("main", &f.root("billing")).unwrap();
|
||||
let workspace = HostWorkspace(Arc::downgrade(&f.host));
|
||||
assert!(f.host.windows_for_root(&f.root("inventory")).is_empty());
|
||||
assert!(workspace.project_windows(&f.root("inventory")).is_empty(), "a plugin's notification finds no window");
|
||||
assert_eq!(f.host.windows_for_root(&f.root("billing")), ["main"]);
|
||||
assert_eq!(workspace.project_windows(&f.root("billing")), ["main"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn unloading_a_project_keeps_the_diagnostics_of_a_window_around_it() {
|
||||
let f = Fixture::new();
|
||||
f.list(&["inventory/parts", "billing"]);
|
||||
f.host.open_project("main", &f.root("inventory")).unwrap();
|
||||
f.open("inventory/parts");
|
||||
f.open("billing");
|
||||
let problem = ide_core::Diagnostic {
|
||||
range: ide_core::Range::point(ide_core::Pos::new(0, 0)),
|
||||
severity: ide_core::Severity::Warning,
|
||||
message: "low stock".into(),
|
||||
source: Some("lint".into()),
|
||||
code: None,
|
||||
unnecessary: false,
|
||||
deprecated: false,
|
||||
server: None,
|
||||
};
|
||||
let (nested, apart) = (f.root("inventory/parts/list.txt"), f.root("billing/notes.txt"));
|
||||
for file in [&nested, &apart] {
|
||||
f.host.diagnostics.replace(file, "lint", vec![problem.clone()]);
|
||||
}
|
||||
assert!(f.background().detach(&f.host, &f.root("inventory/parts"), None));
|
||||
assert!(f.background().detach(&f.host, &f.root("billing"), None));
|
||||
assert!(!f.host.diagnostics.file(&nested).is_empty(), "the window on `inventory` still shows them");
|
||||
assert!(f.host.diagnostics.file(&apart).is_empty(), "no project is left for these");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn the_snapshot_lists_projects_by_root_with_their_idle_time_and_what_holds_them() {
|
||||
let f = Fixture::new();
|
||||
f.open("orders");
|
||||
f.open("billing");
|
||||
let now = f.used("billing") + 10 * MINUTE;
|
||||
let snapshot = f.background().snapshot(&f.host, now);
|
||||
let roots: Vec<_> = snapshot.iter().map(|project| project.root.0.clone()).collect();
|
||||
assert_eq!(roots, [f.root("billing"), f.root("orders")]);
|
||||
let expected = McpBackgroundProject {
|
||||
root: f.root("billing").into(),
|
||||
idle_seconds: 600,
|
||||
unloads_in_seconds: Some(1200),
|
||||
kept_open_by: None,
|
||||
};
|
||||
assert_eq!(snapshot[0], expected);
|
||||
assert_eq!(
|
||||
serde_json::to_value(&snapshot[0]).unwrap(),
|
||||
json!({ "root": IpcPath::from(f.root("billing")), "idleSeconds": 600, "unloadsInSeconds": 1200 })
|
||||
);
|
||||
// Past its time and not swept yet: due now.
|
||||
assert_eq!(f.background().snapshot(&f.host, now + 60 * MINUTE)[0].unloads_in_seconds, Some(0));
|
||||
|
||||
let call = f.call("billing");
|
||||
let held = f.background().snapshot(&f.host, f.used("billing") + MINUTE).remove(0);
|
||||
assert_eq!((held.idle_seconds, held.unloads_in_seconds), (60, None));
|
||||
assert_eq!(serde_json::to_value(&held).unwrap()["keptOpenBy"], json!({ "kind": "request" }));
|
||||
drop(call);
|
||||
let run = McpBackgroundHold::Run { name: "serve stock".into() };
|
||||
assert_eq!(serde_json::to_value(run).unwrap(), json!({ "kind": "run", "name": "serve stock" }));
|
||||
|
||||
f.set("backgroundIdleMinutes", json!(0));
|
||||
assert!(f.snapshot().iter().all(|project| project.unloads_in_seconds.is_none()), "never unloaded");
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn the_timer_unloads_a_project_once_it_has_been_idle_for_the_configured_time() {
|
||||
let f = Fixture::new();
|
||||
f.set("backgroundIdleMinutes", json!(1));
|
||||
f.open("inventory");
|
||||
f.host.start_background_sweeper();
|
||||
// The clock is the runtime's and stands still unless the test moves it.
|
||||
tokio::time::sleep(45 * SECOND).await;
|
||||
assert_eq!(f.loaded(), ["inventory"], "swept once, half a minute idle");
|
||||
tokio::time::sleep(60 * SECOND).await;
|
||||
assert!(f.loaded().is_empty(), "swept again at a minute and a half");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn trust_revoked_while_a_project_opens_restricts_or_unloads_it_once_it_is_open() {
|
||||
use ide_mcp::ToolRegistry;
|
||||
for (mode, stays) in [("listed", true), ("trusted", false)] {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
f.set("backgroundProjects", json!(mode));
|
||||
f.list(if stays { &["inventory"] } else { &[] });
|
||||
f.host.trust.decide(&root, true, false).unwrap();
|
||||
let warm_up = f.hold_warm_up();
|
||||
let open = f.open_in_flight("inventory");
|
||||
wait_until("the open reads the trust decision", || f.an_open_has_read_its_decisions());
|
||||
|
||||
let (host, folder) = (f.host.clone(), root.clone());
|
||||
let (done, refreshed) = std::sync::mpsc::channel();
|
||||
tokio::spawn(async move {
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(host.set_project_trust(&folder, false, false).await.is_ok());
|
||||
});
|
||||
let waited = refreshed.recv_timeout(A_MOMENT).is_err();
|
||||
drop(warm_up);
|
||||
let project = open.await.unwrap();
|
||||
if waited {
|
||||
assert!(refreshed.recv_timeout(30 * SECOND).unwrap(), "{mode}");
|
||||
}
|
||||
|
||||
assert!(!project.is_trusted(), "{mode}: opened with the trust it read, the project is restricted afterwards");
|
||||
if stays {
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
let tools = crate::mcp::Registry::new(f.host.clone()).tools(&root).unwrap();
|
||||
assert!(tools.iter().all(|tool| tool.read_only), "only the tools that read stay on offer");
|
||||
} else {
|
||||
assert!(f.loaded().is_empty(), "served for its trust, it is unloaded");
|
||||
assert!(f.host.project(&BackgroundProjects::key(&root)).is_err());
|
||||
}
|
||||
assert!(waited, "{mode}: the refresh waits for the open under way");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_policy_change_while_a_project_opens_unloads_it_once_it_is_open() {
|
||||
for change in ["the mode turned off", "the folder taken off the list", "the server turned off"] {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let warm_up = f.hold_warm_up();
|
||||
let open = f.open_in_flight("inventory");
|
||||
wait_until("the open reads the settings", || f.an_open_has_read_its_decisions());
|
||||
|
||||
match change {
|
||||
"the mode turned off" => f.set("backgroundProjects", json!("off")),
|
||||
"the folder taken off the list" => f.list(&["billing"]),
|
||||
_ => f.set("enabled", json!(false)),
|
||||
}
|
||||
let host = f.host.clone();
|
||||
let (done, applied) = std::sync::mpsc::channel();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
host.apply_background_policy();
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(());
|
||||
});
|
||||
let waited = applied.recv_timeout(A_MOMENT).is_err();
|
||||
drop(warm_up);
|
||||
open.await.unwrap();
|
||||
if waited {
|
||||
applied.recv_timeout(30 * SECOND).expect(change);
|
||||
}
|
||||
|
||||
assert!(f.loaded().is_empty(), "{change}: the project that was opening is unloaded");
|
||||
assert!(f.host.project(&BackgroundProjects::key(&root)).is_err(), "{change}");
|
||||
assert!(waited, "{change}: the policy waits for the open under way");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_host_that_serves_none_refuses_every_folder_whatever_the_settings_say() {
|
||||
use ide_mcp::ToolRegistry;
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
f.host.mcp_background.serve_none();
|
||||
let registry = crate::mcp::Registry::new(f.host.clone());
|
||||
assert_eq!(registry.resolve(&root.join("parts")), None);
|
||||
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.projects().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_call_that_arrives_after_the_server_was_turned_off_opens_nothing() {
|
||||
use ide_mcp::ToolRegistry;
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
// A request the server had accepted before it stopped still reaches the open.
|
||||
f.set("enabled", json!(false));
|
||||
f.host.apply_background_policy();
|
||||
assert_eq!(f.refused("inventory"), format!("{} is not served in the background", root.display()));
|
||||
assert!(f.loaded().is_empty());
|
||||
assert!(f.host.projects().is_empty());
|
||||
let registry = crate::mcp::Registry::new(f.host.clone());
|
||||
assert_eq!(registry.resolve(&root.join("parts")), None, "no folder is served with the server off");
|
||||
assert!(registry.tools(&root).is_err());
|
||||
|
||||
f.set("enabled", json!(true));
|
||||
assert_eq!(registry.resolve(&root.join("parts")), Some(root));
|
||||
f.open("inventory");
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_opening_another_folder_does_not_wait_for_a_background_open() {
|
||||
let f = Fixture::new();
|
||||
let key = BackgroundProjects::key(&f.root("inventory"));
|
||||
// The background open stops at its own open lock, which it takes with the gate held.
|
||||
let lock = f.host.opening(&key);
|
||||
let held = lock.lock();
|
||||
let open = f.open_in_flight("inventory");
|
||||
|
||||
let (host, billing) = (f.host.clone(), f.root("billing"));
|
||||
let (done, opened) = std::sync::mpsc::channel();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(host.open_project("main", &billing).map(|project| project.root.clone()));
|
||||
});
|
||||
let window = opened.recv_timeout(10 * SECOND).expect("the window opens while the background open is held");
|
||||
assert_eq!(window.unwrap(), f.root("billing"));
|
||||
assert!(f.loaded().is_empty(), "the background open is still under way");
|
||||
|
||||
drop(held);
|
||||
open.await.unwrap();
|
||||
assert_eq!(f.loaded(), ["inventory"]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_window_opening_the_folder_that_is_being_opened_waits_for_it_and_takes_it_over() {
|
||||
let f = Fixture::new();
|
||||
let root = f.root("inventory");
|
||||
let key = BackgroundProjects::key(&root);
|
||||
let lock = f.host.opening(&key);
|
||||
let held = lock.lock();
|
||||
let open = f.open_in_flight("inventory");
|
||||
wait_until("the open marks its root", || f.background().state.lock().opening.as_deref() == Some(root.as_path()));
|
||||
|
||||
let (host, folder) = (f.host.clone(), root.clone());
|
||||
let (done, opened) = std::sync::mpsc::channel();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
// The test may have given up waiting.
|
||||
let _ = done.send(host.open_project("main", &folder).map(|project| project.root.clone()));
|
||||
});
|
||||
let early = opened.recv_timeout(A_MOMENT).ok();
|
||||
assert!(early.is_none(), "the window waits for the background open of its own folder");
|
||||
drop(held);
|
||||
open.await.unwrap();
|
||||
assert_eq!(opened.recv_timeout(30 * SECOND).unwrap().unwrap(), root);
|
||||
assert!(f.host.project(&key).is_err(), "the window took the folder over");
|
||||
assert!(f.loaded().is_empty());
|
||||
assert_eq!(f.claims("inventory"), 0);
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::page::{OFFSET, Page};
|
||||
use super::search::{PathScope, paths_param};
|
||||
use super::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{Diagnostic, IdeResult, Severity};
|
||||
use ide_core::{Diagnostic, IdeError, IdeResult, Severity};
|
||||
use serde_json::{Map, Value, json};
|
||||
|
||||
/// Problems `get_project_problems` lists by default.
|
||||
@@ -51,7 +51,28 @@ Lines and UTF-16 columns are 1-based.",
|
||||
]
|
||||
}
|
||||
|
||||
/// Editors and the Problems view are reported by a window: a project served in the
|
||||
/// background has none, and says so instead of answering as if nothing were open.
|
||||
fn reported_by_a_window(call: &Call) -> IdeResult<()> {
|
||||
if !super::BackgroundProjects::is_key(call.window()) {
|
||||
return Ok(());
|
||||
}
|
||||
let (tool, root) = (&call.tool, call.root().display());
|
||||
Err(IdeError::unavailable(format!(
|
||||
"{tool} needs the project open in a window: {root} is served in the background."
|
||||
)))
|
||||
}
|
||||
|
||||
/// [`reported_by_a_window`] for the Problems view, which `check_files` stands in for.
|
||||
fn problems_reported_by_a_window(call: &Call) -> IdeResult<()> {
|
||||
reported_by_a_window(call).map_err(|mut error| {
|
||||
error.message.push_str(" Use check_files for diagnostics.");
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
reported_by_a_window(&call)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
let windows = call.host.mcp_windows(call.root());
|
||||
let open = call.host.mcp_reports.editors(&windows);
|
||||
@@ -63,6 +84,7 @@ async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
}
|
||||
|
||||
async fn current_file(call: Call) -> IdeResult<Output> {
|
||||
reported_by_a_window(&call)?;
|
||||
let editor = call.host.mcp_reports.focused(call.window());
|
||||
Output::json(match editor {
|
||||
None => json!({}),
|
||||
@@ -85,6 +107,7 @@ pub(super) fn problem(d: Diagnostic, text: &str) -> Value {
|
||||
}
|
||||
|
||||
async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
problems_reported_by_a_window(&call)?;
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
|
||||
@@ -101,6 +124,7 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
}
|
||||
|
||||
async fn project_problems(call: Call) -> IdeResult<Output> {
|
||||
problems_reported_by_a_window(&call)?;
|
||||
let page = Page::of(&call, PROBLEMS_LIMIT)?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
|
||||
@@ -1,10 +1,12 @@
|
||||
//! Built-in IDE tools. Transport and discovery live in `ide-mcp`.
|
||||
mod background;
|
||||
mod check;
|
||||
mod edit;
|
||||
mod editors;
|
||||
mod requests;
|
||||
pub(crate) mod run;
|
||||
mod vcs;
|
||||
pub use background::{BackgroundProjects, McpBackgroundHold, McpBackgroundProject};
|
||||
pub use requests::Requests;
|
||||
mod files;
|
||||
mod http;
|
||||
@@ -55,12 +57,13 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
|
||||
}
|
||||
|
||||
impl Registry {
|
||||
fn target(&self, root: &Path) -> Result<(String, Arc<crate::Project>), String> {
|
||||
/// The window that answers for `root`: one with the root open, or one it is attached in.
|
||||
fn window(&self, root: &Path) -> Result<Option<(String, Arc<crate::Project>)>, String> {
|
||||
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
|
||||
return Err("project is on a remote host; connect to the MCP server on that host".into());
|
||||
}
|
||||
let projects = self.0.projects.read();
|
||||
let open = || projects.iter().filter(|(_, p)| !p.light);
|
||||
let open = || projects.iter().filter(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
|
||||
let mut windows: Vec<_> = open().filter(|(_, p)| p.root == root).map(|(w, p)| (w.clone(), p.clone())).collect();
|
||||
if windows.is_empty() {
|
||||
// A project attached to an open one: the window it is attached in.
|
||||
@@ -74,23 +77,57 @@ impl Registry {
|
||||
windows.sort_by(|a, b| {
|
||||
(Some(&b.0) == focused.as_ref()).cmp(&(Some(&a.0) == focused.as_ref())).then(a.0.cmp(&b.0))
|
||||
});
|
||||
windows.into_iter().next().ok_or_else(|| "project is no longer open".into())
|
||||
Ok(windows.into_iter().next())
|
||||
}
|
||||
|
||||
/// The window and project a tool call for `root` runs in. Without a window the project
|
||||
/// is served in the background, under its key, and opened now if need be; the guard
|
||||
/// then keeps it loaded for as long as the caller holds it.
|
||||
fn target(&self, root: &Path) -> Result<background::Served, String> {
|
||||
match self.window(root)? {
|
||||
Some((window, project)) => Ok((window, project, None)),
|
||||
None => self.0.mcp_background.open(&self.0, root).map_err(|e| e.message),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the tools listed for `root` include those that write and run. Opens nothing:
|
||||
/// a background project that is not loaded is judged as its open will judge it.
|
||||
fn lists_as_trusted(&self, root: &Path) -> Result<bool, String> {
|
||||
if let Some((_, project)) = self.window(root)? {
|
||||
return Ok(project.is_trusted());
|
||||
}
|
||||
if let Some(project) = self.0.mcp_background.project(&self.0, root) {
|
||||
return Ok(project.is_trusted());
|
||||
}
|
||||
if background::serving_root(&self.0, root).as_deref() == Some(root) {
|
||||
return Ok(self.0.trust.window_trusted(root).unwrap_or(false));
|
||||
}
|
||||
Err("project is no longer open".into())
|
||||
}
|
||||
}
|
||||
impl ToolRegistry for Registry {
|
||||
fn projects(&self) -> Vec<PathBuf> {
|
||||
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).collect();
|
||||
// Window projects only: a background project is reached through `resolve`, so a
|
||||
// request that names no folder still means the only window.
|
||||
let open: Vec<_> = {
|
||||
let projects = self.0.projects.read();
|
||||
let windows = projects.iter().filter(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
|
||||
windows.map(|(_, p)| p.clone()).collect()
|
||||
};
|
||||
// Attached projects are listed too, so a `projectPath` inside one names it.
|
||||
let attached: Vec<_> = open.iter().flat_map(|p| tool::attached_projects(&p.root)).collect();
|
||||
open.into_iter().map(|p| p.root.clone()).chain(attached).chain(self.0.mcp_reports.remote_roots()).collect()
|
||||
}
|
||||
fn resolve(&self, path: &Path) -> Option<PathBuf> {
|
||||
background::serving_root(&self.0, path)
|
||||
}
|
||||
fn tools(&self, root: &Path) -> Result<Vec<ide_mcp::Tool>, String> {
|
||||
let (_, project) = self.target(root)?;
|
||||
let trusted = self.lists_as_trusted(root)?;
|
||||
let mut all: Vec<_> = tools().into_iter().map(|t| t.metadata).collect();
|
||||
if let Some(plugins) = self.0.plugin_host() {
|
||||
all.extend(plugins.mcp_tools(root).into_iter().map(|(_, _, tool)| tool));
|
||||
}
|
||||
Ok(all.into_iter().filter(|t| allowed(t, project.is_trusted())).collect())
|
||||
Ok(all.into_iter().filter(|t| allowed(t, trusted)).collect())
|
||||
}
|
||||
fn call(
|
||||
&self,
|
||||
@@ -109,7 +146,9 @@ impl ToolRegistry for Registry {
|
||||
cancel: CancellationToken,
|
||||
client: &str,
|
||||
) -> Result<String, ToolCallError> {
|
||||
let (window, project) = self.target(root).map_err(ToolCallError::Failed)?;
|
||||
// The guard lives until the call ends, whichever way it leaves: neither the idle
|
||||
// sweep nor the limit unloads a background project a call runs in.
|
||||
let (window, project, _activity) = self.target(root).map_err(ToolCallError::Failed)?;
|
||||
if let Some(plugins) = self.0.plugin_host()
|
||||
&& let Some((plugin, tool, metadata)) =
|
||||
plugins.mcp_tools(root).into_iter().find(|(_, _, t)| t.name == name && allowed(t, project.is_trusted()))
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Agents › IDE MCP Server: runs `ide_mcp::McpServer` over built-in host tools
|
||||
//! while `mcpServer.enabled` is on, and reports where it listens.
|
||||
|
||||
use super::McpBackgroundProject;
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeResult, IpcPath};
|
||||
@@ -10,6 +11,7 @@ use specta::Type;
|
||||
use std::net::IpAddr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::time::Instant;
|
||||
|
||||
/// The server while it runs, or why it doesn't.
|
||||
#[derive(Default)]
|
||||
@@ -57,6 +59,17 @@ impl McpService {
|
||||
/// Starts, stops or restarts the server to match the global `mcpServer` settings:
|
||||
/// `enabled`, and the address, port and token it listens with.
|
||||
pub fn apply(&self, host: &Arc<Host>) {
|
||||
// Callers include the main thread (sync commands, app set-up), which must not wait for
|
||||
// a background project that is being opened.
|
||||
let worker = {
|
||||
let host = host.clone();
|
||||
host.runtime.clone().spawn_blocking(move || host.apply_background_policy())
|
||||
};
|
||||
host.runtime.spawn(async move {
|
||||
if let Err(error) = worker.await {
|
||||
tracing::warn!(%error, "applying the background project policy failed");
|
||||
}
|
||||
});
|
||||
let settings = host.global_settings.effective().mcp_server;
|
||||
let mut server = self.server.lock();
|
||||
if !settings.enabled {
|
||||
@@ -247,6 +260,24 @@ pub fn mcp_regenerate_token(host: &Arc<Host>) -> IdeResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Settings › Agents › IDE MCP Server › Background projects: the projects this host's server
|
||||
/// keeps loaded without a window.
|
||||
#[command(trust = always)]
|
||||
pub fn mcp_background_projects(host: &Host) -> IdeResult<Vec<McpBackgroundProject>> {
|
||||
Ok(host.mcp_background.snapshot(host, Instant::now()))
|
||||
}
|
||||
|
||||
/// Unloads one background project; a root that is not loaded is already unloaded.
|
||||
#[command(trust = always)]
|
||||
pub async fn mcp_unload_background_project(host: &Arc<Host>, root: IpcPath) -> IdeResult<()> {
|
||||
let h = host.clone();
|
||||
host.blocking(move || {
|
||||
h.mcp_background.detach(&h, &root, None);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_ui_ready(host: &Host, window: &str, ready: bool) -> IdeResult<()> {
|
||||
let window = host.owner_window(window);
|
||||
@@ -289,8 +320,10 @@ mod tests {
|
||||
ide_command::domain!(
|
||||
mcp:
|
||||
mcp_agent_run_closed,
|
||||
mcp_background_projects,
|
||||
mcp_regenerate_token,
|
||||
mcp_respond,
|
||||
mcp_server_status,
|
||||
mcp_ui_ready,
|
||||
mcp_unload_background_project,
|
||||
);
|
||||
@@ -176,7 +176,9 @@ impl Call {
|
||||
let r = ide_vfs::split_archive_path(&r).map_or(r.clone(), |(archive, _)| archive);
|
||||
dunce::canonicalize(r).is_ok_and(|r| real.starts_with(r))
|
||||
}) {
|
||||
return Err(IdeError::invalid("path is outside the project's content roots"));
|
||||
return Err(IdeError::invalid(
|
||||
"path is outside the project's content roots: ask the user before reading anything else outside the project",
|
||||
));
|
||||
}
|
||||
Ok(entry.map_or_else(|| real.clone(), |entry| PathBuf::from(format!("{}!/{entry}", real.display()))))
|
||||
})
|
||||
@@ -236,7 +238,7 @@ impl Tool {
|
||||
destructive: false,
|
||||
output_schema: None,
|
||||
input_schema: json!({ "type": "object", "properties": {
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
|
||||
"projectPath": { "type": "string", "description": "Any directory inside a project that is open in a window or served in the background. Defaults to the connection's project (`?project=`) or the only one open in a window." }
|
||||
}, "required": [] }),
|
||||
},
|
||||
handler: Arc::new(move |call| Box::pin(handler(call))),
|
||||
@@ -307,7 +309,9 @@ pub fn resolve_inside(root: &Path, raw: &str) -> IdeResult<PathBuf> {
|
||||
}
|
||||
let root = dunce::canonicalize(root)?;
|
||||
if !real.starts_with(&root) {
|
||||
return Err(IdeError::invalid("path is outside the project"));
|
||||
return Err(IdeError::invalid(
|
||||
"path is outside the project: these tools change files inside it only; ask the user before touching anything outside it",
|
||||
));
|
||||
}
|
||||
if real
|
||||
.strip_prefix(&root)
|
||||
|
||||
@@ -33,6 +33,16 @@ pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider
|
||||
Ok(providers)
|
||||
}
|
||||
|
||||
/// Hermes Agent profiles on this machine (`default` first); empty without Hermes.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_hermes_profiles(host: &Host, window: &str) -> IdeResult<Vec<ide_agent::hermes::HermesProfile>> {
|
||||
host.require_trust(window)?;
|
||||
let root = ide_agent::hermes::root(dirs::home_dir().as_deref());
|
||||
tokio::task::spawn_blocking(move || root.map(|r| ide_agent::hermes::labeled_profiles(&r)).unwrap_or_default())
|
||||
.await
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_refresh_models(
|
||||
@@ -1075,6 +1085,7 @@ ide_command::domain!(
|
||||
agent_external_sessions,
|
||||
agent_fork,
|
||||
agent_grouped_changes,
|
||||
agent_hermes_profiles,
|
||||
agent_import_session,
|
||||
agent_mcp_discover_sources,
|
||||
agent_mcp_import,
|
||||
|
||||
@@ -32,7 +32,12 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
|
||||
let java_exec = java_exec_path(&config);
|
||||
let agents = if is_jvm_launch(&config) {
|
||||
ide_run::java_agent::current_for(java_exec.as_deref())
|
||||
} else {
|
||||
Default::default()
|
||||
};
|
||||
let config = add_java_agents(config, &agents.options);
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
@@ -211,6 +216,12 @@ fn is_jvm_launch(config: &LaunchConfig) -> bool {
|
||||
&& matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER | ide_dap::adapter::JAVA_ANALYZER)
|
||||
}
|
||||
|
||||
/// `javaExec` from the launch extras, for gating contributed `vmOptions` on JetBrains Runtime.
|
||||
fn java_exec_path(config: &LaunchConfig) -> Option<std::path::PathBuf> {
|
||||
let extra: serde_json::Value = serde_json::from_str(config.extra_json.as_deref()?).ok()?;
|
||||
extra.get("javaExec").and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(std::path::PathBuf::from)
|
||||
}
|
||||
|
||||
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
|
||||
/// java-debug's and java-analyzer's `vmArgs` (one line, or a list) or the Kotlin debugger's
|
||||
/// `vmArguments` (a list).
|
||||
|
||||
@@ -1976,6 +1976,7 @@ pub struct PluginLanguageVisuals {
|
||||
pub injections: Vec<ide_plugin::language_features::Injection>,
|
||||
pub colors: Vec<(String, ide_plugin::language_features::ColorInfo)>,
|
||||
pub gutter_actions: Vec<(String, ide_plugin::language_features::GutterAction)>,
|
||||
pub hover_actions: Vec<(String, ide_plugin::language_features::HoverAction)>,
|
||||
}
|
||||
#[command(trust = trusted)]
|
||||
pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> IdeResult<PluginLanguageVisuals> {
|
||||
@@ -1989,14 +1990,20 @@ pub async fn plugin_language_visuals(host: &Host, window: &str, doc: DocId) -> I
|
||||
version: u64::from(snap.version),
|
||||
text: snap.text,
|
||||
};
|
||||
let mut out =
|
||||
PluginLanguageVisuals { version: d.version, injections: vec![], colors: vec![], gutter_actions: vec![] };
|
||||
let mut out = PluginLanguageVisuals {
|
||||
version: d.version,
|
||||
injections: vec![],
|
||||
colors: vec![],
|
||||
gutter_actions: vec![],
|
||||
hover_actions: vec![],
|
||||
};
|
||||
if d.text.len() <= crate::plugins::navigation::MAX_DOCUMENT_BYTES
|
||||
&& let Some(plugins) = crate::plugins::editor_plugin_host()
|
||||
{
|
||||
out.injections = plugins.provide_injections(&d);
|
||||
out.colors = plugins.language_colors(&d);
|
||||
out.gutter_actions = plugins.language_gutter_actions(&d);
|
||||
out.hover_actions = plugins.language_hover_actions(&d);
|
||||
}
|
||||
project.lsp.set_injections_at(
|
||||
doc,
|
||||
|
||||
@@ -542,7 +542,8 @@ fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local:
|
||||
if !ide_run::java_agent::applies(&config.kind) {
|
||||
return;
|
||||
}
|
||||
let agents = ide_run::java_agent::current();
|
||||
let java = std::path::Path::new(&config.command);
|
||||
let agents = ide_run::java_agent::current_for(Some(java));
|
||||
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
|
||||
if !local {
|
||||
if !agents.options.is_empty() {
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::output_encoding::decode_tool_output;
|
||||
use ide_core::{CancellationToken, Diagnostic, IdeEvent, Pos, Range, Severity, SharedSink};
|
||||
use ide_text::AppliedChange;
|
||||
use ide_workspace::SettingsStore;
|
||||
use ide_workspace::documents::DocumentObserver;
|
||||
use parking_lot::Mutex;
|
||||
@@ -51,6 +52,8 @@ pub(crate) struct Phpstan {
|
||||
changed: Notify,
|
||||
/// Files with PHPStan diagnostics, the only ones a clean result or a removal clears.
|
||||
shown: Mutex<HashSet<PathBuf>>,
|
||||
/// Files edited since their last save: a check of the saved text has no ranges for them.
|
||||
edited: Mutex<HashSet<PathBuf>>,
|
||||
}
|
||||
|
||||
impl Phpstan {
|
||||
@@ -71,6 +74,7 @@ impl Phpstan {
|
||||
queue: Mutex::new(Queue::default()),
|
||||
changed: Notify::new(),
|
||||
shown: Mutex::new(HashSet::new()),
|
||||
edited: Mutex::new(HashSet::new()),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -96,6 +100,12 @@ impl Phpstan {
|
||||
if self.lifetime.is_cancelled() || files.peek().is_none() {
|
||||
return;
|
||||
}
|
||||
let files: Vec<PathBuf> = files.collect();
|
||||
let mut edited = self.edited.lock();
|
||||
for path in &files {
|
||||
edited.remove(path);
|
||||
}
|
||||
drop(edited);
|
||||
self.queue.lock().push(files);
|
||||
self.changed.notify_one();
|
||||
}
|
||||
@@ -205,6 +215,10 @@ impl Phpstan {
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
for (path, items) in results {
|
||||
// Edited while the saved text was checked: its lines moved since.
|
||||
if self.edited.lock().contains(&path) {
|
||||
continue;
|
||||
}
|
||||
// Severe errors (a syntax error) stop the analysis of the other files.
|
||||
if report.complete || !items.is_empty() {
|
||||
self.publish(path, items);
|
||||
@@ -246,6 +260,23 @@ impl DocumentObserver for Phpstan {
|
||||
fn saved(&self, _doc: ide_core::DocId, path: &Path, _text: &str) {
|
||||
self.files_saved([path.to_path_buf()]);
|
||||
}
|
||||
|
||||
/// The shown ranges belong to the saved text PHPStan ran on, so an edit that
|
||||
/// reaches the buffer before the next save would paint them on other lines
|
||||
/// (`issue #4482`): drop them until the file is saved again.
|
||||
fn changed(
|
||||
&self,
|
||||
_doc: ide_core::DocId,
|
||||
path: &Path,
|
||||
_version: u32,
|
||||
_changes: &[AppliedChange],
|
||||
_full_text: &dyn Fn() -> String,
|
||||
) {
|
||||
if !path.extension().is_some_and(|e| e == "php") || !self.edited.lock().insert(path.to_path_buf()) {
|
||||
return;
|
||||
}
|
||||
self.publish(path.to_path_buf(), Vec::new());
|
||||
}
|
||||
}
|
||||
|
||||
async fn debounce(cancel: &CancellationToken, lifetime: &CancellationToken) -> bool {
|
||||
@@ -847,4 +878,52 @@ mod tests {
|
||||
assert_eq!(f.diagnostics()[1], (a, vec![]));
|
||||
f.checker.stop();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn an_edit_before_the_next_save_drops_the_saved_text_diagnostics() {
|
||||
let f = Fixture::new();
|
||||
let a = f.file("A.php");
|
||||
f.report(&a, &["constant.notFound"]);
|
||||
f.checker.files_saved([a.clone()]);
|
||||
f.until("the check", |f| f.diagnostics().len() == 1).await;
|
||||
|
||||
let edit = || {
|
||||
[AppliedChange { range: ide_core::Range::point(ide_core::Pos::new(1, 0)), text: "$aaa = array();".into() }]
|
||||
};
|
||||
let full = || String::new();
|
||||
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 1, &edit(), &full);
|
||||
f.until("the drop", |f| f.diagnostics().len() == 2).await;
|
||||
assert_eq!(f.diagnostics()[1], (a.clone(), vec![]));
|
||||
// Further edits of the same dirty buffer change nothing.
|
||||
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 2, &edit(), &full);
|
||||
tokio::time::sleep(Duration::from_millis(150)).await;
|
||||
assert_eq!(f.diagnostics().len(), 2);
|
||||
|
||||
// The next save checks the file again.
|
||||
f.report(&a, &["constant.notFound"]);
|
||||
f.checker.files_saved([a.clone()]);
|
||||
f.until("the fresh check", |f| f.diagnostics().len() == 3).await;
|
||||
assert_eq!(f.diagnostics()[2], (a.clone(), vec![Some("constant.notFound".to_string())]));
|
||||
f.checker.stop();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_check_finishing_after_an_edit_shows_nothing_until_the_next_save() {
|
||||
let f = Fixture::new();
|
||||
let a = f.file("A.php");
|
||||
f.report(&a, &["constant.notFound"]);
|
||||
f.checker.files_saved([a.clone()]);
|
||||
let edit = [AppliedChange { range: ide_core::Range::point(ide_core::Pos::new(1, 0)), text: "\n".into() }];
|
||||
DocumentObserver::changed(f.checker.as_ref(), ide_core::DocId(0), &a, 1, &edit, &String::new);
|
||||
f.until("the check", |f| !f.runs().is_empty()).await;
|
||||
tokio::time::sleep(Duration::from_millis(300)).await;
|
||||
assert!(f.diagnostics().is_empty(), "{:?}", f.diagnostics());
|
||||
|
||||
f.checker.files_saved([a.clone()]);
|
||||
f.until("the next check", |f| f.diagnostics().len() == 1).await;
|
||||
assert_eq!(f.diagnostics()[0], (a.clone(), vec![Some("constant.notFound".to_string())]));
|
||||
f.checker.stop();
|
||||
}
|
||||
}
|
||||
@@ -406,15 +406,16 @@ impl Proc {
|
||||
}
|
||||
}
|
||||
|
||||
/// What it printed since the last call, each stream at most `max` bytes.
|
||||
/// What it printed since the last call, each stream at most `max` bytes. The status
|
||||
/// comes with the last chunk only: once it ended, its pipes reached the end and
|
||||
/// nothing is left to read, so a caller can stop at the first chunk that has one.
|
||||
fn chunk(&self, max: usize) -> ProcessChunk {
|
||||
let mut state = self.state.lock();
|
||||
let eof = state.readers == 0;
|
||||
ProcessChunk {
|
||||
stdout: take_text(&mut state.stdout, max, eof),
|
||||
stderr: take_text(&mut state.stderr, max, eof),
|
||||
status: state.status,
|
||||
}
|
||||
let stdout = take_text(&mut state.stdout, max, eof);
|
||||
let stderr = take_text(&mut state.stderr, max, eof);
|
||||
let drained = eof && state.stdout.is_empty() && state.stderr.is_empty();
|
||||
ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2116,6 +2117,23 @@ impl HostApi for PluginApi {
|
||||
.emit(None, PluginEvent::StatusItemChanged { plugin_id: self.id().to_owned(), id: id.to_owned(), item });
|
||||
}
|
||||
|
||||
fn check_status_menu(&self, menu: &[ide_plugin::StatusMenuEntry]) -> Result<(), HostError> {
|
||||
let actions: Vec<ide_plugin::NotificationAction> = menu
|
||||
.iter()
|
||||
.filter_map(|entry| match entry {
|
||||
ide_plugin::StatusMenuEntry::Action { label, command, argument, .. } => {
|
||||
Some(ide_plugin::NotificationAction {
|
||||
label: label.clone(),
|
||||
command: command.clone(),
|
||||
argument: argument.clone(),
|
||||
})
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
check_actions(self, &actions)
|
||||
}
|
||||
|
||||
fn window_status_item(&self, client: &str, id: &str, item: Option<StatusItem>) -> Result<(), HostError> {
|
||||
let closed = self.shared.closed_clients.lock();
|
||||
let blocked = self.shared.prompts_blocked.lock();
|
||||
@@ -4109,6 +4127,27 @@ mod tests {
|
||||
api.release_process(id);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn the_status_comes_with_the_last_of_the_output() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let api = shell_api(tmp.path());
|
||||
let token = CancellationToken::new();
|
||||
let id = api.start_process(shell("printf 'abcdefghij'; printf 'xyz' >&2"), None, None).unwrap();
|
||||
let first = api.wait_process(id, 4, Duration::from_secs(5), &token).unwrap();
|
||||
assert_eq!((first.stdout.as_str(), first.stderr.as_str(), first.status), ("abcd", "xyz", None));
|
||||
let mut stdout = first.stdout;
|
||||
let status = loop {
|
||||
let chunk = api.poll_process(id, 4).unwrap();
|
||||
stdout.push_str(&chunk.stdout);
|
||||
if let Some(status) = chunk.status {
|
||||
break status;
|
||||
}
|
||||
};
|
||||
assert_eq!((stdout.as_str(), status), ("abcdefghij", 0));
|
||||
api.release_process(id);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn programs_run_only_as_approved() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -1,10 +1,13 @@
|
||||
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
|
||||
//! JVM of Application, Spring Boot and JAR Application configurations.
|
||||
//! The `javaAgents` extension point (API 1.10; `vmOptions` / `jdk` in 1.14): a Java
|
||||
//! agent the host loads into the JVM of Application, Spring Boot and JAR Application
|
||||
//! configurations, with optional JVM flags.
|
||||
//!
|
||||
//! ```toml
|
||||
//! [[contributes.javaAgents]]
|
||||
//! path = "agent/openidea-spring-agent.jar" # inside the package
|
||||
//! args = "optional-arguments" # optional
|
||||
//! vmOptions = ["-XX:+AllowEnhancedClassRedefinition"] # optional, API 1.14
|
||||
//! jdk = "jetbrains" # optional: only those VM options on JBR
|
||||
//! ```
|
||||
//!
|
||||
//! One agent per plugin. The declaration derives the optional high-risk `java.agent`
|
||||
@@ -23,6 +26,8 @@ use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
pub const POINT_ID: &str = "javaAgents";
|
||||
const MAX_ARGS: usize = 4096;
|
||||
const MAX_VM_OPTION: usize = 512;
|
||||
const MAX_VM_OPTIONS: usize = 32;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
@@ -30,6 +35,10 @@ struct Decl {
|
||||
path: PathBuf,
|
||||
#[serde(default)]
|
||||
args: Option<String>,
|
||||
#[serde(default, rename = "vmOptions")]
|
||||
vm_options: Vec<String>,
|
||||
#[serde(default)]
|
||||
jdk: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -37,6 +46,8 @@ pub(super) struct Agent {
|
||||
/// The jar, resolved inside the package.
|
||||
pub(super) jar: PathBuf,
|
||||
pub(super) args: Option<String>,
|
||||
pub(super) vm_options: Vec<String>,
|
||||
pub(super) jdk: Option<String>,
|
||||
}
|
||||
|
||||
/// Agents of enabled plugins.
|
||||
@@ -95,20 +106,65 @@ impl ExtensionPoint for JavaAgentsPoint {
|
||||
{
|
||||
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
|
||||
}
|
||||
let label = label(&d.path, args.as_deref());
|
||||
let vm_options = validate_vm_options(&d.vm_options)?;
|
||||
let jdk = validate_jdk(d.jdk)?;
|
||||
if !vm_options.is_empty() || jdk.is_some() {
|
||||
pkg.manifest.needs_api("contributes.javaAgents.vmOptions", 14)?;
|
||||
}
|
||||
let label = label(&d.path, args.as_deref(), &vm_options);
|
||||
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
|
||||
let agent = Agent { jar, args };
|
||||
let agent = Agent { jar, args, vm_options, jdk };
|
||||
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
|
||||
}
|
||||
}
|
||||
|
||||
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
|
||||
fn label(path: &Path, args: Option<&str>) -> String {
|
||||
fn validate_vm_options(raw: &[String]) -> Result<Vec<String>, String> {
|
||||
if raw.len() > MAX_VM_OPTIONS {
|
||||
return Err(format!("contributes.javaAgents: at most {MAX_VM_OPTIONS} `vmOptions`"));
|
||||
}
|
||||
let mut out = Vec::with_capacity(raw.len());
|
||||
for opt in raw {
|
||||
let opt = opt.trim();
|
||||
if opt.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if !opt.starts_with('-')
|
||||
|| opt.len() > MAX_VM_OPTION
|
||||
|| opt.contains(|c: char| c.is_control() || c.is_whitespace())
|
||||
{
|
||||
return Err(format!(
|
||||
"contributes.javaAgents: each `vmOptions` entry must be one flag starting with `-` (at most {MAX_VM_OPTION} bytes, no spaces)"
|
||||
));
|
||||
}
|
||||
if !out.iter().any(|o: &String| o == opt) {
|
||||
out.push(opt.to_owned());
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn validate_jdk(jdk: Option<String>) -> Result<Option<String>, String> {
|
||||
let Some(raw) = jdk.map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()) else {
|
||||
return Ok(None);
|
||||
};
|
||||
if raw != "jetbrains" {
|
||||
return Err("contributes.javaAgents: `jdk` must be \"jetbrains\" when set".into());
|
||||
}
|
||||
Ok(Some(raw))
|
||||
}
|
||||
|
||||
/// What Settings › Plugins shows: jar name, args, and any JVM options.
|
||||
fn label(path: &Path, args: Option<&str>, vm_options: &[String]) -> String {
|
||||
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
match args {
|
||||
let mut out = match args {
|
||||
Some(args) => format!("{name}={args}"),
|
||||
None => name,
|
||||
};
|
||||
if !vm_options.is_empty() {
|
||||
out.push(' ');
|
||||
out.push_str(&vm_options.join(" "));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The jar a package's declaration names, as an absolute path inside the package:
|
||||
@@ -135,6 +191,16 @@ pub(super) fn declared_jar(manifest: &Manifest, dir: &Path) -> Option<PathBuf> {
|
||||
resolve(dir, &d.path).ok()
|
||||
}
|
||||
|
||||
/// Declared `vmOptions` (for consent / Settings copy), if the package has a valid declaration.
|
||||
pub(super) fn declared_vm_options(manifest: &Manifest) -> Vec<String> {
|
||||
let decl = manifest.declarations(POINT_ID).into_iter().next();
|
||||
let Some(decl) = decl else { return Vec::new() };
|
||||
let Ok(d) = decode::<Decl>(POINT_ID, decl) else {
|
||||
return Vec::new();
|
||||
};
|
||||
validate_vm_options(&d.vm_options).unwrap_or_default()
|
||||
}
|
||||
|
||||
type Pins = Arc<RwLock<HashMap<(String, String), ProgramPin>>>;
|
||||
|
||||
/// [`JavaAgentSource`] over the agents and the hashes granted for them.
|
||||
@@ -155,6 +221,8 @@ impl JavaAgentSource for PluginJavaAgents {
|
||||
plugin: plugin.clone(),
|
||||
jar: agent.jar.clone(),
|
||||
args: agent.args.clone(),
|
||||
vm_options: agent.vm_options.clone(),
|
||||
jdk: agent.jdk.clone(),
|
||||
approved_hash: pins.get(&(plugin.clone(), cap.clone())).map(|pin| pin.hash.clone()),
|
||||
})
|
||||
.collect()
|
||||
@@ -167,6 +235,8 @@ mod tests {
|
||||
|
||||
const MANIFEST: &str =
|
||||
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.10\"\n";
|
||||
const MANIFEST_14: &str =
|
||||
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.14\"\n";
|
||||
|
||||
fn package(dir: &Path, manifest: &str) -> Package {
|
||||
std::fs::create_dir_all(dir.join("agent")).unwrap();
|
||||
@@ -209,12 +279,33 @@ mod tests {
|
||||
(agents[0].plugin.as_str(), agents[0].args.as_deref(), agents[0].approved_hash.as_ref()),
|
||||
("acme.spring", Some("port=0,trace"), None)
|
||||
);
|
||||
assert!(agents[0].vm_options.is_empty());
|
||||
source.pins.write().insert(("acme.spring".into(), "java.agent".into()), ProgramPin::approve(&jar).unwrap());
|
||||
assert!(source.agents()[0].approved_hash.is_some());
|
||||
disposable.dispose();
|
||||
assert!(source.agents().is_empty(), "disabling the plugin drops its agent");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_vm_options_and_jdk_gate() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let toml = format!(
|
||||
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"-XX:+AllowEnhancedClassRedefinition\"]\njdk = \"jetbrains\"\n"
|
||||
);
|
||||
let pkg = package(tmp.path(), &toml);
|
||||
let prepared = prepare(&pkg).unwrap();
|
||||
assert_eq!(prepared.label, "spring agent.jar -XX:+AllowEnhancedClassRedefinition");
|
||||
assert_eq!(declared_vm_options(&pkg.manifest), ["-XX:+AllowEnhancedClassRedefinition"]);
|
||||
|
||||
let store: Arc<JavaAgents> = Arc::default();
|
||||
let point = JavaAgentsPoint::new(store.clone());
|
||||
let decl = pkg.manifest.declarations(POINT_ID).remove(0);
|
||||
let _keep = (point.prepare(&pkg, decl).unwrap().commit)().unwrap();
|
||||
let agent = store.for_plugin("acme.spring").unwrap();
|
||||
assert_eq!(agent.vm_options, ["-XX:+AllowEnhancedClassRedefinition"]);
|
||||
assert_eq!(agent.jdk.as_deref(), Some("jetbrains"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_what_would_fail_at_launch() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -242,6 +333,33 @@ mod tests {
|
||||
);
|
||||
let old = format!("{}{}", MANIFEST.replace("^1.10", "^1.9"), agent("agent/spring agent.jar"));
|
||||
assert!(refused(7, &old).contains("new in plugin API 1.10"));
|
||||
assert!(
|
||||
refused(
|
||||
9,
|
||||
&format!(
|
||||
"{MANIFEST}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"-XX:+AllowEnhancedClassRedefinition\"]\n"
|
||||
),
|
||||
)
|
||||
.contains("new in plugin API 1.14")
|
||||
);
|
||||
assert!(
|
||||
refused(
|
||||
10,
|
||||
&format!(
|
||||
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nvmOptions = [\"not-a-flag\"]\n"
|
||||
),
|
||||
)
|
||||
.contains("starting with `-`")
|
||||
);
|
||||
assert!(
|
||||
refused(
|
||||
11,
|
||||
&format!(
|
||||
"{MANIFEST_14}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\njdk = \"temurin\"\n"
|
||||
),
|
||||
)
|
||||
.contains("jetbrains")
|
||||
);
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let dir = tmp.path().join("8");
|
||||
|
||||
@@ -276,6 +276,34 @@ impl PluginHost {
|
||||
}
|
||||
out
|
||||
}
|
||||
/// Optional API 1.14 hover actions. Only plugins declaring the
|
||||
/// `hover-actions` provider kind are asked; the released language-features
|
||||
/// export remains unchanged.
|
||||
pub fn language_hover_actions(&self, doc: &ProviderDocument) -> Vec<(String, HoverAction)> {
|
||||
let mut out = Vec::new();
|
||||
for (d, _bounds) in self.feature_documents(doc, None) {
|
||||
let snapshot = d.clone();
|
||||
let text = ide_text::Document::new(&snapshot.text);
|
||||
let d = Arc::new(d);
|
||||
let results = self
|
||||
.document_calls(ProviderKind::HoverActions, &snapshot, move |rt, t| rt.language_hover_actions(&d, t));
|
||||
for (p, items) in results {
|
||||
let commands: std::collections::HashSet<_> =
|
||||
self.ui.items(super::COMMANDS, Some(p.id())).into_iter().map(|c| c.key).collect();
|
||||
for i in items {
|
||||
let lines = text.line_count();
|
||||
let anchor_ok = i.line < lines;
|
||||
let range_ok = i.start_line <= i.end_line && i.end_line < lines;
|
||||
let contains_anchor = i.start_line <= i.line && i.line <= i.end_line;
|
||||
if anchor_ok && range_ok && contains_anchor && commands.contains(&i.command) {
|
||||
out.push((p.id().to_owned(), i));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn language_gutter_actions(&self, doc: &ProviderDocument) -> Vec<(String, GutterAction)> {
|
||||
let mut out = Vec::new();
|
||||
for (d, bounds) in self.feature_documents(doc, None) {
|
||||
|
||||
@@ -925,6 +925,7 @@ impl PluginHost {
|
||||
capabilities.push(CapabilityInfo::new(extra, true, granted(extra)));
|
||||
}
|
||||
}
|
||||
annotate_java_agent_vm_options(&mut capabilities, m);
|
||||
capabilities.sort_by(|a, b| b.risk.cmp(&a.risk).then(a.id.cmp(&b.id)));
|
||||
let signer_changed = self.signer_changed(&m.id, src);
|
||||
let answered = |c: &CapabilityInfo| {
|
||||
@@ -3085,6 +3086,7 @@ impl PluginHost {
|
||||
capabilities.push(CapabilityInfo::new(extra, true, granted(extra)));
|
||||
}
|
||||
}
|
||||
annotate_java_agent_vm_options(&mut capabilities, m);
|
||||
// Hosts remembered through `net:ask` are grants of their own: listed
|
||||
// separately so the user can revoke them one by one.
|
||||
let net_hosts = grant
|
||||
@@ -3118,6 +3120,8 @@ impl PluginHost {
|
||||
.map(|name| name.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| agent.jar.display().to_string()),
|
||||
args: agent.args,
|
||||
vm_options: agent.vm_options,
|
||||
jdk: agent.jdk,
|
||||
approved,
|
||||
}
|
||||
}),
|
||||
@@ -3157,6 +3161,20 @@ fn agent_jar_grant(manifest: &Manifest, dir: &Path) -> Option<BinaryGrant> {
|
||||
Some(BinaryGrant { path, hash })
|
||||
}
|
||||
|
||||
/// Consent / Settings: surface exact contributed JVM flags on the `java.agent` permission.
|
||||
fn annotate_java_agent_vm_options(capabilities: &mut [CapabilityInfo], manifest: &Manifest) {
|
||||
let opts = java_agents::declared_vm_options(manifest);
|
||||
if opts.is_empty() {
|
||||
return;
|
||||
}
|
||||
let flags = opts.join(" ");
|
||||
for cap in capabilities.iter_mut() {
|
||||
if cap.id == "java.agent" {
|
||||
cap.description = format!("{}; JVM options: {flags}", cap.description);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn request_for<'a>(subject: &Subject, m: &'a Manifest, hash: &'a str, declared: &[Capability]) -> Request<'a> {
|
||||
let mut optional = m.capabilities.optional.clone();
|
||||
// What declarations need (a language server's `process:`) is optional:
|
||||
|
||||
@@ -54,6 +54,7 @@ pub enum ProviderKind {
|
||||
Implementation,
|
||||
TypeDefinition,
|
||||
GutterActions,
|
||||
HoverActions,
|
||||
Injections,
|
||||
}
|
||||
|
||||
@@ -204,11 +205,15 @@ impl ExtensionPoint for ProvidersPoint {
|
||||
| ProviderKind::Implementation
|
||||
| ProviderKind::TypeDefinition
|
||||
| ProviderKind::GutterActions
|
||||
| ProviderKind::HoverActions
|
||||
| ProviderKind::Injections
|
||||
)
|
||||
}) {
|
||||
pkg.manifest.needs_api("contributes.providers: language features and injections", 4)?;
|
||||
}
|
||||
if d.kinds.contains(&ProviderKind::HoverActions) {
|
||||
pkg.manifest.needs_api("contributes.providers: hover-actions", 14)?;
|
||||
}
|
||||
for l in &d.languages {
|
||||
if l != "*"
|
||||
&& (l.is_empty()
|
||||
|
||||
@@ -63,6 +63,10 @@ pub struct PluginJavaAgent {
|
||||
pub file_name: String,
|
||||
/// The optional argument passed after `=`.
|
||||
pub args: Option<String>,
|
||||
/// Extra JVM flags from `vmOptions` (API 1.14).
|
||||
pub vm_options: Vec<String>,
|
||||
/// When `Some("jetbrains")`, those VM options apply only on JetBrains Runtime.
|
||||
pub jdk: Option<String>,
|
||||
/// The jar still has the hash recorded when `java.agent` was granted.
|
||||
pub approved: bool,
|
||||
}
|
||||
|
||||
@@ -106,6 +106,9 @@ impl Host {
|
||||
{
|
||||
return Ok(current);
|
||||
}
|
||||
// A window takes the root over from the MCP server's background project, whose
|
||||
// shutdown the wait below sits out; none opens until this open is over.
|
||||
let _claim = (!crate::mcp::BackgroundProjects::is_key(window)).then(|| self.mcp_background.claim(self, &root));
|
||||
self.close_project(window);
|
||||
self.wait_detached_closes();
|
||||
let sink: SharedSink = (self.sink_for)(window);
|
||||
|
||||
@@ -177,6 +177,7 @@ pub fn event_sink(peer: Arc<OnceLock<Peer>>, window: Option<String>) -> ide_core
|
||||
pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
|
||||
match event {
|
||||
IdeEvent::WindowGroupsChanged
|
||||
| IdeEvent::McpBackgroundProjectsChanged
|
||||
| IdeEvent::WindowFullscreenChanged
|
||||
| IdeEvent::RemoteConnectionLost { .. }
|
||||
| IdeEvent::UpdateStatusChanged { .. }
|
||||
@@ -323,6 +324,7 @@ mod tests {
|
||||
},
|
||||
IdeEvent::WindowGroupsChanged,
|
||||
IdeEvent::WindowFullscreenChanged,
|
||||
IdeEvent::McpBackgroundProjectsChanged,
|
||||
] {
|
||||
assert!(!client_accepts(&event, true), "{event:?}");
|
||||
}
|
||||
|
||||
@@ -244,6 +244,9 @@ impl crate::Host {
|
||||
}
|
||||
|
||||
pub async fn refresh_project_trust(&self) -> IdeResult<()> {
|
||||
// A background project that is being opened read the trust before this decision and
|
||||
// is not among the projects yet: once its open is over, the loop below corrects it.
|
||||
Self::in_place(|| self.mcp_background.wait_for_open());
|
||||
for project in self.projects().into_iter().filter(|p| !p.light) {
|
||||
let trusted = self.trust.window_trusted(&project.root).unwrap_or(false);
|
||||
let roots = project.content_roots();
|
||||
@@ -305,6 +308,9 @@ impl crate::Host {
|
||||
crate::ops::sdk::container_python::ensure(self, &project);
|
||||
project.sink.emit(ide_core::IdeEvent::ProjectTrustChanged { root: project.root.clone().into(), trusted });
|
||||
}
|
||||
// Trust decides which projects are served without a window. The step waits for a
|
||||
// background open under way and reads files: not on an async worker.
|
||||
Self::in_place(|| self.apply_background_policy());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use ide_core::{CancellationToken, ChangeSet, Diagnostic, IdeEvent, Pos, Range, Severity, TextChange};
|
||||
use ide_host::mcp::{FileProblems, FocusedEditor, Registry};
|
||||
use ide_host::mcp::{BackgroundProjects, FileProblems, FocusedEditor, Registry};
|
||||
use ide_host::{Host, HostConfig};
|
||||
use ide_mcp::ToolRegistry;
|
||||
use serde_json::{Value, json};
|
||||
@@ -83,14 +83,65 @@ impl Harness {
|
||||
async fn json(&self, name: &str, args: Value) -> Value {
|
||||
serde_json::from_str(&self.call(name, args).await).unwrap()
|
||||
}
|
||||
fn set(&self, key: &str, value: Value) {
|
||||
let key = format!("mcpServer.{key}");
|
||||
self.host.global_settings.set(ide_workspace::SettingsScope::Global, &key, value).unwrap();
|
||||
}
|
||||
/// The folder `inventory` next to the open project, listed to be served without a window.
|
||||
fn serve_inventory(&self) -> PathBuf {
|
||||
let inventory = self.root.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir_all(inventory.join("src")).unwrap();
|
||||
std::fs::write(inventory.join("src/stock.txt"), "forty crates\n").unwrap();
|
||||
self.set("enabled", json!(true));
|
||||
self.set("backgroundProjects", json!("listed"));
|
||||
self.set("backgroundProjectPaths", json!([inventory]));
|
||||
inventory
|
||||
}
|
||||
/// Roots of the projects loaded without a window.
|
||||
fn background(&self) -> Vec<PathBuf> {
|
||||
let loaded = self.host.mcp_background.snapshot(&self.host, std::time::Instant::now());
|
||||
loaded.into_iter().map(|project| project.root.into_path_buf()).collect()
|
||||
}
|
||||
/// A tool call for the project at `root`: its text, or its error.
|
||||
async fn call_at(&self, root: &Path, name: &str, args: Value) -> Result<String, String> {
|
||||
let (host, root, name) = (self.host.clone(), root.to_owned(), name.to_owned());
|
||||
let call = move || Registry::new(host).call(&root, &name, &args.to_string(), CancellationToken::new());
|
||||
tokio::task::spawn_blocking(call).await.unwrap().map_err(|e| match e {
|
||||
ide_mcp::ToolCallError::Failed(e) | ide_mcp::ToolCallError::UnknownTool(e) => e,
|
||||
})
|
||||
}
|
||||
fn server(&self) -> (ide_mcp::McpServer, PathBuf) {
|
||||
let discovery = ide_mcp::discovery_path(self.tmp.path());
|
||||
let registry = Arc::new(Registry::new(self.host.clone()));
|
||||
let runtime = tokio::runtime::Handle::current();
|
||||
(ide_mcp::McpServer::start(registry, Some(discovery.clone()), &runtime).unwrap(), discovery)
|
||||
}
|
||||
}
|
||||
impl Drop for Harness {
|
||||
fn drop(&mut self) {
|
||||
self.host.close_project("main");
|
||||
self.host.close_project("second");
|
||||
for root in self.background() {
|
||||
self.host.close_project(&BackgroundProjects::key(&root));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What the stdio bridge started in `folder` answers to `requests`, by request id.
|
||||
async fn bridged(discovery: &Path, folder: &Path, requests: &[Value]) -> Vec<Value> {
|
||||
let input: String = requests.iter().map(|request| format!("{request}\n")).collect();
|
||||
let mut output = Vec::new();
|
||||
ide_mcp::stdio::bridge(discovery, folder, input.as_bytes(), &mut output).await.unwrap();
|
||||
let mut replies: Vec<Value> =
|
||||
String::from_utf8(output).unwrap().lines().map(|line| serde_json::from_str(line).unwrap()).collect();
|
||||
replies.sort_by_key(|reply| reply["id"].as_i64());
|
||||
replies
|
||||
}
|
||||
|
||||
fn rpc(id: u32, method: &str, params: Value) -> Value {
|
||||
json!({"jsonrpc":"2.0","id":id,"method":method,"params":params})
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn reads_unsaved_text_and_searches_the_overlay_with_a_limit() {
|
||||
let h = Harness::new();
|
||||
@@ -1300,3 +1351,235 @@ async fn call_hierarchy_pages_are_sorted_and_scoped() {
|
||||
assert_eq!(scoped["total"], 1);
|
||||
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the paths");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_folder_without_a_window_is_opened_by_its_first_tool_call() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
let (_server, discovery) = h.server();
|
||||
let folder = inventory.join("src");
|
||||
let replies =
|
||||
bridged(&discovery, &folder, &[rpc(1, "initialize", json!({})), rpc(2, "tools/list", json!({}))]).await;
|
||||
let instructions = replies[0]["result"]["instructions"].as_str().unwrap();
|
||||
assert!(instructions.contains(inventory.to_str().unwrap()), "{instructions}");
|
||||
let tools = replies[1]["result"]["tools"].as_array().unwrap();
|
||||
assert!(tools.iter().any(|tool| tool["name"] == "read_file"), "{tools:?}");
|
||||
assert!(tools.iter().all(|tool| tool["annotations"]["readOnlyHint"] == true), "nobody trusted the folder");
|
||||
assert!(h.background().is_empty(), "initialize and tools/list open nothing");
|
||||
assert_eq!(h.host.projects().len(), 1);
|
||||
|
||||
let read = rpc(3, "tools/call", json!({"name":"read_file","arguments":{"file_path":"src/stock.txt"}}));
|
||||
let replies = bridged(&discovery, &folder, &[read]).await;
|
||||
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: forty crates\nL2: ", "{replies:?}");
|
||||
assert_eq!(h.background(), std::slice::from_ref(&inventory));
|
||||
// Loaded, it is still no project of a window.
|
||||
assert_eq!(Registry::new(h.host.clone()).projects(), std::slice::from_ref(&h.root));
|
||||
assert!(h.host.project("main").is_ok());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn with_background_projects_off_a_folder_outside_the_open_projects_is_refused() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.root.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir_all(&inventory).unwrap();
|
||||
let (_server, discovery) = h.server();
|
||||
let list = rpc(1, "tools/list", json!({}));
|
||||
let read = rpc(2, "tools/call", json!({"name":"read_file","arguments":{"file_path":"a.txt"}}));
|
||||
for reply in bridged(&discovery, &inventory, &[list, read]).await {
|
||||
assert_eq!(reply["error"]["code"], -32001, "{reply}");
|
||||
let message = reply["error"]["message"].as_str().unwrap();
|
||||
assert!(message.contains("isn't served in the background"), "{message}");
|
||||
}
|
||||
assert!(h.background().is_empty());
|
||||
assert_eq!(h.host.projects().len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn the_tools_of_a_background_project_are_the_same_before_and_after_it_opens() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
let registry = Registry::new(h.host.clone());
|
||||
let restricted = registry.tools(&inventory).unwrap();
|
||||
assert!(!restricted.is_empty() && restricted.iter().all(|t| t.read_only && !t.destructive));
|
||||
assert!(h.background().is_empty(), "listing opens nothing");
|
||||
h.call_at(&inventory, "read_file", json!({"file_path":"src/stock.txt"})).await.unwrap();
|
||||
assert_eq!(registry.tools(&inventory).unwrap(), restricted);
|
||||
|
||||
// Trusted, loaded or not, it has the tools that write and run as well.
|
||||
h.host.set_project_trust(&inventory, true, false).await.unwrap();
|
||||
let trusted = registry.tools(&inventory).unwrap();
|
||||
assert!(trusted.iter().any(|t| t.name == "create_new_file" && !t.read_only));
|
||||
assert!(h.host.mcp_background.detach(&h.host, &inventory, None));
|
||||
assert_eq!(registry.tools(&inventory).unwrap(), trusted);
|
||||
assert!(h.background().is_empty());
|
||||
// The project in the window lists what it did before.
|
||||
assert!(registry.tools(&h.root).unwrap().iter().all(|t| t.read_only));
|
||||
// A folder nothing serves has no tools.
|
||||
assert!(registry.tools(&inventory.join("src")).is_err());
|
||||
}
|
||||
|
||||
/// POSTs `body` to the server without naming a project.
|
||||
async fn post(server: &ide_mcp::McpServer, body: &Value) -> Value {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let (port, body) = (server.port(), body.to_string());
|
||||
let request = format!(
|
||||
"POST /mcp HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nAuthorization: Bearer {}\r\nContent-Type: application/json\r\nAccept: application/json, text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
server.token(),
|
||||
body.len()
|
||||
);
|
||||
let mut stream = tokio::net::TcpStream::connect(("127.0.0.1", port)).await.unwrap();
|
||||
stream.write_all(request.as_bytes()).await.unwrap();
|
||||
let mut reply = String::new();
|
||||
stream.read_to_string(&mut reply).await.unwrap();
|
||||
serde_json::from_str(reply.split_once("\r\n\r\n").unwrap().1).unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_project_open_in_a_window_answers_before_any_background_project() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
// A listed folder inside the open project: the window's project answers for it.
|
||||
h.set("backgroundProjectPaths", json!([inventory, h.root.join("src")]));
|
||||
let (server, discovery) = h.server();
|
||||
let inside = json!({"projectPath": h.root.join("src"), "file_path": "src/b.txt"});
|
||||
let read = rpc(1, "tools/call", json!({"name":"read_file","arguments":inside.clone()}));
|
||||
let replies = bridged(&discovery, &inventory, &[read]).await;
|
||||
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: needle\nL2: ", "{replies:?}");
|
||||
assert!(h.background().is_empty());
|
||||
|
||||
// With a background project loaded, a request that names no folder goes to the only window.
|
||||
h.call_at(&inventory, "read_file", json!({"file_path":"src/stock.txt"})).await.unwrap();
|
||||
assert_eq!(h.background(), std::slice::from_ref(&inventory));
|
||||
let unnamed = rpc(2, "tools/call", json!({"name":"read_file","arguments":{"file_path":"src/b.txt"}}));
|
||||
let reply = post(&server, &unnamed).await;
|
||||
assert_eq!(reply["result"]["content"][0]["text"], "L1: needle\nL2: ", "{reply}");
|
||||
// Nor does a background project loaded inside the window's project take its folder over.
|
||||
let nested = h.root.join("src");
|
||||
h.call_at(&nested, "read_file", json!({"file_path":"b.txt"})).await.unwrap();
|
||||
assert_eq!(h.background(), [inventory.clone(), nested]);
|
||||
let read = rpc(3, "tools/call", json!({"name":"read_file","arguments":inside}));
|
||||
let replies = bridged(&discovery, &inventory, &[read]).await;
|
||||
assert_eq!(replies[0]["result"]["content"][0]["text"], "L1: needle\nL2: ", "{replies:?}");
|
||||
// A second window on another root is served as before.
|
||||
let second = h.root.parent().unwrap().join("second");
|
||||
std::fs::create_dir_all(&second).unwrap();
|
||||
std::fs::write(second.join("unique.txt"), "second project").unwrap();
|
||||
h.host.open_project("second", &second).unwrap();
|
||||
let read = h.call_at(&second, "read_file", json!({"file_path":"unique.txt"})).await.unwrap();
|
||||
assert_eq!(read, "L1: second project");
|
||||
assert_eq!(h.background().len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn tools_fed_by_a_window_say_that_a_background_project_has_none() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
for (tool, args, hint) in [
|
||||
("get_all_open_file_paths", json!({}), ""),
|
||||
("get_current_file", json!({}), ""),
|
||||
("get_file_problems", json!({"filePath":"src/stock.txt"}), " Use check_files for diagnostics."),
|
||||
("get_project_problems", json!({}), " Use check_files for diagnostics."),
|
||||
] {
|
||||
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
|
||||
let root = inventory.display();
|
||||
let expected = format!("{tool} needs the project open in a window: {root} is served in the background.{hint}");
|
||||
assert_eq!(error, expected);
|
||||
}
|
||||
// `check_files` answers there, and the project in the window keeps its answers.
|
||||
let checked = h.call_at(&inventory, "check_files", json!({"filePaths":["src/stock.txt"]})).await.unwrap();
|
||||
assert_eq!(serde_json::from_str::<Value>(&checked).unwrap()["files"][0]["status"], "untrusted", "{checked}");
|
||||
assert_eq!(h.json("get_all_open_file_paths", json!({})).await["openFiles"], json!([]));
|
||||
assert_eq!(h.json("get_current_file", json!({})).await, json!({}));
|
||||
assert_eq!(h.json("get_project_problems", json!({})).await["files"], json!([]));
|
||||
let problems = h.json("get_file_problems", json!({"filePath":"src/a.txt"})).await;
|
||||
assert_eq!(problems["errors"], json!([]));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn tools_that_ask_the_user_fail_closed_in_a_background_project() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
h.host.trust.decide(&inventory, true, false).unwrap();
|
||||
for (tool, args) in [
|
||||
("build_project", json!({})),
|
||||
("run_command", json!({"name":"check","command":"true"})),
|
||||
("open_file_in_editor", json!({"filePath":"src/stock.txt"})),
|
||||
] {
|
||||
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
|
||||
assert!(error.contains("no project window"), "{tool}: {error}");
|
||||
}
|
||||
assert!(h.host.processes.list().is_empty());
|
||||
// Running without confirmation does not give `run_command` or the editor a window.
|
||||
h.set("runWithoutConfirmation", json!(true));
|
||||
for (tool, args) in [
|
||||
("run_command", json!({"name":"check","command":"true"})),
|
||||
("open_file_in_editor", json!({"filePath":"src/stock.txt"})),
|
||||
] {
|
||||
let error = h.call_at(&inventory, tool, args).await.unwrap_err();
|
||||
assert!(error.contains("no project window"), "{tool}: {error}");
|
||||
}
|
||||
assert_eq!(h.background(), [inventory]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_cancelled_or_failed_call_leaves_nothing_holding_the_project() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
let (host, root, cancel) = (h.host.clone(), inventory.clone(), CancellationToken::new());
|
||||
cancel.cancel();
|
||||
let cancelled = tokio::task::spawn_blocking(move || {
|
||||
Registry::new(host).call(&root, "read_file", r#"{"file_path":"src/stock.txt"}"#, cancel)
|
||||
});
|
||||
assert!(cancelled.await.unwrap().is_err());
|
||||
assert!(h.call_at(&inventory, "read_file", json!({"file_path":"src/gone.txt"})).await.is_err());
|
||||
assert!(h.call_at(&inventory, "no_such_tool", json!({})).await.is_err());
|
||||
let loaded = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now());
|
||||
assert_eq!(loaded.len(), 1);
|
||||
assert_eq!(loaded[0].kept_open_by, None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_run_started_without_confirmation_works_in_a_background_project_and_holds_it() {
|
||||
let h = Harness::new();
|
||||
let inventory = h.serve_inventory();
|
||||
h.host.trust.decide(&inventory, true, false).unwrap();
|
||||
h.set("runWithoutConfirmation", json!(true));
|
||||
let config = ide_run::RunConfig {
|
||||
id: "serve".into(),
|
||||
name: "serve stock".into(),
|
||||
kind: "shell".into(),
|
||||
command: "sleep 30".into(),
|
||||
args: vec![],
|
||||
cwd: None,
|
||||
env: Default::default(),
|
||||
detected: false,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
};
|
||||
ide_run::save_user_configs(&inventory, &[config]).unwrap();
|
||||
let call = h.call_at(&inventory, "execute_run_configuration", json!({"configurationName":"serve stock"}));
|
||||
let observe = async {
|
||||
let run = tokio::time::timeout(std::time::Duration::from_secs(30), async {
|
||||
loop {
|
||||
if let Some(run) = h.host.processes.running_in(&inventory).pop() {
|
||||
break run;
|
||||
}
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the run starts");
|
||||
// The call still waits for the run: it holds the project first, the run second.
|
||||
let held = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now()).remove(0);
|
||||
assert_eq!(held.kept_open_by, Some(ide_host::mcp::McpBackgroundHold::Request));
|
||||
h.host.processes.stop(run.id).unwrap();
|
||||
};
|
||||
let (result, ()) = tokio::join!(call, observe);
|
||||
let result: Value = serde_json::from_str(&result.unwrap()).unwrap();
|
||||
assert!(result["exitCode"].is_number() || result["exitCode"].is_null(), "{result}");
|
||||
let loaded = h.host.mcp_background.snapshot(&h.host, std::time::Instant::now()).remove(0);
|
||||
assert_eq!(loaded.kept_open_by, None, "the call is over and the run has exited");
|
||||
}
|
||||
@@ -193,6 +193,41 @@ async fn mcp_listing_dispatch_confirmation_and_lifecycle_use_plugin_authority()
|
||||
assert!(spin.await.unwrap().is_err(), "command budget interrupts wasm");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_plugin_tool_call_holds_its_background_project_until_it_ends() {
|
||||
use ide_host::mcp::{BackgroundProjects, McpBackgroundHold};
|
||||
// The fixture's `spin` runs until it is cancelled or its budget ends.
|
||||
let f = Harness::with_timeout(Duration::from_secs(10));
|
||||
let inventory = f.root.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir(&inventory).unwrap();
|
||||
for (key, value) in [
|
||||
("enabled", serde_json::json!(true)),
|
||||
("backgroundProjects", serde_json::json!("listed")),
|
||||
("backgroundProjectPaths", serde_json::json!([inventory])),
|
||||
] {
|
||||
let key = format!("mcpServer.{key}");
|
||||
f.host.global_settings.set(ide_workspace::SettingsScope::Global, &key, value).unwrap();
|
||||
}
|
||||
let held_by = || {
|
||||
let loaded = f.host.mcp_background.snapshot(&f.host, std::time::Instant::now());
|
||||
loaded.into_iter().next().map(|project| project.kept_open_by)
|
||||
};
|
||||
let (registry, root, cancel) = (Registry::new(f.host.clone()), inventory.clone(), CancellationToken::new());
|
||||
let stop = cancel.clone();
|
||||
let call = tokio::task::spawn_blocking(move || registry.call(&root, "test_data_tools__spin", "{}", cancel));
|
||||
tokio::time::timeout(Duration::from_secs(10), async {
|
||||
while held_by() != Some(Some(McpBackgroundHold::Request)) {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the call holds the project while the plugin runs");
|
||||
stop.cancel();
|
||||
assert!(call.await.unwrap().is_err());
|
||||
assert_eq!(held_by(), Some(None), "the project stays loaded with nothing holding it");
|
||||
f.host.close_project(&BackgroundProjects::key(&inventory));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn database_imports_are_denied_without_the_optional_grant() {
|
||||
let f = Harness::new();
|
||||
|
||||
@@ -152,6 +152,9 @@ async fn editor_ops_merge_the_fixture_format_selection_and_execute_owned_command
|
||||
let visuals = ops::lsp::plugin_language_visuals(&host, "main", doc.id).await.unwrap();
|
||||
assert_eq!(visuals.colors.len(), 1);
|
||||
assert_eq!(visuals.gutter_actions.len(), 1);
|
||||
assert_eq!(visuals.hover_actions.len(), 1);
|
||||
assert_eq!(visuals.hover_actions[0].1.command, "run");
|
||||
assert_eq!(visuals.hover_actions[0].1.end_line, 2);
|
||||
assert_eq!(
|
||||
ops::lsp::plugin_color_presentations(&host, "main", doc.id, ID.into(), visuals.colors[0].1.clone())
|
||||
.await
|
||||
|
||||
@@ -2218,6 +2218,8 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
|
||||
let agent = info.java_agent.clone().expect("agent metadata");
|
||||
assert_eq!(agent.file_name, "fixture agent.jar");
|
||||
assert_eq!(agent.args.as_deref(), Some("mode=test"));
|
||||
assert!(agent.vm_options.is_empty());
|
||||
assert!(agent.jdk.is_none());
|
||||
assert!(!agent.approved);
|
||||
let source = f.host.java_agents();
|
||||
let launch = || {
|
||||
@@ -6384,6 +6386,32 @@ fn api14_window_status_overrides_fall_back_and_are_withdrawn() {
|
||||
&& matches!(event, PluginEvent::WindowStatusItemChanged { item: None, .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_status_item_menu_reaches_the_ui_and_names_only_declared_commands() {
|
||||
let f = fixture(Limits::default());
|
||||
f.install(&sample("api14"));
|
||||
f.run("api14", "menu-status", Some("App: running")).unwrap();
|
||||
let item = f.host.status_snapshot("main").into_iter().find(|i| i.id == "menu").unwrap().item;
|
||||
assert_eq!(item.text, "App: running");
|
||||
assert_eq!(
|
||||
item.menu,
|
||||
[
|
||||
ide_plugin::StatusMenuEntry::Header { label: "App".into() },
|
||||
ide_plugin::StatusMenuEntry::Action {
|
||||
label: "Open".into(),
|
||||
description: Some("https://app.test".into()),
|
||||
command: "events".into(),
|
||||
argument: Some("web".into()),
|
||||
},
|
||||
ide_plugin::StatusMenuEntry::Separator,
|
||||
]
|
||||
);
|
||||
let err = f.run("api14", "bad-menu-status", Some("changed")).unwrap_err();
|
||||
assert!(err.contains("undeclared"), "{err}");
|
||||
let item = f.host.status_snapshot("main").into_iter().find(|i| i.id == "menu").unwrap().item;
|
||||
assert_eq!(item.text, "App: running", "a refused menu changes nothing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn api14_command_requests_preserve_window_result_and_reject_cycles() {
|
||||
let f = Arc::new(fixture(Limits::default()));
|
||||
|
||||
@@ -65,8 +65,23 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
|
||||
/// The client for the current proxy settings, rebuilt when they change.
|
||||
pub fn shared() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build)
|
||||
}
|
||||
|
||||
/// The client the HTTP Client executes requests with: redirects off, `exec`
|
||||
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
|
||||
/// 301/302 and puts the redirect chain into the response.
|
||||
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()))
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>>,
|
||||
build: fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
) -> IdeResult<reqwest::Client> {
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let mut cached = CLIENT.lock();
|
||||
let mut cached = slot.lock();
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
{
|
||||
|
||||
@@ -13,6 +13,19 @@ use std::time::Instant;
|
||||
/// Bodies above this are cut (the full size is still reported).
|
||||
pub const MAX_BODY: usize = 16 * 1024 * 1024;
|
||||
|
||||
/// Redirects followed per request; beyond this the redirect response itself is
|
||||
/// returned (IntelliJ's HTTP Client follows the same number).
|
||||
pub const MAX_REDIRECTS: usize = 50;
|
||||
|
||||
/// Responses whose `Location` is followed: 301, 302, 303, 307 and 308, the set
|
||||
/// IntelliJ's HTTP Client redirects on.
|
||||
const REDIRECT_STATUSES: [u16; 5] = [301, 302, 303, 307, 308];
|
||||
|
||||
/// Request headers not re-sent to a redirect on another host. IntelliJ's HTTP
|
||||
/// Client strips the same set and restores it when the redirect stays on the
|
||||
/// original host.
|
||||
const SENSITIVE_HEADERS: [&str; 5] = ["authorization", "cookie", "cookie2", "www-authenticate", "proxy-authorization"];
|
||||
|
||||
/// A request ready to send: variables substituted, includes read.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -24,6 +37,15 @@ pub struct PreparedRequest {
|
||||
pub body: Option<String>,
|
||||
}
|
||||
|
||||
/// One followed redirect: the response and the `Location` it pointed to.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RedirectHop {
|
||||
pub status: u16,
|
||||
pub status_text: String,
|
||||
pub location: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HttpResponse {
|
||||
@@ -32,6 +54,9 @@ pub struct HttpResponse {
|
||||
pub version: String,
|
||||
pub headers: Vec<(String, String)>,
|
||||
pub content_type: Option<String>,
|
||||
/// Followed redirects, first hop first; empty when not redirected.
|
||||
#[serde(default)]
|
||||
pub redirects: Vec<RedirectHop>,
|
||||
/// Body as text (lossy UTF-8); `None` for binary bodies.
|
||||
pub body: Option<String>,
|
||||
/// Size in bytes as received (after decompression).
|
||||
@@ -128,25 +153,84 @@ fn looks_textual(content_type: Option<&str>, bytes: &[u8]) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `req`; cancelled when `cancel` fires.
|
||||
/// The request for one hop: `req`'s headers and body against `url`, the
|
||||
/// sensitive headers dropped when the redirect crosses to another host.
|
||||
fn request_to(
|
||||
client: &reqwest::Client,
|
||||
method: &reqwest::Method,
|
||||
req: &PreparedRequest,
|
||||
body: Option<&str>,
|
||||
original: &reqwest::Url,
|
||||
url: &reqwest::Url,
|
||||
) -> IdeResult<reqwest::Request> {
|
||||
let same_host = url.host_str() == original.host_str();
|
||||
let mut builder = client.request(method.clone(), url.clone());
|
||||
for (k, v) in &req.headers {
|
||||
if same_host || !SENSITIVE_HEADERS.iter().any(|s| k.eq_ignore_ascii_case(s)) {
|
||||
builder = builder.header(k, v);
|
||||
}
|
||||
}
|
||||
if let Some(body) = body {
|
||||
builder = builder.body(body.to_owned());
|
||||
}
|
||||
builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))
|
||||
}
|
||||
|
||||
/// Sends `request`; cancelled when `cancel` fires.
|
||||
async fn send(
|
||||
client: &reqwest::Client,
|
||||
request: reqwest::Request,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<reqwest::Response> {
|
||||
let send = client.execute(request);
|
||||
tokio::select! {
|
||||
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e))),
|
||||
() = cancel.cancelled() => Err(IdeError::cancelled()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `req`, following redirects the way IntelliJ's HTTP Client does:
|
||||
/// 301, 302, 303, 307 and 308 up to [`MAX_REDIRECTS`] times, `303` continuing
|
||||
/// as `GET` without the body, the other statuses keeping the method and body —
|
||||
/// so a `POST` redirected to `https` on the same host is re-sent as a `POST`.
|
||||
/// Sensitive headers (Authorization, cookies, proxy credentials) are not
|
||||
/// re-sent across hosts. The followed hops are reported in the response.
|
||||
/// Cancelled when `cancel` fires.
|
||||
pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeResult<HttpResponse> {
|
||||
let client = crate::client::shared()?;
|
||||
let client = crate::client::shared_without_redirects()?;
|
||||
let method = reqwest::Method::from_bytes(req.method.as_bytes())
|
||||
.map_err(|_| IdeError::invalid(format!("invalid method {}", req.method)))?;
|
||||
let mut builder = client.request(method, &req.url);
|
||||
for (k, v) in &req.headers {
|
||||
builder = builder.header(k, v);
|
||||
}
|
||||
if let Some(body) = &req.body {
|
||||
builder = builder.body(body.clone());
|
||||
}
|
||||
let request = builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
|
||||
let original = req.url.parse::<reqwest::Url>().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
|
||||
let mut url = original.clone();
|
||||
let mut method = method;
|
||||
let mut body = req.body.clone();
|
||||
let mut redirects = Vec::new();
|
||||
let started = Instant::now();
|
||||
let send = client.execute(request);
|
||||
let mut response = tokio::select! {
|
||||
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e)))?,
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
};
|
||||
let mut response;
|
||||
loop {
|
||||
let request = request_to(&client, &method, req, body.as_deref(), &original, &url)?;
|
||||
response = send(&client, request, cancel).await?;
|
||||
let status = response.status();
|
||||
if redirects.len() >= MAX_REDIRECTS || !REDIRECT_STATUSES.contains(&status.as_u16()) {
|
||||
break;
|
||||
}
|
||||
let next = response
|
||||
.headers()
|
||||
.get(reqwest::header::LOCATION)
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.and_then(|location| url.join(location).ok());
|
||||
let Some(next) = next else { break };
|
||||
redirects.push(RedirectHop {
|
||||
status: status.as_u16(),
|
||||
status_text: status.canonical_reason().unwrap_or("").to_owned(),
|
||||
location: next.to_string(),
|
||||
});
|
||||
if status == reqwest::StatusCode::SEE_OTHER {
|
||||
method = reqwest::Method::GET;
|
||||
body = None;
|
||||
}
|
||||
url = next;
|
||||
}
|
||||
let ttfb = started.elapsed();
|
||||
let status = response.status();
|
||||
let version = format!("{:?}", response.version());
|
||||
@@ -179,6 +263,7 @@ pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeRe
|
||||
version,
|
||||
headers,
|
||||
content_type,
|
||||
redirects,
|
||||
body,
|
||||
size: size as f64,
|
||||
truncated: size > bytes.len(),
|
||||
@@ -249,6 +334,47 @@ mod tests {
|
||||
assert_eq!(url("GET https://api.test/cb?u=http://x\n"), "https://api.test/cb?u=http://x");
|
||||
}
|
||||
|
||||
/// A loopback server answering each accepted connection with the next of
|
||||
/// `responses`, returning every request as its head and body.
|
||||
async fn scripted(responses: Vec<String>) -> (u16, tokio::task::JoinHandle<Vec<(String, String)>>) {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let handle = tokio::spawn(async move {
|
||||
let mut seen = Vec::new();
|
||||
for response in responses {
|
||||
let (mut socket, _) = listener.accept().await.unwrap();
|
||||
let mut request = Vec::new();
|
||||
let (head, body) = loop {
|
||||
let mut buffer = [0u8; 4096];
|
||||
let read = socket.read(&mut buffer).await.unwrap();
|
||||
assert!(read > 0, "request ended before its body");
|
||||
request.extend_from_slice(&buffer[..read]);
|
||||
let Some(end) = request.windows(4).position(|w| w == b"\r\n\r\n") else { continue };
|
||||
let head = String::from_utf8_lossy(&request[..end]).into_owned();
|
||||
let length: usize = head
|
||||
.lines()
|
||||
.find_map(|line| {
|
||||
let (name, value) = line.split_once(':')?;
|
||||
name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse().unwrap())
|
||||
})
|
||||
.unwrap_or(0);
|
||||
if request.len() >= end + 4 + length {
|
||||
break (head, String::from_utf8_lossy(&request[end + 4..end + 4 + length]).into_owned());
|
||||
}
|
||||
};
|
||||
seen.push((head, body));
|
||||
socket.write_all(response.as_bytes()).await.unwrap();
|
||||
}
|
||||
seen
|
||||
});
|
||||
(port, handle)
|
||||
}
|
||||
|
||||
fn response(status_line: &str, headers: &str, body: &str) -> String {
|
||||
format!("HTTP/1.1 {status_line}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sends_exact_environment_numbers_to_a_local_server() {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
@@ -341,6 +467,7 @@ mod tests {
|
||||
assert_eq!(r.status_text, "Created");
|
||||
assert_eq!(r.body.as_deref(), Some("{\"ok\":true}"));
|
||||
assert!(r.headers.iter().any(|(k, v)| k == "x-a" && v == "b"));
|
||||
assert!(r.redirects.is_empty());
|
||||
assert!(r.total_ms >= r.ttfb_ms);
|
||||
}
|
||||
|
||||
@@ -369,4 +496,150 @@ mod tests {
|
||||
let err = execute(&req, &cancel).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn post_keeps_method_and_body_on_301_302_307_308() {
|
||||
for status_line in ["301 Moved Permanently", "302 Found", "307 Temporary Redirect", "308 Permanent Redirect"] {
|
||||
let status: u16 = status_line[..3].parse().unwrap();
|
||||
let (port, server) =
|
||||
scripted(vec![response(status_line, "Location: /landing\r\n", ""), response("200 OK", "", "ok")]).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://127.0.0.1:{port}/submit"),
|
||||
headers: vec![("Content-Type".into(), "application/json".into())],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
let (head, body) = &seen[1];
|
||||
assert_eq!(head.lines().next().unwrap(), "POST /landing HTTP/1.1", "{status_line}");
|
||||
assert!(head.to_ascii_lowercase().contains("content-type: application/json"), "{head}");
|
||||
assert_eq!(body, "{\"a\":1}", "{status_line}");
|
||||
assert_eq!(r.status, 200, "{status_line}");
|
||||
assert_eq!(r.body.as_deref(), Some("ok"), "{status_line}");
|
||||
assert_eq!(
|
||||
r.redirects,
|
||||
vec![RedirectHop {
|
||||
status,
|
||||
status_text: status_line[4..].to_owned(),
|
||||
location: format!("http://127.0.0.1:{port}/landing"),
|
||||
}],
|
||||
"{status_line}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn see_other_303_resends_as_get_without_the_body() {
|
||||
let (port, server) =
|
||||
scripted(vec![response("303 See Other", "Location: /after\r\n", ""), response("200 OK", "", "done")]).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://127.0.0.1:{port}/submit"),
|
||||
headers: vec![],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(seen[1].0.lines().next().unwrap(), "GET /after HTTP/1.1");
|
||||
assert_eq!(seen[1].1, "");
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("done"));
|
||||
assert_eq!(r.redirects[0].status, 303);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn same_host_redirect_keeps_authorization() {
|
||||
let (port, server) = scripted(vec![
|
||||
response("301 Moved Permanently", "Location: /landing\r\n", ""),
|
||||
response("200 OK", "", "ok"),
|
||||
])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/start"),
|
||||
headers: vec![("Authorization".into(), "Bearer secret".into())],
|
||||
body: None,
|
||||
};
|
||||
execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert!(seen[1].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen[1].0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cross_host_redirect_keeps_the_method_but_drops_authorization() {
|
||||
let (port_b, server_b) = scripted(vec![response("200 OK", "", "moved")]).await;
|
||||
let (port_a, server_a) = scripted(vec![response(
|
||||
"301 Moved Permanently",
|
||||
&format!("Location: http://127.0.0.1:{port_b}/x\r\n"),
|
||||
"",
|
||||
)])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://localhost:{port_a}/start"),
|
||||
headers: vec![("Authorization".into(), "Bearer secret".into())],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen_a = server_a.await.unwrap();
|
||||
let seen_b = server_b.await.unwrap();
|
||||
assert!(seen_a[0].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen_a[0].0);
|
||||
assert_eq!(seen_b[0].0.lines().next().unwrap(), "POST /x HTTP/1.1");
|
||||
assert!(!seen_b[0].0.to_ascii_lowercase().contains("authorization"), "{}", seen_b[0].0);
|
||||
assert_eq!(seen_b[0].1, "{\"a\":1}");
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("moved"));
|
||||
assert_eq!(r.redirects.len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn redirects_beyond_the_limit_return_the_last_redirect_response() {
|
||||
let responses = vec![response("301 Moved Permanently", "Location: /loop\r\n", ""); MAX_REDIRECTS + 1];
|
||||
let (port, server) = scripted(responses).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/start"),
|
||||
headers: vec![],
|
||||
body: None,
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(r.status, 301);
|
||||
assert_eq!(r.status_text, "Moved Permanently");
|
||||
assert_eq!(r.redirects.len(), MAX_REDIRECTS);
|
||||
assert_eq!(seen.len(), MAX_REDIRECTS + 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn redirect_chain_is_recorded_across_hops() {
|
||||
let (port, server) = scripted(vec![
|
||||
response("302 Found", "Location: /b\r\n", ""),
|
||||
response("302 Found", "Location: /c\r\n", ""),
|
||||
response("200 OK", "", "end"),
|
||||
])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/a"),
|
||||
headers: vec![],
|
||||
body: None,
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("end"));
|
||||
assert_eq!(r.redirects.len(), 2);
|
||||
assert_eq!(r.redirects[0].status, 302);
|
||||
assert_eq!(r.redirects[0].location, format!("http://127.0.0.1:{port}/b"));
|
||||
assert_eq!(r.redirects[1].status, 302);
|
||||
assert_eq!(r.redirects[1].location, format!("http://127.0.0.1:{port}/c"));
|
||||
assert_eq!(seen[2].0.lines().next().unwrap(), "GET /c HTTP/1.1");
|
||||
}
|
||||
}
|
||||
@@ -31,3 +31,8 @@ zip.workspace = true
|
||||
tempfile.workspace = true
|
||||
encoding_rs.workspace = true
|
||||
tokio = { workspace = true, features = ["rt-multi-thread", "macros", "test-util"] }
|
||||
criterion = { version = "0.5", default-features = false }
|
||||
|
||||
[[bench]]
|
||||
name = "did_change"
|
||||
harness = false
|
||||
@@ -0,0 +1,158 @@
|
||||
//! `cargo bench -p ide-lsp`: an incremental LSP change on a 1 MB document.
|
||||
|
||||
use criterion::{Criterion, black_box, criterion_group, criterion_main};
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_core::{DocId, IdeEvent, LanguageId, Pos, Range};
|
||||
use ide_jsonrpc::{Handler, Peer};
|
||||
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
|
||||
use ide_lsp::{Launcher, LspManager};
|
||||
use ide_text::AppliedChange;
|
||||
use serde_json::{Value, json};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
struct MockServer;
|
||||
|
||||
impl Handler for MockServer {
|
||||
fn on_notification(&self, _method: &str, _params: Value) {}
|
||||
|
||||
fn on_request(&self, method: &str, _params: Value) -> Result<Value, (i64, String)> {
|
||||
match method {
|
||||
"initialize" => Ok(json!({
|
||||
"capabilities": {
|
||||
"textDocumentSync": { "openClose": true, "change": 2 }
|
||||
}
|
||||
})),
|
||||
"shutdown" => Ok(Value::Null),
|
||||
_ => Ok(Value::Null),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct MockLauncher {
|
||||
servers: Mutex<Vec<Peer>>,
|
||||
}
|
||||
|
||||
impl Launcher for MockLauncher {
|
||||
fn launch(
|
||||
&self,
|
||||
_config: &LanguageServerConfig,
|
||||
_root: &Path,
|
||||
handler: Arc<dyn Handler>,
|
||||
_on_stderr: Box<dyn Fn(String) + Send + Sync>,
|
||||
) -> Result<Peer, ide_lsp::LaunchError> {
|
||||
let (server_io, client_io) = tokio::io::duplex(1 << 20);
|
||||
let (server_read, server_write) = tokio::io::split(server_io);
|
||||
let (client_read, client_write) = tokio::io::split(client_io);
|
||||
let server = Peer::connect(server_read, server_write, Arc::new(MockServer));
|
||||
self.servers.lock().unwrap().push(server);
|
||||
Ok(Peer::connect(client_read, client_write, handler))
|
||||
}
|
||||
}
|
||||
|
||||
fn server_config() -> LanguageServerConfig {
|
||||
LanguageServerConfig {
|
||||
name: "mock".into(),
|
||||
command: "mock".into(),
|
||||
args: vec![],
|
||||
env: Default::default(),
|
||||
requires_env: Vec::new(),
|
||||
root_markers: vec!["mock.toml".into()],
|
||||
require_root_marker: false,
|
||||
initialization_options: None,
|
||||
settings: None,
|
||||
install_hint: None,
|
||||
connect: None,
|
||||
fallback: false,
|
||||
replaces: Vec::new(),
|
||||
features: Vec::new(),
|
||||
code_action_kinds: Vec::new(),
|
||||
max_java: None,
|
||||
launch_error: None,
|
||||
tsserver_project: false,
|
||||
tsserver_project_extras: Default::default(),
|
||||
resync_on_configuration: false,
|
||||
display_name: None,
|
||||
pinned: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn language_config() -> LanguageConfig {
|
||||
LanguageConfig {
|
||||
id: LanguageId::new("mock"),
|
||||
name: "Mock".into(),
|
||||
extensions: vec!["mk".into()],
|
||||
filenames: vec![],
|
||||
first_line: None,
|
||||
line_comment: None,
|
||||
block_comment: None,
|
||||
indent: None,
|
||||
ui_mode: None,
|
||||
framework_ui_modes: Vec::new(),
|
||||
framework_files: Vec::new(),
|
||||
formatter: None,
|
||||
scratch_template: None,
|
||||
rainbow_brackets: Default::default(),
|
||||
tree_sitter: None,
|
||||
language_servers: vec![server_config()],
|
||||
debugger: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn sample_text(bytes: usize) -> String {
|
||||
let mut text = String::with_capacity(bytes);
|
||||
let mut i = 0;
|
||||
while text.len() < bytes {
|
||||
text.push_str(&format!(" let value_{i} = compute({i});\n"));
|
||||
i += 1;
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
fn wait_until_ready(manager: &LspManager) {
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while manager.servers().iter().all(|server| server.status != ServerStatus::Ready) {
|
||||
assert!(std::time::Instant::now() < deadline, "mock language server did not become ready");
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
|
||||
fn bench(c: &mut Criterion) {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let registry = Arc::new(LanguageRegistry::from_configs(vec![language_config()]));
|
||||
let manager = LspManager::with_launcher(
|
||||
root.path().to_owned(),
|
||||
registry,
|
||||
Arc::new(|_: IdeEvent| {}),
|
||||
Arc::new(MockLauncher::default()),
|
||||
);
|
||||
let text = sample_text(1 << 20);
|
||||
let path: PathBuf = root.path().join("large.mk");
|
||||
std::fs::write(&path, &text).unwrap();
|
||||
let doc = DocId::next();
|
||||
manager.did_open(doc, &path, &LanguageId::new("mock"), 1, &text);
|
||||
wait_until_ready(&manager);
|
||||
|
||||
let changes = [AppliedChange { range: Range::new(Pos::new(0, 4), Pos::new(0, 8)), text: "same".into() }];
|
||||
let mut version = 2;
|
||||
c.bench_function("lsp/did_change_incremental_1mb", |b| {
|
||||
b.iter(|| {
|
||||
manager.did_change(doc, version, black_box(&changes), &|| unreachable!("valid incremental edit"));
|
||||
version = version.wrapping_add(1);
|
||||
});
|
||||
});
|
||||
|
||||
tokio::runtime::Runtime::new().unwrap().block_on(manager.shutdown_all());
|
||||
}
|
||||
|
||||
criterion_group! {
|
||||
name = benches;
|
||||
config = Criterion::default()
|
||||
.sample_size(30)
|
||||
.warm_up_time(std::time::Duration::from_secs(1))
|
||||
.measurement_time(std::time::Duration::from_secs(3));
|
||||
targets = bench
|
||||
}
|
||||
|
||||
criterion_main!(benches);
|
||||
@@ -79,7 +79,7 @@ use server::{Conn, Running, Server};
|
||||
use std::collections::{BTreeMap, HashMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Weak};
|
||||
use std::sync::{Arc, OnceLock, Weak};
|
||||
use std::time::Duration;
|
||||
use text::{DocText, Encoding};
|
||||
use types::*;
|
||||
@@ -88,6 +88,21 @@ const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
const COMPLETION_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const LONG_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
|
||||
fn did_change_content(
|
||||
sync: SyncKind,
|
||||
in_sync: bool,
|
||||
key: u8,
|
||||
events: &HashMap<u8, Vec<Value>>,
|
||||
full: &OnceLock<Value>,
|
||||
text: &str,
|
||||
) -> Value {
|
||||
if !in_sync || sync == SyncKind::Full {
|
||||
full.get_or_init(|| json!([{ "text": text }])).clone()
|
||||
} else {
|
||||
Value::Array(events.get(&key).cloned().unwrap_or_default())
|
||||
}
|
||||
}
|
||||
|
||||
/// How long a server may take to answer `initialize`. Some import the whole
|
||||
/// build there (kotlin-lsp, jdtls on a large Gradle project) and need minutes
|
||||
/// on a cold start; the status shows "starting" meanwhile, and a crash still
|
||||
@@ -1366,18 +1381,14 @@ impl LspManager {
|
||||
tracing::warn!("lsp text copy of {} out of sync; resending full text", d.path.display());
|
||||
text.set(&full_text());
|
||||
}
|
||||
let full = json!([{ "text": text.as_str() }]);
|
||||
let full = OnceLock::new();
|
||||
for (server, run, sync, enc) in targets {
|
||||
let key = match enc {
|
||||
Encoding::Utf8 => 8,
|
||||
Encoding::Utf16 => 16,
|
||||
Encoding::Utf32 => 32,
|
||||
};
|
||||
let content = if !in_sync || sync == SyncKind::Full {
|
||||
full.clone()
|
||||
} else {
|
||||
Value::Array(events.get(&key).cloned().unwrap_or_default())
|
||||
};
|
||||
let content = did_change_content(sync, in_sync, key, &events, &full, text.as_str());
|
||||
let params = json!({
|
||||
"textDocument": { "uri": d.uri, "version": d.version },
|
||||
"contentChanges": content,
|
||||
@@ -4378,6 +4389,56 @@ mod code_action_tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod did_change_content_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn incremental_content_does_not_build_the_full_document() {
|
||||
let full = OnceLock::new();
|
||||
let key = 16;
|
||||
let events = HashMap::from([(
|
||||
key,
|
||||
vec![json!({
|
||||
"range": {
|
||||
"start": { "line": 0, "character": 0 },
|
||||
"end": { "line": 0, "character": 1 }
|
||||
},
|
||||
"text": "x"
|
||||
})],
|
||||
)]);
|
||||
|
||||
let content = did_change_content(SyncKind::Incremental, true, key, &events, &full, "1 MB document");
|
||||
|
||||
assert_eq!(content, Value::Array(events[&key].clone()));
|
||||
assert!(full.get().is_none(), "incremental sync must not materialize the full document");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_sync_reuses_the_full_document_payload() {
|
||||
let full = OnceLock::new();
|
||||
let key = 16;
|
||||
let events = HashMap::new();
|
||||
|
||||
let first = did_change_content(SyncKind::Full, true, key, &events, &full, "whole document");
|
||||
let second = did_change_content(SyncKind::Full, true, key, &events, &full, "whole document");
|
||||
|
||||
assert_eq!(first, json!([{ "text": "whole document" }]));
|
||||
assert_eq!(second, first);
|
||||
assert!(full.get().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn out_of_sync_incremental_change_sends_the_full_document() {
|
||||
let full = OnceLock::new();
|
||||
let events = HashMap::new();
|
||||
|
||||
let content = did_change_content(SyncKind::Incremental, false, 16, &events, &full, "whole document");
|
||||
|
||||
assert_eq!(content, json!([{ "text": "whole document" }]));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod external_go_routing_tests {
|
||||
use super::*;
|
||||
|
||||
@@ -8,7 +8,8 @@
|
||||
//! `Authorization: Bearer <token>` (random, per run); requests from another
|
||||
//! `Origin` or `Host` are refused (DNS rebinding).
|
||||
//! - **Projects:** the `X-OpenIDEA-Project` header or the `?project=` query
|
||||
//! names a folder; the server picks the open project containing it.
|
||||
//! names a folder; the server picks the open project containing it, or the
|
||||
//! project the IDE serves it from without a window.
|
||||
//! - **Discovery:** `<app-data>/mcp/server.json` (`address`, `port`, `token`,
|
||||
//! `pid`, `version`; readable only by the user) while the server runs.
|
||||
//! - **Stdio:** `<app exe> --mcp-stdio [--project <path>]` reads the discovery
|
||||
@@ -60,10 +61,16 @@ pub enum ToolCallError {
|
||||
/// Where the tools come from (the IDE host). Calls block; the server runs
|
||||
/// them off its async threads.
|
||||
pub trait ToolRegistry: Send + Sync + 'static {
|
||||
/// Roots of the projects open in the IDE that the server serves.
|
||||
/// Roots of the projects open in a window of the IDE that the server serves.
|
||||
fn projects(&self) -> Vec<PathBuf>;
|
||||
/// The tools callable for `project` (one of [`Self::projects`]). `Err`
|
||||
/// says why there are none (an unsupported project).
|
||||
/// The root of the project the IDE serves `path` from without a window (a background
|
||||
/// project), asked when no project of [`Self::projects`] contains `path`. Opens nothing:
|
||||
/// the first call for that root does.
|
||||
fn resolve(&self, _path: &Path) -> Option<PathBuf> {
|
||||
None
|
||||
}
|
||||
/// The tools callable for `project` (one of [`Self::projects`] or a root
|
||||
/// [`Self::resolve`] gave). `Err` says why there are none (an unsupported project).
|
||||
fn tools(&self, project: &Path) -> Result<Vec<Tool>, String>;
|
||||
fn call_with_client(
|
||||
&self,
|
||||
|
||||
@@ -34,7 +34,7 @@ const PARSE_ERROR: i64 = -32700;
|
||||
const INVALID_REQUEST: i64 = -32600;
|
||||
const METHOD_NOT_FOUND: i64 = -32601;
|
||||
const INVALID_PARAMS: i64 = -32602;
|
||||
/// The requested folder isn't a project open in the IDE (or has no tools there).
|
||||
/// The requested folder isn't in a project the IDE serves (or has no tools there).
|
||||
pub(crate) const NOT_OPEN: i64 = -32001;
|
||||
|
||||
pub(crate) struct RpcError {
|
||||
@@ -158,15 +158,16 @@ impl Session<'_> {
|
||||
let asked = params.get("protocolVersion").and_then(Value::as_str).unwrap_or(LATEST);
|
||||
let version = if SUPPORTED.contains(&asked) { asked } else { LATEST };
|
||||
let about = match self.project() {
|
||||
Ok(root) => format!("the project open in OpenIDEA at {}", root.display()),
|
||||
Err(_) => "a project open in OpenIDEA".to_owned(),
|
||||
Ok(root) => format!("the project OpenIDEA serves at {}", root.display()),
|
||||
Err(_) => "a project open in OpenIDEA or served in the background".to_owned(),
|
||||
};
|
||||
json!({
|
||||
"protocolVersion": version,
|
||||
"capabilities": { "tools": { "listChanged": false } },
|
||||
"serverInfo": { "name": "OpenIDEA", "version": env!("CARGO_PKG_VERSION") },
|
||||
"instructions": format!(
|
||||
"Built-in OpenIDEA tools for {about}: they see the files and editors the IDE has open."
|
||||
"Built-in OpenIDEA tools for {about}: they see the files as the IDE has them and, \
|
||||
for a project open in a window, its editors."
|
||||
),
|
||||
})
|
||||
}
|
||||
@@ -205,7 +206,7 @@ impl Session<'_> {
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// The open project the request names.
|
||||
/// The project the request names.
|
||||
fn project(&self) -> Result<PathBuf, RpcError> {
|
||||
self.resolve_project(self.project)
|
||||
}
|
||||
@@ -215,11 +216,14 @@ impl Session<'_> {
|
||||
roots.sort();
|
||||
roots.dedup();
|
||||
if let Some(requested) = requested.filter(|p| !p.trim().is_empty()) {
|
||||
return resolve(&roots, Path::new(requested)).ok_or_else(|| {
|
||||
let path = Path::new(requested);
|
||||
// An open project wins; the registry is asked only for a folder outside all of them.
|
||||
return resolve(&roots, path).or_else(|| self.registry.resolve(path)).ok_or_else(|| {
|
||||
RpcError::new(
|
||||
NOT_OPEN,
|
||||
format!(
|
||||
"this folder isn't open in OpenIDEA: {requested}. Open projects: {}",
|
||||
"this folder isn't open in OpenIDEA and isn't served in the background \
|
||||
(Settings › Agents › IDE MCP Server): {requested}. Open projects: {}",
|
||||
roots.iter().map(|p| p.display().to_string()).collect::<Vec<_>>().join(", ")
|
||||
),
|
||||
)
|
||||
|
||||
@@ -213,6 +213,87 @@ async fn folders_that_are_not_open_are_named_in_the_error() {
|
||||
assert!(serde_json::from_str::<Value>(&body).unwrap()["result"]["tools"].is_array());
|
||||
}
|
||||
|
||||
/// One project open in a window and, optionally, one folder served without a window.
|
||||
struct WithBackground {
|
||||
open: PathBuf,
|
||||
background: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl ToolRegistry for WithBackground {
|
||||
fn projects(&self) -> Vec<PathBuf> {
|
||||
vec![self.open.clone()]
|
||||
}
|
||||
fn resolve(&self, path: &Path) -> Option<PathBuf> {
|
||||
self.background.clone().filter(|root| path.starts_with(root))
|
||||
}
|
||||
fn tools(&self, project: &Path) -> Result<Vec<Tool>, String> {
|
||||
Ok(vec![Tool {
|
||||
name: "where".into(),
|
||||
description: format!("Names {}", project.display()),
|
||||
input_schema: json!({ "type": "object" }),
|
||||
read_only: true,
|
||||
destructive: false,
|
||||
output_schema: None,
|
||||
}])
|
||||
}
|
||||
fn call(&self, project: &Path, _: &str, _: &str, _: ide_mcp::CancellationToken) -> Result<String, ToolCallError> {
|
||||
Ok(json!({"project":project}).to_string())
|
||||
}
|
||||
}
|
||||
|
||||
/// The server over [`WithBackground`]; the folder `inventory` next to the open project.
|
||||
fn setup_with_background(served: bool) -> (Setup, PathBuf) {
|
||||
let mut s = setup();
|
||||
s.server.take().unwrap().stop();
|
||||
let inventory = s.project.parent().unwrap().join("inventory");
|
||||
std::fs::create_dir_all(inventory.join("src")).unwrap();
|
||||
let registry = WithBackground { open: s.project.clone(), background: served.then(|| inventory.clone()) };
|
||||
s.server = Some(McpServer::start(Arc::new(registry), None, &tokio::runtime::Handle::current()).unwrap());
|
||||
(s, inventory)
|
||||
}
|
||||
|
||||
async fn rpc_for(s: &Setup, folder: &Path, method: &str, params: Value) -> Value {
|
||||
let project = format!("X-OpenIDEA-Project: {}", folder.display());
|
||||
let body = json!({ "jsonrpc": "2.0", "id": 7, "method": method, "params": params });
|
||||
let (status, body) = post(s, "/mcp", &[&bearer(s), &project], &body).await;
|
||||
assert_eq!(status, 200, "{body}");
|
||||
serde_json::from_str(&body).unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_folder_served_in_the_background_answers_initialize_list_and_call() {
|
||||
let (s, inventory) = setup_with_background(true);
|
||||
let inside = inventory.join("src");
|
||||
let init = rpc_for(&s, &inside, "initialize", json!({})).await;
|
||||
let instructions = init["result"]["instructions"].as_str().unwrap();
|
||||
assert!(instructions.contains(inventory.to_str().unwrap()), "{instructions}");
|
||||
let list = rpc_for(&s, &inside, "tools/list", json!({})).await;
|
||||
assert_eq!(list["result"]["tools"][0]["description"], format!("Names {}", inventory.display()), "{list}");
|
||||
let call = rpc_for(&s, &inside, "tools/call", json!({ "name": "where" })).await;
|
||||
assert_eq!(call["result"]["structuredContent"]["project"], json!(inventory), "{call}");
|
||||
// The argument names it as well, whatever project the header is for.
|
||||
let routed = rpc(&s, "tools/call", json!({ "name": "where", "arguments": { "projectPath": inside } })).await;
|
||||
assert_eq!(routed["result"]["structuredContent"]["project"], json!(inventory), "{routed}");
|
||||
// A folder inside the open project stays with that project.
|
||||
let open = rpc(&s, "tools/call", json!({ "name": "where" })).await;
|
||||
assert_eq!(open["result"]["structuredContent"]["project"], json!(s.project), "{open}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_folder_that_is_neither_open_nor_served_in_the_background_says_where_to_turn_it_on() {
|
||||
let (s, inventory) = setup_with_background(false);
|
||||
for (method, params) in [("tools/list", json!({})), ("tools/call", json!({ "name": "where" }))] {
|
||||
let reply = rpc_for(&s, &inventory, method, params).await;
|
||||
assert_eq!(reply["error"]["code"], -32001, "{method}: {reply}");
|
||||
let message = reply["error"]["message"].as_str().unwrap();
|
||||
assert!(message.contains("isn't open in OpenIDEA and isn't served in the background"), "{message}");
|
||||
assert!(message.contains("Settings › Agents › IDE MCP Server"), "{message}");
|
||||
assert!(message.contains(inventory.to_str().unwrap()) && message.contains(s.project.to_str().unwrap()));
|
||||
}
|
||||
let init = rpc_for(&s, &inventory, "initialize", json!({})).await;
|
||||
assert!(init["result"]["instructions"].is_string(), "initialize answers without a project: {init}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn the_discovery_file_lives_while_the_server_runs() {
|
||||
let mut s = setup();
|
||||
|
||||
@@ -100,6 +100,22 @@ pub struct GutterAction {
|
||||
pub command: String,
|
||||
pub argument: Option<String>,
|
||||
}
|
||||
/// An action rendered at the left edge of a line and revealed by hover.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HoverAction {
|
||||
/// The line the button is drawn on; normally the declaration line.
|
||||
pub line: u32,
|
||||
/// First line whose leftmost strip reveals this action, inclusive.
|
||||
pub start_line: u32,
|
||||
/// Last line whose leftmost strip reveals this action, inclusive.
|
||||
pub end_line: u32,
|
||||
pub icon: Option<String>,
|
||||
pub label: String,
|
||||
pub tooltip: Option<String>,
|
||||
pub command: String,
|
||||
pub argument: Option<String>,
|
||||
}
|
||||
/// Injection data.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
||||
@@ -16,6 +16,7 @@ use crate::types::{
|
||||
FieldValue, ServiceLog, ServiceLogToggle, ServicePane, ServiceTab, TableSort, View, ViewBody, ViewButton,
|
||||
ViewEvent, ViewField, ViewListItem, ViewTable, ViewTreeItem, Viewport,
|
||||
};
|
||||
use crate::wit_host::hover_actions_bindings::exports::openidea::plugin::hover_actions as wit_hia;
|
||||
use crate::wit_host::injections_bindings::exports::openidea::plugin::injections as wit_inj;
|
||||
use crate::wit_host::language_features_bindings::exports::openidea::plugin::language_features as wit_lf;
|
||||
use crate::wit_host::run_target_validation_bindings::exports::openidea::plugin::run_target_validation as wit_rtv;
|
||||
@@ -57,7 +58,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
|
||||
use views_bindings::openidea::plugin::view_types as wit_vt;
|
||||
|
||||
/// The API version of the world above, `major.minor` of [`host_api`].
|
||||
pub const API_VERSION: &str = "1.13";
|
||||
pub const API_VERSION: &str = "1.14";
|
||||
const EPOCH_TICK: Duration = Duration::from_millis(10);
|
||||
pub(crate) const MAX_TEXT: usize = 1 << 20;
|
||||
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
|
||||
@@ -387,6 +388,11 @@ pub trait HostApi: Send + Sync {
|
||||
}
|
||||
/// Sets (`Some`) or removes the plugin's status bar item `id`.
|
||||
fn status_item(&self, id: &str, item: Option<StatusItem>);
|
||||
/// Checks a status item menu before it is set: its actions name commands the plugin declares.
|
||||
fn check_status_menu(&self, menu: &[crate::StatusMenuEntry]) -> Result<(), HostError> {
|
||||
let _ = menu;
|
||||
Ok(())
|
||||
}
|
||||
/// Sets or removes the status override in the invoking window.
|
||||
fn window_status_item(&self, client: &str, id: &str, item: Option<StatusItem>) -> Result<(), HostError> {
|
||||
let _ = (client, id, item);
|
||||
@@ -1049,6 +1055,7 @@ struct Exports {
|
||||
inlay: Option<wit_inlay::Guest>,
|
||||
endpoints: Option<wit_endpoints::Guest>,
|
||||
search: Option<wit_search::Guest>,
|
||||
hover_actions: Option<wit_hia::Guest>,
|
||||
run_configurations: Option<wit_configs::Guest>,
|
||||
launch_configurations: Option<wit_launch::Guest>,
|
||||
test_results: Option<wit_tests::Guest>,
|
||||
@@ -1190,6 +1197,7 @@ impl Runtime {
|
||||
let inlay_indices = wit_inlay::GuestIndices::new(&pre).ok();
|
||||
let endpoint_indices = wit_endpoints::GuestIndices::new(&pre).ok();
|
||||
let search_indices = wit_search::GuestIndices::new(&pre).ok();
|
||||
let hover_actions_indices = wit_hia::GuestIndices::new(&pre).ok();
|
||||
let configs_indices = wit_configs::GuestIndices::new(&pre).ok();
|
||||
let launch_indices = wit_launch::GuestIndices::new(&pre).ok();
|
||||
let tests_indices = wit_tests::GuestIndices::new(&pre).ok();
|
||||
@@ -1255,6 +1263,8 @@ impl Runtime {
|
||||
None => None,
|
||||
};
|
||||
let search = search_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
|
||||
let hover_actions =
|
||||
hover_actions_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
|
||||
let endpoints = match endpoint_indices {
|
||||
Some(indices) => Some(indices.load(&mut store, &instance).map_err(api_hint)?),
|
||||
None => None,
|
||||
@@ -1278,6 +1288,7 @@ impl Runtime {
|
||||
inlay,
|
||||
endpoints,
|
||||
search,
|
||||
hover_actions,
|
||||
run_configurations,
|
||||
launch_configurations,
|
||||
test_results,
|
||||
@@ -2616,6 +2627,19 @@ fn gutter_action_from(v: wit_lf::GutterAction) -> crate::language_features::Gutt
|
||||
argument: v.argument.map(|v| crate::runtime::clip(v, 65536)),
|
||||
}
|
||||
}
|
||||
fn hover_action_from(v: wit_hia::HoverAction) -> crate::language_features::HoverAction {
|
||||
crate::language_features::HoverAction {
|
||||
line: v.line,
|
||||
start_line: v.start_line,
|
||||
end_line: v.end_line,
|
||||
icon: v.icon.map(|v| crate::runtime::clip(v, 65536)),
|
||||
label: crate::runtime::clip(v.label, 65536),
|
||||
tooltip: v.tooltip.map(|v| crate::runtime::clip(v, 65536)),
|
||||
command: crate::runtime::clip(v.command, 65536),
|
||||
argument: v.argument.map(|v| crate::runtime::clip(v, 65536)),
|
||||
}
|
||||
}
|
||||
|
||||
fn parameter_label_from(v: wit_lf::ParameterLabel) -> crate::language_features::ParameterLabel {
|
||||
use crate::language_features::ParameterLabel as P;
|
||||
match v {
|
||||
@@ -2844,6 +2868,30 @@ impl Runtime {
|
||||
let result = self.language_feature_call(timeout, |p, s| p.call_gutter_actions(s, &d))?;
|
||||
Ok(result.into_iter().take(10000).map(gutter_action_from).collect())
|
||||
}
|
||||
pub fn has_hover_actions(&self) -> bool {
|
||||
self.exports.hover_actions.is_some()
|
||||
}
|
||||
|
||||
pub fn language_hover_actions(
|
||||
&mut self,
|
||||
doc: &ProviderDocument,
|
||||
timeout: Duration,
|
||||
) -> Result<Vec<crate::language_features::HoverAction>, CallError> {
|
||||
if self.exports.hover_actions.is_none() {
|
||||
return Err(CallError::missing_export("hover-actions"));
|
||||
}
|
||||
let d = wit_hia::Document {
|
||||
path: to_ipc(&doc.path),
|
||||
language: doc.language.clone(),
|
||||
version: doc.version,
|
||||
text: doc.text.clone(),
|
||||
};
|
||||
let result = self.call(Invocation::default(), timeout, |exports, store| {
|
||||
exports.hover_actions.as_ref().expect("checked").call_hover_actions(store, &d)
|
||||
})?;
|
||||
Ok(result.into_iter().take(10_000).map(hover_action_from).collect())
|
||||
}
|
||||
|
||||
pub fn provide_injections(
|
||||
&mut self,
|
||||
doc: &ProviderDocument,
|
||||
|
||||
@@ -70,6 +70,28 @@ pub struct StatusItem {
|
||||
pub tooltip: Option<String>,
|
||||
/// One of the plugin's commands, run on click.
|
||||
pub command: Option<String>,
|
||||
/// Opened on click instead of running `command` when not empty (API 1.14).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
#[specta(optional)]
|
||||
pub menu: Vec<StatusMenuEntry>,
|
||||
}
|
||||
|
||||
/// An entry of a plugin status bar item's menu (API 1.14, `ui.set-status-item-menu`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum StatusMenuEntry {
|
||||
/// Runs one of the plugin's commands with `argument`.
|
||||
#[serde(rename_all = "camelCase")]
|
||||
Action {
|
||||
label: String,
|
||||
description: Option<String>,
|
||||
command: String,
|
||||
argument: Option<String>,
|
||||
},
|
||||
Separator,
|
||||
Header {
|
||||
label: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// A plugin's highlight rule for Run and Debug console output (API 1.12, `ui.set-console-rules`).
|
||||
|
||||
@@ -72,6 +72,46 @@ pub(crate) mod syntax_bindings {
|
||||
});
|
||||
}
|
||||
|
||||
/// The optional `hover-actions` export, bound on its own when present.
|
||||
pub(crate) mod hover_actions_bindings {
|
||||
wasmtime::component::bindgen!({
|
||||
world: "plugin-hover-actions",
|
||||
path: "../../wit",
|
||||
imports: { default: trappable },
|
||||
with: {
|
||||
"openidea:plugin/types": super::bindings::openidea::plugin::types,
|
||||
"openidea:plugin/log": super::bindings::openidea::plugin::log,
|
||||
"openidea:plugin/ui": super::bindings::openidea::plugin::ui,
|
||||
"openidea:plugin/storage": super::bindings::openidea::plugin::storage,
|
||||
"openidea:plugin/workspace": super::bindings::openidea::plugin::workspace,
|
||||
"openidea:plugin/editor": super::bindings::openidea::plugin::editor,
|
||||
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
|
||||
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
|
||||
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
|
||||
"openidea:plugin/build": super::bindings::openidea::plugin::build,
|
||||
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
|
||||
"openidea:plugin/events": super::bindings::openidea::plugin::events,
|
||||
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
|
||||
"openidea:plugin/diagnostics": super::bindings::openidea::plugin::diagnostics,
|
||||
"openidea:plugin/net": super::bindings::openidea::plugin::net,
|
||||
"openidea:plugin/secrets": super::bindings::openidea::plugin::secrets,
|
||||
"openidea:plugin/run": super::bindings::openidea::plugin::run,
|
||||
"openidea:plugin/process": super::bindings::openidea::plugin::process,
|
||||
"openidea:plugin/output": super::bindings::openidea::plugin::output,
|
||||
"openidea:plugin/auth": super::bindings::openidea::plugin::auth,
|
||||
"openidea:plugin/command-runner": super::bindings::openidea::plugin::command_runner,
|
||||
"openidea:plugin/language-servers": super::bindings::openidea::plugin::language_servers,
|
||||
"openidea:plugin/ipc": super::bindings::openidea::plugin::ipc,
|
||||
"openidea:plugin/fs": super::bindings::openidea::plugin::fs,
|
||||
"openidea:plugin/views": super::bindings::openidea::plugin::views,
|
||||
"openidea:plugin/settings": super::bindings::openidea::plugin::settings,
|
||||
"openidea:plugin/database": super::bindings::openidea::plugin::database,
|
||||
"openidea:plugin/mcp": super::bindings::openidea::plugin::mcp,
|
||||
"openidea:plugin/extensions": super::bindings::openidea::plugin::extensions,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/// The optional `providers` export.
|
||||
pub(crate) mod providers_bindings {
|
||||
wasmtime::component::bindgen!({
|
||||
@@ -387,6 +427,22 @@ impl StoreData {
|
||||
self.ask(Prompt::QuickPick { title: clip(title, MAX_TITLE), items, multiple })
|
||||
}
|
||||
|
||||
/// A status item with its checked menu (`ui.set-status-item-menu`).
|
||||
fn status_item_with_menu(
|
||||
&self,
|
||||
item: ui::StatusItem,
|
||||
menu: Vec<ui::StatusMenuEntry>,
|
||||
) -> Result<StatusItem, wit::Error> {
|
||||
let menu = status_menu(menu)?;
|
||||
self.host.check_status_menu(&menu).map_err(to_wit)?;
|
||||
Ok(StatusItem {
|
||||
text: clip(item.text, MAX_STATUS_TEXT),
|
||||
tooltip: item.tooltip.map(|t| clip(t, 1024)),
|
||||
command: item.command.map(|c| clip(c, 128)),
|
||||
menu,
|
||||
})
|
||||
}
|
||||
|
||||
fn require_window(&self) -> Result<(), wit::Error> {
|
||||
self.require_interactive()?;
|
||||
if self.invocation.client.is_none() {
|
||||
@@ -404,6 +460,47 @@ impl StoreData {
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks a status item's menu (`ui.set-status-item-menu`); the host checks that its commands are declared.
|
||||
fn status_menu(entries: Vec<ui::StatusMenuEntry>) -> Result<Vec<crate::StatusMenuEntry>, wit::Error> {
|
||||
const MAX_ENTRIES: usize = 64;
|
||||
if entries.len() > MAX_ENTRIES {
|
||||
return Err(wit::Error::Invalid(format!("a status item menu has at most {MAX_ENTRIES} entries")));
|
||||
}
|
||||
let line = |text: &str, what: &str| {
|
||||
if text.trim().is_empty() || text.len() > 256 || text.chars().any(char::is_control) {
|
||||
Err(wit::Error::Invalid(format!("invalid menu {what} {text:?}")))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
};
|
||||
let mut checked = Vec::with_capacity(entries.len());
|
||||
for entry in entries {
|
||||
checked.push(match entry {
|
||||
ui::StatusMenuEntry::Action(a) => {
|
||||
line(&a.label, "label")?;
|
||||
if let Some(description) = &a.description {
|
||||
line(description, "description")?;
|
||||
}
|
||||
if a.argument.as_ref().is_some_and(|arg| arg.len() > 64 << 10) {
|
||||
return Err(wit::Error::Invalid("a menu argument is limited to 64 KiB".into()));
|
||||
}
|
||||
crate::StatusMenuEntry::Action {
|
||||
label: a.label,
|
||||
description: a.description,
|
||||
command: a.command,
|
||||
argument: a.argument,
|
||||
}
|
||||
}
|
||||
ui::StatusMenuEntry::Separator => crate::StatusMenuEntry::Separator,
|
||||
ui::StatusMenuEntry::Header(label) => {
|
||||
line(&label, "header")?;
|
||||
crate::StatusMenuEntry::Header { label }
|
||||
}
|
||||
});
|
||||
}
|
||||
Ok(checked)
|
||||
}
|
||||
|
||||
/// Checks `ui.notify` buttons; the host checks that their commands are declared.
|
||||
fn notification_actions(actions: Vec<ui::NotificationAction>) -> Result<Vec<crate::NotificationAction>, wit::Error> {
|
||||
const MAX_ACTIONS: usize = 3;
|
||||
@@ -473,6 +570,7 @@ impl ui::Host for StoreData {
|
||||
text: clip(item.text, MAX_STATUS_TEXT),
|
||||
tooltip: item.tooltip.map(|t| clip(t, 1024)),
|
||||
command: item.command.map(|c| clip(c, 128)),
|
||||
menu: Vec::new(),
|
||||
};
|
||||
self.host.status_item(&clip(id, 64), Some(item));
|
||||
Ok(())
|
||||
@@ -491,6 +589,38 @@ impl ui::Host for StoreData {
|
||||
text: clip(item.text, MAX_STATUS_TEXT),
|
||||
tooltip: item.tooltip.map(|t| clip(t, 1024)),
|
||||
command: item.command.map(|c| clip(c, 128)),
|
||||
menu: Vec::new(),
|
||||
};
|
||||
Ok(self
|
||||
.host
|
||||
.window_status_item(self.invocation.client.as_deref().expect("checked"), &clip(id, 64), Some(item))
|
||||
.map_err(to_wit))
|
||||
}
|
||||
fn set_status_item_menu(
|
||||
&mut self,
|
||||
id: String,
|
||||
item: ui::StatusItem,
|
||||
menu: Vec<ui::StatusMenuEntry>,
|
||||
) -> Fallible<()> {
|
||||
let item = match self.status_item_with_menu(item, menu) {
|
||||
Ok(item) => item,
|
||||
Err(e) => return Ok(Err(e)),
|
||||
};
|
||||
self.host.status_item(&clip(id, 64), Some(item));
|
||||
Ok(Ok(()))
|
||||
}
|
||||
fn set_window_status_item_menu(
|
||||
&mut self,
|
||||
id: String,
|
||||
item: ui::StatusItem,
|
||||
menu: Vec<ui::StatusMenuEntry>,
|
||||
) -> Fallible<()> {
|
||||
if let Err(e) = self.require_window() {
|
||||
return Ok(Err(e));
|
||||
}
|
||||
let item = match self.status_item_with_menu(item, menu) {
|
||||
Ok(item) => item,
|
||||
Err(e) => return Ok(Err(e)),
|
||||
};
|
||||
Ok(self
|
||||
.host
|
||||
|
||||
@@ -33,6 +33,7 @@ fn components() -> Vec<PathBuf> {
|
||||
repo().join("crates/ide-plugin/tests/fixtures/diagnostics/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/inlay-hints/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/language-features/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/symbols/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/api14/dist/plugin.wasm"),
|
||||
repo().join("crates/ide-plugin/tests/fixtures/execution/dist/plugin.wasm"),
|
||||
@@ -92,7 +93,7 @@ fn the_sdk_carries_the_hosts_wit() {
|
||||
|
||||
#[test]
|
||||
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
|
||||
let host = v("1.13.0");
|
||||
let host = v("1.14.0");
|
||||
for ok in [
|
||||
"1.0.0",
|
||||
"1.3.0",
|
||||
@@ -106,15 +107,16 @@ fn the_version_check_runs_compatible_components_and_explains_the_rest() {
|
||||
"1.11.0",
|
||||
"1.12.0",
|
||||
"1.13.0",
|
||||
"1.14.0",
|
||||
"1.0.0-rc.1",
|
||||
] {
|
||||
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
|
||||
}
|
||||
let newer = check_api(&v("1.14.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.13") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
let newer = check_api(&v("1.15.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.15") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
|
||||
let older = check_api(&v("0.2.0"), &host).unwrap_err();
|
||||
assert!(older.contains("rebuild it with the 1.13 SDK"), "{older}");
|
||||
assert!(older.contains("rebuild it with the 1.14 SDK"), "{older}");
|
||||
// 0.x: every minor is its own API.
|
||||
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
|
||||
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
|
||||
@@ -141,6 +143,21 @@ fn shipped_components_are_built_for_this_api() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_1_14_component_exports_the_optional_hover_actions_world() {
|
||||
let engine = PluginEngine::new().unwrap();
|
||||
let component =
|
||||
engine.compile(&repo().join("crates/ide-plugin/tests/fixtures/hover-actions/dist/plugin.wasm")).unwrap();
|
||||
let exports: Vec<String> =
|
||||
component.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
|
||||
assert!(exports.iter().any(|name| name.starts_with("openidea:plugin/[email protected]")), "{exports:?}");
|
||||
// A 1.13-compatible plugin that does not export the new world stays valid.
|
||||
let old = engine.compile(&repo().join("plugins/official/test-runner/dist/plugin.wasm")).unwrap();
|
||||
let old_exports: Vec<String> =
|
||||
old.component_type().exports(engine.engine()).map(|(name, _)| name.to_owned()).collect();
|
||||
assert!(!old_exports.iter().any(|name| name.starts_with("openidea:plugin/hover-actions")));
|
||||
}
|
||||
|
||||
// --- a later host, simulated -------------------------------------------------------------
|
||||
|
||||
struct Data {
|
||||
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
1e2844d1172750841afd4ba2a8b811522e90522588b1330474207468cbf2a3df
|
||||
b59392bcc1999048f0ab922ec659bc21d9e825c696fa41d9f0a40c85627a5b2c
|
||||
@@ -28,6 +28,14 @@ title = "fetch"
|
||||
id = "window-status"
|
||||
title = "window-status"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "menu-status"
|
||||
title = "menu-status"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "bad-menu-status"
|
||||
title = "bad-menu-status"
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "remove-window-status"
|
||||
title = "remove-window-status"
|
||||
|
||||
+12
-1
@@ -1,4 +1,4 @@
|
||||
use openidea_plugin::{Error, Event, Invocation, Plugin, StatusItem, host, register_plugin};
|
||||
use openidea_plugin::{Error, Event, Invocation, Plugin, StatusItem, StatusMenuEntry, host, register_plugin};
|
||||
#[derive(Default)]
|
||||
struct Api14;
|
||||
impl Plugin for Api14 {
|
||||
@@ -82,6 +82,17 @@ impl Plugin for Api14 {
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
"menu-status" | "bad-menu-status" => {
|
||||
let item = StatusItem { text: arg.into(), tooltip: None, command: None };
|
||||
let command = if id == "menu-status" { "events" } else { "undeclared" };
|
||||
let menu = [
|
||||
StatusMenuEntry::Header("App".into()),
|
||||
StatusMenuEntry::action("Open", command).with_description("https://app.test").with_argument("web"),
|
||||
StatusMenuEntry::Separator,
|
||||
];
|
||||
host::set_status_item_menu("menu", &item, &menu)?;
|
||||
Ok(None)
|
||||
}
|
||||
"remove-window-status" => {
|
||||
host::remove_window_status_item("state")?;
|
||||
Ok(None)
|
||||
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
c4d00fe3170a0159e56af61fe715ffb892755cce17cdae5ecb1355fd8e90189e
|
||||
034b99891313c03eb2a6b8c3cb2e4784129e1936965be803512f1d869b1768c2
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ce791decf9a771b43872777a5c97050d9b7b48f5dd0ba0342ad0580bceb93d8c
|
||||
29ec0a96e2a0f6965915c7c25e35036743fc27a49037df588c217e8abfff93e3
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
f8e768db576e717ec00696098faa3434e9cea0680a1770f303bc071206727607
|
||||
87b367cfdd65c360920eff7be4d6a8d6b939721f6398aa6a01e39a289590699e
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
2bd0f9e7f3ca03410389d0b125372eb322fae411272b597795cbd77ea894076d
|
||||
7d034ee1a4b99615642d5bf033802f8e4662216d45b209c4c7a24eb8f1338f48
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
30dee06cb90e54e7d930996569a3d44e9c9013077c2439880f99e1c99e15cf58
|
||||
3fdf985273ec14ae623fa84602a9220cfbfb2e0e587ab192fc2bcb8d990ce9e3
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
63772fa0f67274c5326a162340aa773c54bd08d0233c726213feedc827bd1a6c
|
||||
8434e9271e27a6778bb3d5922e8925f3fd9f1d35377e5dddf5b5eb5416bd09bb
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
910d62d7f53480961b8c25b5e8d6300bee3fc0e413f35d3b7d78d6e238c65387
|
||||
9fa7468ce385ff33c1f3b99c84711e0d11a84b10e8e4f95b358fcd2ccc96e255
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
b05e1146eb97d5c787c826206b0d2257d1390f21a87501efa8901de3f5cb6017
|
||||
5220a5bfb6ec0467a72e63e21d690e70b7d46b4f2eaff4116a8a79220a5eca8f
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
aa14bcafa1009b014ba2ca754711fc3b19149ff05dfefddd10edb94d16551c3d
|
||||
a962127d1c6e37e85b81973a272a5d6b383cc2884b41bb2d82e8640ef5f8f943
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
3c0d0aa400e83c2f8e77fbec32277a23af290d4469d62d5c0046923ee7ae2c49
|
||||
92ad3e43e7f343004dcf26a51e282e97ed694cc9bd7325ff75aa5b18f1a2eeb6
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
a1a3f1691d6d7e837f893580f75935bf83a6c0ae9224ac832c9401885f9ef504
|
||||
2200ed0d44dbafb70ad864cb9569b0b2c37cf9eec1582b05efa903a9e8ec89ee
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
97f80158eda60e5b34e4760607cfdf5c8f22debf49e438a4b3fffaf7184ad59e
|
||||
644612ee4228010f141042ea0eab5431b8386370f863a70b63cd3315f69d963a
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
7eff77b3997303adab7b8ef7999b563325e333f0696c63e1a6505579a2a41070
|
||||
2af5d46516bfc1d38ad1f24d6cf3c57e2d6db6b0d3225748f55c4f13110430fb
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "anyhow"
|
||||
version = "1.0.104"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "2.13.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
|
||||
|
||||
[[package]]
|
||||
name = "equivalent"
|
||||
version = "1.0.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
|
||||
|
||||
[[package]]
|
||||
name = "foldhash"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
|
||||
|
||||
[[package]]
|
||||
name = "hashbrown"
|
||||
version = "0.17.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
|
||||
dependencies = [
|
||||
"foldhash",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
||||
|
||||
[[package]]
|
||||
name = "id-arena"
|
||||
version = "2.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "2.14.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
|
||||
dependencies = [
|
||||
"equivalent",
|
||||
"hashbrown",
|
||||
"serde",
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4"
|
||||
|
||||
[[package]]
|
||||
name = "leb128fmt"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
version = "0.4.35"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
|
||||
|
||||
[[package]]
|
||||
name = "macro-string"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e7b3a5bbb2f63aaa223a671ea1bd0e7bc16bd30ce387324cf63995deaddbbd2"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
|
||||
|
||||
[[package]]
|
||||
name = "openidea-plugin"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
"wit-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "openidea-test-hover-actions"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"openidea-plugin",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "prettyplease"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "1.0.28"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.154"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "3.0.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-encoder"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
|
||||
dependencies = [
|
||||
"leb128fmt",
|
||||
"wasmparser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-metadata"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c86ff6668190d9fb70372b306b4f9fe8930f0e2f57ce72e4922bf2f117900949"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"indexmap",
|
||||
"wasm-encoder",
|
||||
"wasmparser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasmparser"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"hashbrown",
|
||||
"indexmap",
|
||||
"semver",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b85a987ab61d365382d25c7d47e26edd48941b3bf6e3fbf76eff918bc71dab06"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"wit-bindgen-rust-macro",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen-core"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "775e122e390603abfacd548027016cd0113a6e2bf2f8ce6bdd3658b013456ea8"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"heck",
|
||||
"wit-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen-rust"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "84e26e13b9d972026778d2ffb7985736de116026fdc8d9464f966e12df2eb240"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"heck",
|
||||
"indexmap",
|
||||
"prettyplease",
|
||||
"syn",
|
||||
"wasm-metadata",
|
||||
"wit-bindgen-core",
|
||||
"wit-component",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen-rust-macro"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "16a008a0d6b4840677326beb4edbeb210a2f1b7d0183fb7cc33f466b90fd7fb6"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"macro-string",
|
||||
"prettyplease",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"wit-bindgen-core",
|
||||
"wit-bindgen-rust",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-component"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "078def49fdb49cab405c3006e05793b3fdaf7069126ba6b9c97d01ec8c98fe4c"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"bitflags",
|
||||
"indexmap",
|
||||
"log",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"wasm-encoder",
|
||||
"wasm-metadata",
|
||||
"wasmparser",
|
||||
"wit-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-parser"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "00f0dc051466ffe46787721fca3d088536f158ae400be044f1b1c386ba9397ad"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"hashbrown",
|
||||
"id-arena",
|
||||
"indexmap",
|
||||
"log",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"unicode-ident",
|
||||
"wasmparser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
@@ -0,0 +1,20 @@
|
||||
[package]
|
||||
name = "openidea-test-hover-actions"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
publish = false
|
||||
|
||||
[workspace]
|
||||
|
||||
[lib]
|
||||
crate-type = ["cdylib", "rlib"]
|
||||
|
||||
[dependencies]
|
||||
openidea-plugin = { path = "../../../../../sdk/rust/openidea-plugin" }
|
||||
|
||||
[profile.release]
|
||||
opt-level = "s"
|
||||
lto = true
|
||||
strip = true
|
||||
codegen-units = 1
|
||||
panic = "abort"
|
||||
Бінарний файл не відображається.
@@ -0,0 +1 @@
|
||||
0ee0773cefd61b8144d0550718e1988a1e60438bee826c3867350e28886a56f7
|
||||
@@ -0,0 +1,14 @@
|
||||
id = "test.hover-actions"
|
||||
name = "Hover actions fixture"
|
||||
version = "0.1.0"
|
||||
engines.openidea = "^1.14"
|
||||
wasm = "dist/plugin.wasm"
|
||||
|
||||
[[contributes.providers]]
|
||||
kinds = ["hover-actions"]
|
||||
languages = ["plaintext", "text"]
|
||||
|
||||
[[contributes.commands]]
|
||||
id = "run"
|
||||
title = "Run hover action"
|
||||
icon = "run"
|
||||
@@ -0,0 +1,32 @@
|
||||
//! Minimal API 1.13 fixture for the optional `hover-actions` export.
|
||||
use openidea_plugin::language_features::Document;
|
||||
use openidea_plugin::{Error, HoverAction, HoverActions, Invocation, Plugin, register_plugin};
|
||||
|
||||
#[derive(Default)]
|
||||
struct Fixture;
|
||||
|
||||
impl Plugin for Fixture {
|
||||
fn run_command(&mut self, id: &str, _: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error> {
|
||||
match id {
|
||||
"run" => Ok(arg.map(str::to_owned)),
|
||||
_ => Err(Error::NotFound(id.into())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl HoverActions for Fixture {
|
||||
fn hover_actions(&mut self, _: &Document) -> Vec<HoverAction> {
|
||||
vec![HoverAction {
|
||||
line: 0,
|
||||
start_line: 0,
|
||||
end_line: 2,
|
||||
icon: Some("run".into()),
|
||||
label: "Run hover action".into(),
|
||||
tooltip: Some("Run hover action".into()),
|
||||
command: "run".into(),
|
||||
argument: Some("hover".into()),
|
||||
}]
|
||||
}
|
||||
}
|
||||
|
||||
register_plugin!(Fixture, hover_actions);
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
507827131b48fc6c679d8c2558c2e519e03e77ebbdeaaf25d9322f36d721201e
|
||||
941cb9008aaab11464b193c37b91e2476d771ec526247713f291c6642caf5995
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ba97c6ec41ee0e2996ddd1d1c9432fad2ea0afb4c237f67c2ffb61cd25b4296c
|
||||
06d70aae3152c88d1299a9b33f151b0baa4a77c3ca7145215c6f6e0aa40727b2
|
||||
Бінарний файл не відображається.
Loaded 100 of 630 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача