дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-20 16:39:31 +02:00
Порівняти коміти
49
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
45634809e9 | ||
|
|
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 | ||
|
|
0f355c286d | ||
|
|
a0a51a63cb |
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();
|
||||
}
|
||||
|
||||
+309
-112
@@ -357,9 +357,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 +386,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 +414,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 +438,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 {
|
||||
@@ -796,6 +839,7 @@ impl AgentManager {
|
||||
entries: Vec::new(),
|
||||
wanted: Vec::new(),
|
||||
pending_model: None,
|
||||
pending_switch: None,
|
||||
before: BTreeMap::new(),
|
||||
saved: None,
|
||||
touched: Some(BTreeSet::new()),
|
||||
@@ -912,6 +956,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 +994,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 +1116,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 +1141,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 +1152,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 +1189,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 {
|
||||
@@ -1265,6 +1324,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 +1370,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 +1970,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 +1995,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 +2192,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 +2346,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 +2380,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 +2408,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(())
|
||||
@@ -2612,10 +2729,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 +2757,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 +2777,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 +2803,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 +2910,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 +2924,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 +2963,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 +2987,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 +2996,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 +3031,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 +3041,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 +3060,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();
|
||||
@@ -3361,6 +3528,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 +3566,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1935,7 +1935,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!({}));
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()) {
|
||||
|
||||
@@ -119,6 +119,29 @@ fn php_cs_fixer_edits(
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Some language servers (Vue's, for one) answer Reformat Code with one edit replacing the
|
||||
/// whole file; applied as is, it moves the caret and the view to the top of the file. The same
|
||||
/// result as one edit per changed region keeps them where they were.
|
||||
fn minimal_edits(text: &str, edits: Vec<TextEdit>) -> Vec<TextEdit> {
|
||||
if !edits.iter().any(|e| e.range.end.line > e.range.start.line) {
|
||||
return edits;
|
||||
}
|
||||
let original = ide_text::Document::new(text);
|
||||
let mut formatted = original.clone();
|
||||
if formatted.apply_edits(&edits).is_err() {
|
||||
return edits;
|
||||
}
|
||||
original
|
||||
.diff(&formatted.text())
|
||||
.changes
|
||||
.into_iter()
|
||||
.map(|c| TextEdit {
|
||||
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
|
||||
new_text: c.insert,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub async fn format(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -292,7 +315,11 @@ async fn provider_edits(
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
}
|
||||
return project.lsp.format(doc, range, options).await.map(Some);
|
||||
let edits = project.lsp.format(doc, range, options).await?;
|
||||
let text = snap.text;
|
||||
return tokio::task::spawn_blocking(move || Some(minimal_edits(&text, edits)))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()));
|
||||
};
|
||||
let tool_settings = settings.languages.formatter(selected);
|
||||
if options.on_save && !tool_settings.run_on_save {
|
||||
@@ -523,6 +550,25 @@ mod tests {
|
||||
|
||||
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
|
||||
|
||||
#[test]
|
||||
fn a_whole_file_edit_becomes_one_edit_per_changed_region() {
|
||||
let text = "a\n b\nc\nd\n e\n";
|
||||
let formatted = "a\nb\nc\nd\ne\n";
|
||||
let whole = vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(5, 0)), new_text: formatted.into() }];
|
||||
let edits = minimal_edits(text, whole);
|
||||
assert_eq!(
|
||||
edits,
|
||||
[
|
||||
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() },
|
||||
TextEdit { range: Range::new(Pos::new(4, 0), Pos::new(4, 2)), new_text: String::new() },
|
||||
]
|
||||
);
|
||||
assert_eq!(after(text, &edits), formatted);
|
||||
// Single-line edits are already minimal and pass through.
|
||||
let small = vec![TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() }];
|
||||
assert_eq!(minimal_edits(text, small.clone()), small);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
|
||||
let php = LanguageId::new("php");
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -2116,6 +2116,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();
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -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
|
||||
9ec6fcb9763867a747206b0efaf8bbeac7934a4ec0d1915623557839cf2dba5e
|
||||
@@ -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
|
||||
2015380825fc406a6466f90658443f824ef06311894b82acae2ecc1446ff0813
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ce791decf9a771b43872777a5c97050d9b7b48f5dd0ba0342ad0580bceb93d8c
|
||||
7388e5ef7a5bff42f41ed613bfb75a8da835f93a63f8fb26358bb50b77b44c00
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
f8e768db576e717ec00696098faa3434e9cea0680a1770f303bc071206727607
|
||||
aded25a93667f14a683b0bbb7547b35eed23e4971fdf2761496b09fd898b5034
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
2bd0f9e7f3ca03410389d0b125372eb322fae411272b597795cbd77ea894076d
|
||||
178bba6e74a51c0911502524f253cf7148854c46883c3f7f96d2c968e70522f5
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
30dee06cb90e54e7d930996569a3d44e9c9013077c2439880f99e1c99e15cf58
|
||||
786e1abf853d615bf0eab7315280b3884e4c2ff6362c23a41a917d6af4c050e9
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
63772fa0f67274c5326a162340aa773c54bd08d0233c726213feedc827bd1a6c
|
||||
77a825aa6adc3aa39ee390204e1fd35a12425d0a38552f116c74497dac446046
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
910d62d7f53480961b8c25b5e8d6300bee3fc0e413f35d3b7d78d6e238c65387
|
||||
352246ecdba1e3d43127c7b808a3b1cdf48cf0b4ae7d85d532ffaae734158e15
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
b05e1146eb97d5c787c826206b0d2257d1390f21a87501efa8901de3f5cb6017
|
||||
da9abe9bd086f7808cc1520a592f47c843f26ecc0a5291110915467f57816dc4
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
aa14bcafa1009b014ba2ca754711fc3b19149ff05dfefddd10edb94d16551c3d
|
||||
322b82aa432e072f8ae1d4345d321d227dbcb9376bd113c166b816254e7ddf13
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
3c0d0aa400e83c2f8e77fbec32277a23af290d4469d62d5c0046923ee7ae2c49
|
||||
e1ff50682e4aa18ca6bb96547cdd7b2815ad700e6ecaa3aede6d9f20205d4cdb
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
a1a3f1691d6d7e837f893580f75935bf83a6c0ae9224ac832c9401885f9ef504
|
||||
d3757cea9bcc8e33521c50c66b396d8ece2a90d830c2e57e651ebeb018536c62
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
97f80158eda60e5b34e4760607cfdf5c8f22debf49e438a4b3fffaf7184ad59e
|
||||
409e7017849fc68bd3241bfa5357366259e1eb634fb71ef69d4b857bec0aa821
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
7eff77b3997303adab7b8ef7999b563325e333f0696c63e1a6505579a2a41070
|
||||
0b217ad8f0c8f802c1d670422d9621d07553985b9852f3efb724b17688cfa3b9
|
||||
+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 @@
|
||||
8cc7d2ce4e21838f8f1b0f5bd56aea61257fe288f6b7189343ccf849a78de665
|
||||
@@ -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
|
||||
19b8af5e283a0a6ae866538096d2fa95e51020a9fd423768224c2ae4cfcefa27
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
ba97c6ec41ee0e2996ddd1d1c9432fad2ea0afb4c237f67c2ffb61cd25b4296c
|
||||
ccaa7d24825c05409dbcfe1491276b229ee6d712f2ba18556413a87d851c475c
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
2db9659a4a5fee1cf7179fc5f66ee7ea93f98fa8e844db4213be8cb280998b62
|
||||
b0ae383f86a8059e0bc723ca1cd21dfa76a0faa68975a1b827b44ebe1ffad2f1
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
f6ca5c93b202794571b09d0882b6809e28cd54be61765265565e991c49f9b021
|
||||
38eadb34cc096538f2b529beb07d10860323356c554dd8171ccc7ca25ebfec8e
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
ef28c6f306a3adfc7d9fc7e6ec057845b2dc159866cd07745e949436de8a2107
|
||||
1c5c9a19b4dc05219b3c144b21cad6e05a98fe5c01da7c67383cc39223b6e4d8
|
||||
@@ -1,11 +1,11 @@
|
||||
id = "test.language-features"
|
||||
name = "Language features fixture"
|
||||
version = "0.1.0"
|
||||
engines.openidea = "^1.4"
|
||||
engines.openidea = "^1.14"
|
||||
wasm = "dist/plugin.wasm"
|
||||
|
||||
[[contributes.providers]]
|
||||
kinds = ["formatting", "signature-help", "document-highlights", "document-links", "code-lenses", "selection-ranges", "folding", "colors", "document-symbols", "implementation", "type-definition", "gutter-actions", "injections"]
|
||||
kinds = ["formatting", "signature-help", "document-highlights", "document-links", "code-lenses", "selection-ranges", "folding", "colors", "document-symbols", "implementation", "type-definition", "gutter-actions", "hover-actions", "injections"]
|
||||
languages = ["plaintext", "text", "sql"]
|
||||
|
||||
[[contributes.providers]]
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use openidea_plugin::language_features::*;
|
||||
use openidea_plugin::{
|
||||
Diagnostic, Error, Invocation, Location, Plugin, Position, Range, Severity, TextEdit, register_plugin, text,
|
||||
Diagnostic, Error, HoverAction, HoverActions, Invocation, Location, Plugin, Position, Range, Severity, TextEdit,
|
||||
register_plugin, text,
|
||||
};
|
||||
#[derive(Default)]
|
||||
struct Fixture {
|
||||
@@ -102,6 +103,20 @@ impl LanguageFeatures for Fixture {
|
||||
}]
|
||||
}
|
||||
}
|
||||
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 fixture".into(),
|
||||
tooltip: Some("Run fixture".into()),
|
||||
command: "run".into(),
|
||||
argument: Some("inline".into()),
|
||||
}]
|
||||
}
|
||||
}
|
||||
impl Injections for Fixture {
|
||||
fn injections(&mut self, d: &Document) -> Vec<Injection> {
|
||||
if d.language == "sql" {
|
||||
@@ -141,4 +156,4 @@ impl openidea_plugin::diagnostics::DiagnosticsProvider for Fixture {
|
||||
]
|
||||
}
|
||||
}
|
||||
register_plugin!(Fixture, language_features, injections, providers, hover, diagnostics);
|
||||
register_plugin!(Fixture, language_features, hover_actions, injections, providers, hover, diagnostics);
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
abcb633eb89a522e4659cb21770517bb51e889d55c80854d6adc55d0ba33c41b
|
||||
d76fe0c659ef337ae7bb9c75ecfa5a9bcdff2eb92d487ca0df2aefa77bd21daf
|
||||
Loaded 100 of 462 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача