Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai 9658fadd4f fix(format): keep the caret when a language server replaces the whole file
Vue's language server (Volar) answers Reformat Code with a single edit that
replaces the whole document. Applied as is, the caret and the scroll position
jump to the top of the file. Multi-line LSP formatting edits are now reduced to
one edit per changed region (via Document::diff) before they reach the editor,
so the caret and view stay where they were for every server that does this.
2026-11-19 19:05:05 +08:00
1258 змінених файлів з 10153 додано та 66867 видалено

No files matched your search

Створено
-21
Переглянути файл
@@ -4156,8 +4156,6 @@ dependencies = [
"ide-vcs",
"ide-vfs",
"parking_lot",
"rustix",
"semver",
"serde",
"serde_json",
"specta",
@@ -4359,20 +4357,6 @@ dependencies = [
"which",
]
[[package]]
name = "ide-drag-out"
version = "0.1.49"
dependencies = [
"gtk",
"objc2 0.6.5",
"objc2-app-kit 0.3.2",
"objc2-foundation 0.3.2",
"raw-window-handle",
"tempfile",
"windows",
"windows-core",
]
[[package]]
name = "ide-extension"
version = "0.1.49"
@@ -4527,7 +4511,6 @@ dependencies = [
name = "ide-http"
version = "0.1.49"
dependencies = [
"hyper-util",
"ide-core",
"ide-vfs",
"parking_lot",
@@ -4677,7 +4660,6 @@ dependencies = [
name = "ide-lsp"
version = "0.1.49"
dependencies = [
"criterion",
"dunce",
"encoding_rs",
"futures",
@@ -4961,7 +4943,6 @@ dependencies = [
"portable-pty",
"serde",
"specta",
"tokio",
"tracing",
]
@@ -5034,7 +5015,6 @@ dependencies = [
"ignore",
"notify",
"parking_lot",
"rayon",
"rustix",
"serde",
"serde_json",
@@ -6714,7 +6694,6 @@ dependencies = [
"ide-dap",
"ide-db",
"ide-docker",
"ide-drag-out",
"ide-extension",
"ide-fonts",
"ide-github",
-1
Переглянути файл
@@ -38,7 +38,6 @@ ide-web = { path = "crates/ide-web" }
ide-spell = { path = "crates/ide-spell" }
ide-agent = { path = "crates/ide-agent" }
ide-clipboard = { path = "crates/ide-clipboard" }
ide-drag-out = { path = "crates/ide-drag-out" }
ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
-4
Переглянути файл
@@ -25,10 +25,6 @@ dunce.workspace = true
uuid.workspace = true
tempfile.workspace = true
which = "8"
semver = "1"
[target.'cfg(unix)'.dependencies]
rustix = { version = "1", features = ["fs"] }
[dev-dependencies]
tokio = { workspace = true, features = ["test-util"] }
+1 -1
Переглянути файл
@@ -51,7 +51,7 @@ async fn run_once(
move || launch.resolve_for_launch_with_copilot_env(&root, strip_ambient)
})
.await
.map_err(|e| e.to_string())??;
.map_err(|e| e.to_string())?;
let cwd = dunce::canonicalize(&root).unwrap_or(root);
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
let client = Dialect::wrap(updates.clone());
-32
Переглянути файл
@@ -256,38 +256,6 @@ 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();
+25 -193
Переглянути файл
@@ -323,36 +323,6 @@ 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,
@@ -360,12 +330,6 @@ enum ChatSwitch {
ResumeFails,
Unavailable,
Idle,
Uncached,
NoEffort,
DiscoveryFails,
EffortUnavailable,
EffortRejected,
Superseded,
}
async fn switch_chat_model(scenario: ChatSwitch) {
@@ -412,21 +376,7 @@ 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();
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 {
if matches!(scenario, ChatSwitch::Idle) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
@@ -435,122 +385,41 @@ 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(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"));
}
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let resumed_launch = if missing_settings { 3 } else { 2 };
let offline = matches!(scenario, ChatSwitch::Idle);
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();
}
}
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:?}"),
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();
}
}
// 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(&current).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()), (resumed_launch, "session/load"));
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
@@ -578,7 +447,6 @@ 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");
@@ -604,60 +472,24 @@ async fn switch_chat_model(scenario: ChatSwitch) {
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
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();
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
assert_eq!((set.launch, set.method.as_str()), (2, "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(&current).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 { resumed_launch }, "session/prompt", &json!("saved-chat"))
(if live { 0 } else { 2 }, "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!(
effort(&current).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 == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
-395
Переглянути файл
@@ -1,395 +0,0 @@
//! Checks and updates only the global npm installation selected by the agent launcher.
use crate::{AgentManager, AgentSource, provider};
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::{
fs, io,
path::{Path, PathBuf},
process::Command,
};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
pub struct AgentCliOffer {
pub current: String,
pub latest: String,
pub prefix: PathBuf,
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "status", rename_all = "camelCase")]
pub enum AgentCliUpdateResult {
Available(AgentCliOffer),
Permission(AgentCliOffer),
Current { current: String },
Channel { current: String },
Updated { current: String },
Unmanaged,
Error { code: String },
}
pub(crate) fn package(id: &str) -> Option<&'static str> {
Some(match id {
"claude" => "@anthropic-ai/claude-code",
"codex" => "@openai/codex",
"gemini" => "@google/gemini-cli",
"opencode" => "opencode-ai",
"copilot" => "@github/copilot",
"qwen" => "@qwen-code/qwen-code",
"auggie" => "@augmentcode/auggie",
"qoder" => "@qoder-ai/qodercli",
"omp" => "@oh-my-pi/pi-coding-agent",
_ => return None,
})
}
impl AgentManager {
pub fn cli_update(
&self,
id: &str,
offer: Option<&AgentCliOffer>,
cancel: &CancellationToken,
) -> IdeResult<AgentCliUpdateResult> {
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
return Ok(AgentCliUpdateResult::Unmanaged);
};
if spec.source != AgentSource::Builtin {
return Ok(AgentCliUpdateResult::Unmanaged);
}
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
result => result,
}
}
}
struct Installation {
modules: PathBuf,
folder: PathBuf,
link: PathBuf,
}
impl Installation {
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
Self { folder: modules.join(pkg), modules, link }
}
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
return Ok(None);
}
let folder = dunce::canonicalize(&self.folder)?;
if fs::symlink_metadata(&self.folder)?.is_symlink()
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
{
return Ok(None);
}
let manifest = self.folder.join("package.json");
if !manifest.try_exists()? {
return Ok(None);
}
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
let Some(version) = manifest["version"].as_str() else {
return Err(IdeError::invalid("Missing npm package version"));
};
let entry = folder.join(entry);
if !entry.try_exists()? {
return Ok(None);
}
let entry = dunce::canonicalize(entry)?;
if !entry.starts_with(&folder) {
return Ok(None);
}
#[cfg(unix)]
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
#[cfg(windows)]
let owns = {
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
};
Ok(owns.then(|| version.to_owned()))
}
fn writable(&self) -> io::Result<bool> {
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
#[cfg(unix)]
let access: io::Result<()> =
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
.map_err(Into::into);
#[cfg(windows)]
let access = tempfile::tempfile_in(dir).map(drop);
match access {
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
return Ok(false);
}
other => other?,
}
}
Ok(true)
}
}
fn stable(version: &str) -> Option<semver::Version> {
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
}
fn maintain(
npm: &Path,
program: &Path,
bin: &str,
pkg: &str,
approved: Option<&AgentCliOffer>,
cancel: &CancellationToken,
) -> IdeResult<AgentCliUpdateResult> {
use AgentCliUpdateResult::*;
let run = |args: &[&str]| {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let mut cmd = Command::new(npm);
cmd.args(args)
.current_dir(npm.parent().unwrap())
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
.env("NPM_CONFIG_LOGLEVEL", "error");
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
if e.kind == ErrorKind::Cancelled {
return e;
}
// npm diagnostics can contain private registry URLs; expose only known codes.
let code = e
.message
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
.find(|w| {
matches!(
*w,
"EACCES"
| "EPERM"
| "EROFS"
| "ENOTFOUND"
| "EAI_AGAIN"
| "ETIMEDOUT"
| "E404"
| "E401"
| "E403"
)
})
.unwrap_or("npm");
IdeError::unavailable(code)
})
};
let output = run(&["prefix", "-g"])?;
let prefix = Path::new(output.trim_end());
if !prefix.is_absolute() {
return Err(IdeError::invalid("Invalid npm global prefix"));
}
let installation = Installation::at(prefix, pkg, bin);
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
let (Some(before), Some(after)) = (stable(&current), stable(&latest)) else {
return Ok(Channel { current });
};
if before >= after {
return Ok(Current { current });
}
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
if !installation.writable()? {
return Ok(Permission(offer));
}
if approved != Some(&offer) {
return Ok(Available(offer));
}
run(&[
"install",
"-g",
"--prefix",
prefix.to_str().unwrap(),
"--no-audit",
"--no-fund",
&format!("{pkg}@{}", offer.latest),
])?;
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
return Err(IdeError::invalid("npm installation verification failed"));
}
Ok(Updated { current: offer.latest })
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use tempfile::TempDir;
const PKG: &str = "@anthropic-ai/claude-code";
struct Fixture {
root: TempDir,
install: Installation,
}
impl Fixture {
fn new() -> Self {
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
let install = Installation::at(root.path(), PKG, "claude");
fs::create_dir_all(&install.folder).unwrap();
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
fs::write(install.folder.join("entry.js"), "").unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
#[cfg(windows)]
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
let fixture = Self { root, install };
fixture.manifest(PKG, "2.1.9");
fixture
}
fn manifest(&self, name: &str, version: &str) {
fs::write(
self.install.folder.join("package.json"),
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
)
.unwrap();
}
fn version(&self) -> Option<String> {
self.install.version(&self.install.link, PKG, "claude").unwrap()
}
#[cfg(unix)]
fn npm(&self, script: &str) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = self.root.path().join("npm");
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
path
}
}
#[test]
fn requires_the_selected_install_and_its_exact_package_entry() {
let f = Fixture::new();
assert_eq!(f.version().as_deref(), Some("2.1.9"));
let other = f.root.path().join("other");
fs::write(&other, "").unwrap();
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
f.manifest("other-package", "2.1.9");
assert_eq!(f.version(), None);
f.manifest(PKG, "2.1.9");
fs::remove_file(&f.install.link).unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
#[cfg(windows)]
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
assert_eq!(f.version(), None);
}
#[cfg(unix)]
const NPM: &str = r#"case "$1" in
prefix) pwd -P ;;
view) cat latest ;;
install)
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
test "$7" = "@anthropic-ai/[email protected]"
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
touch installed ;;
*) exit 2 ;;
esac"#;
#[cfg(unix)]
#[test]
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
use AgentCliUpdateResult::*;
let f = Fixture::new();
let npm = f.npm(NPM);
let cancel = CancellationToken::new();
let run =
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
let latest = f.root.path().join("latest");
fs::write(&latest, r#""2.1.12""#).unwrap();
let Available(offer) = run(None) else { panic!("expected an offer") };
for different in [
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
] {
assert_eq!(run(Some(&different)), Available(offer.clone()));
}
fs::write(&latest, r#""2.2.0""#).unwrap();
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
fs::write(&latest, r#""2.0.0""#).unwrap();
assert!(matches!(run(Some(&offer)), Current { .. }));
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
assert!(matches!(run(Some(&offer)), Channel { .. }));
fs::write(&latest, r#""2.1.12""#).unwrap();
f.manifest("other-package", "2.1.9");
assert_eq!(run(Some(&offer)), Unmanaged);
assert!(!f.root.path().join("installed").exists());
f.manifest(PKG, "2.1.12");
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
f.manifest(PKG, "2.1.9");
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
assert!(f.root.path().join("installed").exists());
assert_eq!(run(None), Current { current: "2.1.12".into() });
}
#[cfg(unix)]
#[test]
fn permission_failure_never_starts_an_install() {
use std::os::unix::fs::PermissionsExt;
let f = Fixture::new();
let npm = f.npm(NPM);
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
let run = |offer: Option<&AgentCliOffer>| {
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
};
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
// root can write even when no mode bit grants write permission.
if tempfile::tempfile_in(&f.install.folder).is_err() {
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
}
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
assert!(!f.root.path().join("installed").exists());
}
#[cfg(unix)]
#[test]
fn cancellation_stops_a_running_npm_process() {
use std::time::{Duration, Instant};
let f = Fixture::new();
let npm = f.npm(
r#"case "$1" in
prefix) pwd -P ;;
view) echo '"2.1.12"' ;;
install) touch started; exec sleep 30 ;;
esac"#,
);
let cancel = CancellationToken::new();
let AgentCliUpdateResult::Available(offer) =
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
else {
panic!("expected an offer")
};
let started = f.root.path().join("started");
std::thread::scope(|s| {
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
let deadline = Instant::now() + Duration::from_secs(5);
while !started.exists() && Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
cancel.cancel();
assert!(started.exists());
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
});
assert_eq!(f.version().as_deref(), Some("2.1.9"));
}
}
+1 -22
Переглянути файл
@@ -3,7 +3,7 @@
use crate::model::{
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
AgentModelPricing, AgentTokens, AgentUsage,
AgentModelPricing, AgentUsage,
};
use serde_json::{Value, json};
@@ -272,18 +272,6 @@ pub(crate) fn usage_of(update: &Value) -> Option<AgentUsage> {
Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)?, cost })
}
/// The `usage` of a `session/prompt` result: `{ inputTokens, cachedReadTokens, outputTokens }`.
pub(crate) fn tokens_of(result: &Value) -> Option<AgentTokens> {
let usage = result.get("usage")?;
let tokens = |key: &str| usage.get(key).and_then(Value::as_u64).map_or(0, |n| u32::try_from(n).unwrap_or(u32::MAX));
let tokens = AgentTokens {
input: tokens("inputTokens"),
cached: tokens("cachedReadTokens"),
output: tokens("outputTokens"),
};
(tokens != AgentTokens::default()).then_some(tokens)
}
/// The usage-limit windows a [`crate::LIMITS_UPDATE`] carries; malformed entries are skipped.
pub(crate) fn limits_of(update: &Value) -> Vec<AgentLimit> {
let limits = update.get("limits").and_then(Value::as_array).into_iter().flatten();
@@ -380,15 +368,6 @@ mod tests {
c.iter().map(|o| (o.id.as_str(), o.current.as_deref())).collect()
}
#[test]
fn a_hermes_prompt_result_reports_the_turns_tokens() {
let result = json!({"stopReason": "end_turn", "usage": {"cachedReadTokens": 51306, "inputTokens": 77284,
"outputTokens": 509, "thoughtTokens": 0, "totalTokens": 77793}});
assert_eq!(tokens_of(&result), Some(AgentTokens { input: 77284, cached: 51306, output: 509 }));
assert_eq!(tokens_of(&json!({"stopReason": "end_turn"})), None);
assert_eq!(tokens_of(&json!({"usage": {}})), None);
}
#[test]
fn config_options_win_over_the_older_fields() {
let r = json!({
-111
Переглянути файл
@@ -1,111 +0,0 @@
//! Hermes Agent profiles on disk: `default` is the Hermes home itself, the others are
//! `<home>/profiles/<name>` directories holding one of Hermes' identity files.
use std::path::{Path, PathBuf};
use serde::Serialize;
use specta::Type;
const PROFILE_FILES: &[&str] = &["config.yaml", ".env", "SOUL.md", "profile.yaml", "auth.json", "state.db"];
/// Hermes' home directory (`~/.hermes`; `%LOCALAPPDATA%\hermes` on Windows).
pub fn root(home: Option<&Path>) -> Option<PathBuf> {
#[cfg(windows)]
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
return Some(PathBuf::from(local).join("hermes"));
}
home.map(|h| h.join(".hermes"))
}
/// The profile names under `root`: `default` first, then the others by name; none without `root`.
pub fn profiles(root: &Path) -> Vec<String> {
if !root.is_dir() {
return Vec::new();
}
let mut named: Vec<String> = std::fs::read_dir(root.join("profiles"))
.into_iter()
.flatten()
.flatten()
.filter(|e| PROFILE_FILES.iter().any(|f| e.path().join(f).exists()))
.filter_map(|e| e.file_name().to_str().map(str::to_owned))
.filter(|name| name != "default")
.collect();
named.sort();
std::iter::once("default".to_owned()).chain(named).collect()
}
/// A profile and the name Hermes shows for it (`hermes profile list`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Type)]
pub struct HermesProfile {
/// What `hermes -p` takes; `default` is the Hermes home itself.
pub name: String,
/// `display_name` from the profile's `profile.yaml`, else the name.
pub label: String,
}
/// [`profiles`] with the names Hermes shows for them.
pub fn labeled_profiles(root: &Path) -> Vec<HermesProfile> {
profiles(root)
.into_iter()
.map(|name| {
let home = if name == "default" { root.to_path_buf() } else { root.join("profiles").join(&name) };
let label = display_name(&home).unwrap_or_else(|| name.clone());
HermesProfile { name, label }
})
.collect()
}
/// The top-level `display_name:` of `<home>/profile.yaml`, the only key read (no YAML parser).
fn display_name(home: &Path) -> Option<String> {
let text = std::fs::read_to_string(home.join("profile.yaml")).ok()?;
let value = text.lines().find_map(|l| l.strip_prefix("display_name:"))?;
let value = value.trim().trim_matches(['"', '\'']).trim();
(!value.is_empty()).then(|| value.to_owned())
}
/// The home of the profile an agent id stands for: `hermes` and `hermes-default` are the
/// default profile, `hermes-<slug>` the profile whose name slugifies to `<slug>`.
pub fn profile_home(root: &Path, provider: &str) -> Option<PathBuf> {
let slug = match provider {
"hermes" | "hermes-default" => return Some(root.to_path_buf()),
_ => provider.strip_prefix("hermes-")?,
};
profiles(root).into_iter().find(|p| crate::provider::slugify_id(p) == slug).map(|p| root.join("profiles").join(p))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn lists_default_and_profiles_with_an_identity_file() {
let dir = tempfile::tempdir().unwrap();
assert!(profiles(&dir.path().join("missing")).is_empty());
let root = dir.path().join(".hermes");
std::fs::create_dir_all(root.join("profiles/empty")).unwrap();
assert_eq!(profiles(&root), ["default"]);
for (name, file) in [("work", "config.yaml"), ("Dom 2", "SOUL.md"), ("db", "state.db")] {
std::fs::create_dir_all(root.join("profiles").join(name)).unwrap();
std::fs::write(root.join("profiles").join(name).join(file), "").unwrap();
}
std::fs::write(root.join("profiles/stray.yaml"), "").unwrap();
assert_eq!(profiles(&root), ["default", "Dom 2", "db", "work"]);
assert_eq!(profile_home(&root, "hermes"), Some(root.clone()));
assert_eq!(profile_home(&root, "hermes-dom-2"), Some(root.join("profiles/Dom 2")));
assert_eq!(profile_home(&root, "hermes-empty"), None);
assert_eq!(profile_home(&root, "claude"), None);
}
#[test]
fn labels_profiles_with_their_display_name() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join(".hermes");
std::fs::create_dir_all(root.join("profiles/work")).unwrap();
std::fs::write(root.join("profile.yaml"), "description: mine\ndisplay_name: \"qb\"\n").unwrap();
std::fs::write(root.join("profiles/work/profile.yaml"), "ui_meta:\n display_name: nested\n").unwrap();
let label = |name: &str, label: &str| HermesProfile { name: name.into(), label: label.into() };
assert_eq!(labeled_profiles(&root), [label("default", "qb"), label("work", "work")]);
std::fs::remove_file(root.join("profile.yaml")).unwrap();
assert_eq!(labeled_profiles(&root)[0], label("default", "default"));
}
}
File diff suppressed because it is too large. Load diff
-138
Переглянути файл
@@ -45,8 +45,6 @@ pub struct AgentCapabilities {
pub steer: bool,
/// It reports its background tasks and stops them one by one.
pub background_tasks: bool,
/// The connected agent can report a breakdown of its context window.
pub context_usage: bool,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -110,32 +108,6 @@ pub struct AgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub mcp_overrides: BTreeMap<String, bool>,
/// Per-session skill modes (`skill name` -> mode), on top of the settings' policies.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub skill_overrides: BTreeMap<String, AgentSkillMode>,
/// Token counts of the last turn and context compressions, when the agent reports them.
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
#[serde(default)]
pub stats: Box<AgentSessionStats>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentSessionStats {
/// The last turn's tokens (`session/prompt` result `usage`).
#[serde(default)]
pub tokens: Option<AgentTokens>,
/// How many times the agent compressed the conversation (Hermes `compressionDepth`).
#[serde(default)]
pub compressions: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentTokens {
pub input: u32,
pub cached: u32,
pub output: u32,
}
/// A task the agent runs in the background while the conversation goes on.
@@ -280,24 +252,6 @@ pub struct AgentUsage {
pub cost: Option<Box<AgentCost>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentContextUsage {
pub categories: Vec<AgentContextCategory>,
pub total_tokens: u32,
pub max_tokens: u32,
pub model: String,
pub is_auto_compact_enabled: Option<bool>,
pub auto_compact_threshold: Option<u32>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
pub struct AgentContextCategory {
pub name: String,
pub tokens: u32,
pub kind: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentCost {
@@ -525,9 +479,6 @@ pub enum AgentEntry {
},
Thought {
text: String,
/// When the reasoning started (ms since the epoch); `None` in tasks saved before.
#[serde(default)]
started_ms: Option<f64>,
},
Tool {
id: String,
@@ -539,11 +490,6 @@ pub enum AgentEntry {
/// Text the tool reported (command output…), truncated.
output: Option<String>,
diffs: Vec<AgentToolDiff>,
/// When the call started and ended (ms since the epoch); `None` in tasks saved before.
#[serde(default)]
started_ms: Option<f64>,
#[serde(default)]
ended_ms: Option<f64>,
},
Plan {
items: Vec<AgentPlanItem>,
@@ -617,9 +563,6 @@ pub struct AgentProvider {
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
/// Whether the command was found (on `PATH`).
pub installed: bool,
/// The built-in command can be owned by a global npm package.
#[serde(default)]
pub can_check_cli_update: bool,
/// Environment variables it starts with (from its agent file).
pub env: BTreeMap<String, String>,
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
@@ -690,9 +633,6 @@ pub struct NewAgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
/// Per-session skill modes (`skill name` -> mode).
#[serde(default)]
pub skill_overrides: BTreeMap<String, AgentSkillMode>,
/// Creates the task without sending `prompt` (it only names the task): the composer's
/// `!` command runs in it first.
#[serde(default)]
@@ -885,84 +825,6 @@ fn default_true() -> bool {
true
}
pub use ide_core::settings::{AgentSkillMode, AgentSkillPolicy};
/// Which CLI's own folders a skill was discovered in (Settings › Agents › Skills groups by it).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentSkillSource {
/// The project's `.agents/skills` and `.openidea/skills`.
#[default]
Workspace,
/// The user's `~/.agents/skills` (what `npx skills add` fills).
User,
/// The project's `.claude/skills`.
ClaudeWorkspace,
/// `~/.claude/skills`.
ClaudeUser,
/// The project's `.github/skills` (Copilot's repository skills).
GithubWorkspace,
/// `~/.copilot/skills` and `~/.copilot/installed-plugins/*`.
CopilotUser,
/// The project's `.codex/skills`.
CodexWorkspace,
/// `~/.codex/skills`.
CodexUser,
/// The project's `.cursor/skills`.
CursorWorkspace,
/// `~/.cursor/skills`.
CursorUser,
}
impl AgentSkillSource {
/// Whether skills of this source are only read, never delivered by OpenIDEA: the CLI
/// discovers them itself, so "off" holds only where the CLI supports a native disable.
pub fn discovered(&self) -> bool {
!matches!(self, Self::Workspace | Self::User)
}
}
/// One discovered skill: a folder with a `SKILL.md`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentSkill {
/// The frontmatter `name`, else the folder's name.
pub name: String,
pub description: String,
/// Canonical folder holding `SKILL.md` (symlinks resolved, so duplicates collapse).
pub path: IpcPath,
pub source: AgentSkillSource,
/// The `SKILL.md` passes validation (`name` matches its folder, `description` present).
pub valid: bool,
/// What validation found (`name` mismatch, missing or over-long description…).
pub warnings: Vec<String>,
}
/// A skill as Settings › Agents › Skills shows it: discovery plus the effective mode and
/// which layer decided it.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AgentSkillState {
pub skill: AgentSkill,
pub mode: AgentSkillMode,
/// What set `mode`: a session override, the workspace, the user's settings, workspace
/// trust, or nothing (the default `auto`).
pub origin: AgentSkillOrigin,
}
/// Which layer decided a skill's [`AgentSkillState::mode`].
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentSkillOrigin {
#[default]
None,
Session,
Workspace,
User,
/// An untrusted workspace's skills and policies may only turn skills off.
Trust,
}
/// An external MCP configuration file discovered on disk (user CLI config or workspace file).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+1 -21
Переглянути файл
@@ -172,10 +172,6 @@ struct Session {
mcp_config: Option<tempfile::TempPath>,
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
mcp_off: Vec<String>,
/// The staged skills folder passed as `--add-dir` (its `.claude/skills` holds the copies).
skills_add_dir: Option<PathBuf>,
/// The staged skills' `--settings` JSON (`skillOverrides` for the native ones too).
skills_settings: Option<String>,
shim: Weak<Shim>,
st: Mutex<State>,
/// Serializes (re)starting the process.
@@ -360,13 +356,10 @@ impl Shim {
None
}
});
let skills = params.pointer("/_meta/openidea/skills");
let session = Arc::new(Session {
id: id.to_owned(),
mcp_config,
mcp_off,
skills_add_dir: skills.and_then(|s| s.get("claudeAddDir")).and_then(Value::as_str).map(PathBuf::from),
skills_settings: skills.and_then(|s| s.get("claudeSettings")).and_then(Value::as_str).map(str::to_owned),
shim: Arc::downgrade(self),
st: Mutex::new(State {
proc: None,
@@ -414,7 +407,7 @@ impl Shim {
"promptCapabilities": { "image": true, "embeddedContext": true },
"sessionCapabilities": { "fork": {} },
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
},
"agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
"authMethods": [],
@@ -499,11 +492,6 @@ impl Shim {
session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
Ok(json!({}))
}
"_openidea/context_usage" => {
let session = self.session(&params)?;
let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
rt.block_on(proc.control(json!({ "subtype": "get_context_usage" }))).map_err(internal)
}
"_openidea/stop_task" => {
let session = self.session(&params)?;
let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
@@ -680,14 +668,6 @@ impl Session {
if !self.mcp_off.is_empty() {
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
}
// The staged skills: `.claude/skills` of the added directory is discovered like the
// project's own, and the settings hold the modes of the skills it sees natively too.
if let Some(dir) = &self.skills_add_dir {
args.extend(["--add-dir".to_owned(), dir.to_string_lossy().into_owned()]);
}
if let Some(settings) = &self.skills_settings {
args.extend(["--settings".to_owned(), settings.clone()]);
}
args.extend(start.args());
let launch =
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
+9 -56
Переглянути файл
@@ -334,31 +334,6 @@ fn str_param<'a>(params: &'a Value, key: &str) -> Result<&'a str, ResponseError>
params.get(key).and_then(Value::as_str).ok_or_else(|| invalid(format!("missing {key}")))
}
/// Fills a `thread/start`/`thread/resume`/`thread/fork` request's `config` with the session's
/// MCP servers and its staged skills: the off ones, by path (`skills.config` entries with
/// `enabled = false`, which the CLI honors for the copies it discovers natively too).
fn apply_thread_config(params: &Value, request: &mut Value) {
let mut config = translate::mcp_config(params).unwrap_or_else(|| json!({}));
let off: Vec<Value> = params
.pointer("/_meta/openidea/skills/codexOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|entry| {
let path = entry.get(1)?.as_str()?;
Some(json!({ "path": path, "enabled": false }))
})
.collect();
if !off.is_empty()
&& let Some(map) = config.as_object_mut()
{
map.insert("skills".into(), json!({ "config": off }));
}
if !config.as_object().is_some_and(|m| m.is_empty()) {
request["config"] = config;
}
}
impl CodexShim {
fn codex(&self) -> &Peer {
self.codex.get().expect("attached before any message")
@@ -439,31 +414,6 @@ impl CodexShim {
}
}
/// Hands the session's staged skills to the app-server: the farm's `codex` tree joins
/// its discovery roots. Best-effort: a CLI version without `skills/extraRoots/set`
/// (the method arrived later than some pinned installs) runs without the farm, as
/// before.
async fn apply_skill_roots(&self, session: &str, params: &Value) {
let roots = params
.pointer("/_meta/openidea/skills/codexExtraRoots")
.and_then(Value::as_array)
.map(|a| a.iter().filter_map(Value::as_str).collect::<Vec<_>>())
.unwrap_or_default();
if roots.is_empty() {
return;
}
let set = tokio::time::timeout(
Duration::from_secs(5),
self.call("skills/extraRoots/set", json!({ "extraRoots": roots })),
)
.await;
match set {
Ok(Ok(_)) => {}
Ok(Err(e)) => tracing::info!("codex session {session}: could not set the extra skill roots: {}", e.message),
Err(e) => tracing::info!("codex session {session}: could not set the extra skill roots: {e}"),
}
}
/// Registers a thread codex opened for a session of its own; returns its `configOptions`.
fn open_thread(&self, result: &Value, models: &[ModelInfo], settings: Option<Settings>) -> (String, Value) {
let thread = result.get("thread").unwrap_or(&Value::Null);
@@ -484,13 +434,14 @@ impl CodexShim {
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "cwd": params.get("cwd") });
apply_thread_config(params, &mut request);
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
}
let result = self.call("thread/start", request).await?;
let (id, options) = self.open_thread(&result, &models, None);
if id.is_empty() {
return Err(error(codes::INTERNAL_ERROR, "codex started no thread"));
}
self.apply_skill_roots(&id, params).await;
self.publish_skills(&id).await;
Ok(json!({ "sessionId": id, "configOptions": options }))
}
@@ -501,7 +452,9 @@ impl CodexShim {
let models = self.models().await?;
self.prepare_project_trust(params).await;
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
apply_thread_config(params, &mut request);
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
}
let result = self.call("thread/resume", request).await?;
let (_, options) = self.open_thread(&result, &models, None);
let cwd = self.state.lock().threads.get(id).and_then(|t| t.cwd.clone());
@@ -509,7 +462,6 @@ impl CodexShim {
for update in translate::history(thread, cwd.as_deref()) {
self.emit(id, update);
}
self.apply_skill_roots(id, params).await;
self.publish_skills(id).await;
Ok(json!({ "configOptions": options }))
}
@@ -520,7 +472,9 @@ impl CodexShim {
self.prepare_project_trust(params).await;
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
apply_thread_config(params, &mut request);
if let Some(config) = translate::mcp_config(params) {
request["config"] = config;
}
if let Some(s) = &settings {
request["model"] = json!(s.model_slug(&models));
request["approvalPolicy"] = json!(s.mode.approval_policy());
@@ -528,7 +482,6 @@ impl CodexShim {
}
let result = self.call("thread/fork", request).await?;
let (id, options) = self.open_thread(&result, &models, settings);
self.apply_skill_roots(&id, params).await;
self.publish_skills(&id).await;
Ok(json!({ "sessionId": id, "configOptions": options }))
}
+1 -22
Переглянути файл
@@ -144,8 +144,7 @@ async fn discover_once(spec: ProviderSpec, cwd: PathBuf, strip_ambient: bool) ->
move || spec.resolve_for_launch_with_copilot_env(&cwd, strip_ambient)
})
.await
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?
.map_err(|e| DiscoverError { message: e, allow_acp_fallback: false })?;
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?;
let cwd = dunce::canonicalize(&cwd).unwrap_or(cwd);
let args = headless_args(&launch.args);
let peer = Peer::spawn_framed(
@@ -372,24 +371,6 @@ fn error(code: i64, message: impl Into<String>) -> ResponseError {
ResponseError { code, message: message.into(), data: None }
}
/// Adds the session's staged skills to a `session.create`/`session.resume` request:
/// `skillDirectories` (the farm's `copilot` tree) and `disabledSkills` (the off and
/// slash-only ones; Copilot invokes skills with the model only, so a slash-only skill has
/// no other switch here).
fn apply_skills(params: &Value, req: &mut Value) {
let skills = params.pointer("/_meta/openidea/skills");
if let Some(dirs) = skills.and_then(|s| s.get("copilotSkillDirectories")).and_then(Value::as_array)
&& !dirs.is_empty()
{
req["skillDirectories"] = json!(dirs.iter().filter_map(Value::as_str).collect::<Vec<_>>());
}
if let Some(disabled) = skills.and_then(|s| s.get("copilotDisabledSkills")).and_then(Value::as_array)
&& !disabled.is_empty()
{
req["disabledSkills"] = json!(disabled.iter().filter_map(Value::as_str).collect::<Vec<_>>());
}
}
fn invalid(message: impl Into<String>) -> ResponseError {
error(codes::INVALID_PARAMS, message)
}
@@ -514,7 +495,6 @@ impl CopilotShim {
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
apply_skills(params, &mut req);
let created = self.call("session.create", req).await?;
let session_id = created
@@ -565,7 +545,6 @@ impl CopilotShim {
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
apply_skills(params, &mut req);
let resumed = self.call("session.resume", req).await?;
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
+2 -14
Переглянути файл
@@ -312,7 +312,7 @@ impl Settings {
}
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
/// prepending `"auto"` when direct models are present or Copilot advertises an enabled Auto tier.
/// prepending `"auto"` when not already in the list.
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
let units = parse_price_units(price_units);
let raw = list
@@ -322,7 +322,7 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
.map(Vec::as_slice)
.unwrap_or_default();
let mut out = Vec::new();
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && (!raw.is_empty() || auto_model_available(list)) {
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
out.push(ModelEntry {
id: "auto".into(),
name: "Auto".into(),
@@ -344,18 +344,6 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
out
}
fn auto_model_available(list: &Value) -> bool {
let Some(auto) = list.get("auto") else { return false };
if auto.get("enabled").or_else(|| auto.pointer("/status/enabled")).and_then(Value::as_bool) == Some(false) {
return false;
}
let Some(tiers) = auto.get("tiers").and_then(Value::as_array) else { return auto.is_object() };
tiers.is_empty()
|| tiers.iter().any(|tier| {
tier.get("enabled").or_else(|| tier.pointer("/status/enabled")).and_then(Value::as_bool) != Some(false)
})
}
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
let id = str_of(m, "id")?.to_owned();
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
-66
Переглянути файл
@@ -110,72 +110,6 @@ fn sample_price_units() -> Value {
})
}
#[test]
fn parses_an_enabled_auto_only_catalog() {
let list = json!({
"models": [],
"auto": {
"defaultTier": "balance",
"tiers": [
{
"id": "balance",
"displayName": "Standard",
"type": "auto",
"fusionTier": "standard",
"status": { "enabled": true, "pickerVisible": true }
},
{
"id": "hydrafusion",
"displayName": "High",
"type": "fusion",
"fusionTier": "high",
"status": {
"enabled": false,
"pickerVisible": true,
"reason": "user_not_eligible"
}
},
{
"id": "fast",
"displayName": "Fast",
"type": "auto",
"status": { "enabled": true, "pickerVisible": false }
}
],
"providerId": "copilot"
},
"imageModels": []
});
let catalog = models::parse_catalog(&list, None);
assert_eq!(catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(), ["auto"]);
assert_eq!(Settings::new(&catalog, &UserDefaults::default()).model, "auto");
let options =
config::parse_options(&models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default())));
let model = options.iter().find(|option| option.id == MODEL).unwrap();
assert_eq!(model.current.as_deref(), Some("auto"));
assert_eq!(model.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["auto"]);
}
#[test]
fn rejects_an_auto_only_catalog_when_every_tier_is_disabled() {
let list = json!({
"models": [],
"auto": {
"defaultTier": "balance",
"tiers": [
{
"id": "balance",
"status": { "enabled": false, "pickerVisible": true }
}
]
}
});
assert!(models::parse_catalog(&list, None).is_empty());
}
#[test]
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
+3 -141
Переглянути файл
@@ -9,8 +9,6 @@ use serde_json::Value;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
pub(crate) const COPILOT_GITHUB_ACCOUNT_ENV: &str = "OPENIDEA_COPILOT_GITHUB_ACCOUNT";
/// The protocol an agent speaks. Native ones run behind an in-process ACP endpoint
/// (`native`), so tasks see every agent as ACP and read features from its capabilities.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -84,7 +82,6 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
("kiro", "Kiro", Driver::Acp, &["kiro-cli", "acp"], "Run `kiro-cli login` in a terminal."),
("vibe", "Mistral Vibe", Driver::Acp, &["vibe-acp"], "Run `vibe` in a terminal and sign in."),
("omp", "OMP", Driver::Acp, &["omp", "acp"], "Run `omp` in a terminal and sign in."),
("hermes", "Hermes Agent", Driver::Acp, &["hermes", "acp"], "Run `hermes model` in a terminal."),
];
fn builtins() -> Vec<ProviderSpec> {
@@ -140,31 +137,15 @@ impl ProviderSpec {
/// Resolve once before connecting, so authentication guidance names that same install.
pub(crate) fn resolve_for_launch(self, cwd: &Path) -> Self {
let strip = prefer_stored_copilot_auth();
self.resolve_for_launch_base(cwd, strip)
self.resolve_for_launch_with_copilot_env(cwd, strip)
}
pub(crate) fn resolve_for_launch_with_copilot_env(
self,
cwd: &Path,
strip_ambient_tokens: bool,
) -> Result<Self, String> {
let account = is_copilot_provider(&self.id).then(|| copilot_github_account(&self.env)).flatten();
let mut resolved = self.resolve_for_launch_base(cwd, strip_ambient_tokens || account.is_some());
if let Some(account) = account {
let token = github_token_for_account(&account)?;
resolved.env.retain(|(name, _)| !AMBIENT_COPILOT_AUTH_VARS.contains(&name.as_str()));
resolved.env.push(("COPILOT_GITHUB_TOKEN".into(), token));
}
Ok(resolved)
}
fn resolve_for_launch_base(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
pub(crate) fn resolve_for_launch_with_copilot_env(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
if self.driver != Driver::Acp {
self.command = crate::native::newest_install(&self.command);
}
if is_copilot_provider(&self.id) {
self.env = sanitized_copilot_env(&self.env, strip_ambient_tokens);
self.env.retain(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV);
}
let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
self.command =
@@ -182,50 +163,6 @@ pub(crate) fn is_copilot_provider(id: &str) -> bool {
id == "copilot" || id.starts_with("copilot-")
}
pub(crate) fn copilot_github_account(env: &[(String, String)]) -> Option<String> {
env.iter()
.rev()
.find(|(name, _)| name == COPILOT_GITHUB_ACCOUNT_ENV)
.map(|(_, value)| value.trim())
.filter(|value| !value.is_empty())
.map(str::to_owned)
}
fn github_token_for_account(account: &str) -> Result<String, String> {
let path = ide_core::process::shell_env()
.find(|(name, _)| name == "PATH")
.map(|(_, value)| value)
.or_else(|| ide_core::process::host_var_os("PATH"));
let program = path
.as_deref()
.and_then(|path| ide_core::process::find_executable("gh", path))
.ok_or_else(|| "GitHub CLI (`gh`) is required to select a Copilot GitHub account".to_owned())?;
let mut command = std::process::Command::new(program);
command.args(["auth", "token", "--hostname", "github.com", "--user", account]).envs(ide_core::process::shell_env());
for name in AMBIENT_COPILOT_AUTH_VARS {
command.env_remove(name);
}
let output = command
.output()
.map_err(|error| format!("Couldn't read GitHub authentication for account {account}: {error}"))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
let detail = stderr.trim();
return Err(if detail.is_empty() {
format!("GitHub CLI has no authenticated account named {account}")
} else {
format!("Couldn't use GitHub account {account}: {detail}")
});
}
let token = String::from_utf8(output.stdout)
.map_err(|_| format!("GitHub CLI returned a non-text token for account {account}"))?;
let token = token.trim();
if token.is_empty() {
return Err(format!("GitHub CLI returned no token for account {account}"));
}
Ok(token.to_owned())
}
pub(crate) fn prefer_stored_copilot_auth() -> bool {
PREFER_STORED_COPILOT_AUTH.load(std::sync::atomic::Ordering::Acquire)
}
@@ -373,7 +310,6 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
command_editable: reason.is_none(),
command_read_only_reason: reason,
installed: installed(&spec.command),
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
env: spec.env.iter().cloned().collect(),
config: vec![],
thought_levels: BTreeMap::new(),
@@ -402,31 +338,6 @@ pub(crate) fn set_builtin_env(
id: &str,
env: BTreeMap<String, String>,
) -> IdeResult<()> {
if id == "copilot" {
let file = custom_dir.join("copilot.toml");
if file.try_exists()?
&& let mut agent = CustomAgent::read_with(&file, id, secrets).map_err(IdeError::invalid)?
&& agent.registry.is_some()
{
let existing = agent.env.clone();
let mut existing_launch_env = existing.clone();
let mut next_launch_env = env.clone();
existing_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
next_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
if existing_launch_env != next_launch_env {
return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
}
match env.get(COPILOT_GITHUB_ACCOUNT_ENV).filter(|value| !value.trim().is_empty()) {
Some(account) => {
agent.env.insert(COPILOT_GITHUB_ACCOUNT_ENV.into(), account.trim().into());
}
None => {
agent.env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
}
}
return agent.write(&file).map_err(Into::into);
}
}
update_builtin(custom_dir, secrets, id, |agent, _| agent.env = env)
}
@@ -592,7 +503,7 @@ fn validated_custom_id(id: &str) -> IdeResult<String> {
}
/// Turns an `acp.json` server name into a file-stem id (`"My Agent!"` → `"my-agent"`).
pub(crate) fn slugify_id(name: &str) -> String {
fn slugify_id(name: &str) -> String {
let mut id = String::with_capacity(name.len());
for c in name.chars() {
if c.is_ascii_alphanumeric() {
@@ -805,15 +716,6 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn hermes_is_built_in_over_acp() {
let spec = builtin_spec("hermes").unwrap();
assert_eq!(spec.driver, Driver::Acp);
let info = describe(&spec);
assert_eq!((info.name.as_str(), info.command.as_str()), ("Hermes Agent", "hermes acp"));
assert_eq!(info.login_hint.as_deref(), Some("Run `hermes model` in a terminal."));
}
#[test]
fn qoder_global_and_cn_editions_are_both_built_in() {
let info = |id: &str| describe(&load(None, None).into_iter().find(|s| s.id == id).unwrap());
@@ -1043,46 +945,6 @@ mod tests {
set_builtin_env(dir.path(), None, "not-a-builtin", env).unwrap_err();
}
#[test]
fn registry_copilot_allows_only_the_github_account_override() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("copilot.toml");
CustomAgent {
name: Some("GitHub Copilot".into()),
driver: Driver::Acp,
command: "/tools/copilot".into(),
args: vec!["--acp".into()],
env: BTreeMap::from([("REGISTRY_SETTING".into(), "kept".into())]),
registry: Some(RegistryRef { id: "copilot".into(), version: "1.0.0".into() }),
}
.write(&file)
.unwrap();
set_builtin_env(
dir.path(),
None,
"copilot",
BTreeMap::from([
("REGISTRY_SETTING".into(), "kept".into()),
(COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()),
]),
)
.unwrap();
let spec = load(Some(dir.path()), None).into_iter().find(|spec| spec.id == "copilot").unwrap();
assert_eq!(copilot_github_account(&spec.env).as_deref(), Some("dengliu_microsoft"));
set_builtin_env(dir.path(), None, "copilot", BTreeMap::from([("REGISTRY_SETTING".into(), "changed".into())]))
.unwrap_err();
}
#[test]
fn launch_metadata_never_passes_the_github_account_control_to_copilot() {
let mut spec = builtin_spec("copilot").unwrap();
spec.env.push((COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()));
let resolved = spec.resolve_for_launch(Path::new("."));
assert!(resolved.env.iter().all(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV));
}
#[test]
fn acp_adapters_of_native_agents_are_unlisted_until_customized() {
let dir = tempfile::tempdir().unwrap();
-8
Переглянути файл
@@ -537,14 +537,6 @@ fn install_entry_with(
return Err(e);
}
};
let github_account = (entry.id == "copilot")
.then(|| CustomAgent::read(&file).ok())
.flatten()
.and_then(|agent| agent.env.get(provider::COPILOT_GITHUB_ACCOUNT_ENV).cloned());
let mut env = env;
if let Some(account) = github_account {
env.insert(provider::COPILOT_GITHUB_ACCOUNT_ENV.into(), account);
}
let agent = CustomAgent {
name: Some(entry.name.clone()),
driver: Driver::Acp,
+6 -635
Переглянути файл
@@ -1,17 +1,10 @@
//! Slash commands and skills on disk. Claude Code's own discovery (`.claude/skills` and
//! `.claude/commands` of the working directory tree and `~/.claude`, and a Hermes profile's
//! `skills`) for completion before (or without) a session, plus the multi-level skills hub
//! of #3897: every CLI's skill folders discovered once, deduplicated by canonical path,
//! resolved against the `[agents.skills.<name>]` policies of the global and workspace
//! settings, and staged into a per-session folder the CLIs each receive their own way.
//! Claude Code's slash commands on disk, for completion before (or without) a session:
//! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
//! of the working directory and every directory above it, then the user's `~/.claude`.
use crate::{
AgentCommand, AgentCommandSource, AgentSkill, AgentSkillMode, AgentSkillOrigin, AgentSkillPolicy, AgentSkillSource,
AgentSkillState,
};
use ide_core::output_encoding::strip_ansi;
use std::collections::{BTreeMap, HashSet};
use std::path::{Path, PathBuf};
use crate::{AgentCommand, AgentCommandSource};
use std::collections::HashSet;
use std::path::Path;
const MAX_DESCRIPTION: usize = 200;
/// Command directories nest this deep at most (`a/b/c.md` → `a:b:c`).
@@ -41,19 +34,6 @@ pub(crate) fn discover(cwd: &Path, home: Option<&Path>) -> Vec<AgentCommand> {
out
}
/// The skills of a Hermes profile: `<profile>/skills/<skill>` and `<profile>/skills/<category>/<skill>`;
/// the first of a name wins.
pub(crate) fn hermes(profile: &Path) -> Vec<AgentCommand> {
let root = profile.join("skills");
let mut found = skills(&root);
for category in sorted(&root).into_iter().filter(|p| !p.join("SKILL.md").exists()) {
found.extend(skills(&category));
}
let mut seen = HashSet::new();
found.retain(|c| seen.insert(c.name.clone()));
found
}
/// `first` (the agent's own list) plus the commands of `more` it lacks.
pub(crate) fn merge(first: Vec<AgentCommand>, more: Vec<AgentCommand>) -> Vec<AgentCommand> {
let mut out = first;
@@ -206,370 +186,6 @@ fn truncate(s: &str) -> String {
}
}
// ─── The skills hub (#3897): discovery, policy, delivery ────────────────────────────
/// A skill's `name` must be this and lowercase letters, digits and hyphens only.
fn valid_name(name: &str) -> bool {
(1..=64).contains(&name.len()) && name.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
}
/// A `SKILL.md`'s description is at most this many characters.
const MAX_SKILL_DESCRIPTION: usize = 1024;
/// The workspace folders skills are discovered in, by the source they report.
const WORKSPACE_ROOTS: &[(&str, AgentSkillSource)] = &[
(".agents/skills", AgentSkillSource::Workspace),
(".openidea/skills", AgentSkillSource::Workspace),
(".claude/skills", AgentSkillSource::ClaudeWorkspace),
(".github/skills", AgentSkillSource::GithubWorkspace),
(".codex/skills", AgentSkillSource::CodexWorkspace),
(".cursor/skills", AgentSkillSource::CursorWorkspace),
];
/// The home folders skills are discovered in, by the source they report.
const HOME_ROOTS: &[(&str, AgentSkillSource)] = &[
(".agents/skills", AgentSkillSource::User),
(".claude/skills", AgentSkillSource::ClaudeUser),
(".copilot/skills", AgentSkillSource::CopilotUser),
(".codex/skills", AgentSkillSource::CodexUser),
(".cursor/skills", AgentSkillSource::CursorUser),
];
/// Every skill found under `workspace` (a project, scanned even for a worktree task, whose
/// checkout lacks untracked skills) and `home`, in source precedence order, symlinked
/// duplicates collapsed by canonical path: the first of a path wins, and so does the first
/// of a name (the higher source), so a session never sees one skill twice.
pub fn discover_skills(workspace: &Path, home: Option<&Path>) -> Vec<AgentSkill> {
let mut out: Vec<AgentSkill> = Vec::new();
let mut seen_paths: HashSet<PathBuf> = HashSet::new();
let mut seen_names: HashSet<String> = HashSet::new();
let mut roots: Vec<(PathBuf, AgentSkillSource)> = Vec::new();
roots.extend(WORKSPACE_ROOTS.iter().map(|(rel, source)| (workspace.join(rel), *source)));
let mut plugin_roots = Vec::new();
if let Some(home) = home {
roots.extend(HOME_ROOTS.iter().map(|(rel, source)| (home.join(rel), *source)));
// `copilot install` unpacks plugins under `installed-plugins/<plugin>/`, whose skills
// sit in a `skills` folder (or directly in the plugin folder).
let plugins = home.join(".copilot/installed-plugins");
if let Ok(plugins) = plugins.read_dir() {
for plugin in plugins.flatten() {
if plugin.path().is_dir() {
plugin_roots.push((plugin.path().join("skills"), AgentSkillSource::CopilotUser));
plugin_roots.push((plugin.path(), AgentSkillSource::CopilotUser));
}
}
}
}
roots.extend(plugin_roots);
for (root, source) in roots {
for skill in skills_of(&root, source) {
let path = dunce::canonicalize(&skill.path.0).unwrap_or_else(|_| skill.path.0.clone());
if !seen_paths.insert(path.clone()) || !seen_names.insert(skill.name.clone()) {
continue;
}
out.push(AgentSkill { path: path.into(), ..skill });
}
}
out
}
/// The skills of one root: `<name>/SKILL.md` folders, validated.
fn skills_of(root: &Path, source: AgentSkillSource) -> Vec<AgentSkill> {
let mut out: Vec<AgentSkill> = Vec::new();
let Ok(entries) = std::fs::read_dir(root) else { return out };
for entry in entries.flatten() {
let dir = entry.path();
let Some(folder) = dir.file_name().and_then(|n| n.to_str()).map(str::to_owned) else { continue };
if !dir.is_dir() || folder.starts_with('.') {
continue;
}
let Ok(text) = std::fs::read_to_string(dir.join("SKILL.md")) else { continue };
let meta = Frontmatter::parse(&text);
let name = meta.get("name").filter(|n| !n.is_empty()).map(str::to_owned).unwrap_or_else(|| folder.clone());
let mut warnings = Vec::new();
if !valid_name(&name) {
warnings.push(format!("`name: {name}` is not 1-64 lowercase letters, digits or hyphens"));
}
if name != folder {
warnings.push(format!("`name: {name}` does not match the folder `{folder}`"));
}
let description = meta.get("description").unwrap_or_default();
let description = strip_ansi(description).trim().to_owned();
if description.is_empty() {
warnings.push("no `description`: the model never sees when to use it".into());
} else if description.chars().count() > MAX_SKILL_DESCRIPTION {
warnings.push(format!("`description` is over {MAX_SKILL_DESCRIPTION} characters"));
}
out.push(AgentSkill {
name,
description: truncate(&description),
path: dir.into(),
source,
valid: warnings.is_empty(),
warnings,
});
}
out.sort_by(|a, b| a.name.cmp(&b.name));
out
}
/// A skill's mode, as one policy layer of the settings has it.
type Policies = BTreeMap<String, AgentSkillPolicy>;
/// Resolves every skill's mode: a session override, then the workspace's and the user's
/// `[agents.skills.<name>]` policy, then the default `auto` — with an untrusted workspace
/// able to turn skills off only: its own skills stay off (whatever the session chose), and
/// its policies hold only when they turn a skill off.
pub fn resolve(
skills: Vec<AgentSkill>,
session: Option<&BTreeMap<String, AgentSkillMode>>,
workspace: &Policies,
user: &Policies,
workspace_trusted: bool,
) -> Vec<AgentSkillState> {
let mut out = Vec::new();
for skill in skills {
let workspace_skill = matches!(
skill.source,
AgentSkillSource::Workspace
| AgentSkillSource::ClaudeWorkspace
| AgentSkillSource::GithubWorkspace
| AgentSkillSource::CodexWorkspace
| AgentSkillSource::CursorWorkspace
);
let (mode, origin) = if workspace_skill && !workspace_trusted {
// Workspace trust gates the workspace's own skills, whatever else says.
(AgentSkillMode::Off, AgentSkillOrigin::Trust)
} else if let Some(chosen) = session.and_then(|s| s.get(&skill.name)) {
(*chosen, AgentSkillOrigin::Session)
} else if let Some(policy) =
workspace.get(&skill.name).filter(|p| workspace_trusted || p.mode == AgentSkillMode::Off)
{
(policy.mode, AgentSkillOrigin::Workspace)
} else if let Some(policy) = user.get(&skill.name) {
(policy.mode, AgentSkillOrigin::User)
} else {
(AgentSkillMode::Auto, AgentSkillOrigin::None)
};
out.push(AgentSkillState { skill, mode, origin });
}
out
}
/// What one CLI session receives for its active skills. Sent to the shims in
/// `session/new`'s `_meta.openidea.skills`, so each driver applies its own fields.
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct Delivery {
/// Claude Code: the farm passed as `--add-dir` (its `.claude/skills` holds the staged copies).
#[serde(skip_serializing_if = "Option::is_none")]
pub claude_add_dir: Option<PathBuf>,
/// Claude Code: the `--settings` JSON with `skillOverrides` (the native skills too).
#[serde(skip_serializing_if = "Option::is_none")]
pub claude_settings: Option<String>,
/// Copilot: `skillDirectories` (the farm's `copilot` tree).
#[serde(skip_serializing_if = "Vec::is_empty")]
pub copilot_skill_directories: Vec<String>,
/// Copilot: `disabledSkills`, spelled as the skills are.
#[serde(skip_serializing_if = "Vec::is_empty")]
pub copilot_disabled_skills: Vec<String>,
/// Codex: `skills/extraRoots/set` roots (the farm's `codex` tree).
#[serde(skip_serializing_if = "Vec::is_empty")]
pub codex_extra_roots: Vec<String>,
/// Codex: `skills.config` entries turning skills off by path.
#[serde(skip_serializing_if = "Vec::is_empty")]
pub codex_off: Vec<(String, String)>,
}
/// Stages the skills a session of `provider` runs with into `farm` — linking (copying on
/// Windows, where directory symlinks need Developer Mode) every active skill folder into
/// the CLI's tree — and reports what to hand the CLI. Skills the CLI discovers natively
/// (its own folders of the working directory and the home) are not staged again: it already
/// sees them, and seeing both would list one skill twice. Skills `off` are never staged;
/// the CLI's native disable (where it has one) receives their names or paths. An ACP
/// agent gets nothing here: its `/` menu is filtered instead.
pub fn stage(
farm: &Path,
provider: &str,
states: &[AgentSkillState],
cwd: &Path,
home: Option<&Path>,
) -> std::io::Result<Delivery> {
let mut out = Delivery::default();
let cwd = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf());
// Only the native drivers take the farm, each its own tree; `provider` is their key
// (`claude`, `copilot`, `codex`), anything else (an ACP agent) gets the `/` menu filter.
let (claude_tree, copilot_tree, codex_tree) = match provider {
"claude" => (Some(farm.join(".claude/skills")), None, None),
"copilot" => (None, Some(farm.join("copilot")), None),
"codex" => (None, None, Some(farm.join("codex"))),
_ => return Ok(out),
};
// Restage from scratch: a skill turned off or deleted since the last session must not
// linger in the tree. Removing a tree removes its links, never the skills they point at.
for tree in [&claude_tree, &copilot_tree, &codex_tree].into_iter().flatten() {
match std::fs::remove_dir_all(tree) {
Err(e) if e.kind() != std::io::ErrorKind::NotFound => return Err(e),
_ => {}
}
}
for state in states {
let name = state.skill.name.as_str();
let path = state.skill.path.0.as_path();
match state.mode {
AgentSkillMode::Off => {
out.codex_off.push((name.to_owned(), state.skill.path.to_string_lossy().into_owned()));
}
// Claude Code runs a slash-only skill on `/name`, so it has to see the folder;
// Copilot and Codex have no such mode and get it disabled or left out.
AgentSkillMode::SlashOnly => {
if let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home)) {
link_skill(&tree.join(name), path)?;
}
}
AgentSkillMode::Auto => {
if let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home)) {
link_skill(&tree.join(name), path)?;
}
if let Some(tree) = copilot_tree.as_ref().filter(|_| !native_copilot(&state.skill, &cwd, home)) {
link_skill(&tree.join(name), path)?;
}
if let Some(tree) = codex_tree.as_ref().filter(|_| !native_codex(&state.skill, &cwd, home)) {
link_skill(&tree.join(name), path)?;
}
}
}
}
if claude_tree.as_ref().is_some_and(|t| t.exists()) {
out.claude_add_dir = Some(farm.to_path_buf());
}
if let Some(tree) = copilot_tree.as_ref().filter(|t| t.exists()) {
out.copilot_skill_directories.push(tree.to_string_lossy().into_owned());
}
if let Some(tree) = codex_tree.as_ref().filter(|t| t.exists()) {
out.codex_extra_roots.push(tree.to_string_lossy().into_owned());
}
// Claude Code's `skillOverrides` and Copilot's `disabledSkills` take the names of the
// off and slash-only skills — the native copies included.
let off: Vec<&str> =
states.iter().filter(|s| s.mode == AgentSkillMode::Off).map(|s| s.skill.name.as_str()).collect();
let slash: Vec<&str> =
states.iter().filter(|s| s.mode == AgentSkillMode::SlashOnly).map(|s| s.skill.name.as_str()).collect();
if !off.is_empty() || !slash.is_empty() {
let mut overrides = serde_json::Map::new();
for (name, mode) in off.iter().map(|n| (*n, "off")).chain(slash.iter().map(|n| (*n, "user-invocable-only"))) {
overrides.insert(name.to_owned(), serde_json::Value::String(mode.to_owned()));
}
out.claude_settings = Some(
serde_json::to_string(&serde_json::json!({ "skillOverrides": overrides })).expect("settings serialize"),
);
out.copilot_disabled_skills = off.iter().chain(slash.iter()).map(|n| (*n).to_owned()).collect();
out.copilot_disabled_skills.sort();
}
Ok(out)
}
/// Claude Code sees this skill without the farm: its own `.claude/skills` of the working
/// directory (a worktree lacks the untracked originals) or the home.
fn native_claude(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
match skill.source {
AgentSkillSource::ClaudeWorkspace => is_under(skill.path.0.as_path(), cwd),
AgentSkillSource::ClaudeUser => home.is_some_and(|h| is_under(skill.path.0.as_path(), &h.join(".claude"))),
_ => false,
}
}
/// Copilot reads the repository's `.github/skills` and the home's `.copilot` itself.
fn native_copilot(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
match skill.source {
AgentSkillSource::GithubWorkspace => is_under(skill.path.0.as_path(), cwd),
AgentSkillSource::CopilotUser => home.is_some_and(|h| is_under(skill.path.0.as_path(), &h.join(".copilot"))),
_ => false,
}
}
/// Codex reads its own folders itself.
fn native_codex(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
match skill.source {
AgentSkillSource::CodexWorkspace => is_under(skill.path.0.as_path(), cwd),
AgentSkillSource::CodexUser => home.is_some_and(|h| is_under(skill.path.0.as_path(), &h.join(".codex"))),
_ => false,
}
}
fn is_under(path: &Path, root: &Path) -> bool {
path.starts_with(root)
}
/// Puts `name` into the farm tree: a directory symlink where they work, a copy otherwise
/// (Windows needs Developer Mode for directory symlinks).
fn link_skill(link: &Path, target: &Path) -> std::io::Result<()> {
let _ = std::fs::remove_file(link);
if let Some(parent) = link.parent() {
std::fs::create_dir_all(parent)?;
}
#[cfg(unix)]
{
std::os::unix::fs::symlink(target, link)
}
#[cfg(windows)]
{
copy_dir_all(target, link)
}
}
#[cfg(windows)]
fn copy_dir_all(from: &Path, to: &Path) -> std::io::Result<()> {
std::fs::create_dir_all(to)?;
for entry in std::fs::read_dir(from)?.flatten() {
let path = entry.path();
let dest = to.join(entry.file_name());
if path.is_dir() {
copy_dir_all(&path, &dest)?;
} else {
std::fs::copy(&path, &dest)?;
}
}
Ok(())
}
/// Removes a task's farm (task deleted or archived); missing is fine.
pub fn remove_farm(store_dir: &Path, task: &str) {
let farm = farm_dir(store_dir, task);
match std::fs::remove_dir_all(&farm) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => tracing::warn!("removing the session skills folder {}: {e}", farm.display()),
}
}
/// Where a task's staged skills live.
pub fn farm_dir(store_dir: &Path, task: &str) -> PathBuf {
store_dir.join("session-skills").join(sanitized(task))
}
/// A task id is a uuid, but never trust it with a path segment.
fn sanitized(id: &str) -> String {
id.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '-').collect()
}
/// The `/` menu's skills: the active ones as commands (the agent's own listing wins on a
/// name clash). `Off` ones drop out everywhere; an ACP agent gets no other enforcement, so
/// `slashOnly` ones stay listed — there is nothing to hold them back with.
pub fn menu_commands(offered: Vec<AgentCommand>, states: &[AgentSkillState]) -> Vec<AgentCommand> {
let extra = states
.iter()
.filter(|s| s.mode != AgentSkillMode::Off)
.map(|s| AgentCommand {
name: s.skill.name.clone(),
description: s.skill.description.clone(),
hint: None,
source: AgentCommandSource::Skill,
})
.collect();
merge(offered, extra)
}
#[cfg(test)]
mod tests {
use super::*;
@@ -640,24 +256,6 @@ mod tests {
);
}
#[test]
fn hermes_skills_flat_and_in_categories() {
let tmp = tempfile::tempdir().unwrap();
let profile = tmp.path();
assert!(hermes(profile).is_empty());
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan", "skills/empty"] {
std::fs::create_dir_all(profile.join(dir)).unwrap();
}
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan"] {
std::fs::write(profile.join(dir).join("SKILL.md"), "---\ndescription: d\n---\n").unwrap();
}
let names: Vec<_> = hermes(profile).into_iter().map(|c| (c.name, c.source)).collect();
assert_eq!(
names,
[("plan".to_owned(), AgentCommandSource::Skill), ("review".to_owned(), AgentCommandSource::Skill)]
);
}
#[test]
fn nothing_without_claude_dirs() {
let tmp = tempfile::tempdir().unwrap();
@@ -703,231 +301,4 @@ mod tests {
assert_eq!(f.get("name"), Some("quoted"));
assert_eq!(truncate(&"é".repeat(MAX_DESCRIPTION + 5)).chars().count(), MAX_DESCRIPTION + 1);
}
fn skill(name: &str, source: AgentSkillSource, root: &Path) -> AgentSkill {
AgentSkill {
name: name.into(),
description: format!("{name} does things"),
path: root.join(name).into(),
source,
valid: true,
warnings: Vec::new(),
}
}
fn policy(mode: AgentSkillMode) -> Option<AgentSkillPolicy> {
Some(AgentSkillPolicy { mode })
}
#[test]
fn hub_discovery_scans_every_root_and_collapses_symlinks() {
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("home");
let repo = tmp.path().join("work/app");
std::fs::create_dir_all(&repo).unwrap();
write(&repo.join(".agents/skills/dep/SKILL.md"), "---\nname: dep\ndescription: From the standard root\n---\n");
write(&repo.join(".openidea/skills/local/SKILL.md"), "---\nname: local\ndescription: OpenIDEA's own\n---\n");
write(&repo.join(".claude/skills/claudey/SKILL.md"), "---\nname: claudey\ndescription: Claude's\n---\n");
write(&repo.join(".github/skills/gh/SKILL.md"), "---\nname: gh\ndescription: Copilot's repo one\n---\n");
write(
&home.join(".agents/skills/shared/SKILL.md"),
"---\nname: shared\ndescription: From npx skills add\n---\n",
);
write(&home.join(".codex/skills/codexy/SKILL.md"), "---\nname: codexy\ndescription: Codex's\n---\n");
write(&home.join(".cursor/skills/cursory/SKILL.md"), "---\nname: cursory\ndescription: Cursor's\n---\n");
// A symlink to `dep` in the home (the same canonical folder): collapsed.
#[cfg(unix)]
{
std::fs::create_dir_all(home.join(".claude/skills")).unwrap();
std::os::unix::fs::symlink(repo.join(".agents/skills/dep"), home.join(".claude/skills/dep")).unwrap();
}
// Hidden folders and files are not skills.
write(&repo.join(".agents/skills/.stash/SKILL.md"), "---\nname: hidden\ndescription: x\n---\n");
write(&repo.join(".agents/skills/loose.txt"), "not a folder");
// Same name from a lower-precedence source: the workspace one wins.
write(&home.join(".cursor/skills/local/SKILL.md"), "---\nname: local\ndescription: from cursor\n---\n");
let found = discover_skills(&repo, Some(&home));
assert_eq!(
found.iter().map(|s| (s.name.as_str(), s.source)).collect::<Vec<_>>(),
[
("dep", AgentSkillSource::Workspace),
("local", AgentSkillSource::Workspace),
("claudey", AgentSkillSource::ClaudeWorkspace),
("gh", AgentSkillSource::GithubWorkspace),
("shared", AgentSkillSource::User),
("codexy", AgentSkillSource::CodexUser),
("cursory", AgentSkillSource::CursorUser),
],
"symlinks collapse and the first of a name wins"
);
assert!(found.iter().all(|s| s.valid), "{:?}", found.iter().flat_map(|s| &s.warnings).collect::<Vec<_>>());
}
#[test]
fn hub_discovery_validates_and_reports() {
let tmp = tempfile::tempdir().unwrap();
let repo = tmp.path().join("app");
std::fs::create_dir_all(&repo).unwrap();
write(&repo.join(".agents/skills/bad-name/SKILL.md"), "---\nname: Bad_Name\ndescription: x\n---\n");
write(&repo.join(".agents/skills/no-desc/SKILL.md"), "---\nname: no-desc\n---\n");
write(
&repo.join(".agents/skills/verbose/SKILL.md"),
&format!("---\nname: verbose\ndescription: {}\n---\n", "x".repeat(MAX_SKILL_DESCRIPTION + 1)),
);
let found = discover_skills(&repo, None);
let by = |n: &str| found.iter().find(|s| s.name == n).unwrap();
assert!(!by("Bad_Name").valid && !by("Bad_Name").warnings.is_empty());
assert!(!by("no-desc").valid && by("no-desc").warnings.len() == 1);
assert!(!by("verbose").valid);
}
#[test]
fn hub_resolution_precedence_and_trust() {
let root = PathBuf::from("/r");
let ws = skill("tdd", AgentSkillSource::Workspace, &root);
let user = skill("lint", AgentSkillSource::User, &root);
let claude = skill("claudey", AgentSkillSource::ClaudeWorkspace, &root);
let session = BTreeMap::from([("tdd".to_owned(), AgentSkillMode::Off)]);
let workspace = BTreeMap::from([
("tdd".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap()),
("lint".to_owned(), policy(AgentSkillMode::Off).unwrap()),
]);
let user_policies = BTreeMap::from([
("lint".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap()),
("claudey".to_owned(), policy(AgentSkillMode::Auto).unwrap()),
]);
// Session > workspace policy > user policy.
let resolved = resolve(vec![ws.clone(), user.clone()], Some(&session), &workspace, &user_policies, true);
assert_eq!((resolved[0].mode, resolved[0].origin), (AgentSkillMode::Off, AgentSkillOrigin::Session));
assert_eq!((resolved[1].mode, resolved[1].origin), (AgentSkillMode::Off, AgentSkillOrigin::Workspace));
// Without a workspace policy the user's applies.
let resolved = resolve(vec![user.clone()], None, &BTreeMap::new(), &user_policies, true);
assert_eq!((resolved[0].mode, resolved[0].origin), (AgentSkillMode::SlashOnly, AgentSkillOrigin::User));
// Untrusted: the workspace's own skills stay off whatever the session chose, its
// policies hold only when they turn a skill off, and user skills keep resolving.
let resolved = resolve(vec![ws, user, claude], Some(&session), &workspace, &user_policies, false);
assert_eq!((resolved[0].mode, resolved[0].origin), (AgentSkillMode::Off, AgentSkillOrigin::Trust));
assert_eq!((resolved[1].mode, resolved[1].origin), (AgentSkillMode::Off, AgentSkillOrigin::Workspace));
assert_eq!((resolved[2].mode, resolved[2].origin), (AgentSkillMode::Off, AgentSkillOrigin::Trust));
}
fn listed(dir: &Path) -> Vec<String> {
let mut names: Vec<String> =
std::fs::read_dir(dir).unwrap().flatten().map(|e| e.file_name().to_string_lossy().into_owned()).collect();
names.sort();
names
}
#[test]
fn hub_staging_hands_each_cli_its_own_tree() {
let tmp = tempfile::tempdir().unwrap();
// Discovery reports canonical paths (macOS's temp folder is a symlink).
let root = dunce::canonicalize(tmp.path()).unwrap();
let home = root.join("home");
let repo = root.join("app");
std::fs::create_dir_all(&repo).unwrap();
// The staged folders must exist: Windows copies them (symlinks need Developer Mode).
for path in [
repo.join(".agents/skills/tdd"),
repo.join(".agents/skills/off"),
repo.join(".github/skills/gh"),
home.join(".agents/skills/lint"),
home.join(".agents/skills/muted"),
home.join(".codex/skills/codexy"),
] {
std::fs::create_dir_all(path).unwrap();
}
let states = resolve(
vec![
skill("tdd", AgentSkillSource::Workspace, &repo.join(".agents/skills")),
skill("gh", AgentSkillSource::GithubWorkspace, &repo.join(".github/skills")),
skill("lint", AgentSkillSource::User, &home.join(".agents/skills")),
skill("codexy", AgentSkillSource::CodexUser, &home.join(".codex/skills")),
skill("muted", AgentSkillSource::User, &home.join(".agents/skills")),
skill("off", AgentSkillSource::Workspace, &repo.join(".agents/skills")),
],
None,
&BTreeMap::from([("muted".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap())]),
&BTreeMap::from([("off".to_owned(), policy(AgentSkillMode::Off).unwrap())]),
true,
);
// Local (non-worktree) session: the project's GitHub skills are Copilot's own.
let farm = farm_dir(&root.join("store"), "task-1");
let delivery = stage(&farm, "claude", &states, &repo, Some(&home)).unwrap();
assert_eq!(delivery.claude_add_dir.as_deref(), Some(farm.as_path()));
let claude_tree = farm.join(".claude/skills");
let staged = listed(&claude_tree);
assert_eq!(
staged,
["codexy", "gh", "lint", "muted", "tdd"],
"everything but the off one: none is native to Claude here, and slash-only needs the folder"
);
let delivery = stage(&farm, "copilot", &states, &repo, Some(&home)).unwrap();
assert_eq!(delivery.copilot_skill_directories, [farm.join("copilot").to_string_lossy().into_owned()]);
assert_eq!(delivery.copilot_disabled_skills, ["muted", "off"]);
let copilot_staged = listed(&farm.join("copilot"));
assert_eq!(copilot_staged, ["codexy", "lint", "tdd"], "`gh` is native to a local Copilot session");
assert_eq!(
delivery.codex_off,
[("off".to_owned(), repo.join(".agents/skills").join("off").to_string_lossy().into_owned())]
);
// A worktree task: the repo's skills are untracked, so nothing is native any more.
let worktree = root.join("wt");
std::fs::create_dir_all(&worktree).unwrap();
let _ = stage(&farm, "copilot", &states, &worktree, Some(&home)).unwrap();
let copilot_staged = listed(&farm.join("copilot"));
assert!(copilot_staged.contains(&"gh".to_string()));
// Slash-only reaches Claude as `user-invocable-only`, off as `off`.
let delivery = stage(&farm, "claude", &states, &repo, Some(&home)).unwrap();
let settings: serde_json::Value = serde_json::from_str(delivery.claude_settings.as_deref().unwrap()).unwrap();
assert_eq!(settings["skillOverrides"]["muted"], "user-invocable-only");
assert_eq!(settings["skillOverrides"]["off"], "off");
// Restaging after a session turned `lint` off drops its link and leaves the skill.
let session = BTreeMap::from([("lint".to_owned(), AgentSkillMode::Off)]);
let restated = resolve(
states.iter().map(|s| s.skill.clone()).collect(),
Some(&session),
&BTreeMap::from([("muted".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap())]),
&BTreeMap::from([("off".to_owned(), policy(AgentSkillMode::Off).unwrap())]),
true,
);
stage(&farm, "claude", &restated, &repo, Some(&home)).unwrap();
assert_eq!(listed(&claude_tree), ["codexy", "gh", "muted", "tdd"]);
assert!(home.join(".agents/skills/lint").is_dir());
assert!(farm.join("copilot").is_dir(), "restaging Claude's tree leaves Copilot's alone");
// An ACP agent gets no farm.
let delivery = stage(&farm, "cursor-acp", &states, &repo, Some(&home)).unwrap();
assert_eq!(delivery, Delivery::default());
// The farm goes away with the task.
remove_farm(&root.join("store"), "task-1");
assert!(!farm.exists());
}
#[test]
fn hub_menu_filters_off_and_keeps_the_agents_own() {
let root = PathBuf::from("/r");
let states = resolve(
vec![skill("tdd", AgentSkillSource::Workspace, &root), skill("lint", AgentSkillSource::User, &root)],
Some(&BTreeMap::from([("lint".to_owned(), AgentSkillMode::Off)])),
&BTreeMap::new(),
&BTreeMap::new(),
true,
);
let menu = menu_commands(vec![cmd("tdd", "from the agent itself")], &states);
assert_eq!(names(&menu), ["tdd"]);
assert_eq!(menu[0].description, "from the agent itself");
assert_eq!(menu[0].source, AgentCommandSource::Skill);
}
}
+5 -136
Переглянути файл
@@ -452,35 +452,6 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {
manager_at(dir, &dir.join("models.json"), agent)
}
#[tokio::test]
async fn subscribers_do_not_replace_or_close_each_other() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let main = Arc::new(Mutex::new(Vec::new()));
let child = Arc::new(Mutex::new(Vec::new()));
let subscribe = |window: &str, events: &Arc<Mutex<Vec<AgentEvent>>>| {
let events = events.clone();
mgr.subscribe_as(window, Arc::new(move |event| events.lock().push(event)));
};
subscribe("main", &main);
subscribe("editor-main-1", &child);
mgr.shared.emit(AgentEvent::Providers);
assert_eq!(main.lock().len(), 1);
assert_eq!(child.lock().len(), 1);
// A reloaded webview replaces only its own old channel.
let reloaded = Arc::new(Mutex::new(Vec::new()));
subscribe("editor-main-1", &reloaded);
mgr.shared.emit(AgentEvent::Providers);
assert_eq!(main.lock().len(), 2);
assert_eq!(child.lock().len(), 1);
assert_eq!(reloaded.lock().len(), 1);
mgr.unsubscribe("editor-main-1");
mgr.shared.emit(AgentEvent::Providers);
assert_eq!(main.lock().len(), 3);
assert_eq!(reloaded.lock().len(), 1);
mgr.shutdown();
}
fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {
// These tests speak to FakeAgent, never an installed CLI, including after a provider reload.
let agents = dir.join("agents");
@@ -938,27 +909,6 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
mgr3.shutdown();
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread")]
async fn hermes_profiles_complete_their_own_skills() {
let tmp = tempfile::tempdir().unwrap();
let skill = |dir: &str, name: &str| {
let dir = tmp.path().join(dir).join(name);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("SKILL.md"), format!("---\nname: {name}\ndescription: d\n---\n")).unwrap();
};
skill(".hermes/skills", "plan");
skill(".hermes/profiles/dom/skills/home", "lights");
std::fs::write(tmp.path().join(".hermes/profiles/dom/config.yaml"), "").unwrap();
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), Arc::new(FakeAgent::default()));
let names = |c: Vec<AgentCommand>| c.into_iter().map(|c| c.name).collect::<Vec<_>>();
assert!(names(mgr.commands("hermes", None).await.unwrap()).contains(&"plan".to_owned()));
let dom = names(mgr.commands("hermes-dom", None).await.unwrap());
assert!(dom.contains(&"lights".to_owned()) && !dom.contains(&"plan".to_owned()));
assert!(!names(mgr.commands("claude", None).await.unwrap()).contains(&"plan".to_owned()));
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
let tmp = tempfile::tempdir().unwrap();
@@ -1927,32 +1877,6 @@ async fn real_claude_task_in_a_worktree() {
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn hermes_session_info_names_the_task_and_counts_compressions() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let task = mgr
// "again" ends the turn at once; the default prompt waits for a permission answer.
.create(NewAgentTask { prompt: text("again"), provider: "claude".into(), ..Default::default() })
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let handle = mgr.task(&task.id).unwrap();
let info = |title: &str, depth: u32| {
json!({"sessionUpdate": "session_info_update", "title": title, "updatedAt": "2026-11-18T18:35:32.068362+00:00",
"_meta": {"hermes": {"sessionProvenance": {"sessionKind": "root", "parentHermesSessionId": null,
"compressionDepth": depth}}}})
};
handle.on_update(None, &info("Make a 3-step plan and carry it out: 1) list the…", 0));
handle.on_update(None, &info("List files and edit notes.txt", 0));
let t = handle.state.lock().task.clone();
assert_eq!(t.title, "List files and edit notes.txt", "the agent's latest title wins");
assert_eq!(t.stats.compressions, 0);
handle.on_update(None, &info("List files and edit notes.txt", 2));
assert_eq!(handle.state.lock().task.stats.compressions, 2);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn renamed_titles_survive_updates_forks_and_restart() {
let tmp = tempfile::tempdir().unwrap();
@@ -2011,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::new(&handle, None);
let client = Client { task: Arc::downgrade(&handle) };
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!({}));
@@ -2362,56 +2286,6 @@ async fn idle_model_switches_discover_controls_and_no_control_models_without_ano
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn session_without_a_model_option_can_select_from_a_recovered_catalog() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.model_options.lock() = HashMap::from([
("big".into(), effort_options(&["low", "high"], "high")),
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
]);
let mgr = manager(tmp.path(), agent);
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let spec = mgr.shared.spec("claude-acp").unwrap();
let (_, flight) = mgr.shared.paths.catalogs.request(&mgr.shared, spec, true, None);
if let Some(mut ready) = flight {
tokio::time::timeout(Duration::from_secs(5), async {
while !*ready.borrow_and_update() {
ready.changed().await.unwrap();
}
})
.await
.unwrap();
}
{
let task = mgr.task(&task.id).unwrap();
let mut state = task.state.lock();
state.task.config.retain(|option| option.category.as_deref() != Some("model"));
state.task.model = Some("stale-model".into());
}
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
let task = mgr.task(&task.id).unwrap();
{
let state = task.state.lock();
assert_eq!(state.task.model.as_deref(), Some("small"));
let model = state.task.config.iter().find(|option| option.category.as_deref() == Some("model")).unwrap();
assert_eq!(model.current.as_deref(), Some("small"));
assert!(model.values.iter().any(|value| value.value == "small"));
}
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
let tmp = tempfile::tempdir().unwrap();
@@ -3657,13 +3531,11 @@ fn streamed_text_is_sent_as_appends() {
);
let replaced = entry_event("t", &mut streamed, None, 3, &agent("Other"));
assert!(matches!(replaced, AgentEvent::Entry { .. }), "text that doesn't extend the sent text is sent whole");
let thought = AgentEntry::Thought { text: "hmm…".into(), started_ms: None };
let thought = entry_event("t", &mut streamed, None, 4, &thought);
let thought = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm…".into() });
assert!(matches!(thought, AgentEvent::Entry { index: 4, .. }), "a new message starts whole");
let tool = AgentEntry::Error { message: "x".into() };
entry_event("t", &mut streamed, None, 4, &tool);
let again = AgentEntry::Thought { text: "hmm… ok".into(), started_ms: None };
let again = entry_event("t", &mut streamed, None, 4, &again);
let again = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm… ok".into() });
assert!(matches!(again, AgentEvent::Entry { .. }), "an entry replaced by another kind forgets its text");
let long = "é".repeat(5000);
@@ -4532,7 +4404,6 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
base: None,
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
idle: false,
skill_overrides: BTreeMap::new(),
})
.await
.unwrap();
@@ -4661,7 +4532,6 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
skill_overrides: BTreeMap::new(),
})
.await
.unwrap();
@@ -4687,7 +4557,6 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
skill_overrides: BTreeMap::new(),
})
.await
.unwrap();
@@ -4766,10 +4635,10 @@ done
#[test]
fn session_params_name_the_servers_off() {
let mcp = McpForSession { servers: vec![json!({ "name": "docs" })], off: vec!["github".into()] };
let params = session_params("/p", &mcp, None);
let params = session_params("/p", &mcp);
assert_eq!(params["cwd"], "/p");
assert_eq!(params["mcpServers"][0]["name"], "docs");
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
assert!(session_params("/p", &none, None).get("_meta").is_none());
assert!(session_params("/p", &none).get("_meta").is_none());
}
+4 -41
Переглянути файл
@@ -85,8 +85,6 @@ impl Timeline {
locations: locations(update.get("locations")),
output: None,
diffs: Vec::new(),
started_ms: Some(crate::now_ms()),
ended_ms: None,
};
let index = match self.tools.get(&id) {
Some(&i) => {
@@ -136,22 +134,17 @@ impl Timeline {
fn append_text(&mut self, thought: bool, text: &str) -> usize {
match self.entries.last_mut() {
Some(AgentEntry::Agent { text: t }) if !thought => t.push_str(text),
Some(AgentEntry::Thought { text: t, .. }) if thought => t.push_str(text),
Some(AgentEntry::Thought { text: t }) if thought => t.push_str(text),
_ => {
let text = text.to_owned();
return self.push(if thought {
AgentEntry::Thought { text, started_ms: Some(crate::now_ms()) }
} else {
AgentEntry::Agent { text }
});
return self.push(if thought { AgentEntry::Thought { text } } else { AgentEntry::Agent { text } });
}
}
self.entries.len() - 1
}
fn merge_tool(&mut self, index: usize, update: &Value) {
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, ended_ms, .. } =
&mut self.entries[index]
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, .. } = &mut self.entries[index]
else {
return;
};
@@ -163,9 +156,6 @@ impl Timeline {
}
if let Some(s) = tool_status(update.get("status")) {
*status = s;
if matches!(s, AgentToolStatus::Completed | AgentToolStatus::Failed) && ended_ms.is_none() {
*ended_ms = Some(crate::now_ms());
}
}
if update.get("locations").is_some_and(Value::is_array) {
*locs = locations(update.get("locations"));
@@ -193,11 +183,6 @@ impl Timeline {
}
}
if !text.is_empty() {
// The command a call announced (`$ cmd`) stays above the result that replaces it.
let command = output.as_deref().and_then(|o| o.lines().next()).filter(|l| l.starts_with("$ "));
if let Some(command) = command.filter(|c| !text.starts_with(c)) {
text = format!("{command}\n{text}");
}
*output = Some(tail(text));
}
if !new_diffs.is_empty() {
@@ -447,14 +432,11 @@ mod tests {
assert_eq!(t.apply(&chunk("lo")).changed, vec![0]);
t.apply(&json!({"sessionUpdate": "agent_thought_chunk", "content": {"type": "text", "text": "hmm"}}));
t.apply(&chunk("again"));
// The thought's start is the clock's: it is there, and the rest compares exactly.
let AgentEntry::Thought { started_ms, .. } = &mut t.entries[1] else { panic!("{:?}", t.entries) };
assert!(started_ms.take().is_some());
assert_eq!(
t.entries,
vec![
AgentEntry::Agent { text: "Hello".into() },
AgentEntry::Thought { text: "hmm".into(), started_ms: None },
AgentEntry::Thought { text: "hmm".into() },
AgentEntry::Agent { text: "again".into() },
]
);
@@ -546,25 +528,6 @@ mod tests {
assert!(matches!(t.entries[2], AgentEntry::User { done_ms: None, .. }));
}
#[test]
fn a_hermes_terminal_call_keeps_its_command_and_times() {
let text = |t: &str| serde_json::json!([{"type": "content", "content": {"type": "text", "text": t}}]);
let mut t = Timeline::default();
t.apply(&serde_json::json!({"sessionUpdate": "tool_call", "toolCallId": "tc-0b98b5e30a28",
"kind": "execute", "title": "terminal: echo ok + 2 commands", "locations": [],
"content": text("$ echo ok >> notes.txt && wc -l notes.txt")}));
let AgentEntry::Tool { started_ms, ended_ms, .. } = &t.entries[0] else { panic!() };
assert!(started_ms.is_some() && ended_ms.is_none());
t.apply(&serde_json::json!({"sessionUpdate": "tool_call_update", "toolCallId": "tc-0b98b5e30a28",
"kind": "execute", "status": "completed",
"content": text("terminal result\n- **output:** 3 notes.txt\n- **exit_code:** 0")}));
let AgentEntry::Tool { output, status, ended_ms, .. } = &t.entries[0] else { panic!() };
assert_eq!(*status, AgentToolStatus::Completed);
assert!(ended_ms.is_some());
let expected = "$ echo ok >> notes.txt && wc -l notes.txt\nterminal result\n- **output:** 3 notes.txt\n";
assert_eq!(output.as_deref(), Some(format!("{expected}- **exit_code:** 0").as_str()));
}
#[test]
fn long_output_keeps_its_tail() {
let s = tail("é".repeat(MAX_OUTPUT));
+4 -3
Переглянути файл
@@ -236,9 +236,10 @@ fn classpath(
}
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
let top_dir = subdir(root, &target.top.dir);
let mut command = ProcCommand::new(&target.top.command);
command.args(&args).envs(&target.top.env).current_dir(&top_dir);
let status = ide_core::process::prepare(&mut command)
let status = ProcCommand::new(&target.top.command)
.args(&args)
.envs(&target.top.env)
.current_dir(&top_dir)
.output()
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
if !status.status.success() {
+1 -13
Переглянути файл
@@ -82,23 +82,11 @@ pub fn load_linked(
maven_repo: Option<PathBuf>,
settings: &ide_core::settings::MavenSettings,
gradle_settings: &ide_core::settings::GradleSettings,
) -> BuildModel {
load_linked_with_jdk(root, cache_dir, maven_repo, settings, gradle_settings, None)
}
/// [`load_linked`] with the JDK Maven runs on, for JDK-activated Maven profiles.
pub fn load_linked_with_jdk(
root: &Path,
cache_dir: &Path,
maven_repo: Option<PathBuf>,
settings: &ide_core::settings::MavenSettings,
gradle_settings: &ide_core::settings::GradleSettings,
maven_jdk_version: Option<u32>,
) -> BuildModel {
let maven = maven::has_projects(root, settings).then(|| {
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
let repo = maven_repo.or_else(maven::default_local_repo);
let mut m = maven::load_with_linked_jdk(root, repo, &profiles, maven_jdk_version, &settings.linked_projects);
let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
// The user settings' profiles can be chosen too (`-P` applies to them as well).
for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
File diff suppressed because it is too large. Load diff
+1 -37
Переглянути файл
@@ -197,7 +197,6 @@ pub enum ImportsOnPaste {
#[serde(default, rename_all = "camelCase")]
pub struct FoldingSettings {
pub show_outline: bool,
pub outline_visibility: FoldingOutlineVisibility,
pub file_header: bool,
pub imports: bool,
pub doc_comments: bool,
@@ -205,24 +204,10 @@ pub struct FoldingSettings {
impl Default for FoldingSettings {
fn default() -> Self {
Self {
show_outline: true,
outline_visibility: FoldingOutlineVisibility::Hover,
file_header: true,
imports: true,
doc_comments: false,
}
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum FoldingOutlineVisibility {
#[default]
Hover,
Always,
}
/// Editor › General › Editor Tabs.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -558,24 +543,3 @@ mod auto_import_tests {
}
}
}
#[cfg(test)]
mod folding_tests {
use super::{FoldingOutlineVisibility, FoldingSettings};
#[test]
fn folding_outline_defaults_to_hover_for_existing_settings() {
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
assert!(!settings.show_outline);
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
}
#[test]
fn folding_outline_visibility_round_trips() {
for mode in ["hover", "always"] {
let json = serde_json::json!({ "outlineVisibility": mode });
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
}
}
}
-12
Переглянути файл
@@ -36,8 +36,6 @@ 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
@@ -89,21 +87,11 @@ pub enum IdeEvent {
DocDirty {
doc: DocId,
dirty: bool,
/// Text version when this transition occurred, including when it was saved.
version: u32,
},
/// An open document's file changed on disk while the buffer had unsaved changes. The buffer
/// keeps them (autosave leaves the file alone); the UI offers to load the disk version.
DocDiskConflict {
doc: DocId,
path: String,
},
/// A complete workspace edit can be undone as one operation.
WorkspaceEditApplied {
id: u32,
paths: Vec<crate::IpcPath>,
/// Files the edit renamed, as the edit named them: editors open on them follow.
moves: Vec<crate::FileMove>,
/// Made by an agent through the MCP server's tools: undoable like a refactoring, but
/// not announced as one.
by_agent: bool,
-1
Переглянути файл
@@ -15,7 +15,6 @@ pub mod inspection_settings;
pub mod ipc_path;
pub mod java_runtime;
pub mod jsonc;
pub mod memory;
pub mod output_encoding;
pub mod platform;
pub mod process;
-20
Переглянути файл
@@ -1,20 +0,0 @@
//! Returning freed heap pages to the OS.
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
/// short-lived allocations (a full index scan); until then they still count towards the
/// process's memory footprint.
pub fn release_free_pages() {
#[cfg(target_os = "macos")]
{
unsafe extern "C" {
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
}
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
}
#[cfg(all(target_os = "linux", target_env = "gnu"))]
// SAFETY: malloc_trim only returns free memory to the OS.
unsafe {
libc::malloc_trim(0);
}
}
+14 -148
Переглянути файл
@@ -34,8 +34,6 @@ 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,
@@ -100,6 +98,16 @@ pub struct AgentSettings {
pub smooth_text: bool,
/// Conversations and the composer expand to the full width of the pane instead of staying in a centred column.
pub fit_window_width: bool,
/// While the agent works, playful words fill the pauses in what it reports.
pub playful_status: bool,
/// Seconds the agent reports nothing new before the playful words take over; 0 shows them
/// from the start.
pub playful_after_seconds: u32,
/// The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing
/// the built-in ones of that activity; an empty list keeps its status factual.
#[serde(deserialize_with = "or_default")]
#[specta(type = BTreeMap<String, Vec<String>>)]
pub playful_words: BTreeMap<String, Vec<String>>,
#[serde(deserialize_with = "or_default")]
#[specta(type = ThinkingDisplay)]
pub thinking: ThinkingDisplay,
@@ -130,11 +138,6 @@ pub struct AgentSettings {
#[serde(deserialize_with = "or_default")]
#[specta(type = BTreeMap<String, AgentMcpServer>)]
pub mcp_servers: BTreeMap<String, AgentMcpServer>,
/// How agent skills may run, keyed by skill name (`[agents.skills.<name>]`); `SKILL.md`
/// files on disk are never modified.
#[serde(deserialize_with = "or_default")]
#[specta(type = BTreeMap<String, AgentSkillPolicy>)]
pub skills: BTreeMap<String, AgentSkillPolicy>,
}
impl Default for AgentSettings {
@@ -147,6 +150,9 @@ impl Default for AgentSettings {
fold_turns: true,
smooth_text: true,
fit_window_width: false,
playful_status: false,
playful_after_seconds: 0,
playful_words: BTreeMap::new(),
thinking: ThinkingDisplay::Auto,
tool_calls: ToolCallDisplay::Grouped,
expand_tool_output: false,
@@ -155,7 +161,6 @@ impl Default for AgentSettings {
new_task_approvals: NewTaskApprovals::Bypass,
defaults: BTreeMap::new(),
mcp_servers: BTreeMap::new(),
skills: BTreeMap::new(),
}
}
}
@@ -211,34 +216,6 @@ impl Default for AgentMcpServer {
}
}
/// How an agent skill may run (`[agents.skills.<name>] mode = …`).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentSkillMode {
/// The model decides when to use it.
#[default]
Auto,
/// Only when the user invokes it with `/name`.
SlashOnly,
/// Never.
Off,
}
/// A skill's policy in Settings › Agents › Skills, stored without touching its `SKILL.md`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct AgentSkillPolicy {
#[serde(deserialize_with = "or_default")]
#[specta(type = AgentSkillMode)]
pub mode: AgentSkillMode,
}
impl Default for AgentSkillPolicy {
fn default() -> Self {
Self { mode: AgentSkillMode::Auto }
}
}
/// A hand-edited value these settings don't know reads as the default, rather than
/// failing the whole settings file.
fn or_default<'de, D, T>(d: D) -> Result<T, D::Error>
@@ -340,20 +317,6 @@ 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")]
@@ -378,21 +341,6 @@ 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`].
@@ -411,10 +359,6 @@ 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,
}
}
}
@@ -564,7 +508,6 @@ 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(),
@@ -1251,31 +1194,11 @@ pub struct ArduinoSettings {
}
/// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[derive(Clone, Debug, Default, 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 {
@@ -2194,63 +2117,6 @@ 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)]
-19
Переглянути файл
@@ -110,17 +110,6 @@ pub struct WorkspaceEditPrecondition {
}
impl WorkspaceEdit {
/// The files and folders the edit renames, in order.
pub fn moves(&self) -> Vec<FileMove> {
self.files
.iter()
.filter_map(|f| match f {
FileEdit::Rename { from, to } => Some(FileMove { from: from.clone(), to: to.clone() }),
_ => None,
})
.collect()
}
/// Coalesces aliases of the same file before applying edits against its original text.
/// Resource operations separate batches because later edits may use the new contents.
pub fn deduplicate(&mut self) {
@@ -195,14 +184,6 @@ pub enum FileEdit {
},
}
/// One file or folder move.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FileMove {
pub from: crate::IpcPath,
pub to: crate::IpcPath,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum Severity {
-48
Переглянути файл
@@ -11,8 +11,6 @@ use std::collections::BTreeMap;
pub struct VcsSettings {
/// Colour folders that contain changed files (project tree, tabs).
pub show_dirty_directories: bool,
/// Diffs the user opens show in an editor tab; off, in a separate window.
pub diff_as_editor_tab: bool,
/// Stop file history (Show History) after `history_limit` commits.
pub limit_history: bool,
pub history_limit: u32,
@@ -57,7 +55,6 @@ impl Default for VcsSettings {
Self {
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
show_dirty_directories: false,
diff_as_editor_tab: true,
limit_history: true,
history_limit: 1000,
git: GitSettings::default(),
@@ -79,8 +76,6 @@ pub struct GitSettings {
/// label is plain text and a click on it places the caret as past the line end.
pub inline_blame_clickable: bool,
pub show_branch_in_project_view: bool,
/// Branch operations from the branches popup act on every repository of the project.
pub sync_branch_operations: bool,
/// Path to the git executable; empty = auto-detect.
pub executable: String,
/// Default of Update Project: `merge` | `rebase`.
@@ -122,7 +117,6 @@ impl Default for GitSettings {
inline_blame: false,
inline_blame_clickable: true,
show_branch_in_project_view: false,
sync_branch_operations: true,
executable: String::new(),
update_method: "merge".into(),
auto_update_on_push_rejected: false,
@@ -176,14 +170,6 @@ 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,
/// Show the Generate Commit Message with Agent button above the commit message.
pub agent_button: bool,
}
impl Default for CommitSettings {
@@ -206,10 +192,6 @@ 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(),
agent_button: true,
}
}
}
@@ -326,23 +308,6 @@ 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")]
@@ -615,16 +580,3 @@ impl Default for AgentSecuritySettings {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn git_settings_without_sync_key_execute_on_all_repositories() {
let missing: GitSettings = serde_json::from_str("{}").unwrap();
assert!(missing.sync_branch_operations);
let off: GitSettings = serde_json::from_str(r#"{"syncBranchOperations":false}"#).unwrap();
assert!(!off.sync_branch_operations);
}
}
+6 -13
Переглянути файл
@@ -49,8 +49,6 @@ pub struct AdapterSpec {
pub connect: Option<String>,
/// A plugin language's adapter: start exactly this approved program.
pub pinned: Option<ProgramPin>,
/// See [`DebuggerConfig::resolve_lazy_variables`].
pub resolve_lazy_variables: bool,
}
/// Built-in adapters used when no language definition names `adapter`.
@@ -62,7 +60,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
transport: transport.to_owned(),
connect: None,
install_hint: Some(hint.to_owned()),
resolve_lazy_variables: false,
pinned: None,
};
Some(match adapter {
@@ -133,15 +130,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => DebuggerConfig {
resolve_lazy_variables: true,
..cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
)
},
"java-debug" => cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
),
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
// runs the executable of the java-analyzer serving the module.
JAVA_ANALYZER => cfg(
@@ -192,7 +186,6 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
server_host: None,
connect: config.connect.clone(),
pinned: config.pinned.clone(),
resolve_lazy_variables: config.resolve_lazy_variables,
}
}
+9 -76
Переглянути файл
@@ -68,16 +68,10 @@ 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::Sender<Vec<u8>>,
out: mpsc::UnboundedSender<Vec<u8>>,
pending: Mutex<Pending>,
seq: AtomicI64,
closed: AtomicBool,
@@ -120,7 +114,7 @@ impl Connection {
R: AsyncRead + Unpin + Send + 'static,
W: AsyncWrite + Unpin + Send + 'static,
{
let (out_tx, mut out_rx) = mpsc::channel::<Vec<u8>>(OUT_CAPACITY);
let (out_tx, mut out_rx) = mpsc::unbounded_channel::<Vec<u8>>();
let (in_tx, in_rx) = mpsc::unbounded_channel();
let inner = Arc::new(Inner {
out: out_tx,
@@ -189,17 +183,17 @@ impl Connection {
self.inner.closed.load(Ordering::Acquire)
}
async fn send(&self, value: &Value) -> Result<(), DapError> {
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).await.map_err(|_| DapError::Closed)
self.inner.out.send(body).map_err(|_| DapError::Closed)
}
/// Sends a request and returns a receiver for its response body, without waiting.
pub async fn send_request(
pub fn send_request(
&self,
command: &str,
arguments: Value,
@@ -211,7 +205,7 @@ impl Connection {
if !arguments.is_null() {
msg["arguments"] = arguments;
}
if let Err(e) = self.send(&msg).await {
if let Err(e) = self.send(&msg) {
self.inner.pending.lock().remove(&seq);
return Err(e);
}
@@ -220,7 +214,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).await?;
let rx = self.send_request(command, arguments)?;
rx.await.unwrap_or(Err(DapError::Closed))
}
@@ -232,12 +226,7 @@ impl Connection {
}
/// Answers a reverse request.
pub async fn respond(
&self,
request_seq: i64,
command: &str,
result: Result<Value, String>,
) -> Result<(), DapError> {
pub 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,
@@ -251,7 +240,7 @@ impl Connection {
Ok(_) => {}
Err(message) => msg["message"] = Value::String(message),
}
self.send(&msg).await
self.send(&msg)
}
}
@@ -330,62 +319,6 @@ 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.
-1
Переглянути файл
@@ -102,7 +102,6 @@ pub(crate) fn bare_session_of(name: &str, request: &str) -> BareSession {
server_host: None,
connect: None,
pinned: None,
resolve_lazy_variables: false,
};
let session = Session::new(
DebugSessionId(1),
+18 -68
Переглянути файл
@@ -236,11 +236,6 @@ pub struct Variable {
/// > 0 when expandable.
pub variables_reference: i64,
pub evaluate_name: Option<String>,
/// `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
/// `variables` returns for `variables_reference` holds the value and its children.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
#[specta(optional)]
pub lazy: bool,
}
/// A completion the adapter offers for an expression (DAP `completions`).
@@ -732,46 +727,9 @@ pub(crate) fn variable_from(v: &Value) -> Variable {
type_name: s("type").filter(|t| !t.is_empty()),
variables_reference: v.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: s("evaluateName"),
lazy: v.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
}
}
async fn session_variables(session: &Session, reference: i64) -> IdeResult<Vec<Variable>> {
let body =
session.conn.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT).await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
}
async fn resolve_in(session: &Session, variable: Variable) -> IdeResult<Variable> {
if !variable.lazy || variable.variables_reference <= 0 {
return Ok(variable);
}
let mut inner = session_variables(session, variable.variables_reference).await?;
Ok(match (inner.pop(), inner.is_empty()) {
(Some(value), true) => Variable {
type_name: value.type_name.or(variable.type_name),
evaluate_name: variable.evaluate_name.or(value.evaluate_name),
name: variable.name,
value: value.value,
variables_reference: value.variables_reference,
lazy: value.lazy,
},
_ => variable,
})
}
/// A value that cannot be computed stays lazy, so the row can still be opened by hand.
async fn resolve_lazy(session: &Session, variable: Variable) -> Variable {
if !variable.lazy {
return variable;
}
resolve_in(session, variable.clone()).await.unwrap_or(variable)
}
impl DebugManager {
pub fn new(languages: Arc<LanguageRegistry>) -> Arc<Self> {
Self::with_launcher(languages, Arc::new(ProcessLauncher))
@@ -1186,7 +1144,7 @@ impl DebugManager {
let mut launch = if launch_in_config {
None
} else {
let reply = s.conn.send_request(request, arguments.clone()).await?;
let reply = s.conn.send_request(request, arguments.clone())?;
Some(Box::pin(async move { reply.await.unwrap_or(Err(DapError::Closed)) }))
};
let mut initialized = s.initialized.subscribe();
@@ -1264,7 +1222,7 @@ impl DebugManager {
}
if s.supports("supportsConfigurationDoneRequest") {
if s.adapter == kotlin::ADAPTER {
drop(s.conn.send_request("configurationDone", json!({})).await?);
drop(s.conn.send_request("configurationDone", json!({}))?);
} else {
s.conn.request_timeout("configurationDone", Value::Null, REQUEST_TIMEOUT).await?;
}
@@ -1278,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).await?;
let reply = s.conn.send_request(request, arguments)?;
reply.await.unwrap_or(Err(DapError::Closed))?;
}
}
@@ -1288,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()).await?;
let answer = s.conn.send_request("enableNetworking", js_debug::networking_arguments())?;
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.
@@ -1539,7 +1497,6 @@ impl DebugManager {
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: evaluate_name.or(Some(name)),
lazy: false,
})
}
@@ -1610,18 +1567,16 @@ impl DebugManager {
}
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
let session = self.session(s)?;
let vars = session_variables(&session, reference).await?;
if !session.spec.resolve_lazy_variables {
return Ok(vars);
}
Ok(join_all(vars.into_iter().map(|v| resolve_lazy(&session, v))).await)
}
/// Computes a lazy variable's value (DAP `presentationHint.lazy`); any other variable, or one
/// whose value the adapter does not give as a single variable, comes back unchanged.
pub async fn resolve_variable(&self, s: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
resolve_in(&*self.session(s)?, variable).await
let body = self
.session(s)?
.conn
.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT)
.await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
}
/// Evaluates in the `repl` context.
@@ -1647,18 +1602,13 @@ impl DebugManager {
args["frameId"] = f.into();
}
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
let result = Variable {
Ok(Variable {
name: expression.clone(),
value: body.get("result").and_then(Value::as_str).unwrap_or_default().to_owned(),
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: Some(expression),
lazy: body.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
};
if !session.spec.resolve_lazy_variables {
return Ok(result);
}
Ok(resolve_lazy(&session, result).await)
})
}
/// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
@@ -1763,7 +1713,7 @@ impl DebugManager {
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1875,7 +1825,7 @@ impl DebugManager {
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
+3 -11
Переглянути файл
@@ -924,11 +924,7 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
match command {
"runInTerminal" => {
let result = run_in_terminal(s, &args);
let conn = s.conn.clone();
let command = command.to_owned();
tokio::spawn(async move {
let _ = conn.respond(seq, &command, result).await;
});
let _ = s.conn.respond(seq, command, result);
}
"startDebugging" => {
let mgr = mgr.clone();
@@ -937,15 +933,11 @@ 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)).await;
let _ = s.conn.respond(seq, "startDebugging", result.map(|_| Value::Null).map_err(|e| e.message));
});
}
_ => {
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;
});
let _ = s.conn.respond(seq, command, Err(format!("unsupported reverse request {command}")));
}
}
}
+7 -71
Переглянути файл
@@ -505,29 +505,13 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
"scopes" => {
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
}
// 200 holds a lazy value (java-debug's toString(), js-debug's getters): asked for, its
// reference answers one nameless child with the value and the reference of its fields.
"variables" => match msg["arguments"]["variablesReference"].as_i64() {
Some(200) => ok!(
msg,
json!({"variables": [
{"name": "order", "value": "Order@7", "type": "Order", "variablesReference": 201,
"evaluateName": "order", "presentationHint": {"lazy": true}},
{"name": "n", "value": "2", "type": "int", "variablesReference": 0, "presentationHint": {"lazy": false}},
]})
),
Some(201) => ok!(
msg,
json!({"variables": [{"name": "", "value": "Order@7 \"Order(1)\"", "variablesReference": 202, "evaluateName": "order"}]})
),
_ => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
},
"variables" => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
"completions" => ok!(
msg,
@@ -2036,7 +2020,6 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
transport: "tcp".into(),
connect: Some(format!("127.0.0.1:{port}")),
install_hint: Some("Open the project in the Godot editor".into()),
resolve_lazy_variables: false,
pinned: None,
}),
};
@@ -2780,53 +2763,6 @@ async fn step_of_one_thread_keeps_the_others_suspended() {
assert_eq!(session.suspended.ticket(), ticket + 1);
h.manager.step_in_target(id, 7, 1).await.unwrap();
assert!(!session.suspended.get());
// The UI stays on a thread that is still stopped only when told the step ran one thread.
for thread in [7, 8] {
let continued =
h.wait_event(|e| matches!(e, DebugEvent::Continued { thread_id, .. } if *thread_id == thread)).await;
assert!(matches!(continued, DebugEvent::Continued { all_threads_continued: false, .. }), "{continued:?}");
}
}
#[tokio::test]
async fn lazy_variables_are_resolved_when_the_adapter_declares_them_safe() {
let h = harness(Script::default());
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
let order = &vars[0];
assert_eq!(
(order.name.as_str(), order.value.as_str(), order.type_name.as_deref()),
("order", "Order@7 \"Order(1)\"", Some("Order"))
);
assert_eq!((order.variables_reference, order.lazy), (202, false));
assert_eq!(order.evaluate_name.as_deref(), Some("order"));
assert_eq!((vars[1].name.as_str(), vars[1].lazy), ("n", false));
}
#[tokio::test]
async fn lazy_variables_stay_lazy_for_other_adapters() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
assert_eq!((vars[0].value.as_str(), vars[0].variables_reference, vars[0].lazy), ("Order@7", 201, true));
assert_eq!(requests(&h, "variables").len(), 1, "nothing is computed until asked for");
let order = h.manager.resolve_variable(id, vars[0].clone()).await.unwrap();
assert_eq!((order.name.as_str(), order.value.as_str()), ("order", "Order@7 \"Order(1)\""));
assert_eq!((order.variables_reference, order.lazy), (202, false));
let n = h.manager.resolve_variable(id, vars[1].clone()).await.unwrap();
assert_eq!((n.value.as_str(), requests(&h, "variables").len()), ("2", 2), "only lazy values are computed");
}
#[test]
fn java_debug_declares_its_lazy_variables_safe_to_resolve() {
let languages = LanguageRegistry::load(None).unwrap();
for registry in [&languages, &LanguageRegistry::from_configs(Vec::new())] {
assert!(adapter::find_config(registry, "java-debug").unwrap().resolve_lazy_variables);
assert!(!adapter::find_config(registry, "js-debug").unwrap().resolve_lazy_variables);
}
}
#[tokio::test]
+72 -148
Переглянути файл
@@ -145,38 +145,30 @@ impl ClickhousePool {
let cancel = CancellationToken::new();
let initialize = async {
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
let Some(setting) = rejected_driver_setting(&error) else {
if !rejects_driver_setting(&error) {
return Err(error);
};
}
if !use_http_session {
if setting == "readonly" {
return Err(error);
}
if !source.read_only {
return Err(IdeError::new(
error.kind,
format!(
"{}; enable Read-only for independent queries on a strict read-only server",
error.message
),
));
}
// Every request still sends readonly=1, regardless of which node answers.
pool.0.session.lock().await.strict_read_only = true;
pool.execute("SELECT 1", 1, &cancel).await?;
} else {
// Only rely on the server's write protection after proving strict read-only
// in this same named session.
{
let mut session = pool.0.session.lock().await;
// The rejected probe may have opened a session on a different node.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
return Err(IdeError::new(
error.kind,
format!(
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
error.message
),
));
}
// Retry only the connection probe. Keep relying on the server for write protection
// only after verifying strict read-only mode in this same session.
{
let mut session = pool.0.session.lock().await;
// Start the proof in a fresh session: the rejected probe may have left
// its id on another replica without applying the configured database.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
}
// The HTTP database parameter applies to one request. A named session needs
@@ -244,7 +236,7 @@ impl ClickhousePool {
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
if self.0.read_only && !session.strict_read_only {
request = request.query(&[("readonly", "1")]);
}
request
@@ -332,7 +324,7 @@ impl ClickhousePool {
result
}
None => {
let killed = self.kill(&client, &query_id, &session).await;
let killed = self.kill(&client, &query_id).await;
match killed {
Ok(()) => Err(IdeError::cancelled()),
Err(error) => Err(IdeError::new(
@@ -344,16 +336,15 @@ impl ClickhousePool {
}
}
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
let mut request = client
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
let response = client
.post(self.0.endpoint.clone())
.basic_auth(&self.0.user, Some(&self.0.password))
.timeout(Duration::from_secs(3));
if self.0.read_only && session.id.is_none() {
request = request.query(&[("readonly", "1")]);
}
let response =
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
.timeout(Duration::from_secs(3))
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
.send()
.await
.map_err(http_error)?;
let status = response.status();
let code = response
.headers()
@@ -560,14 +551,13 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
}
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
fn rejects_driver_setting(error: &IdeError) -> bool {
error
.message
.split_once(": ")
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
.and_then(|detail| detail.split_once("' setting in readonly mode"))
.map(|(name, _)| name)
.filter(|&name| {
.is_some_and(|(name, _)| {
matches!(
name,
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
@@ -963,77 +953,19 @@ mod tests {
}
#[tokio::test]
async fn strict_stateless_connections_keep_readonly_on_every_request() {
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
let (port, requests) = server(vec![
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
("200 OK", "", ONE),
(
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "fixture_database".into(),
read_only: true,
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let cancel = CancellationToken::new();
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
let result = pool.execute(sql, 1, &cancel).await.unwrap();
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
assert!(result.has_more);
let requests = requests.await.unwrap();
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("SELECT 1"));
assert!(requests[2].ends_with(write));
assert!(requests[3].ends_with(sql));
for (index, request) in requests.iter().enumerate() {
let url = request_url(request);
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
assert_eq!(query_value(&url, name), None, "{name}");
}
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
}
}
#[tokio::test]
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
for (read_only, detail, body) in [
(
false,
"enable Read-only",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
),
(
true,
"Cannot modify 'readonly'",
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
),
(
true,
"Cannot modify 'max_threads'",
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
),
] {
let (port, requests) =
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
)])
.await;
let source =
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
assert!(error.message.contains(detail), "{}", error.message);
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(error.message.contains("use_http_session=false requires per-request"));
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
@@ -1109,7 +1041,7 @@ mod tests {
let error = IdeError::invalid(format!(
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
));
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
}
}
@@ -1152,45 +1084,37 @@ mod tests {
#[tokio::test]
async fn cancellation_sends_kill_outside_the_busy_session() {
for stateless in [false, true] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (started, received) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut health, _) = listener.accept().await.unwrap();
read_request(&mut health).await;
reply(&mut health, "200 OK", "", ONE).await;
drop(health);
let (mut query, _) = listener.accept().await.unwrap();
let request = read_request(&mut query).await;
started.send(()).unwrap();
let (mut kill, _) =
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
let kill_request = read_request(&mut kill).await;
reply(&mut kill, "200 OK", "", "").await;
(request, kill_request)
});
let source = DataSource {
read_only: true,
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let cancel = CancellationToken::new();
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
let cancelled = async {
received.await.unwrap();
cancel.cancel();
};
let (result, ()) = tokio::join!(query, cancelled);
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
let (query, kill) = server.await.unwrap();
let query_id = query_value(&request_url(&query), "query_id").unwrap();
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
let url = request_url(&kill);
assert_eq!(query_value(&url, "session_id"), None);
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
}
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (started, received) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut health, _) = listener.accept().await.unwrap();
read_request(&mut health).await;
reply(&mut health, "200 OK", "", ONE).await;
drop(health);
let (mut query, _) = listener.accept().await.unwrap();
let request = read_request(&mut query).await;
started.send(()).unwrap();
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
let kill_request = read_request(&mut kill).await;
reply(&mut kill, "200 OK", "", "").await;
(request, kill_request)
});
let pool = Pool::connect(&source(port), None, None).await.unwrap();
let cancel = CancellationToken::new();
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
let cancelled = async {
received.await.unwrap();
cancel.cancel();
};
let (result, ()) = tokio::join!(query, cancelled);
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
let (query, kill) = server.await.unwrap();
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
assert!(!kill.contains("session_id="));
}
#[tokio::test]
+1 -10
Переглянути файл
@@ -217,8 +217,7 @@ impl ManageConnection for MssqlConnectionManager {
let row = client.simple_query("SELECT DB_NAME()").await?.into_row().await?;
let default = row
.and_then(|r| r.get::<&str, _>(0).map(str::to_owned))
// Statements that `USE` another database must not move the pooled connection for good.
.map(|db| format!("USE {}", crate::sql::quote_ident(DbDriver::SqlServer, &db)));
.and_then(|db| crate::sql::use_schema(DbDriver::SqlServer, &db));
Ok(MssqlConnection(Some(client), Context::new(default)))
}
@@ -749,14 +748,6 @@ impl Pool {
}
/// The keep-alive ping (Oracle needs a FROM clause).
/// Keep-alive: one cheap round trip on the session.
pub async fn ping(&self) -> IdeResult<()> {
match self {
Pool::Jdbc(p) => p.ping().await,
_ => self.rows(self.ping_sql(), 1).await.map(|_| ()),
}
}
pub fn ping_sql(&self) -> &'static str {
match self {
Pool::Oracle(_) => "SELECT 1 FROM DUAL",
+3 -101
Переглянути файл
@@ -5,7 +5,6 @@ use crate::{DataSource, DbManager, QueryResult, ResultColumn};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::HashMap;
use std::io::{Cursor, Read};
use std::path::{Path, PathBuf};
use std::process::Stdio;
@@ -303,9 +302,7 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
const CANCEL_GRACE: Duration = Duration::from_secs(3);
fn cancel_timeout() -> IdeError {
IdeError::invalid(
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
)
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
}
async fn exchange(
@@ -461,44 +458,6 @@ impl JdbcPool {
}
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
let result = self.exchange_once(fields, sql, cancel).await;
if let Err(e) = &result
&& fields.first() != Some(&"open")
&& e.kind != ide_core::error::ErrorKind::Cancelled
&& !self.is_closed()
&& !self.session_valid().await
{
// The session is gone (a proxy or tunnel dropped the idle TCP connection): close the
// pool so the next statement or Connect starts a new one instead of failing forever.
self.close().await;
}
result
}
/// Keep-alive: checks the session (any SQL would be dialect-specific) and closes a dead one.
pub(crate) async fn ping(&self) -> IdeResult<()> {
if self.session_valid().await {
return Ok(());
}
self.close().await;
Err(IdeError::new(ide_core::error::ErrorKind::Io, "JDBC connection was lost"))
}
/// Whether the JDBC session still works, asked after a failed statement.
async fn session_valid(&self) -> bool {
if self.bridge.lock().await.is_none() {
return false;
}
let cancel = CancellationToken::new();
match tokio::time::timeout(Duration::from_secs(10), self.exchange_once(&["valid"], "", &cancel)).await {
Ok(Ok(result)) => {
result.rows.first().and_then(|row| row.first()).cloned().flatten().as_deref() != Some("false")
}
Ok(Err(_)) | Err(_) => false,
}
}
async fn exchange_once(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
let mut slot = tokio::select! {
biased;
() = cancel.cancelled() => return Err(IdeError::cancelled()),
@@ -603,32 +562,14 @@ fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
impl DbManager {
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
let mut tables = vec![];
let mut column_count = 0;
// Read the schemas the source's Schemas tab picks, like the database tree does. It also
// keeps large instances usable: an Oracle server exposes dozens of system schemas, and
// dumping the columns of all of them takes minutes, during which the bridge (a single
// Java process that runs one command at a time) executes none of the user's statements.
let introspection = self.source(id)?.introspection;
let schemas: Vec<String> =
self.schemas(id).await?.into_iter().filter(|s| introspection.shows_schema(s)).collect();
let schemas = self.schemas(id).await?;
for schema in &schemas {
// Columns of the whole namespace in one call; a driver that refuses it still completes tables.
let mut columns = if column_count < crate::MAX_META_ROWS {
pool.metadata(&["schemaColumns", schema]).await.map(schema_columns).unwrap_or_else(|e| {
tracing::warn!("JDBC columns of {schema}: {}", e.message);
HashMap::new()
})
} else {
HashMap::new()
};
for table in self.tables(id, schema).await? {
let columns = columns.remove(&table.name).unwrap_or_default();
column_count += columns.len();
tables.push(crate::CompletionTable {
schema: schema.clone(),
name: table.name,
kind: table.kind,
columns,
columns: vec![],
});
if tables.len() >= crate::MAX_META_ROWS {
break;
@@ -653,49 +594,10 @@ impl DbManager {
}
}
/// The bridge's `schemaColumns` rows (table, name, type, nullable, default) by table.
fn schema_columns(rows: Vec<Vec<Option<String>>>) -> HashMap<String, Vec<crate::CompletionColumn>> {
let mut by_table: HashMap<String, Vec<crate::CompletionColumn>> = HashMap::new();
for row in rows {
let mut it = row.into_iter();
let (Some(Some(table)), Some(Some(name))) = (it.next(), it.next()) else { continue };
let data_type = it.next().flatten().unwrap_or_default();
let nullable = it.next().flatten().as_deref() != Some("0");
let has_default = it.next().flatten().is_some();
by_table.entry(table).or_default().push(crate::CompletionColumn {
name,
data_type,
nullable,
primary_key: false,
has_default,
});
}
by_table
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn schema_columns_group_by_table() {
let row = |t: &str, n: &str, null: &str, def: Option<&str>| {
vec![Some(t.into()), Some(n.into()), Some("INT".into()), Some(null.into()), def.map(Into::into)]
};
let by_table = schema_columns(vec![
row("orders", "id", "0", None),
row("orders", "note", "1", Some("'none'")),
row("items", "sku", "1", None),
vec![None, Some("orphan".into())],
]);
let orders = &by_table["orders"];
assert_eq!(orders.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "note"]);
assert_eq!((orders[0].nullable, orders[0].has_default), (false, false));
assert_eq!((orders[1].nullable, orders[1].has_default), (true, true));
assert_eq!(by_table["items"].len(), 1);
assert_eq!(by_table.len(), 2);
}
#[tokio::test]
async fn frame_codec_checks_both_16_mib_boundaries() {
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
+7 -12
Переглянути файл
@@ -379,8 +379,8 @@ pub(crate) fn keep_alive(pool: &Arc<Pool>, every: Duration) {
loop {
tick.tick().await;
let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
if let Err(e) = p.ping().await {
tracing::info!("keep-alive: {}", e.message);
if let Err(e) = p.rows(p.ping_sql(), 1).await {
tracing::debug!("keep-alive: {}", e.message);
}
}
});
@@ -847,12 +847,12 @@ impl DbManager {
}
pub fn is_connected(&self, id: &str) -> bool {
self.pools.lock().get(id).is_some_and(|p| !p.is_closed())
self.pools.lock().contains_key(id)
}
/// Connected targets (data source ids, `<id>:<database>`).
pub fn connected(&self) -> Vec<String> {
self.pools.lock().iter().filter(|(_, p)| !p.is_closed()).map(|(id, _)| id.clone()).collect()
self.pools.lock().keys().cloned().collect()
}
/// The pool of target `id`, connecting first if needed.
@@ -862,13 +862,8 @@ impl DbManager {
if self.tunnels.lock().get(source_id).is_some_and(|t| t.is_closed()) {
self.disconnect_source(source_id).await;
}
let cached = self.pools.lock().get(id).cloned();
if let Some(p) = cached {
if !p.is_closed() {
return Ok(p);
}
// The connection broke (a custom JDBC session whose TCP connection was dropped): reconnect.
self.disconnect(id).await;
if let Some(p) = self.pools.lock().get(id) {
return Ok(p.clone());
}
let source = self.source(id)?;
let password = self.password(&source).await;
@@ -922,7 +917,7 @@ impl DbManager {
/// Disconnects every database of data source `id`.
pub async fn disconnect_source(&self, id: &str) {
let targets: Vec<String> = self.pools.lock().keys().filter(|t| split_target(t).0 == id).cloned().collect();
let targets: Vec<String> = self.connected().into_iter().filter(|t| split_target(t).0 == id).collect();
for t in targets {
self.disconnect(&t).await;
}
-59
Переглянути файл
@@ -124,45 +124,6 @@ impl Default for DbIntrospection {
}
}
impl DbIntrospection {
/// Whether the tree shows this schema: every one with `all_schemas`, otherwise it has to
/// match one of the `schemas` patterns. The completion model uses the same test, so it
/// offers exactly the tables the tree lists (and does not read the ones it never shows).
pub fn shows_schema(&self, name: &str) -> bool {
self.all_schemas
|| self.schemas.iter().map(|p| p.trim()).filter(|p| !p.is_empty()).any(|p| schema_matches(p, name))
}
}
/// `*` matches any run of characters, `?` a single one; a pattern without wildcards matches the
/// name as typed (the dialog fills names from the list the server returned, so case is settled).
fn schema_matches(pattern: &str, name: &str) -> bool {
if !pattern.contains('*') && !pattern.contains('?') {
return pattern == name;
}
let p: Vec<char> = pattern.chars().collect();
let n: Vec<char> = name.chars().collect();
let (mut pi, mut ni) = (0, 0);
// Position of the last `*` and how much of the name it has already swallowed.
let mut star: Option<(usize, usize)> = None;
while ni < n.len() {
if pi < p.len() && (p[pi] == '?' || p[pi] == n[ni]) {
pi += 1;
ni += 1;
} else if pi < p.len() && p[pi] == '*' {
star = Some((pi, ni));
pi += 1;
} else if let Some((at, taken)) = star {
pi = at + 1;
ni = taken + 1;
star = Some((at, taken + 1));
} else {
return false;
}
}
p[pi..].iter().all(|&c| c == '*')
}
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
/// SQLite: pragmas. See [`crate::conn`].
@@ -804,24 +765,4 @@ mod tests {
assert_eq!(r.snowflake().auth, DbSnowflakeAuth::Browser);
assert_eq!(scheme_driver("snowflake"), Some(DbDriver::Snowflake));
}
#[test]
fn introspection_shows_only_the_picked_schemas() {
let mut i = DbIntrospection::default();
assert!(i.shows_schema("SYS"), "the default reads every schema");
i.all_schemas = false;
assert!(!i.shows_schema("SYS"), "nothing picked: the tree lists nothing either");
i.schemas = vec!["XMCB".into(), " APP_* ".into()];
assert!(i.shows_schema("XMCB"));
assert!(i.shows_schema("APP_INFO"));
assert!(!i.shows_schema("APP"), "`*` needs the text that follows it");
assert!(!i.shows_schema("SYS"));
assert!(!i.shows_schema("xmcb"), "patterns match the names the server returned");
i.schemas = vec!["?".into()];
assert!(i.shows_schema("A"));
assert!(!i.shows_schema("AB"));
}
}
+6 -8
Переглянути файл
@@ -442,8 +442,7 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
DbDriver::Sqlite | DbDriver::Jdbc => None,
DbDriver::Postgres => Some("SELECT current_schema()"),
DbDriver::Mysql => Some("SELECT DATABASE()"),
// The login's default schema; the database is the console's target (IDEA's `database.schema`).
DbDriver::SqlServer => Some("SELECT SCHEMA_NAME()"),
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
DbDriver::Oracle => Some("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL"),
DbDriver::Snowflake => Some("SELECT CURRENT_SCHEMA()"),
}
@@ -451,13 +450,12 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
/// The statement that makes unqualified names resolve in `schema` on the
/// connection that runs it (a query console's active schema; `None`: the driver
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs, and SQL Server
/// cannot change a session's default schema, so its console schema only scopes resolution).
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
match driver {
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc | DbDriver::SqlServer => None,
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
DbDriver::Mysql => Some(format!("USE {}", quote_ident(driver, schema))),
DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
DbDriver::Snowflake => Some(format!("USE SCHEMA {}", quote_ident(driver, schema))),
}
@@ -1032,7 +1030,7 @@ mod tests {
assert_eq!(quote_ident(DbDriver::SqlServer, "a]b"), "[a]]b]");
assert_eq!(qualified(DbDriver::SqlServer, "dbo", "t"), "[dbo].[t]");
assert_eq!(qualified(DbDriver::SqlServer, "", "t"), "[t]");
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT SCHEMA_NAME()"));
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT DB_NAME()"));
assert_eq!(crate::conn::begin_statement(DbDriver::SqlServer), "BEGIN TRAN");
assert_eq!(
schemas(DbDriver::SqlServer, true),
@@ -1151,7 +1149,7 @@ mod tests {
fn schema_switch_statement_per_dialect() {
assert_eq!(use_schema(DbDriver::Postgres, "app data"), Some("SET search_path TO \"app data\"".into()));
assert_eq!(use_schema(DbDriver::Mysql, "a`b"), Some("USE `a``b`".into()));
assert_eq!(use_schema(DbDriver::SqlServer, "dbo"), None);
assert_eq!(use_schema(DbDriver::SqlServer, "app] data"), Some("USE [app]] data]".into()));
assert_eq!(use_schema(DbDriver::Postgres, "a\"b"), Some("SET search_path TO \"a\"\"b\"".into()));
assert_eq!(use_schema(DbDriver::Oracle, "a\"b"), Some("ALTER SESSION SET CURRENT_SCHEMA = \"a\"\"b\"".into()));
assert!(sqlserver_databases().contains("state = 0 AND HAS_DBACCESS(name) = 1"));
+3 -43
Переглянути файл
@@ -90,10 +90,7 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
assert!(result.has_more);
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
assert_eq!(result.columns[1].name, "label");
let completion = db.completion("test").await?;
assert_eq!(completion.default_schema, "main");
let items = completion.tables.iter().find(|t| t.schema == "main" && t.name == "items").expect("items");
assert_eq!(items.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "label"]);
assert_eq!(db.completion("test").await?.default_schema, "main");
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
let stop = CancellationToken::new();
let (cancelled, ()) =
@@ -210,46 +207,9 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
})
.await
.expect("driver cancellation must be bounded");
assert_eq!(
result.unwrap_err().message,
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
);
assert!(db.connected().is_empty());
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
assert_eq!(db.connected(), ["test"]);
assert!(result.unwrap_err().message.contains("Reconnect"));
db.disconnect("test").await;
Ok(())
}
#[tokio::test]
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
let tmp = tempfile::tempdir()?;
let db = manager(tmp.path());
db.save_jdbc_driver(DbJdbcDriver {
id: "fixture".into(),
name: "Fixture".into(),
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
url_template: String::new(),
})?;
let source = DataSource {
id: "test".into(),
name: "Fixture".into(),
driver: DbDriver::Jdbc,
global: true,
jdbc_driver: "fixture".into(),
url: "jdbc:fixture:".into(),
..Default::default()
};
db.save_sources(vec![source]).await?;
let cancel = CancellationToken::new();
db.execute("test", "first", 1, &cancel).await?;
// The fixture's session reports itself invalid after "drop", like a connection a proxy reset.
assert!(db.execute("test", "drop", 1, &cancel).await.unwrap_err().message.contains("connection reset"));
assert!(!db.is_connected("test"), "a lost session is no longer listed as connected");
assert_eq!(db.execute("test", "after reconnect", 1, &cancel).await?.affected, Some(1.0));
assert!(db.is_connected("test"));
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
db.disconnect("test").await;
Ok(())
}
+9 -382
Переглянути файл
@@ -7,10 +7,9 @@
use crate::{
COMPOSE_DIR, COMPOSE_FILES, COMPOSE_PROJECT, COMPOSE_SERVICE, ContainerOp, DockerAvailability, DockerContainer,
DockerEndpoint, DockerImage, DockerImageLayer, DockerLogLine, DockerNetwork, DockerObject, DockerProcessList,
DockerSnapshot, DockerVolume, split_csv,
DockerEndpoint, DockerImage, DockerNetwork, DockerObject, DockerSnapshot, DockerVolume, split_csv,
};
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_core::{IdeError, IdeResult};
use serde::Deserialize;
use std::collections::BTreeMap;
use std::io::{Read, Write};
@@ -194,15 +193,9 @@ fn request(addr: &Address, method: &str, path: &str, timeout: Duration) -> IdeRe
read_response(&mut conn)
}
/// A response's status line and body framing.
struct Head {
status: u16,
chunked: bool,
length: Option<usize>,
}
/// Reads an HTTP/1.1 response head until `\r\n\r\n`.
fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
/// Reads an HTTP/1.1 response: head until `\r\n\r\n`, then the body per its
/// framing (chunked, `Content-Length`, or until the connection closes).
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
let mut head: Vec<u8> = Vec::new();
let mut byte = [0u8; 1];
loop {
@@ -235,27 +228,16 @@ fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
length = value.parse().ok();
}
}
Ok(Head { status, chunked, length })
}
/// Reads an HTTP/1.1 response: its head, then the body per its framing
/// (chunked, `Content-Length`, or until the connection closes).
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
let head = read_head(stream)?;
let body = read_body(stream, &head)?;
Ok(Response { status: head.status, body })
}
fn read_body(stream: &mut impl Read, head: &Head) -> IdeResult<Vec<u8>> {
Ok(if head.chunked {
let body = if chunked {
read_chunked(stream)?
} else if let Some(n) = head.length {
} else if let Some(n) = length {
read_exact_n(stream, n)?
} else {
let mut body = Vec::new();
stream.read_to_end(&mut body)?;
body
})
};
Ok(Response { status, body })
}
/// Reads one `\n`-terminated line (returned without it).
@@ -500,292 +482,6 @@ pub(crate) fn inspect(
})())
}
/// The processes running in a container (`docker top`).
pub(crate) fn container_top(ep: &DockerEndpoint, id: &str, timeout: Duration) -> Option<IdeResult<DockerProcessList>> {
let addr = address(ep)?;
Some((|| {
let body = check(request(&addr, "GET", &format!("/containers/{}/top", path_segment(id)), timeout)?)?;
serde_json::from_str::<ApiTop>(&body)
.map(|t| DockerProcessList { titles: t.titles, processes: t.processes })
.map_err(|e| IdeError::internal(format!("the Docker daemon's process list is not JSON: {e}")))
})())
}
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiTop {
titles: Vec<String>,
processes: Vec<Vec<String>>,
}
/// An image's layers, newest first (`docker image history`).
pub(crate) fn image_history(
ep: &DockerEndpoint,
id: &str,
timeout: Duration,
) -> Option<IdeResult<Vec<DockerImageLayer>>> {
let addr = address(ep)?;
Some((|| {
let body = check(request(&addr, "GET", &format!("/images/{}/history", path_segment(id)), timeout)?)?;
let layers = serde_json::from_str::<Vec<ApiLayer>>(&body)
.map_err(|e| IdeError::internal(format!("the Docker daemon's image history is not JSON: {e}")))?;
Ok(map_layers(layers, unix_now()))
})())
}
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiLayer {
id: String,
created: i64,
created_by: String,
size: i64,
comment: String,
}
fn map_layers(layers: Vec<ApiLayer>, now: i64) -> Vec<DockerImageLayer> {
layers
.into_iter()
.map(|l| DockerImageLayer {
id: l.id,
created_by: l.created_by,
size: human_size(l.size),
created_since: human_duration((now - l.created).max(0)),
created_at: unix_utc(l.created),
comment: l.comment,
})
.collect()
}
fn unix_now() -> i64 {
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
}
/// How often a log stream that has nothing to read checks for cancellation.
const LOG_POLL: Duration = Duration::from_millis(200);
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiContainerInspect {
config: ApiContainerConfig,
}
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct ApiContainerConfig {
tty: bool,
}
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
/// from `ep`'s daemon until they end or `cancel` fires.
#[allow(clippy::too_many_arguments)]
pub(crate) fn logs(
ep: &DockerEndpoint,
id: &str,
tail: u32,
follow: bool,
timestamps: bool,
timeout: Duration,
cancel: &CancellationToken,
on_line: &dyn Fn(DockerLogLine),
) -> Option<IdeResult<()>> {
let addr = address(ep)?;
Some((|| {
// A TTY container's log is one raw stream; otherwise it is framed per stream.
let body = check(request(&addr, "GET", &format!("/containers/{}/json", path_segment(id)), timeout)?)?;
let tty = serde_json::from_str::<ApiContainerInspect>(&body).map(|c| c.config.tty).unwrap_or(false);
let path = format!(
"/containers/{}/logs?stdout=1&stderr=1&tail={tail}&follow={}&timestamps={}",
path_segment(id),
u8::from(follow),
u8::from(timestamps),
);
let mut conn = Conn::connect(&addr, timeout)?;
conn.write_all(
format!("GET {path} HTTP/1.1\r\nHost: docker\r\nUser-Agent: openidea\r\nConnection: close\r\n\r\n")
.as_bytes(),
)?;
let head = read_head(&mut conn)?;
if !(200..300).contains(&head.status) {
let body = read_body(&mut conn, &head)?;
check(Response { status: head.status, body })?;
}
conn.set_timeouts(LOG_POLL);
let mut decoder = LogDecoder::new(&head, tty);
let mut buf = [0u8; 8192];
while !decoder.done() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
match conn.read(&mut buf) {
Ok(0) => break,
Ok(n) => decoder.feed(&buf[..n], &mut |line| on_line(line))?,
Err(e)
if matches!(
e.kind(),
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted
) => {}
Err(e) => return Err(e.into()),
}
}
decoder.finish(&mut |line| on_line(line));
Ok(())
})())
}
/// Turns a log response body, as it arrives, into lines: undoes the chunked
/// transfer encoding, then the per-stream frames (8-byte header: stream, 3 zero
/// bytes, big-endian length) unless the container has a TTY.
struct LogDecoder {
body: BodyFraming,
tty: bool,
header: Vec<u8>,
frame_left: usize,
frame_stderr: bool,
/// Partial lines of stdout and stderr.
partial: [Vec<u8>; 2],
}
enum BodyFraming {
Chunked { state: ChunkState, line: Vec<u8> },
Length(usize),
Close,
}
#[derive(Clone, Copy, PartialEq)]
enum ChunkState {
Size,
Data(usize),
DataEnd,
Trailer,
Done,
}
impl LogDecoder {
fn new(head: &Head, tty: bool) -> Self {
let body = if head.chunked {
BodyFraming::Chunked { state: ChunkState::Size, line: Vec::new() }
} else if let Some(n) = head.length {
BodyFraming::Length(n)
} else {
BodyFraming::Close
};
Self { body, tty, header: Vec::new(), frame_left: 0, frame_stderr: false, partial: [Vec::new(), Vec::new()] }
}
fn done(&self) -> bool {
matches!(self.body, BodyFraming::Chunked { state: ChunkState::Done, .. } | BodyFraming::Length(0))
}
fn feed(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) -> IdeResult<()> {
let mut payload = Vec::new();
match &mut self.body {
BodyFraming::Close => payload.extend_from_slice(bytes),
BodyFraming::Length(left) => {
let take = (*left).min(bytes.len());
payload.extend_from_slice(&bytes[..take]);
*left -= take;
}
BodyFraming::Chunked { state, line } => {
while !bytes.is_empty() {
match *state {
ChunkState::Done => break,
ChunkState::Data(n) => {
let take = n.min(bytes.len());
payload.extend_from_slice(&bytes[..take]);
bytes = &bytes[take..];
*state = if take == n { ChunkState::DataEnd } else { ChunkState::Data(n - take) };
}
_ => {
let b = bytes[0];
bytes = &bytes[1..];
if b != b'\n' {
if b != b'\r' {
line.push(b);
}
continue;
}
let text = String::from_utf8_lossy(line).into_owned();
line.clear();
*state = match *state {
ChunkState::Size => {
let size = text.split(';').next().unwrap_or_default().trim();
match usize::from_str_radix(size, 16) {
Ok(0) => ChunkState::Trailer,
Ok(n) => ChunkState::Data(n),
Err(_) => {
return Err(IdeError::internal(
"the Docker daemon answered with a malformed chunked response",
));
}
}
}
ChunkState::DataEnd => ChunkState::Size,
_ if text.is_empty() => ChunkState::Done,
other => other,
};
}
}
}
}
}
self.frames(&payload, emit);
Ok(())
}
fn frames(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
if self.tty {
self.lines(false, bytes, emit);
return;
}
while !bytes.is_empty() {
if self.frame_left == 0 {
let take = (8 - self.header.len()).min(bytes.len());
self.header.extend_from_slice(&bytes[..take]);
bytes = &bytes[take..];
if self.header.len() == 8 {
self.frame_stderr = self.header[0] == 2;
self.frame_left =
u32::from_be_bytes([self.header[4], self.header[5], self.header[6], self.header[7]]) as usize;
self.header.clear();
}
continue;
}
let take = self.frame_left.min(bytes.len());
self.lines(self.frame_stderr, &bytes[..take], emit);
self.frame_left -= take;
bytes = &bytes[take..];
}
}
fn lines(&mut self, stderr: bool, bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
let partial = &mut self.partial[usize::from(stderr)];
for &b in bytes {
if b == b'\n' {
emit(DockerLogLine { stderr, text: line_text(partial) });
partial.clear();
} else {
partial.push(b);
}
}
}
/// Emits the last lines that ended without a newline.
fn finish(&mut self, emit: &mut dyn FnMut(DockerLogLine)) {
for stderr in [false, true] {
let partial = &mut self.partial[usize::from(stderr)];
if !partial.is_empty() {
emit(DockerLogLine { stderr, text: line_text(partial) });
partial.clear();
}
}
}
}
fn line_text(bytes: &[u8]) -> String {
String::from_utf8_lossy(bytes.strip_suffix(b"\r").unwrap_or(bytes)).into_owned()
}
/// One URL path segment, percent-encoded so an id cannot change the path.
fn path_segment(id: &str) -> String {
let mut out = String::with_capacity(id.len());
@@ -1121,75 +817,6 @@ mod tests {
assert!(read_response(&mut &garbage[..]).is_err());
}
/// Feeds `body` one byte at a time, as a slow connection delivers it.
fn decode(head: Head, tty: bool, body: &[u8]) -> (Vec<(bool, String)>, bool) {
let mut lines = Vec::new();
let mut decoder = LogDecoder::new(&head, tty);
for b in body {
decoder.feed(std::slice::from_ref(b), &mut |l| lines.push((l.stderr, l.text))).unwrap();
}
let done = decoder.done();
decoder.finish(&mut |l| lines.push((l.stderr, l.text)));
(lines, done)
}
fn frame(stream: u8, text: &str) -> Vec<u8> {
let mut f = vec![stream, 0, 0, 0];
f.extend((text.len() as u32).to_be_bytes());
f.extend(text.as_bytes());
f
}
#[test]
fn engine_image_history_reads_like_the_cli() {
let layers: Vec<ApiLayer> = serde_json::from_str(
r#"[{"Id":"sha256:abc","Created":1000,"CreatedBy":"CMD [\"python3\"]","Size":20500,"Comment":"buildkit","Tags":["py:3"]},
{"Id":"<missing>","Created":940,"CreatedBy":"RUN x","Size":0,"Comment":""}]"#,
)
.unwrap();
let rows = map_layers(layers, 1000 + 2 * 7 * 86_400);
assert_eq!(
rows.iter().map(|l| (l.id.as_str(), l.size.as_str(), l.created_since.as_str())).collect::<Vec<_>>(),
[("sha256:abc", "20.5kB", "2 weeks ago"), ("<missing>", "0B", "2 weeks ago")]
);
assert_eq!(rows[0].created_by, "CMD [\"python3\"]");
let top: ApiTop = serde_json::from_str(r#"{"Titles":["PID","CMD"],"Processes":[["1","sh"]]}"#).unwrap();
assert_eq!(
(top.titles, top.processes),
(vec!["PID".to_owned(), "CMD".to_owned()], vec![vec!["1".to_owned(), "sh".to_owned()]])
);
}
#[test]
fn container_logs_split_into_stream_lines_across_chunks_and_frames() {
// Frames split mid-line, a CRLF line, and a stderr line between stdout parts.
let mut framed = frame(1, "tick 1\r\ntick");
framed.extend(frame(2, "oops\n"));
framed.extend(frame(1, " 2\nlast"));
let mut chunked = Vec::new();
for part in framed.chunks(7) {
chunked.extend(format!("{:x}\r\n", part.len()).as_bytes());
chunked.extend(part);
chunked.extend(b"\r\n");
}
chunked.extend(b"0\r\n\r\n");
let (lines, done) = decode(Head { status: 200, chunked: true, length: None }, false, &chunked);
assert!(done);
let expected = [(false, "tick 1"), (true, "oops"), (false, "tick 2"), (false, "last")];
assert_eq!(lines, expected.map(|(e, t)| (e, t.to_owned())));
// A TTY container's log is one raw stream; the body may end with the connection.
let (lines, done) = decode(Head { status: 200, chunked: false, length: None }, true, b"a\r\nb\n");
assert!(!done);
assert_eq!(lines, [(false, "a".to_owned()), (false, "b".to_owned())]);
// A Content-Length body ends after its length.
let body = frame(1, "one\n");
let (lines, done) = decode(Head { status: 200, chunked: false, length: Some(body.len()) }, false, &body);
assert!(done);
assert_eq!(lines, [(false, "one".to_owned())]);
}
#[test]
fn daemon_errors_carry_their_message() {
let resp = Response { status: 404, body: br#"{"message":"No such container: missing"}"#.to_vec() };
-15
Переглянути файл
@@ -287,11 +287,6 @@ fn check_id(id: &str) -> IdeResult<&str> {
/// `docker image history --no-trunc --format '{{json .}}'` of one image.
pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImageLayer>> {
let id = check_id(id)?;
if docker_executable().is_none()
&& let Some(layers) = engine::image_history(ep, id, QUICK)
{
return layers;
}
let out = run(ep, &["image", "history", "--no-trunc", "--format", "{{json .}}", id], QUICK)?;
Ok(parse_image_history(&out))
}
@@ -299,11 +294,6 @@ pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImage
/// `docker top <id>` of a running container.
pub fn container_top(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerProcessList> {
let id = check_id(id)?;
if docker_executable().is_none()
&& let Some(processes) = engine::container_top(ep, id, QUICK)
{
return processes;
}
let out = run(ep, &["top", id], QUICK)?;
Ok(parse_container_top(&out))
}
@@ -326,11 +316,6 @@ pub fn logs(
cancel: &CancellationToken,
on_line: &dyn Fn(DockerLogLine),
) -> IdeResult<()> {
if docker_executable().is_none()
&& let Some(streamed) = engine::logs(ep, id, tail, follow, timestamps, QUICK, cancel, on_line)
{
return streamed;
}
let tail = tail.to_string();
let mut args = vec!["logs", "--tail", &tail];
if follow {
-54
Переглянути файл
@@ -1,54 +0,0 @@
[package]
name = "ide-drag-out"
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
[target.'cfg(target_os = "linux")'.dependencies]
gtk = "0.18"
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
raw-window-handle = "0.6"
[target.'cfg(windows)'.dependencies]
windows = { version = "0.62", features = [
"Win32_Foundation",
"Win32_Graphics_Gdi",
"Win32_System_Com",
"Win32_System_Com_StructuredStorage",
"Win32_System_Memory",
"Win32_System_Ole",
"Win32_System_SystemServices",
"Win32_UI_Shell",
"Win32_UI_Shell_Common",
] }
# `#[implement]` expands to paths into `windows_core`.
windows-core = "0.62"
[target.'cfg(target_os = "macos")'.dependencies]
objc2 = { version = "0.6", default-features = false, features = ["std"] }
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
objc2-app-kit = { version = "0.3", default-features = false, features = [
"std",
"objc2-core-foundation",
"NSApplication",
"NSDragging",
"NSDraggingItem",
"NSDraggingSession",
"NSEvent",
"NSGraphics",
"NSGraphicsContext",
"NSImage",
"NSPasteboard",
"NSPasteboardItem",
"NSResponder",
"NSView",
"NSWindow",
"NSWorkspace",
] }
[dev-dependencies]
tempfile.workspace = true
-122
Переглянути файл
@@ -1,122 +0,0 @@
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
use super::Outcome;
use objc2::rc::Retained;
use objc2::runtime::ProtocolObject;
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
use objc2_app_kit::{
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
};
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
use std::cell::Cell;
use std::io;
use std::path::PathBuf;
/// The size of each file's icon under the pointer, in points.
const ICON_SIZE: f64 = 32.0;
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
/// Finder icon; `done` runs on the main thread when the drag ends.
pub fn start<W: HasWindowHandle>(
window: &W,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
let RawWindowHandle::AppKit(handle) =
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
else {
return Err(io::Error::other("not an AppKit window"));
};
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
// In window coordinates, which are the content view's.
let pointer = window.mouseLocationOutsideOfEventStream();
let frame = NSRect::new(
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
NSSize::new(ICON_SIZE, ICON_SIZE),
);
let workspace = NSWorkspace::sharedWorkspace();
let mut items = Vec::with_capacity(paths.len());
for path in &paths {
let path = NSString::from_str(&path.to_string_lossy());
let url = NSURL::fileURLWithPath(&path)
.absoluteString()
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
let item = NSPasteboardItem::new();
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
}
let drag_item =
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
let icon = workspace.iconForFile(&path);
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
items.push(drag_item);
}
// The session starts from a drag event at the pointer: the web view's own mouse events
// went to WebKit, and the current event may be a later one.
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
NSEventType::LeftMouseDragged,
pointer,
NSEventModifierFlags::empty(),
timestamp,
window.windowNumber(),
None,
0,
1,
1.0,
)
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
let source = DragSource::new(Box::new(done), mtm);
content.beginDraggingSessionWithItems_event_source(
&NSArray::from_retained_slice(&items),
&event,
ProtocolObject::from_ref(&*source),
);
Ok(())
}
type Done = Box<dyn FnOnce(Outcome)>;
struct Ivars {
done: Cell<Option<Done>>,
}
define_class!(
#[unsafe(super(NSObject))]
#[thread_kind = MainThreadOnly]
#[name = "OpenIdeaDragOutSource"]
#[ivars = Ivars]
struct DragSource;
unsafe impl NSObjectProtocol for DragSource {}
unsafe impl NSDraggingSource for DragSource {
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
NSDragOperation::Copy
}
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
if let Some(done) = self.ivars().done.take() {
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
}
}
}
);
impl DragSource {
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
unsafe { msg_send![super(this), init] }
}
}
-190
Переглянути файл
@@ -1,190 +0,0 @@
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
//! dragged from IDEA's Project view (#2867).
//!
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
//! always a copy, never a move, so no target can take project files away.
//!
//! [`start`] runs on the UI thread while the primary button is still held. It returns
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
//! when it ends, or is dropped without being called when the backend lost track of it.
use std::io;
use std::path::PathBuf;
/// How a drag ended.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Outcome {
/// A target accepted the drop.
Dropped,
/// Released where nothing accepted it, or cancelled with Escape.
Cancelled,
}
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
/// on this machine. A remote project's paths name files on its server and fail here.
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
if paths.is_empty() {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
}
for path in &paths {
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
}
if cfg!(windows) && !fits_max_path(path) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("path too long to drag: {}", path.display()),
));
}
}
Ok(paths)
}
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
fn fits_max_path(path: &std::path::Path) -> bool {
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
}
#[cfg(target_os = "linux")]
pub use gtk_impl::start;
#[cfg(target_os = "linux")]
mod gtk_impl {
use super::Outcome;
use gtk::glib::{self, SignalHandlerId};
use gtk::prelude::*;
use gtk::{TargetList, gdk};
use std::cell::{Cell, RefCell};
use std::io;
use std::path::PathBuf;
use std::rc::Rc;
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
/// the UI thread when the drag ends.
pub fn start(
window: &gtk::ApplicationWindow,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
// `file://` URIs with every reserved or non-ASCII byte escaped.
let uris = paths
.iter()
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
.collect::<Result<Vec<_>, _>>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
let targets = TargetList::new(&[]);
targets.add_uri_targets(0);
// The button that started the drag (1), not its mask: GTK ends the drag on that
// button's release.
let context = window
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
context.connect_drop_performed({
let outcome = outcome.clone();
move |_, _| outcome.set(Outcome::Dropped)
});
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
let data = window.connect_drag_data_get({
let context = context.clone();
move |_, ctx, selection, _, _| {
if *ctx == context {
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
selection.set_uris(&uris);
}
}
});
// The target asks for the data after the drop (XDND is asynchronous), so the data
// handler stays connected until `drag-end`, which GTK emits last.
let done = Cell::new(Some(done));
let end = window.connect_drag_end({
let handlers = handlers.clone();
move |window, ctx| {
if *ctx != context {
return;
}
for handler in handlers.borrow_mut().drain(..) {
window.disconnect(handler);
}
if let Some(done) = done.take() {
done(outcome.get());
}
}
});
handlers.borrow_mut().extend([data, end]);
Ok(())
}
}
#[cfg(windows)]
mod ole;
#[cfg(windows)]
pub use ole::start;
#[cfg(target_os = "macos")]
mod appkit;
#[cfg(target_os = "macos")]
pub use appkit::start;
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
/// second NUL after the last.
#[cfg(any(windows, test))]
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
let mut list = Vec::new();
for path in paths {
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
list.push(0);
}
list.push(0);
list
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_existing_absolute_files_and_folders() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a b ü.txt");
std::fs::write(&file, "x").unwrap();
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
}
#[test]
fn measures_max_path_in_utf16_units() {
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
assert!(fits_max_path(&path(259)));
assert!(!fits_max_path(&path(260)));
}
#[test]
fn lists_hdrop_files_double_nul_terminated() {
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
assert_eq!(list, expected);
}
#[test]
fn refuses_an_empty_drag() {
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
}
#[test]
fn refuses_relative_and_missing_paths() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a.txt");
std::fs::write(&file, "x").unwrap();
// One path that is not local fails the whole drag: none of it is half-copied.
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
}
}
}
-171
Переглянути файл
@@ -1,171 +0,0 @@
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
use super::{Outcome, hdrop_file_list};
use raw_window_handle::HasWindowHandle;
use std::io;
use std::os::windows::ffi::OsStrExt;
use std::path::PathBuf;
use windows::Win32::Foundation::{
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
OLE_E_ADVISENOTSUPPORTED, S_OK,
};
use windows::Win32::System::Com::{
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
};
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
use windows::Win32::System::Ole::{
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
OleUninitialize,
};
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
pub fn start<W: HasWindowHandle>(
_window: &W,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
// The window's event loop has initialised OLE on this thread already; this takes a
// reference that `OleUninitialize` gives back.
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
let outcome = drag(files);
unsafe { OleUninitialize() };
done(outcome.map_err(io::Error::other)?);
Ok(())
}
fn drag(files: Vec<u16>) -> Result<Outcome> {
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
// the source's data object) are kept by a plain shell data object.
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
let data: IDataObject = DataObject { files, inner }.into();
let source: IDropSource = DropSource.into();
let mut effect = DROPEFFECT_NONE;
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
error => Err(Error::from_hresult(error)),
}
}
#[implement(IDropSource)]
struct DropSource;
impl IDropSource_Impl for DropSource_Impl {
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
if escape_pressed.as_bool() {
DRAGDROP_S_CANCEL
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
DRAGDROP_S_DROP
} else {
S_OK
}
}
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
DRAGDROP_S_USEDEFAULTCURSORS
}
}
#[implement(IDataObject)]
struct DataObject {
/// The `DROPFILES` file list ([`hdrop_file_list`]).
files: Vec<u16>,
inner: IDataObject,
}
const HDROP: FORMATETC = FORMATETC {
cfFormat: CF_HDROP.0,
ptd: std::ptr::null_mut(),
dwAspect: DVASPECT_CONTENT.0,
lindex: -1,
tymed: TYMED_HGLOBAL.0 as u32,
};
fn is_hdrop(format: *const FORMATETC) -> bool {
unsafe { format.as_ref() }.is_some_and(|format| {
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
})
}
impl DataObject {
/// A new `DROPFILES` block; the receiver frees it.
fn hdrop(&self) -> Result<HGLOBAL> {
let header = size_of::<DROPFILES>();
let size = header + std::mem::size_of_val(self.files.as_slice());
unsafe {
let handle = GlobalAlloc(GHND, size)?;
let block = GlobalLock(handle).cast::<u8>();
if block.is_null() {
let error = Error::from_thread();
let _ = GlobalFree(Some(handle));
return Err(error);
}
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
pFiles: header as u32,
fWide: true.into(),
..Default::default()
});
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
// Fails with no error once the lock count is back to zero, which it is.
let _ = GlobalUnlock(handle);
Ok(handle)
}
}
}
impl IDataObject_Impl for DataObject_Impl {
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
if !is_hdrop(format) {
return unsafe { self.inner.GetData(format) };
}
Ok(STGMEDIUM {
tymed: TYMED_HGLOBAL.0 as u32,
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
pUnkForRelease: std::mem::ManuallyDrop::new(None),
})
}
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
if is_hdrop(format) {
return Err(DV_E_FORMATETC.into());
}
unsafe { self.inner.GetDataHere(format, medium) }
}
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
}
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
}
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
}
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
if direction != DATADIR_GET.0 as u32 {
return Err(E_NOTIMPL.into());
}
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
}
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
fn DUnadvise(&self, _connection: u32) -> Result<()> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
}
+1 -1
Переглянути файл
@@ -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.14.0";
pub const ENGINE_VERSION: &str = "1.13.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.
-1
Переглянути файл
@@ -98,7 +98,6 @@ 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()) {
+13 -39
Переглянути файл
@@ -69,10 +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: std::sync::Arc<trust::TrustStore>,
pub trust: trust::TrustStore,
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
pub config_dir: PathBuf,
/// Persistent user state, including credentials and recovery history.
@@ -127,16 +125,10 @@ 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. A project served without a window
/// has none.
/// Windows whose current project has this root.
pub(crate) fn windows_for_root(&self, root: &std::path::Path) -> Vec<String> {
let mut windows: Vec<_> = self
.projects
.read()
.iter()
.filter(|(w, p)| p.root == root && !mcp::BackgroundProjects::is_key(w))
.map(|(w, _)| w.clone())
.collect();
let mut windows: Vec<_> =
self.projects.read().iter().filter(|(_, p)| p.root == root).map(|(w, _)| w.clone()).collect();
windows.sort();
windows
}
@@ -167,9 +159,8 @@ impl Host {
mcp_reports: Default::default(),
mcp_requests: Default::default(),
mcp_agent_runs: Default::default(),
mcp_background: Default::default(),
agent_catalogs: Arc::default(),
trust: std::sync::Arc::new(trust::TrustStore::load(&config_dir, &data_dir)),
trust: trust::TrustStore::load(&config_dir, &data_dir),
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
proxy_password: ide_ssh::secrets::SecretFile::new(data_dir.join("proxy-password.json")),
proxy_session_password: Mutex::default(),
@@ -331,18 +322,9 @@ 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.
if !shared {
self.diagnostics.forget_root(&project.root);
}
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);
@@ -373,8 +355,7 @@ impl Host {
vec![project.notebooks.clone()],
project.kotlin_bridge.iter().cloned().collect(),
Some(project.lsp.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((self.debugger.clone(), window.to_owned(), project.root.clone())),
Some(project),
))
}
@@ -387,7 +368,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, Option<std::path::PathBuf>)>,
debug: Option<(Arc<ide_dap::DebugManager>, String, std::path::PathBuf)>,
retired: Option<Arc<Project>>,
) -> std::thread::JoinHandle<()> {
for bridge in &bridges {
@@ -414,9 +395,7 @@ impl Host {
}
if let Some((debug, key, root)) = debug {
debug.stop_key(&key).await;
if let Some(root) = root {
debug.stop_under(&root).await;
}
debug.stop_under(&root).await;
}
});
if let Some(retired) = retired {
@@ -435,22 +414,17 @@ impl Host {
}
fn wait_blocking(&self, shutdown: std::thread::JoinHandle<()>) {
Self::in_place(move || {
let wait = 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(work)
tokio::task::block_in_place(wait);
} else {
work()
wait();
}
}
-498
Переглянути файл
@@ -1,498 +0,0 @@
//! 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);
}
}
-229
Переглянути файл
@@ -1,229 +0,0 @@
//! 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"))
);
}
}
-792
Переглянути файл
@@ -1,792 +0,0 @@
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 -25
Переглянути файл
@@ -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, IdeError, IdeResult, Severity};
use ide_core::{Diagnostic, IdeResult, Severity};
use serde_json::{Map, Value, json};
/// Problems `get_project_problems` lists by default.
@@ -51,28 +51,7 @@ 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);
@@ -84,7 +63,6 @@ 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!({}),
@@ -107,7 +85,6 @@ 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()));
@@ -124,7 +101,6 @@ 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)?;
+7 -46
Переглянути файл
@@ -1,12 +1,10 @@
//! 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;
@@ -57,13 +55,12 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
}
impl Registry {
/// 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> {
fn target(&self, root: &Path) -> Result<(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(|(w, p)| !p.light && !BackgroundProjects::is_key(w));
let open = || projects.iter().filter(|(_, p)| !p.light);
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.
@@ -77,57 +74,23 @@ 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))
});
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())
windows.into_iter().next().ok_or_else(|| "project is no longer open".into())
}
}
impl ToolRegistry for Registry {
fn projects(&self) -> Vec<PathBuf> {
// 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()
};
let open: Vec<_> = self.0.projects().into_iter().filter(|p| !p.light).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 trusted = self.lists_as_trusted(root)?;
let (_, project) = self.target(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, trusted)).collect())
Ok(all.into_iter().filter(|t| allowed(t, project.is_trusted())).collect())
}
fn call(
&self,
@@ -146,9 +109,7 @@ impl ToolRegistry for Registry {
cancel: CancellationToken,
client: &str,
) -> Result<String, ToolCallError> {
// 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)?;
let (window, project) = 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()))
+3 -7
Переглянути файл
@@ -668,8 +668,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
if hits.len() > limit {
break;
}
// Find in Files reports a very long line in windows cut around its matches: such lines
// are matched again in the file's whole text, so a match keeps its real end.
// Find in Files keeps a window of very long lines and drops the matches outside it:
// such lines are matched again in the file's whole text.
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
let whole = if file.matches.iter().any(long) {
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
@@ -679,15 +679,11 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
} else {
None
};
// One window per far-apart match: a line is expanded once.
let mut expanded = std::collections::HashSet::new();
for m in &file.matches {
if let Some((ranges, text)) = &whole
&& long(m)
{
if expanded.insert(m.line) {
hits.extend(line_hits(path, text, ranges, m.line));
}
hits.extend(line_hits(path, text, ranges, m.line));
continue;
}
let line_end = m.text_offset + m.text.encode_utf16().count() as u32;
-33
Переглянути файл
@@ -1,7 +1,6 @@
//! 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};
@@ -11,7 +10,6 @@ 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)]
@@ -59,17 +57,6 @@ 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 {
@@ -260,24 +247,6 @@ 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);
@@ -320,10 +289,8 @@ 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,
);
+3 -7
Переглянути файл
@@ -176,9 +176,7 @@ 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: ask the user before reading anything else outside the project",
));
return Err(IdeError::invalid("path is outside the project's content roots"));
}
Ok(entry.map_or_else(|| real.clone(), |entry| PathBuf::from(format!("{}!/{entry}", real.display()))))
})
@@ -238,7 +236,7 @@ impl Tool {
destructive: false,
output_schema: None,
input_schema: json!({ "type": "object", "properties": {
"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." }
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
}, "required": [] }),
},
handler: Arc::new(move |call| Box::pin(handler(call))),
@@ -309,9 +307,7 @@ 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: these tools change files inside it only; ask the user before touching anything outside it",
));
return Err(IdeError::invalid("path is outside the project"));
}
if real
.strip_prefix(&root)
+9 -237
Переглянути файл
@@ -5,11 +5,10 @@ use crate::Host;
use crate::agent_secrets::{AgentSecrets, Kept};
use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
AgentPrompt, AgentProvider, AgentQueued, AgentSkillMode, AgentSkillPolicy, AgentSkillState, AgentTask,
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
McpServerInput, McpTransport, NewAgentTask, SkillsPolicy,
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput,
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
};
use ide_command::command;
use ide_core::error::ErrorKind;
@@ -18,28 +17,12 @@ use ide_tools::InstallEvent;
use std::collections::HashSet;
use std::sync::{LazyLock, Mutex};
/// Streams the project's agent events to `subscriber`, one of the project's windows (a remote
/// host sees them all as one `window`); returns every task.
/// Streams the project's agent events to this window; returns every task.
#[command(trust = always)]
pub fn agent_subscribe(
host: &Host,
window: &str,
on_event: Channel<AgentEvent>,
subscriber: String,
) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe_as(
&subscriber,
std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
}),
))
}
/// Stops the events of a window that closed.
#[command(trust = always)]
pub fn agent_unsubscribe(host: &Host, window: &str, subscriber: String) -> IdeResult<()> {
host.project(window)?.agents.unsubscribe(&subscriber);
Ok(())
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
})))
}
#[command(trust = trusted)]
@@ -50,16 +33,6 @@ pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider
Ok(providers)
}
/// Hermes Agent profiles on this machine (`default` first); empty without Hermes.
#[command(trust = trusted)]
pub async fn agent_hermes_profiles(host: &Host, window: &str) -> IdeResult<Vec<ide_agent::hermes::HermesProfile>> {
host.require_trust(window)?;
let root = ide_agent::hermes::root(dirs::home_dir().as_deref());
tokio::task::spawn_blocking(move || root.map(|r| ide_agent::hermes::labeled_profiles(&r)).unwrap_or_default())
.await
.map_err(join_err)
}
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
#[command(trust = trusted)]
pub fn agent_refresh_models(
@@ -360,50 +333,6 @@ pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32)
host.project(window)?.agents.rollback(&task, turns).await
}
/// Checks the selected installation without modifying it.
#[command(trust = trusted)]
pub async fn agent_cli_update_check(
host: &Host,
window: &str,
provider: String,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
cli_update(host, window, provider, None, request).await
}
/// Installs the exact version offered if the selected installation still matches.
#[command(trust = trusted)]
pub async fn agent_cli_update(
host: &Host,
window: &str,
provider: String,
offer: AgentCliOffer,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
cli_update(host, window, provider, Some(offer), request).await
}
async fn cli_update(
host: &Host,
window: &str,
provider: String,
offer: Option<AgentCliOffer>,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
host.require_trust(window)?;
let project = host.project(window)?;
let installing = offer.as_ref().map(|_| Installing::begin(&provider)).transpose()?;
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
let _installing = installing;
project.agents.cli_update(&provider, offer.as_ref(), &cancel)
})
.await
.map_err(join_err);
host.end_request(request);
result?
}
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
/// or sign-in run). Remembered until `refresh`.
#[command(trust = trusted)]
@@ -412,13 +341,6 @@ pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: b
host.project(window)?.agents.probe(&provider, refresh).await
}
/// Reads the running session's context categories without sending a prompt.
#[command(trust = trusted)]
pub async fn agent_context_usage(host: &Host, window: &str, task: String) -> IdeResult<AgentContextUsage> {
host.require_trust(window)?;
host.project(window)?.agents.context_usage(&task).await
}
/// Stops the task's current turn, or with `subagent` only that subagent's work.
#[command(trust = always)]
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
@@ -1029,148 +951,6 @@ pub fn agent_set_mcp_overrides(
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Updates per-session skill modes on `task`.
#[command(trust = always)]
pub fn agent_set_skill_overrides(
host: &Host,
window: &str,
task: String,
overrides: std::collections::BTreeMap<String, AgentSkillMode>,
) -> IdeResult<AgentTask> {
host.project(window)?.agents.set_skill_overrides(&task, overrides)
}
/// Every skill discovered in the project and the user's folders, with the mode a session
/// of this project runs it with (without any session's own overrides).
#[command(trust = always)]
pub async fn agent_skills_list(host: &Host, window: &str) -> IdeResult<Vec<AgentSkillState>> {
let project = host.project(window)?;
let root = project.root.clone();
let (policy, home) = (skills_policy(&project), dirs::home_dir());
tokio::task::spawn_blocking(move || {
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills(&root, home.as_deref()),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// Sets how `name` may run in `scope`, in the settings file of that scope, and returns the
/// updated list. `SKILL.md` files are never touched; the default `auto` removes the entry.
#[command(trust = always)]
pub fn agent_skills_set_mode(
host: &Host,
window: &str,
name: String,
scope: McpScope,
mode: AgentSkillMode,
) -> IdeResult<Vec<AgentSkillState>> {
let name = name.trim().to_owned();
if name.is_empty() {
return Err(IdeError::invalid("a skill needs a name"));
}
let project = host.project(window).ok().filter(|p| !p.light);
let (mut user, mut workspace) = skills_maps(host, project.as_ref());
match scope {
McpScope::User => {
let changed = if mode == AgentSkillMode::Auto {
user.remove(&name).is_some()
} else {
user.insert(name, AgentSkillPolicy { mode }).map(|p| p.mode) != Some(mode)
};
if changed {
persist_skills_map(host, None, scope, &user)?;
}
}
McpScope::Workspace => {
let map =
workspace.as_mut().ok_or_else(|| IdeError::invalid("Open a project to configure workspace skills"))?;
let changed = if mode == AgentSkillMode::Auto {
map.remove(&name).is_some()
} else {
map.insert(name, AgentSkillPolicy { mode }).map(|p| p.mode) != Some(mode)
};
if changed {
let map = map.clone();
persist_skills_map(host, project.as_ref(), scope, &map)?;
}
}
}
match project {
Some(project) => {
let root = project.root.clone();
let policy = skills_policy(&project);
let home = dirs::home_dir();
Ok(ide_agent::skills::resolve(
ide_agent::skills::discover_skills(&root, home.as_deref()),
None,
&policy.workspace,
&policy.user,
policy.workspace_trusted,
))
}
None => Ok(Vec::new()),
}
}
/// The user's and the workspace's skill policies (`[agents.skills.<name>]`).
fn skills_maps(
host: &Host,
project: Option<&std::sync::Arc<crate::Project>>,
) -> (std::collections::BTreeMap<String, AgentSkillPolicy>, Option<std::collections::BTreeMap<String, AgentSkillPolicy>>)
{
let user = host.global_settings.effective().agents.skills.clone();
let workspace =
project.map(|p| p.settings.layer(ide_workspace::settings::SettingsScope::Project).agents.skills.clone());
(user, workspace)
}
/// Saves `map` into its scope's settings and tells the windows.
fn persist_skills_map(
host: &Host,
project: Option<&std::sync::Arc<crate::Project>>,
scope: McpScope,
map: &std::collections::BTreeMap<String, AgentSkillPolicy>,
) -> IdeResult<()> {
let value = if map.is_empty() {
serde_json::Value::Null
} else {
serde_json::to_value(map).map_err(|e| IdeError::invalid(e.to_string()))?
};
let event = IdeEvent::SettingsChanged { key: "agents.skills".into() };
match scope {
McpScope::User => {
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.skills", value)?;
for p in host.projects() {
p.settings.reload();
p.agents.notify_mcp_servers_changed();
p.sink.emit(event.clone());
}
}
McpScope::Workspace => {
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace skills"))?;
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.skills", value)?;
p.agents.notify_mcp_servers_changed();
p.sink.emit(event);
}
}
Ok(())
}
/// The skill policies a session of `project` resolves against.
fn skills_policy(project: &crate::Project) -> SkillsPolicy {
SkillsPolicy {
user: project.settings.layer(ide_workspace::settings::SettingsScope::Global).agents.skills.clone(),
workspace: project.settings.layer(ide_workspace::settings::SettingsScope::Project).agents.skills.clone(),
workspace_trusted: project.trusted.load(std::sync::atomic::Ordering::Acquire),
}
}
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
let Some(requested) = requested else {
return Ok(root.to_path_buf());
@@ -1287,10 +1067,7 @@ ide_command::domain!(
agent_archive,
agent_base_text,
agent_cancel,
agent_context_usage,
agent_changes,
agent_cli_update,
agent_cli_update_check,
agent_commands,
agent_create,
agent_delete,
@@ -1298,7 +1075,6 @@ ide_command::domain!(
agent_external_sessions,
agent_fork,
agent_grouped_changes,
agent_hermes_profiles,
agent_import_session,
agent_mcp_discover_sources,
agent_mcp_import,
@@ -1326,12 +1102,8 @@ ide_command::domain!(
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
agent_set_skill_overrides,
agent_skills_list,
agent_skills_set_mode,
agent_stop_background,
agent_subscribe,
agent_unarchive,
agent_unqueue,
agent_unsubscribe,
);
+4 -25
Переглянути файл
@@ -1,7 +1,6 @@
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
//! `@given('…')` decorators) that could define steps, with their text. The UI
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
@@ -22,8 +21,6 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
/** What a Python step decorator starts with (behave also takes the capitalized names). */
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -41,14 +38,10 @@ fn is_feature(path: &Path) -> bool {
fn is_script(path: &Path) -> bool {
matches!(
path.extension().and_then(|e| e.to_str()),
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
)
}
fn is_python(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()) == Some("py")
}
/// The feature files and step definition files under `root`.
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
@@ -62,8 +55,7 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
if !feature && !calls.iter().any(|call| text.contains(call)) {
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
@@ -84,7 +76,6 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
let mut excludes = project.search_excludes();
// Cucumber's own sources (and every other package's) are not the project's steps.
excludes.push("node_modules".to_owned());
excludes.push("site-packages".to_owned());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
out.extend(sources_in(&root, &excludes));
@@ -113,23 +104,11 @@ mod tests {
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
.unwrap();
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
let files = sources_in(root, &["node_modules".to_owned()]);
let names: Vec<String> =
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
assert_eq!(
names,
[
"features/cart.feature",
"src/CartSteps.java",
"steps/bdd.mjs",
"steps/cart.steps.ts",
"steps/cart_steps.py"
]
);
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
assert!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
+21 -118
Переглянути файл
@@ -8,79 +8,30 @@ use crate::{Host, Project};
use ide_command::command;
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
use ide_build::maven::PomGoto;
use ide_build::maven::completion::{PomCompletion, PomCompletionOption};
use ide_build::maven::{PomGoto, PomManagedDeclaration, PomNavigationOptions};
use ide_build::pom_edit::{ArtifactKey, Exclusion};
use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
use ide_core::settings::Settings;
use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
use std::collections::HashMap;
use std::path::Path;
use std::sync::{Arc, Mutex, OnceLock};
use std::time::{Duration, Instant};
use std::sync::Arc;
fn join_err(e: tokio::task::JoinError) -> IdeError {
IdeError::internal(e.to_string())
}
/// POM gutters in several editors refresh together. A very short cache lets those
/// requests share one reactor scan without serving a stale module list after edits settle.
const MAVEN_MODULE_CACHE_TTL: Duration = Duration::from_millis(250);
type MavenModuleCache = HashMap<String, (Instant, Vec<ide_build::maven::ModulePom>)>;
static MAVEN_MODULES: OnceLock<Mutex<MavenModuleCache>> = OnceLock::new();
fn maven_modules(
project: &Project,
settings: &Settings,
options: &PomNavigationOptions,
) -> Vec<ide_build::maven::ModulePom> {
let key = format!(
"{}\0{:?}\0{:?}\0{:?}\0{:?}",
project.root.display(),
project.build_cache_dir(),
settings.languages.java.maven.linked_projects,
options.profiles,
options.jdk_version
);
let cache = MAVEN_MODULES.get_or_init(|| Mutex::new(HashMap::new()));
if let Some((_at, modules)) = cache.lock().ok().and_then(|mut cache| {
let fresh = cache.get(&key).filter(|(at, _)| at.elapsed() < MAVEN_MODULE_CACHE_TTL).cloned();
if fresh.is_none() {
cache.remove(&key);
}
fresh
}) {
return modules;
}
let model = load(&project.root, &project.build_cache_dir(), settings).maven.unwrap_or_default();
let modules = model
.projects
.into_iter()
.map(|p| ide_build::maven::ModulePom {
group_id: p.group_id,
artifact_id: p.artifact_id,
version: p.version,
pom: project.root.join(&p.pom),
})
.collect::<Vec<_>>();
if let Ok(mut cache) = cache.lock() {
cache.insert(key, (Instant::now(), modules.clone()));
}
modules
}
/// The build model with the launch settings applied: the JDK (`JAVA_HOME`), and
/// the Maven home and options from Settings › Maven.
pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
let jdk = ide_sdk::apply::project_jdk(root, settings);
let mut model = ide_build::load_linked_with_jdk(
let mut model = ide_build::load_linked(
root,
cache,
ide_sdk::apply::maven_local_repository(root, settings),
&settings.languages.java.maven,
&settings.languages.java.gradle,
ide_sdk::apply::maven_jdk(root, settings, None).map(|jdk| jdk.major),
);
let jdk = ide_sdk::apply::project_jdk(root, settings);
if let Some(m) = &mut model.maven {
let mvn = ide_sdk::apply::maven_command(root, settings);
let options = ide_sdk::apply::maven_options(root, settings);
@@ -126,23 +77,6 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
model
}
/// POM navigation follows the same profile choices as the last Maven sync and
/// resolves JDK-activated profiles with the project's selected Maven runtime.
fn pom_navigation_options(project: &Project, settings: &Settings) -> PomNavigationOptions {
let mut profiles = settings.languages.java.maven.profiles(&[]);
for profile in ide_build::maven_profiles(&project.build_cache_dir()) {
if !profiles.contains(&profile) {
profiles.push(profile);
}
}
PomNavigationOptions {
local_repo: ide_sdk::apply::maven_local_repository(&project.root, settings)
.or_else(ide_build::maven::default_local_repo),
profiles,
jdk_version: ide_sdk::apply::maven_jdk(&project.root, settings, None).map(|jdk| jdk.major),
}
}
/// Build and Run use the same selected toolchain and module-local runtime discovery.
fn prepare_plan(mut plan: compile::BuildPlan, root: &Path, settings: &Settings) -> compile::BuildPlan {
let kind = match plan.system {
@@ -613,9 +547,8 @@ pub async fn maven_dependency_declaration(
}
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
/// `${property}` at the caret, the parent POM, or the dependency / plugin's own POM
/// (a project module first, then the local repository). A dependency without a
/// resolvable artifact POM falls back to its management entry.
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
/// entry providing the dependency's / plugin's version, along the parent chain.
#[command(trust = trusted)]
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
@@ -628,55 +561,26 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
let text = project.text_of(&path)?;
let settings = project.settings.effective();
let options = pom_navigation_options(&project, &settings);
let module_options = options.clone();
let modules = || maven_modules(&project, &settings, &module_options);
Ok(ide_build::maven::goto_declaration_with(&text, &path, pos, options, modules))
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings)
.or_else(ide_build::maven::default_local_repo);
let modules = || {
let model = load(&project.root, &project.build_cache_dir(), &settings).maven.unwrap_or_default();
model
.projects
.into_iter()
.map(|p| ide_build::maven::ModulePom {
group_id: p.group_id,
artifact_id: p.artifact_id,
pom: project.root.join(&p.pom),
})
.collect()
};
Ok(ide_build::maven::goto_declaration_in(&text, &path, pos, repo, modules))
})
.await
.map_err(join_err)?
}
/// Gutter targets of the unversioned dependencies and plugins in a Maven POM:
/// the management declarations that actually supply their versions, including
/// parent POMs and imported BOMs. Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
pub async fn maven_managed_declarations(
host: &Host,
window: &str,
pom: String,
request: RequestId,
) -> IdeResult<Vec<PomManagedDeclaration>> {
let project = host.project(window)?;
let cancel = host.begin_project_read_request(window, request);
let result = tokio::task::spawn_blocking(move || {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let given = Path::new(&pom);
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
let text = project.text_of(&path)?;
let settings = project.settings.effective();
let options = pom_navigation_options(&project, &settings);
let cancelled = cancel.clone();
let module_options = options.clone();
let modules = || {
if cancelled.is_cancelled() {
return Vec::new();
}
maven_modules(&project, &settings, &module_options)
};
let declarations = ide_build::maven::managed_declarations_with(&text, &path, options, modules);
if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(declarations) }
})
.await;
host.end_request(request);
match result {
Ok(result) => result,
Err(error) => Err(join_err(error)),
}
}
/// How long completion waits for Maven Central before answering from the local repository.
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
@@ -1429,5 +1333,4 @@ ide_command::domain!(
maven_dependency_declaration,
maven_exclude_dependency,
maven_goto_declaration,
maven_managed_declarations,
);
+1 -18
Переглянути файл
@@ -32,12 +32,7 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
} else {
None
};
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 agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } 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"
@@ -216,12 +211,6 @@ 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).
@@ -342,11 +331,6 @@ pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i6
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_resolve_variable(host: &Host, session: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
host.debugger.resolve_variable(session, variable).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
@@ -839,7 +823,6 @@ ide_command::domain!(
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_resolve_variable,
debug_restart_frame,
debug_resume,
debug_run_to,
-8
Переглянути файл
@@ -70,13 +70,6 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
/// Load Changes from Disk: discards the buffer's unsaved changes and reads its file again.
#[command(trust = always)]
pub async fn doc_reload_from_disk(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.discard_and_reload(doc)).await
}
/// An automatic save: `false` (nothing written) when the file changed on disk after the
/// buffer was edited, which only an explicit save overwrites.
#[command(trust = always)]
@@ -127,7 +120,6 @@ ide_command::domain!(
doc_edit,
doc_open,
doc_open_untitled,
doc_reload_from_disk,
doc_save,
doc_autosave,
doc_save_all,
+3 -6
Переглянути файл
@@ -85,7 +85,7 @@ pub async fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_end
}
/// Structure view: LSP document symbols when available (with tree-sitter
/// visibility and type-alias kinds), tree-sitter otherwise.
/// visibility), tree-sitter otherwise.
/// Tree-sitter answers come from the per-document tree cache (incremental
/// re-parse); large documents get no syntax structure.
#[command(trust = always)]
@@ -113,13 +113,10 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
};
let syntax = || project.syntax.outline(doc, &snap.language, snap.version, &snap.text);
Ok(match lsp {
// Server symbols carry no visibility, nor a kind for type aliases; borrow them from
// the syntax tree.
// Server symbols carry no visibility; borrow it from the syntax tree.
Some(mut items) => {
if !snap.large {
let syntax = syntax();
ide_language::merge_visibility(&mut items, &syntax);
ide_language::merge_kinds(&mut items, &syntax);
ide_language::merge_visibility(&mut items, &syntax());
}
items
}
+3 -5
Переглянути файл
@@ -1,6 +1,6 @@
use super::*;
use crate::{HostConfig, Project};
use ide_core::{IdeEvent, TextChange};
use ide_core::{IdeEvent, TextChange, event::NotifyLevel};
use parking_lot::Mutex;
use std::{path::Path, sync::Arc};
@@ -57,9 +57,7 @@ impl Fixture {
self.events
.lock()
.iter()
.filter(|e| {
matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::DocDiskConflict { .. })
})
.filter(|e| matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::Notify { .. }))
.cloned()
.collect()
}
@@ -112,7 +110,7 @@ async fn dirty_document_keeps_edits_and_warns_once() {
let loaded = f.project.documents.snapshot(original.id).unwrap();
assert_eq!(loaded.text, "local original\n");
assert!(loaded.dirty);
assert!(matches!(f.document_events().as_slice(), [IdeEvent::DocDiskConflict { .. }]));
assert!(matches!(f.document_events().as_slice(), [IdeEvent::Notify { level: NotifyLevel::Warning, .. }]));
f.events.lock().clear();
f.sync().await;
assert!(f.document_events().is_empty());
+2 -9
Переглянути файл
@@ -1976,7 +1976,6 @@ 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> {
@@ -1990,20 +1989,14 @@ 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![],
hover_actions: vec![],
};
let mut out =
PluginLanguageVisuals { version: d.version, injections: vec![], colors: vec![], gutter_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,
-6
Переглянути файл
@@ -335,12 +335,6 @@ pub fn set_settings(
project.agents.notify_mcp_servers_changed();
}
}
// A skill policy change re-resolves the modes; an idle session restarts to pick them up.
if key == "agents" || key == "agents.skills" || key.starts_with("agents.skills.") {
for project in affected() {
project.agents.notify_mcp_servers_changed();
}
}
// A new interpreter / toolchain / server executable restarts the language servers it affects.
// So do inspections that are compiler options (`ide-sdk` `configure_java_compiler`).
let code_style = key == "editor"
+1 -2
Переглянути файл
@@ -542,8 +542,7 @@ fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local:
if !ide_run::java_agent::applies(&config.kind) {
return;
}
let java = std::path::Path::new(&config.command);
let agents = ide_run::java_agent::current_for(Some(java));
let agents = ide_run::java_agent::current();
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
if !local {
if !agents.options.is_empty() {
+21 -31
Переглянути файл
@@ -122,38 +122,28 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
/// The interpreter the project uses: the configured one, else its virtualenv.
#[command(trust = trusted)]
pub async fn sdk_python_effective(
host: &Host,
window: &str,
near: Option<PathBuf>,
) -> IdeResult<Option<ide_core::IpcPath>> {
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
host.require_trust(window)?;
let project = host.project(window)?;
let (config_dir, project_root) = (host.config_dir.clone(), project.root.clone());
// Loading a member's settings needs more stack than a sync command's main thread has left.
tokio::task::spawn_blocking(move || {
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
let near = near.as_deref()?;
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
});
let (root, settings) = match member {
Some(root) => {
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
(root, settings)
}
None => (project_root.clone(), project.settings.effective()),
};
// A member with no Python of its own falls back to the primary project's
// (the same chain run configurations use), so every answer names one interpreter.
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
(root != project_root)
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
.flatten()
});
Ok(interpreter.map(Into::into))
})
.await
.map_err(join_err)?
let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|w| {
let near = near.as_deref()?;
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
});
let (root, settings) = match member {
Some(root) => {
let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
(root, settings)
}
None => (project.root.clone(), project.settings.effective()),
};
// A member with no Python of its own falls back to the primary project's
// (the same chain run configurations use), so every answer names one interpreter.
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
(root != project.root)
.then(|| ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()))
.flatten()
});
Ok(interpreter.map(Into::into))
}
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
@@ -471,7 +461,7 @@ mod tests {
host.open_project("main", &root).unwrap();
let detected = sdk_detect(&host, "main", SdkKind::Python).await.unwrap();
assert!(detected.iter().any(|s| s.path == sdk.path && s.name == sdk.name));
assert_eq!(sdk_python_effective(&host, "main", None).await.unwrap(), Some(sdk.path));
assert_eq!(sdk_python_effective(&host, "main", None).unwrap(), Some(sdk.path));
assert!(sdk_python_interpreter(&host, "main", root.join("README.md")).await.unwrap().is_none());
host.close_project("main");
}
+4 -12
Переглянути файл
@@ -22,17 +22,6 @@ pub fn literal_range(l: ide_language::Literal) -> ide_search::LiteralRange {
ide_search::LiteralRange { start: l.start, end: l.end, kind }
}
/// Comments and string literals of `text`, for the search context of Find and Replace in Files.
pub(crate) fn literals_of(
project: &crate::project::Project,
syntax: &ide_language::Syntax,
path: &Path,
text: &str,
) -> Option<Vec<ide_search::LiteralRange>> {
let language = project.languages.detect(path, text.lines().next());
Some(syntax.literals(&language, text)?.into_iter().map(literal_range).collect())
}
/// Find in Files. Results stream through `on_event`; ends with `Done`.
/// Cancel with `cancel_request(request)`.
#[command(trust = always)]
@@ -109,7 +98,10 @@ pub(crate) fn search_project(
Some(ProjectFileSet::Test) => roots.is_test(rel),
_ => true,
};
let literals = |path: &Path, text: &str| literals_of(project, syntax, path, text);
let literals = |path: &Path, text: &str| {
let language = project.languages.detect(path, text.lines().next());
Some(syntax.literals(&language, text)?.into_iter().map(literal_range).collect())
};
let defaults = project.documents.file_defaults();
let decode = |path: &Path, bytes: &[u8]| ide_vfs::decode_text(bytes, defaults.fallback_for(path));
let mut total = SearchSummary::default();
+3 -13
Переглянути файл
@@ -75,19 +75,9 @@ pub async fn replace_in_files(
let summary = tokio::task::spawn_blocking(move || {
let targets = if all_in_scope { scope_targets(&project, &syntax, &query, targets, &cancel)? } else { targets };
let host = DocumentsHost(&project.documents);
let literals = |path: &Path, text: &str| super::literals_of(&project, &syntax, path, text);
ide_search::replace_files_in_context(
&host,
&query,
&replacement,
preserve_case,
&targets,
Some(&literals),
&cancel,
&|e| {
let _ = events.send(e);
},
)
ide_search::replace_files(&host, &query, &replacement, preserve_case, &targets, &cancel, &|e| {
let _ = events.send(e);
})
})
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()));
+1 -7
Переглянути файл
@@ -633,14 +633,8 @@ pub async fn vcs_add_to_ignore(
host.require_trust(window)?;
let project = host.project(window)?;
blocking(move || {
// The Changes view lists every repository of the window (the project's and the
// attached ones'): a path inside the project folder, or in any of those repositories.
// The folder check stays so a request right after opening, before the repositories
// are discovered, still works.
let repos = project.repos();
for path in &paths {
let in_project = path != &project.root && path.starts_with(&project.root);
if !in_project && repos.for_path(path).is_none() {
if path == &project.root || !path.starts_with(&project.root) {
return Err(ide_core::IdeError::invalid("Ignore selection is outside the project"));
}
}
-79
Переглянути файл
@@ -3,7 +3,6 @@
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;
@@ -52,8 +51,6 @@ 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 {
@@ -74,7 +71,6 @@ impl Phpstan {
queue: Mutex::new(Queue::default()),
changed: Notify::new(),
shown: Mutex::new(HashSet::new()),
edited: Mutex::new(HashSet::new()),
})
}
@@ -100,12 +96,6 @@ 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();
}
@@ -215,10 +205,6 @@ 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);
@@ -260,23 +246,6 @@ 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 {
@@ -878,52 +847,4 @@ 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();
}
}
+6 -45
Переглянути файл
@@ -406,16 +406,15 @@ impl Proc {
}
}
/// What it printed since the last call, each stream at most `max` bytes. The status
/// comes with the last chunk only: once it ended, its pipes reached the end and
/// nothing is left to read, so a caller can stop at the first chunk that has one.
/// What it printed since the last call, each stream at most `max` bytes.
fn chunk(&self, max: usize) -> ProcessChunk {
let mut state = self.state.lock();
let eof = state.readers == 0;
let stdout = take_text(&mut state.stdout, max, eof);
let stderr = take_text(&mut state.stderr, max, eof);
let drained = eof && state.stdout.is_empty() && state.stderr.is_empty();
ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) }
ProcessChunk {
stdout: take_text(&mut state.stdout, max, eof),
stderr: take_text(&mut state.stderr, max, eof),
status: state.status,
}
}
}
@@ -2117,23 +2116,6 @@ 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();
@@ -4127,27 +4109,6 @@ mod tests {
api.release_process(id);
}
#[cfg(unix)]
#[test]
fn the_status_comes_with_the_last_of_the_output() {
let tmp = tempfile::tempdir().unwrap();
let api = shell_api(tmp.path());
let token = CancellationToken::new();
let id = api.start_process(shell("printf 'abcdefghij'; printf 'xyz' >&2"), None, None).unwrap();
let first = api.wait_process(id, 4, Duration::from_secs(5), &token).unwrap();
assert_eq!((first.stdout.as_str(), first.stderr.as_str(), first.status), ("abcd", "xyz", None));
let mut stdout = first.stdout;
let status = loop {
let chunk = api.poll_process(id, 4).unwrap();
stdout.push_str(&chunk.stdout);
if let Some(status) = chunk.status {
break status;
}
};
assert_eq!((stdout.as_str(), status), ("abcdefghij", 0));
api.release_process(id);
}
#[test]
fn programs_run_only_as_approved() {
let tmp = tempfile::tempdir().unwrap();
+7 -125
Переглянути файл
@@ -1,13 +1,10 @@
//! 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.
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
//! JVM of Application, Spring Boot and JAR Application configurations.
//!
//! ```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`
@@ -26,8 +23,6 @@ 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)]
@@ -35,10 +30,6 @@ 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)]
@@ -46,8 +37,6 @@ 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.
@@ -106,65 +95,20 @@ impl ExtensionPoint for JavaAgentsPoint {
{
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
}
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 label = label(&d.path, args.as_deref());
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
let agent = Agent { jar, args, vm_options, jdk };
let agent = Agent { jar, args };
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
}
}
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 {
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
fn label(path: &Path, args: Option<&str>) -> String {
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
let mut out = match args {
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:
@@ -191,16 +135,6 @@ 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.
@@ -221,8 +155,6 @@ 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()
@@ -235,8 +167,6 @@ 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();
@@ -279,33 +209,12 @@ 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();
@@ -333,33 +242,6 @@ 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");
-28
Переглянути файл
@@ -276,34 +276,6 @@ 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) {
-18
Переглянути файл
@@ -925,7 +925,6 @@ 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| {
@@ -3086,7 +3085,6 @@ 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
@@ -3120,8 +3118,6 @@ 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,
}
}),
@@ -3161,20 +3157,6 @@ 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:
-5
Переглянути файл
@@ -54,7 +54,6 @@ pub enum ProviderKind {
Implementation,
TypeDefinition,
GutterActions,
HoverActions,
Injections,
}
@@ -205,15 +204,11 @@ 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()
-4
Переглянути файл
@@ -63,10 +63,6 @@ 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,
}
-16
Переглянути файл
@@ -106,9 +106,6 @@ 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);
@@ -738,19 +735,6 @@ impl Host {
let approvals = self.mcp_approvals.clone();
let secrets = self.agent_secrets.clone();
let root = root.to_path_buf();
// The skill policies sessions resolve against: both settings layers and the
// workspace's trust as it stands when a session starts.
let skill_settings = settings.clone();
let skill_root = root.clone();
let trust = self.trust.clone();
agents.set_skills_policy_hook(Box::new(move || {
let layer = |scope| skill_settings.layer(scope).agents.skills.clone();
ide_agent::SkillsPolicy {
user: layer(ide_workspace::settings::SettingsScope::Global),
workspace: layer(ide_workspace::settings::SettingsScope::Project),
workspace_trusted: trust.trusted(&skill_root).unwrap_or(false),
}
}));
agents.set_mcp_servers_hook(Box::new(move || {
crate::ops::agent::session_mcp_servers(&settings, &approvals, &secrets, &root)
}));
-3
Переглянути файл
@@ -177,7 +177,6 @@ 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 { .. }
@@ -191,7 +190,6 @@ pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
| IdeEvent::ExcludedDirsChanged { .. }
| IdeEvent::DocPatched { .. }
| IdeEvent::DocDirty { .. }
| IdeEvent::DocDiskConflict { .. }
| IdeEvent::WorkspaceEditApplied { .. }
| IdeEvent::DocLanguage { .. }
| IdeEvent::Diagnostics { .. }
@@ -325,7 +323,6 @@ mod tests {
},
IdeEvent::WindowGroupsChanged,
IdeEvent::WindowFullscreenChanged,
IdeEvent::McpBackgroundProjectsChanged,
] {
assert!(!client_accepts(&event, true), "{event:?}");
}
-6
Переглянути файл
@@ -244,9 +244,6 @@ 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();
@@ -308,9 +305,6 @@ 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 -1
Переглянути файл
@@ -161,7 +161,7 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
assert!(ops::sdk::sdk_python_effective(&host, "main", None).await.is_err());
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
assert!(error.message.contains("Restricted Mode"));
+1 -297
Переглянути файл
@@ -1,5 +1,5 @@
use ide_core::{CancellationToken, ChangeSet, Diagnostic, IdeEvent, Pos, Range, Severity, TextChange};
use ide_host::mcp::{BackgroundProjects, FileProblems, FocusedEditor, Registry};
use ide_host::mcp::{FileProblems, FocusedEditor, Registry};
use ide_host::{Host, HostConfig};
use ide_mcp::ToolRegistry;
use serde_json::{Value, json};
@@ -83,65 +83,14 @@ 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();
@@ -187,19 +136,6 @@ async fn reads_unsaved_text_and_searches_the_overlay_with_a_limit() {
assert_eq!(std::fs::read_to_string(h.root.join("src/a.txt")).unwrap(), "old text\nneedle needle\n");
}
#[tokio::test(flavor = "multi_thread")]
async fn every_match_of_a_long_line_is_found_once() {
let h = Harness::new();
std::fs::write(
h.root.join("src/min.js"),
format!("a=1;{}b='longneedle';{}longneedle\n", "x".repeat(2000), "y".repeat(2000)),
)
.unwrap();
let found = h.json("search_text", json!({"q":"longneedle","limit":20})).await;
let columns: Vec<_> = found["items"].as_array().unwrap().iter().map(|i| i["startColumn"].clone()).collect();
assert_eq!(columns, [json!(2008), json!(4020)], "{found}");
}
#[tokio::test(flavor = "multi_thread")]
async fn window_reports_supply_editor_selection_and_problems_then_disappear_on_close() {
let h = Harness::new();
@@ -1364,235 +1300,3 @@ 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");
}
-35
Переглянути файл
@@ -193,41 +193,6 @@ 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();
-3
Переглянути файл
@@ -152,9 +152,6 @@ 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
-28
Переглянути файл
@@ -2218,8 +2218,6 @@ 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 = || {
@@ -6386,32 +6384,6 @@ 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()));
+1 -1
Переглянути файл
@@ -351,7 +351,7 @@ async fn python_venv() {
// The project's virtualenv: listed first, and the interpreter the project uses.
let found = ops::sdk::sdk_detect(&p.host, WINDOW, ide_sdk::SdkKind::Python).await.unwrap();
assert_eq!(found.first().map(|s| s.source.as_str()), Some("venv"), "{found:?}");
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).await.unwrap().expect("an interpreter");
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).unwrap().expect("an interpreter");
assert!(effective.starts_with(p.root.join(".venv")), "{effective:?}");
}
-53
Переглянути файл
@@ -195,56 +195,3 @@ async fn replace_all_saves_open_buffers_without_unsaved_changes() {
assert_eq!(project.documents.text_snapshot(edited).unwrap().text, "DONE\nmore\n");
host.close_project("main");
}
/// Replace All past the limit replaces what the search lists: only the matches its Search
/// Context keeps (comments, string literals or code), as below the limit.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn replace_all_past_the_limit_keeps_to_the_search_context() {
use ide_search::SearchContext as C;
let comments = |word: &str| lines(2001, &format!("// {word}"));
let code = |name: &str, string: &str| format!("fn {name}() -> &'static str {{ \"{string}\" }}\n");
let original = format!("{}{}", comments("tok"), code("tok", "tok"));
let cases = [
(C::Any, format!("{}{}", comments("X"), code("X", "X"))),
(C::InComments, format!("{}{}", comments("X"), code("tok", "tok"))),
(C::InStringLiterals, format!("{}{}", comments("tok"), code("tok", "X"))),
(C::ExceptComments, format!("{}{}", comments("tok"), code("X", "X"))),
(C::ExceptStringLiterals, format!("{}{}", comments("X"), code("X", "tok"))),
(C::ExceptCommentsAndStringLiterals, format!("{}{}", comments("tok"), code("X", "tok"))),
];
for (context, expected) in cases {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("lib.rs"), &original).unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
ops::search::replace_in_files(
&host,
"main",
RequestId::next(),
SearchQuery { context, ..query("tok", false) },
"X".into(),
false,
vec![],
true,
ops::Channel::new(|_| {}),
)
.await
.unwrap();
assert_eq!(std::fs::read_to_string(root.join("lib.rs")).unwrap(), expected, "{context:?}");
host.close_project("main");
}
}
-73
Переглянути файл
@@ -21,7 +21,6 @@ async fn patches_read_and_write_the_requested_repository() {
git(root, &["init", "-b", "main"]);
git(root, &["config", "user.name", "Test"]);
git(root, &["config", "user.email", "[email protected]"]);
git(root, &["config", "core.autocrlf", "false"]);
std::fs::write(root.join("same.txt"), format!("root {i}\n")).unwrap();
git(root, &["add", "."]);
git(root, &["commit", "-m", "initial"]);
@@ -66,75 +65,3 @@ async fn patches_read_and_write_the_requested_repository() {
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
host.close_project("main");
}
/// The Changes view also lists attached projects' repositories, and their untracked files
/// offer Add to .gitignore / .git/info/exclude: the guard must follow the window's
/// repository set, not the project folder alone.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn add_to_ignore_accepts_the_repositories_of_attached_projects() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let project_root = base.join("project");
let attached_root = base.join("attached");
for root in [&project_root, &attached_root] {
std::fs::create_dir_all(root).unwrap();
git(root, &["init", "-b", "main"]);
git(root, &["config", "user.name", "Test"]);
git(root, &["config", "user.email", "[email protected]"]);
git(root, &["config", "core.autocrlf", "false"]);
std::fs::write(root.join("tracked.txt"), "x\n").unwrap();
git(root, &["add", "."]);
git(root, &["commit", "-m", "initial"]);
}
// Untracked files, one per repository; the attached one is what failed.
let own = project_root.join("own.ignore-me");
let attached = attached_root.join("attached.ignore-me");
std::fs::write(&own, "x").unwrap();
std::fs::write(&attached, "x").unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.trust.decide(&project_root, true, false).unwrap();
host.trust.decide(&attached_root, true, false).unwrap();
let project = host.open_project("main", &project_root).unwrap();
ide_host::ops::project::attach_workspace(&host, "main", &attached_root).unwrap();
for _ in 0..500 {
if project.repos().all().len() == 2 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(project.repos().all().len(), 2);
vcs::vcs_add_to_ignore(&host, "main", vec![attached.clone()], ide_vcs::IgnoreDestination::Gitignore).await.unwrap();
assert!(
std::fs::read_to_string(attached_root.join(".gitignore")).unwrap().contains("/attached.ignore-me"),
"the attached repository's .gitignore did not receive the rule"
);
vcs::vcs_add_to_ignore(&host, "main", vec![own.clone()], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();
assert!(
std::fs::read_to_string(project_root.join(".git/info/exclude")).unwrap().contains("/own.ignore-me"),
"the project repository's exclude did not receive the rule"
);
// A repository of an unattached sibling folder stays outside.
let sibling_root = base.join("sibling");
std::fs::create_dir_all(&sibling_root).unwrap();
git(&sibling_root, &["init", "-b", "main"]);
let sibling = sibling_root.join("sibling.ignore-me");
std::fs::write(&sibling, "x").unwrap();
let error =
vcs::vcs_add_to_ignore(&host, "main", vec![sibling], ide_vcs::IgnoreDestination::Gitignore).await.unwrap_err();
assert!(error.message.contains("outside the project"), "{error:?}");
assert!(!sibling_root.join(".gitignore").exists());
host.close_project("main");
}
+1 -10
Переглянути файл
@@ -199,9 +199,7 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
host.trust.decide(&member, true, false).unwrap();
host.open_project("main", &primary).unwrap();
let python = |near: Option<&std::path::Path>| {
futures::executor::block_on(ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())))
.unwrap()
.map(|p| p.into_path_buf())
ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())).unwrap().map(|p| p.into_path_buf())
};
// The primary project's own virtualenv, and the bare member inheriting it.
assert_eq!(python(Some(&primary)), Some(venv_python.clone()));
@@ -219,13 +217,6 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
)
.unwrap();
assert_eq!(python(Some(&member.join("src"))), Some(configured));
// A workspace file that fails to load (a corrupt one, say) falls back to the
// primary project's interpreter instead of failing the whole command.
let workspace_file = primary.join(ide_workspace::workspace::FILE);
let valid = std::fs::read(&workspace_file).unwrap();
std::fs::write(&workspace_file, b"{not json").unwrap();
assert_eq!(python(Some(&member.join("src"))), Some(venv_python.clone()));
std::fs::write(&workspace_file, valid).unwrap();
host.close_project("main");
}
-2
Переглянути файл
@@ -15,8 +15,6 @@ tokio.workspace = true
tracing.workspace = true
parking_lot.workspace = true
reqwest.workspace = true
# The system proxy reqwest reads, to notice when it changes (see `client::shared`).
hyper-util = { version = "0.1", default-features = false, features = ["client-proxy", "client-proxy-system"] }
rustls.workspace = true
rustls-platform-verifier.workspace = true
uuid.workspace = true
+7 -80
Переглянути файл
@@ -5,7 +5,7 @@ use ide_core::proxy_settings::{ProxyMode, ProxyRoute, ProxySettings};
use ide_core::{CancellationToken, IdeError, IdeResult};
use parking_lot::Mutex;
use std::sync::Arc;
use std::time::{Duration, Instant};
use std::time::Duration;
/// `builder` routed as `proxy` says: direct, the environment's proxy (reqwest's
/// default), or the manual proxy except for the "No proxy for" hosts.
@@ -62,61 +62,18 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
with_proxy(builder, proxy).build().map_err(|e| fail(e.to_string()))
}
/// A client built for these proxy settings and, in Auto mode, this system proxy.
struct Cached {
settings: Arc<ProxySettings>,
system: Option<String>,
client: reqwest::Client,
}
/// The client for the current proxy settings, rebuilt when they change.
pub fn shared() -> IdeResult<reqwest::Client> {
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
cached_client(&CLIENT, build, system_proxy)
}
/// The client the HTTP Client executes requests with: redirects off, `exec`
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
/// 301/302 and puts the redirect chain into the response.
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()), system_proxy)
}
/// The system proxy (the environment's, then macOS / Windows settings) as reqwest reads
/// it when a client is built, re-read at most every few seconds. A client in Auto mode
/// keeps the proxy it was built with, so a proxy app that switches the system proxy on
/// after launch would otherwise leave downloads going direct until a restart.
fn system_proxy() -> String {
static LAST: Mutex<Option<(Instant, String)>> = Mutex::new(None);
let mut last = LAST.lock();
if let Some((at, seen)) = last.as_ref()
&& at.elapsed() < Duration::from_secs(3)
{
return seen.clone();
}
// Credentials are left out of the matcher's `Debug`.
let seen = format!("{:?}", hyper_util::client::proxy::matcher::Matcher::from_system());
*last = Some((Instant::now(), seen.clone()));
seen
}
fn cached_client(
slot: &Mutex<Option<Cached>>,
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
system: fn() -> String,
) -> IdeResult<reqwest::Client> {
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
let proxy = ide_core::proxy_settings::proxy();
let system = (proxy.mode == ProxyMode::Auto).then(system);
let mut cached = slot.lock();
if let Some(c) = cached.as_ref()
&& *c.settings == *proxy
&& c.system == system
let mut cached = CLIENT.lock();
if let Some((settings, client)) = cached.as_ref()
&& **settings == *proxy
{
return Ok(c.client.clone());
return Ok(client.clone());
}
let client = build(&proxy)?;
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
*cached = Some((proxy, client.clone()));
Ok(client)
}
@@ -170,36 +127,6 @@ pub fn describe(e: &reqwest::Error) -> String {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
static SYSTEM: Mutex<String> = Mutex::new(String::new());
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
fn system() -> String {
SYSTEM.lock().clone()
}
let slot = Mutex::new(None);
let get = || {
cached_client(
&slot,
|proxy| {
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
build(proxy)
},
system,
)
.unwrap()
};
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
get();
get();
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
// A proxy app switches the system proxy on after launch.
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
get();
get();
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
}
use ide_core::proxy_settings::ProxyKind;
use std::io::{BufRead, BufReader, Write};
use std::net::TcpListener;
+15 -288
Переглянути файл
@@ -13,19 +13,6 @@ use std::time::Instant;
/// Bodies above this are cut (the full size is still reported).
pub const MAX_BODY: usize = 16 * 1024 * 1024;
/// Redirects followed per request; beyond this the redirect response itself is
/// returned (IntelliJ's HTTP Client follows the same number).
pub const MAX_REDIRECTS: usize = 50;
/// Responses whose `Location` is followed: 301, 302, 303, 307 and 308, the set
/// IntelliJ's HTTP Client redirects on.
const REDIRECT_STATUSES: [u16; 5] = [301, 302, 303, 307, 308];
/// Request headers not re-sent to a redirect on another host. IntelliJ's HTTP
/// Client strips the same set and restores it when the redirect stays on the
/// original host.
const SENSITIVE_HEADERS: [&str; 5] = ["authorization", "cookie", "cookie2", "www-authenticate", "proxy-authorization"];
/// A request ready to send: variables substituted, includes read.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -37,15 +24,6 @@ pub struct PreparedRequest {
pub body: Option<String>,
}
/// One followed redirect: the response and the `Location` it pointed to.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RedirectHop {
pub status: u16,
pub status_text: String,
pub location: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct HttpResponse {
@@ -54,9 +32,6 @@ pub struct HttpResponse {
pub version: String,
pub headers: Vec<(String, String)>,
pub content_type: Option<String>,
/// Followed redirects, first hop first; empty when not redirected.
#[serde(default)]
pub redirects: Vec<RedirectHop>,
/// Body as text (lossy UTF-8); `None` for binary bodies.
pub body: Option<String>,
/// Size in bytes as received (after decompression).
@@ -153,84 +128,25 @@ fn looks_textual(content_type: Option<&str>, bytes: &[u8]) -> bool {
}
}
/// The request for one hop: `req`'s headers and body against `url`, the
/// sensitive headers dropped when the redirect crosses to another host.
fn request_to(
client: &reqwest::Client,
method: &reqwest::Method,
req: &PreparedRequest,
body: Option<&str>,
original: &reqwest::Url,
url: &reqwest::Url,
) -> IdeResult<reqwest::Request> {
let same_host = url.host_str() == original.host_str();
let mut builder = client.request(method.clone(), url.clone());
for (k, v) in &req.headers {
if same_host || !SENSITIVE_HEADERS.iter().any(|s| k.eq_ignore_ascii_case(s)) {
builder = builder.header(k, v);
}
}
if let Some(body) = body {
builder = builder.body(body.to_owned());
}
builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))
}
/// Sends `request`; cancelled when `cancel` fires.
async fn send(
client: &reqwest::Client,
request: reqwest::Request,
cancel: &CancellationToken,
) -> IdeResult<reqwest::Response> {
let send = client.execute(request);
tokio::select! {
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e))),
() = cancel.cancelled() => Err(IdeError::cancelled()),
}
}
/// Sends `req`, following redirects the way IntelliJ's HTTP Client does:
/// 301, 302, 303, 307 and 308 up to [`MAX_REDIRECTS`] times, `303` continuing
/// as `GET` without the body, the other statuses keeping the method and body —
/// so a `POST` redirected to `https` on the same host is re-sent as a `POST`.
/// Sensitive headers (Authorization, cookies, proxy credentials) are not
/// re-sent across hosts. The followed hops are reported in the response.
/// Cancelled when `cancel` fires.
/// Sends `req`; cancelled when `cancel` fires.
pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeResult<HttpResponse> {
let client = crate::client::shared_without_redirects()?;
let client = crate::client::shared()?;
let method = reqwest::Method::from_bytes(req.method.as_bytes())
.map_err(|_| IdeError::invalid(format!("invalid method {}", req.method)))?;
let original = req.url.parse::<reqwest::Url>().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
let mut url = original.clone();
let mut method = method;
let mut body = req.body.clone();
let mut redirects = Vec::new();
let started = Instant::now();
let mut response;
loop {
let request = request_to(&client, &method, req, body.as_deref(), &original, &url)?;
response = send(&client, request, cancel).await?;
let status = response.status();
if redirects.len() >= MAX_REDIRECTS || !REDIRECT_STATUSES.contains(&status.as_u16()) {
break;
}
let next = response
.headers()
.get(reqwest::header::LOCATION)
.and_then(|v| v.to_str().ok())
.and_then(|location| url.join(location).ok());
let Some(next) = next else { break };
redirects.push(RedirectHop {
status: status.as_u16(),
status_text: status.canonical_reason().unwrap_or("").to_owned(),
location: next.to_string(),
});
if status == reqwest::StatusCode::SEE_OTHER {
method = reqwest::Method::GET;
body = None;
}
url = next;
let mut builder = client.request(method, &req.url);
for (k, v) in &req.headers {
builder = builder.header(k, v);
}
if let Some(body) = &req.body {
builder = builder.body(body.clone());
}
let request = builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
let started = Instant::now();
let send = client.execute(request);
let mut response = tokio::select! {
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e)))?,
() = cancel.cancelled() => return Err(IdeError::cancelled()),
};
let ttfb = started.elapsed();
let status = response.status();
let version = format!("{:?}", response.version());
@@ -263,7 +179,6 @@ pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeRe
version,
headers,
content_type,
redirects,
body,
size: size as f64,
truncated: size > bytes.len(),
@@ -334,47 +249,6 @@ mod tests {
assert_eq!(url("GET https://api.test/cb?u=http://x\n"), "https://api.test/cb?u=http://x");
}
/// A loopback server answering each accepted connection with the next of
/// `responses`, returning every request as its head and body.
async fn scripted(responses: Vec<String>) -> (u16, tokio::task::JoinHandle<Vec<(String, String)>>) {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let handle = tokio::spawn(async move {
let mut seen = Vec::new();
for response in responses {
let (mut socket, _) = listener.accept().await.unwrap();
let mut request = Vec::new();
let (head, body) = loop {
let mut buffer = [0u8; 4096];
let read = socket.read(&mut buffer).await.unwrap();
assert!(read > 0, "request ended before its body");
request.extend_from_slice(&buffer[..read]);
let Some(end) = request.windows(4).position(|w| w == b"\r\n\r\n") else { continue };
let head = String::from_utf8_lossy(&request[..end]).into_owned();
let length: usize = head
.lines()
.find_map(|line| {
let (name, value) = line.split_once(':')?;
name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse().unwrap())
})
.unwrap_or(0);
if request.len() >= end + 4 + length {
break (head, String::from_utf8_lossy(&request[end + 4..end + 4 + length]).into_owned());
}
};
seen.push((head, body));
socket.write_all(response.as_bytes()).await.unwrap();
}
seen
});
(port, handle)
}
fn response(status_line: &str, headers: &str, body: &str) -> String {
format!("HTTP/1.1 {status_line}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
}
#[tokio::test]
async fn sends_exact_environment_numbers_to_a_local_server() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -467,7 +341,6 @@ mod tests {
assert_eq!(r.status_text, "Created");
assert_eq!(r.body.as_deref(), Some("{\"ok\":true}"));
assert!(r.headers.iter().any(|(k, v)| k == "x-a" && v == "b"));
assert!(r.redirects.is_empty());
assert!(r.total_ms >= r.ttfb_ms);
}
@@ -496,150 +369,4 @@ mod tests {
let err = execute(&req, &cancel).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
}
#[tokio::test]
async fn post_keeps_method_and_body_on_301_302_307_308() {
for status_line in ["301 Moved Permanently", "302 Found", "307 Temporary Redirect", "308 Permanent Redirect"] {
let status: u16 = status_line[..3].parse().unwrap();
let (port, server) =
scripted(vec![response(status_line, "Location: /landing\r\n", ""), response("200 OK", "", "ok")]).await;
let req = PreparedRequest {
name: None,
method: "POST".into(),
url: format!("http://127.0.0.1:{port}/submit"),
headers: vec![("Content-Type".into(), "application/json".into())],
body: Some("{\"a\":1}".into()),
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
let (head, body) = &seen[1];
assert_eq!(head.lines().next().unwrap(), "POST /landing HTTP/1.1", "{status_line}");
assert!(head.to_ascii_lowercase().contains("content-type: application/json"), "{head}");
assert_eq!(body, "{\"a\":1}", "{status_line}");
assert_eq!(r.status, 200, "{status_line}");
assert_eq!(r.body.as_deref(), Some("ok"), "{status_line}");
assert_eq!(
r.redirects,
vec![RedirectHop {
status,
status_text: status_line[4..].to_owned(),
location: format!("http://127.0.0.1:{port}/landing"),
}],
"{status_line}"
);
}
}
#[tokio::test]
async fn see_other_303_resends_as_get_without_the_body() {
let (port, server) =
scripted(vec![response("303 See Other", "Location: /after\r\n", ""), response("200 OK", "", "done")]).await;
let req = PreparedRequest {
name: None,
method: "POST".into(),
url: format!("http://127.0.0.1:{port}/submit"),
headers: vec![],
body: Some("{\"a\":1}".into()),
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert_eq!(seen[1].0.lines().next().unwrap(), "GET /after HTTP/1.1");
assert_eq!(seen[1].1, "");
assert_eq!(r.status, 200);
assert_eq!(r.body.as_deref(), Some("done"));
assert_eq!(r.redirects[0].status, 303);
}
#[tokio::test]
async fn same_host_redirect_keeps_authorization() {
let (port, server) = scripted(vec![
response("301 Moved Permanently", "Location: /landing\r\n", ""),
response("200 OK", "", "ok"),
])
.await;
let req = PreparedRequest {
name: None,
method: "GET".into(),
url: format!("http://127.0.0.1:{port}/start"),
headers: vec![("Authorization".into(), "Bearer secret".into())],
body: None,
};
execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert!(seen[1].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen[1].0);
}
#[tokio::test]
async fn cross_host_redirect_keeps_the_method_but_drops_authorization() {
let (port_b, server_b) = scripted(vec![response("200 OK", "", "moved")]).await;
let (port_a, server_a) = scripted(vec![response(
"301 Moved Permanently",
&format!("Location: http://127.0.0.1:{port_b}/x\r\n"),
"",
)])
.await;
let req = PreparedRequest {
name: None,
method: "POST".into(),
url: format!("http://localhost:{port_a}/start"),
headers: vec![("Authorization".into(), "Bearer secret".into())],
body: Some("{\"a\":1}".into()),
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen_a = server_a.await.unwrap();
let seen_b = server_b.await.unwrap();
assert!(seen_a[0].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen_a[0].0);
assert_eq!(seen_b[0].0.lines().next().unwrap(), "POST /x HTTP/1.1");
assert!(!seen_b[0].0.to_ascii_lowercase().contains("authorization"), "{}", seen_b[0].0);
assert_eq!(seen_b[0].1, "{\"a\":1}");
assert_eq!(r.status, 200);
assert_eq!(r.body.as_deref(), Some("moved"));
assert_eq!(r.redirects.len(), 1);
}
#[tokio::test]
async fn redirects_beyond_the_limit_return_the_last_redirect_response() {
let responses = vec![response("301 Moved Permanently", "Location: /loop\r\n", ""); MAX_REDIRECTS + 1];
let (port, server) = scripted(responses).await;
let req = PreparedRequest {
name: None,
method: "GET".into(),
url: format!("http://127.0.0.1:{port}/start"),
headers: vec![],
body: None,
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert_eq!(r.status, 301);
assert_eq!(r.status_text, "Moved Permanently");
assert_eq!(r.redirects.len(), MAX_REDIRECTS);
assert_eq!(seen.len(), MAX_REDIRECTS + 1);
}
#[tokio::test]
async fn redirect_chain_is_recorded_across_hops() {
let (port, server) = scripted(vec![
response("302 Found", "Location: /b\r\n", ""),
response("302 Found", "Location: /c\r\n", ""),
response("200 OK", "", "end"),
])
.await;
let req = PreparedRequest {
name: None,
method: "GET".into(),
url: format!("http://127.0.0.1:{port}/a"),
headers: vec![],
body: None,
};
let r = execute(&req, &CancellationToken::new()).await.unwrap();
let seen = server.await.unwrap();
assert_eq!(r.status, 200);
assert_eq!(r.body.as_deref(), Some("end"));
assert_eq!(r.redirects.len(), 2);
assert_eq!(r.redirects[0].status, 302);
assert_eq!(r.redirects[0].location, format!("http://127.0.0.1:{port}/b"));
assert_eq!(r.redirects[1].status, 302);
assert_eq!(r.redirects[1].location, format!("http://127.0.0.1:{port}/c"));
assert_eq!(seen[2].0.lines().next().unwrap(), "GET /c HTTP/1.1");
}
}
+4 -4
Переглянути файл
@@ -265,7 +265,7 @@ impl ProjectIndex {
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
let recent = self.shared.recent.lock().clone();
let d = self.shared.data.read();
matching::find_files(&d, &matching::Recents::new(&recent), query, Some(&self.root), limit)
matching::find_files(&d, &matching::Recents::new(&recent), query, limit)
}
/// All indexed files with this exact basename, for resolving printed source locations.
@@ -301,7 +301,7 @@ impl ProjectIndex {
/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
matching::find_dirs(&self.shared.data.read(), query, Some(&self.root), limit)
matching::find_dirs(&self.shared.data.read(), query, limit)
}
/// Fuzzy symbol search; CamelHump aware (`OCo` → `OrderController`).
@@ -574,11 +574,11 @@ pub mod bench_support {
}
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, None, limit)
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, limit)
}
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
matching::find_dirs(&self.data, query, None, limit)
matching::find_dirs(&self.data, query, limit)
}
pub fn find_symbols(&self, query: &str, filter: SymbolFilter, limit: usize) -> Vec<SymbolMatch> {
+8 -56
Переглянути файл
@@ -205,67 +205,29 @@ impl<'a> Recents<'a> {
}
}
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; a pasted absolute path under `root` -> its project-relative
/// form; strips leading `./` and `/`.
fn normalize_file_query(q: &str, root: Option<&Path>) -> String {
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; strips leading `./` and `/`.
fn normalize_file_query(q: &str) -> String {
let mut q = q.trim().replace('\\', "/");
// `\\?\C:\a` (verbatim) and `\\.\C:\a` name `C:/a`.
if let Some(rest) = verbatim_target(&q) {
q = rest.to_owned();
}
while let Some((head, tail)) = q.rsplit_once(':')
&& !tail.is_empty()
&& tail.bytes().all(|b| b.is_ascii_digit())
{
q = head.to_owned();
}
if let Some(root) = root
&& let Some(rel) = strip_root(&q, root)
{
q = rel;
}
let q = q.trim_start_matches("./").trim_start_matches('/');
q.chars().filter(|c| !c.is_whitespace()).collect()
}
/// Path a `\\?\` / `\\.\` verbatim prefix points at, for a `/`-separated path.
fn verbatim_target(q: &str) -> Option<&str> {
q.strip_prefix("//?/").or_else(|| q.strip_prefix("//./"))
}
/// `q` (already `/`-separated) below `root`, without the separating slash. A drive-letter root
/// compares like Windows, where case does not matter.
fn strip_root(q: &str, root: &Path) -> Option<String> {
let root = root.to_string_lossy().replace('\\', "/");
let root = verbatim_target(&root).unwrap_or(&root);
let root = root.trim_end_matches('/');
let windows = root.as_bytes().get(1) == Some(&b':');
let head = q.get(..root.len())?;
if head != root && !(windows && head.eq_ignore_ascii_case(root)) {
return None;
}
match q.get(root.len()..)? {
"" => Some(String::new()),
tail => tail.strip_prefix('/').map(str::to_owned),
}
}
enum FileQuery {
Name(Needle),
Path { dir: Needle, name: Needle },
}
pub(crate) fn find_files(
data: &IndexData,
recents: &Recents,
query: &str,
root: Option<&Path>,
limit: usize,
) -> Vec<FileMatch> {
pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit: usize) -> Vec<FileMatch> {
if limit == 0 {
return Vec::new();
}
let q = normalize_file_query(query, root);
let q = normalize_file_query(query);
if q.is_empty() {
return recents
.paths
@@ -344,8 +306,8 @@ pub(crate) fn find_files(
/// Fuzzy folder search over the folders holding indexed files: folder-name matches beat
/// path matches; `/` in the query matches the whole path. `rel_path` ends in `/`.
pub(crate) fn find_dirs(data: &IndexData, query: &str, root: Option<&Path>, limit: usize) -> Vec<FileMatch> {
let q = normalize_file_query(query, root);
pub(crate) fn find_dirs(data: &IndexData, query: &str, limit: usize) -> Vec<FileMatch> {
let q = normalize_file_query(query);
if limit == 0 || q.is_empty() {
return Vec::new();
}
@@ -711,18 +673,8 @@ mod tests {
#[test]
fn normalizes_queries() {
let root = Path::new("E:/work/sample");
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 ", None), "src/main.rs");
assert_eq!(normalize_file_query("/a b", None), "ab");
// A pasted absolute path names an indexed file (#4079 follow-up).
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go", Some(root)), "pkg/Config.go");
assert_eq!(normalize_file_query(r"e:/WORK/sample\pkg/Config.go", Some(root)), "pkg/Config.go");
assert_eq!(normalize_file_query(r"\\?\E:\work\sample\src\App.kt", Some(root)), "src/App.kt");
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go:12:4", Some(root)), "pkg/Config.go");
// Outside the project, and a POSIX root, keep the path as given.
assert_eq!(normalize_file_query(r"E:\elsewhere\x.go", Some(root)), "E:/elsewhere/x.go");
assert_eq!(normalize_file_query("/home/me/Src/a.rs", Some(Path::new("/home/me/src"))), "home/me/Src/a.rs");
assert_eq!(normalize_file_query("/home/me/src/a.rs", Some(Path::new("/home/me/src"))), "a.rs");
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 "), "src/main.rs");
assert_eq!(normalize_file_query("/a b"), "ab");
assert_eq!(split_symbol_query("Order.save"), (Some("Order"), "save"));
assert_eq!(split_symbol_query("a::b::C::new"), (Some("C"), "new"));
assert_eq!(split_symbol_query("save"), (None, "save"));
+2 -5
Переглянути файл
@@ -13,9 +13,6 @@ const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
const SCHEMA: &str = "openidea-index-4";
/// redb's page cache, which otherwise grows to 1 GiB. Queries run on the in-memory snapshot;
/// the database is read once at startup and written incrementally.
const DB_CACHE_BYTES: usize = 64 * 1024 * 1024;
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
/// containing `gitdir: ...`).
@@ -392,7 +389,7 @@ impl Store {
fn open_db(&self) -> Result<Database> {
let file = self.snapshot.with_file_name("index.redb");
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
let db = match Database::create(&file) {
Ok(db) => db,
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
return Err(format!("{} is in use", file.display()));
@@ -401,7 +398,7 @@ impl Store {
tracing::warn!("index cache {} unreadable ({e}); rebuilding", file.display());
let _ = std::fs::remove_file(&file);
let _ = std::fs::remove_file(&self.snapshot);
Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
Database::create(&file).map_err(err)?
}
};
let valid = {
Loaded 100 of 1258 files, more files were not shown because too many files have changed in this diff. Show more