The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(angular): find ngserver installed through version managers (#260)
Mykhailo Smolinskyi7a46774fdac3
diff --git a/Cargo.lock b/Cargo.lockindex b73037d51..61acdb2b1 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4380,7 +4380,6 @@ dependencies = ["tokio","toml 0.9.12+spec-1.1.0","tracing",- "which",][[package]]@@ -4490,7 +4489,6 @@ dependencies = ["tempfile","toml 0.9.12+spec-1.1.0","tracing",- "which","zip",]diff --git a/crates/ide-agent/src/registry.rs b/crates/ide-agent/src/registry.rsindex 6de90d786..c9bef601b 100644--- a/crates/ide-agent/src/registry.rs+++ b/crates/ide-agent/src/registry.rs@@ -335,7 +335,7 @@ pub fn mark_updates(paths: &RegistryPaths, providers: &mut [AgentProvider]) {/// HTTPS only, redirects included. Tests serve downloads over `file://`.fn http() -> IdeResult<Http> {- let http = Http::new(&ide_tools::default_search_path())?;+ let http = Http::new(&ide_core::tool_path::search_path())?;Ok(if cfg!(test) { http } else { http.https_only() })}diff --git a/crates/ide-core/src/lib.rs b/crates/ide-core/src/lib.rsindex 1b58ba68c..fcb39a1f2 100644--- a/crates/ide-core/src/lib.rs+++ b/crates/ide-core/src/lib.rs@@ -20,6 +20,7 @@ pub mod remote_settings;pub mod settings;pub mod task;pub mod text;+pub mod tool_path;pub mod version_managers;pub mod workflow_settings;diff --git a/crates/ide-core/src/tool_path.rs b/crates/ide-core/src/tool_path.rsnew file mode 100644index 000000000..6abe16a4f--- /dev/null+++ b/crates/ide-core/src/tool_path.rs@@ -0,0 +1,193 @@+//! Where the IDE looks up the executables it runs: language servers, the tools+//! their settings come from, installers. An app started from the desktop gets a+//! minimal `PATH`, and version managers set theirs up in shell rc files.++use crate::process::{host_var_os, login_env};+use crate::version_managers;+use std::collections::HashSet;+use std::ffi::{OsStr, OsString};+use std::path::{Path, PathBuf};++/// Where executables are looked up: this process's `PATH` (the login shell's in the+/// app), the login shell's `PATH` as last read, then per-user directories and mise's,+/// asdf's and pyenv's shims, for when the shell's setup didn't reach the app. Language server+/// launchers, their settings hooks and tool detection all look here, so a settings+/// hook finds the executable its server is launched from.+pub fn search_path() -> OsString {+ let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from);+ let shell_path = login_env().and_then(|env| env.iter().find(|(k, _)| k == "PATH").map(|(_, v)| v.clone()));+ let shims: Vec<PathBuf> = version_managers::managers().iter().map(|m| m.shims()).collect();+ let dirs = search_dirs(host_var_os("PATH").as_deref(), shell_path.as_deref(), home.as_deref(), &shims);+ std::env::join_paths(dirs).unwrap_or_default()+}++/// Resolves a command on the shared path, or an explicit path relative to `root`.+pub fn find_command(command: &str, search: &OsStr, root: &Path) -> Option<PathBuf> {+ let path = Path::new(command);+ let explicit = path.parent().is_some_and(|p| !p.as_os_str().is_empty());+ let pathext = host_var_os("PATHEXT");+ let names = crate::process::executable_names(command, cfg!(windows), pathext.as_deref().and_then(OsStr::to_str));+ let dirs = if explicit {+ vec![root.to_path_buf()]+ } else {+ std::env::split_paths(search).filter(|p| !p.as_os_str().is_empty()).map(|p| root.join(p)).collect()+ };+ dirs.into_iter().find_map(|dir| names.iter().map(|name| dir.join(name)).find(|p| is_executable(p)))+}++fn is_executable(path: &Path) -> bool {+ let Ok(metadata) = path.metadata() else { return false };+ if !metadata.is_file() {+ return false;+ }+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ metadata.permissions().mode() & 0o111 != 0+ }+ #[cfg(not(unix))]+ true+}++/// [`search_path`]'s directories, in order and once each. Only absolute ones: a+/// relative entry (`.`, `node_modules/.bin`) resolves against the project, which+/// could then supply the tools the IDE runs. One that can't be joined (a `:` in a+/// directory name) is left out rather than failing the whole path.+fn search_dirs(+ process_path: Option<&OsStr>,+ shell_path: Option<&OsStr>,+ home: Option<&Path>,+ shims: &[PathBuf],+) -> Vec<PathBuf> {+ let mut dirs: Vec<PathBuf> = process_path.into_iter().chain(shell_path).flat_map(std::env::split_paths).collect();+ if let Some(home) = home {+ dirs.extend(USER_DIRS.iter().map(|d| home.join(d)));+ dirs.extend(nvm_bins(&home.join(".nvm/versions/node")));+ }+ // Version managers' shims after real tool directories: a shim exists for a command any+ // installed version has, and fails when the selected one lacks it. Before the system's,+ // as the managers' shell setup puts them.+ dirs.extend(home.map(|h| h.join(".pyenv/shims")));+ dirs.extend(shims.iter().cloned());+ dirs.extend(SYSTEM_DIRS.iter().map(PathBuf::from));+ let mut seen = HashSet::new();+ dirs.retain(|d| d.is_absolute() && std::env::join_paths([d]).is_ok() && seen.insert(d.clone()));+ dirs+}++/// Tool directories below the home directory.+const USER_DIRS: &[&str] = &[+ ".cargo/bin",+ ".local/bin",+ "go/bin",+ ".bun/bin",+ ".deno/bin",+ ".npm-global/bin",+ ".volta/bin",+ // Set up in shell rc files: fnm's default Node and pnpm's global bin (Linux, then macOS).+ ".local/share/fnm/aliases/default/bin",+ "Library/Application Support/fnm/aliases/default/bin",+ ".fnm/aliases/default/bin",+ ".local/share/pnpm/bin",+ ".local/share/pnpm",+ "Library/pnpm/bin",+ "Library/pnpm",+];++const SYSTEM_DIRS: &[&str] = &["/opt/homebrew/bin", "/usr/local/go/bin", "/usr/local/bin", "/usr/bin", "/bin"];++/// The `bin` directories of nvm's Node versions in `dir`, newest first.+fn nvm_bins(dir: &Path) -> Vec<PathBuf> {+ let mut versions: Vec<(Vec<u64>, PathBuf)> = std::fs::read_dir(dir)+ .into_iter()+ .flatten()+ .flatten()+ .map(|e| (version_key(&e.file_name().to_string_lossy()), e.path().join("bin")))+ .collect();+ versions.sort();+ versions.into_iter().rev().map(|(_, bin)| bin).collect()+}++/// `v22.10.1` as `[22, 10, 1]`: v22 is newer than v9, v20.10 newer than v20.9.+fn version_key(name: &str) -> Vec<u64> {+ name.trim_start_matches('v').split('.').map(|n| n.parse().unwrap_or(0)).collect()+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn commands_resolve_on_path_and_explicit_paths_under_root() {+ let dir = tempfile::tempdir().unwrap();+ let bin = dir.path().join("bin");+ std::fs::create_dir(&bin).unwrap();+ let name = if cfg!(windows) { "ngserver.cmd" } else { "ngserver" };+ std::fs::write(bin.join(name), "").unwrap();+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ std::fs::set_permissions(bin.join(name), std::fs::Permissions::from_mode(0o755)).unwrap();+ }+ let search = std::env::join_paths([&bin]).unwrap();+ assert_eq!(find_command("ngserver", &search, dir.path()), Some(bin.join(name)));+ assert_eq!(find_command("bin/ngserver", &search, dir.path()), Some(bin.join(name)));+ assert_eq!(find_command(bin.join(name).to_str().unwrap(), &search, dir.path()), Some(bin.join(name)));+ assert_eq!(find_command("absent", &search, dir.path()), None);+ for command in ["bin/ngserver", bin.join(name).to_str().unwrap()] {+ assert_eq!(find_command(command, OsStr::new(""), dir.path()), Some(bin.join(name)));+ }+ }++ #[cfg(unix)]+ #[test]+ fn non_executable_files_do_not_shadow_commands() {+ use std::os::unix::fs::PermissionsExt;+ let tmp = tempfile::tempdir().unwrap();+ let dirs = [tmp.path().join("first"), tmp.path().join("second")];+ for (dir, mode) in dirs.iter().zip([0o644, 0o755]) {+ std::fs::create_dir(dir).unwrap();+ let file = dir.join("ngserver");+ std::fs::write(&file, "#!/bin/sh\n").unwrap();+ std::fs::set_permissions(file, std::fs::Permissions::from_mode(mode)).unwrap();+ }+ let path = std::env::join_paths(&dirs).unwrap();+ assert_eq!(find_command("ngserver", &path, tmp.path()), Some(dirs[1].join("ngserver")));+ assert_eq!(find_command("first/ngserver", &path, tmp.path()), None);+ }++ #[cfg(unix)]+ #[test]+ fn search_dirs_put_the_process_path_first_and_shims_after_real_tools() {+ let shims = [PathBuf::from("/home/me/.local/share/mise/shims"), "/home/me/.asdf/shims".into()];+ let dirs = search_dirs(+ Some(OsStr::new("/usr/bin:.:node_modules/.bin:/opt/tools")),+ // nushell prints `$PATH` as is.+ Some(OsStr::new("$PATH:/opt/tools:/home/me/.asdf/shims")),+ Some(Path::new("/home/me")),+ &shims,+ );+ let at = |d: &str| dirs.iter().position(|p| p == Path::new(d)).unwrap();+ assert_eq!(dirs[..3], [PathBuf::from("/usr/bin"), "/opt/tools".into(), "/home/me/.asdf/shims".into()]);+ assert!(at("/home/me/.npm-global/bin") < at("/home/me/.pyenv/shims"));+ assert!(at("/home/me/.local/share/mise/shims") < at("/usr/local/bin"));+ assert!(dirs.iter().all(|d| d.is_absolute()));+ let unique: HashSet<&PathBuf> = dirs.iter().collect();+ assert_eq!(unique.len(), dirs.len());+ // A `:` can't be in a `PATH` entry: those below such a home are left out.+ let dirs = search_dirs(Some(OsStr::new("/usr/bin")), None, Some(Path::new("/home/a:b")), &[]);+ assert!(dirs.contains(&PathBuf::from("/usr/bin")) && !dirs.iter().any(|d| d.starts_with("/home")));+ }++ #[test]+ fn nvm_versions_newest_first() {+ let dir = std::env::temp_dir().join(format!("openidea-nvm-{}", std::process::id()));+ for v in ["v9.11.2", "v20.9.0", "v22.1.0", "v20.10.0"] {+ std::fs::create_dir_all(dir.join(v).join("bin")).unwrap();+ }+ let bins = nvm_bins(&dir);+ std::fs::remove_dir_all(&dir).unwrap();+ let names: Vec<_> = bins.iter().map(|b| b.parent().unwrap().file_name().unwrap().to_owned()).collect();+ assert_eq!(names, ["v22.1.0", "v20.10.0", "v20.9.0", "v9.11.2"]);+ }+}diff --git a/crates/ide-lsp/Cargo.toml b/crates/ide-lsp/Cargo.tomlindex 317f9319a..ed05a90b1 100644--- a/crates/ide-lsp/Cargo.toml+++ b/crates/ide-lsp/Cargo.toml@@ -21,7 +21,6 @@ futures.workspace = trueglobset.workspace = truetoml.workspace = truepercent-encoding = "2"-which = "8"[dev-dependencies]tempfile.workspace = truediff --git a/crates/ide-lsp/src/launch.rs b/crates/ide-lsp/src/launch.rsindex 782df3b8a..3343763d2 100644--- a/crates/ide-lsp/src/launch.rs+++ b/crates/ide-lsp/src/launch.rs@@ -1,11 +1,12 @@//! Starting server processes: binary resolution and the [`Launcher`] seam.use ide_core::CancellationToken;+use ide_core::tool_path::search_path;use ide_jsonrpc::{Handler, Peer};use ide_language::LanguageServerConfig;use std::ffi::OsString;use std::path::{Path, PathBuf};-use std::sync::{Arc, OnceLock};+use std::sync::Arc;#[derive(Debug)]pub enum LaunchError {@@ -72,8 +73,7 @@ impl Launcher for ProcessLauncher {cancel: &CancellationToken,) -> Result<Peer, LaunchError> {let search = server_search_path(config);- let binary = which::which_in(&config.command, Some(&search), root)- .ok()+ let binary = ide_core::tool_path::find_command(&config.command, &search, root).and_then(|b| resolve_rustup_proxy(&config.command, b));let mut env: Vec<(String, String)> = vec![("PATH".into(), search.to_string_lossy().into_owned())];env.extend(config.env.iter().filter(|(k, _)| *k != "PATH").map(|(k, v)| (k.clone(), v.clone())));@@ -95,7 +95,7 @@ impl Launcher for ProcessLauncher {}fn available(&self, config: &LanguageServerConfig, root: &Path) -> bool {- which::which_in(&config.command, Some(server_search_path(config)), root).is_ok()+ ide_core::tool_path::find_command(&config.command, &server_search_path(config), root).is_some()}}@@ -104,9 +104,6 @@ fn server_search_path(config: &LanguageServerConfig) -> OsString {config.env.get("PATH").map(OsString::from).unwrap_or_else(search_path)}-/// `PATH` plus the login shell's `PATH` and common tool directories, so-/// servers resolve even when the app is launched from a GUI shell with a-/// minimal environment./// `~/.cargo/bin/<tool>` is usually a rustup proxy that fails when the active/// toolchain lacks the component (common for rust-analyzer). In that case use/// the newest installed toolchain that ships the binary; with none, the tool is@@ -153,74 +150,6 @@ fn resolve_rustup_proxy(command: &str, binary: PathBuf) -> Option<PathBuf> {}}-pub fn search_path() -> OsString {- static PATH: OnceLock<OsString> = OnceLock::new();- PATH.get_or_init(|| {- let mut dirs: Vec<PathBuf> =- std::env::var_os("PATH").map(|p| std::env::split_paths(&p).collect()).unwrap_or_default();- if let Some(shell_path) = login_shell_path() {- dirs.extend(std::env::split_paths(&shell_path));- }- if let Some(home) = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from) {- for rel in [".cargo/bin", ".local/bin", "go/bin", ".bun/bin", ".deno/bin", ".npm-global/bin", ".volta/bin"]- {- dirs.push(home.join(rel));- }- // nvm: newest installed node's bin.- if let Ok(entries) = std::fs::read_dir(home.join(".nvm/versions/node")) {- let mut versions: Vec<PathBuf> = entries.flatten().map(|e| e.path().join("bin")).collect();- versions.sort();- dirs.extend(versions.into_iter().rev());- }- }- for d in ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"] {- dirs.push(PathBuf::from(d));- }- let mut seen = std::collections::HashSet::new();- dirs.retain(|d| !d.as_os_str().is_empty() && seen.insert(d.clone()));- std::env::join_paths(dirs).unwrap_or_default()- })- .clone()-}--#[cfg(unix)]-fn login_shell_path() -> Option<OsString> {- use std::io::Read;- use std::process::{Command, Stdio};- use std::time::{Duration, Instant};- let shell = std::env::var_os("SHELL")?;- const MARK: &str = "__OPENIDEA_PATH__";- let mut child = ide_core::process::prepare(&mut Command::new(shell))- .args(["-l", "-c", &format!("printf '{MARK}%s{MARK}' \"$PATH\"")])- .stdin(Stdio::null())- .stdout(Stdio::piped())- .stderr(Stdio::null())- .spawn()- .ok()?;- let deadline = Instant::now() + Duration::from_secs(3);- loop {- match child.try_wait() {- Ok(Some(_)) => break,- Ok(None) if Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),- _ => {- let _ = child.kill();- let _ = child.wait();- return None;- }- }- }- let mut out = String::new();- child.stdout.take()?.read_to_string(&mut out).ok()?;- let start = out.find(MARK)? + MARK.len();- let end = start + out[start..].find(MARK)?;- Some(OsString::from(&out[start..end]))-}--#[cfg(not(unix))]-fn login_shell_path() -> Option<OsString> {- None-}-/// Workspace root for `file`: the outermost ancestor within `project_root`/// containing a root marker (so a Cargo/npm workspace gets one server, not one/// per member), else `project_root`. `None` when `file` is outside the project.@@ -258,6 +187,19 @@ mod tests {std::fs::remove_dir_all(&tmp).unwrap();}+ #[test]+ fn marked_root_needs_a_marker() {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path();+ let file = root.join("apps/web/src/app.ts");+ std::fs::create_dir_all(file.parent().unwrap()).unwrap();+ let markers = vec!["angular.json".to_string(), "node_modules/@angular/core".to_string()];+ assert_eq!(marked_root(root, &file, &markers), None);+ std::fs::create_dir_all(root.join("apps/web/node_modules/@angular/core")).unwrap();+ assert_eq!(marked_root(root, &file, &markers), Some(root.join("apps/web")));+ assert_eq!(marked_root(root, &root.join("apps/api/main.ts"), &markers), None);+ }+#[test]fn search_path_contains_env_path() {let p = search_path();diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rsindex 785a1d797..403a82193 100644--- a/crates/ide-lsp/src/lib.rs+++ b/crates/ide-lsp/src/lib.rs@@ -24,7 +24,7 @@ mod uri;mod virtual_doc;pub use inspect::{FileInspection, InspectHost, InspectOptions};-pub use launch::{LaunchError, Launcher, ProcessLauncher, search_path};+pub use launch::{LaunchError, Launcher, ProcessLauncher};pub use scope::{CandidateFiles, CandidateFn, CandidateQuery, MAX_CANDIDATES};pub use uri::{is_virtual_uri, path_to_uri_string, uri_target, uri_to_path};@@ -1921,9 +1921,22 @@ impl LspManager {/// Servers no longer enabled stop; newly enabled ones attach to open documents.pub async fn reconfigure(&self) {self.stop_unlisted().await;+ let Some(me) = self.me.upgrade() else { return };let servers: Vec<Arc<Server>> = self.servers.lock().clone();for s in servers {- let next = self.configured(&s);+ // The settings hook may run tools (`npm root -g`), as when the server starts.+ let next = match tokio::task::spawn_blocking({+ let (me, s) = (me.clone(), s.clone());+ move || me.configured(&s)+ })+ .await+ {+ Ok(next) => next,+ Err(e) => {+ tracing::warn!("{}: settings hook failed: {e}", s.name);+ continue;+ }+ };let current = s.effective_config();if next == current {continue;diff --git a/crates/ide-sdk/Cargo.toml b/crates/ide-sdk/Cargo.tomlindex d4225ada4..8d9a24e70 100644--- a/crates/ide-sdk/Cargo.toml+++ b/crates/ide-sdk/Cargo.toml@@ -17,7 +17,6 @@ serde_json.workspace = truespecta.workspace = truetoml.workspace = truetracing.workspace = true-which = "8"zip.workspace = true[dev-dependencies]diff --git a/crates/ide-sdk/src/angular.rs b/crates/ide-sdk/src/angular.rsindex d7566418b..54c5591aa 100644--- a/crates/ide-sdk/src/angular.rs+++ b/crates/ide-sdk/src/angular.rs@@ -1,15 +1,18 @@//! Angular Language Server (`ngserver`): its package, where TypeScript and//! `@angular/language-service` come from, and the project's Angular version.-use crate::npm::package_dir;+use crate::npm::{package_dir, shim_package};+use std::collections::BTreeMap;+use std::ffi::OsStr;use std::path::{Path, PathBuf};pub(crate) const SERVER: &str = "angular-language-server";const PACKAGE: &str = "@angular/language-server";-/// `@angular/language-server`'s directory for an `ngserver` executable.-pub(crate) fn server_package(bin: &Path) -> Option<PathBuf> {- package_dir(bin, PACKAGE)+/// `@angular/language-server`'s directory for an `ngserver` executable found on+/// `path` and run in `cwd` with `env`.+pub(crate) fn server_package(bin: &Path, path: &OsStr, cwd: &Path, env: &BTreeMap<String, String>) -> Option<PathBuf> {+ package_dir(bin, PACKAGE).or_else(|| shim_package(bin, PACKAGE, path, cwd, env))}/// Why an `ngserver` whose package isn't found can't start: it loads TypeScriptdiff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rsindex acd006928..527e1924a 100644--- a/crates/ide-sdk/src/apply.rs+++ b/crates/ide-sdk/src/apply.rs@@ -519,8 +519,8 @@ fn configure_vue_typescript(cfg: &mut LanguageServerConfig, root: &Path, server_fn configure_angular(cfg: &mut LanguageServerConfig, root: &Path, server_root: &Path, s: &Settings) {// Found as the launcher finds it; missing, it asks to be installed.let path = cfg.env.get("PATH").map_or_else(search_path, OsString::from);- let Ok(bin) = which::which_in(&cfg.command, Some(path), server_root) else { return };- let Some(package) = angular::server_package(&bin) else {+ let Some(bin) = ide_core::tool_path::find_command(&cfg.command, &path, server_root) else { return };+ let Some(package) = angular::server_package(&bin, &path, server_root, &cfg.env) else {cfg.launch_error = Some(angular::missing_package_message(&bin));return;};diff --git a/crates/ide-sdk/src/exec.rs b/crates/ide-sdk/src/exec.rsindex 03333c502..aef10b05c 100644--- a/crates/ide-sdk/src/exec.rs+++ b/crates/ide-sdk/src/exec.rs@@ -3,35 +3,13 @@use ide_core::output_encoding::decode_tool_output;use ide_core::{CancellationToken, IdeError, IdeResult};-use std::ffi::OsString;use std::io::{BufRead, BufReader, Read};use std::path::{Path, PathBuf};use std::process::{Command, Stdio};use std::sync::mpsc;use std::time::{Duration, Instant};-/// The process `PATH` (already the login shell's in the app) plus common tool dirs.-pub fn search_path() -> OsString {- let mut dirs: Vec<PathBuf> =- std::env::var_os("PATH").map(|p| std::env::split_paths(&p).collect()).unwrap_or_default();- if let Some(home) = crate::home_dir() {- for rel in [".cargo/bin", ".local/bin", "go/bin", ".pyenv/shims", ".bun/bin", ".npm-global/bin", ".volta/bin"] {- dirs.push(home.join(rel));- }- // nvm: newest installed node's bin, as language servers are launched.- if let Ok(entries) = std::fs::read_dir(home.join(".nvm/versions/node")) {- let mut versions: Vec<PathBuf> = entries.flatten().map(|e| e.path().join("bin")).collect();- versions.sort();- dirs.extend(versions.into_iter().rev());- }- }- for d in ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"] {- dirs.push(PathBuf::from(d));- }- let mut seen = std::collections::HashSet::new();- dirs.retain(|d| !d.as_os_str().is_empty() && seen.insert(d.clone()));- std::env::join_paths(dirs).unwrap_or_default()-}+pub(crate) use ide_core::tool_path::search_path;/// `dir` in front of the search path, as a `PATH` value.pub(crate) fn path_with(dirs: &[&Path]) -> String {@@ -45,7 +23,7 @@ pub(crate) fn path_with(dirs: &[&Path]) -> String {/// Resolves a command name on the search path.pub(crate) fn which(name: &str) -> Option<PathBuf> {let path = search_path();- std::env::split_paths(&path).map(|d| d.join(crate::exe(name))).find(|p| p.is_file())+ ide_core::process::find_executable(name, &path)}/// Runs `program args` and returns trimmed stdout (stderr when stdout is empty)@@ -66,27 +44,41 @@ pub(crate) fn query_in(if let Some(cwd) = cwd {cmd.current_dir(cwd);}+ if !env.iter().any(|(k, _)| *k == "PATH") {+ cmd.env("PATH", search_path());+ }let mut child = ide_core::process::prepare(&mut cmd).args(args)- .env("PATH", search_path()).envs(env.iter().copied()).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().ok()?;- let mut stdout = child.stdout.take()?;- let mut stderr = child.stderr.take()?;- let out = std::thread::spawn(move || {- let mut s = Vec::new();- let _ = stdout.read_to_end(&mut s);- decode_tool_output(&s)- });- let err = std::thread::spawn(move || {- let mut s = Vec::new();- let _ = stderr.read_to_end(&mut s);- decode_tool_output(&s)- });+ // Chunks as they come, `None` at the end of a pipe. A reader stops once the query+ // has returned, closing the pipe on whatever still writes to it.+ let (tx, rx) = mpsc::channel::<(bool, Option<Vec<u8>>)>();+ let pipes: [(bool, Box<dyn Read + Send>); 2] =+ [(true, Box::new(child.stdout.take()?)), (false, Box::new(child.stderr.take()?))];+ for (is_out, mut pipe) in pipes {+ let tx = tx.clone();+ std::thread::spawn(move || {+ let mut buf = [0u8; 4096];+ loop {+ let chunk = match pipe.read(&mut buf) {+ Ok(0) => None,+ Ok(n) => Some(buf[..n].to_vec()),+ Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,+ Err(_) => None,+ };+ let end = chunk.is_none();+ if tx.send((is_out, chunk)).is_err() || end {+ return;+ }+ }+ });+ }+ drop(tx);let deadline = Instant::now() + timeout;let status = loop {match child.try_wait() {@@ -99,12 +91,27 @@ pub(crate) fn query_in(}}};- let (out, err) = (out.join().unwrap_or_default(), err.join().unwrap_or_default());if !status.success() {return None;}- let text = if out.trim().is_empty() { err } else { out };- Some(text.trim().to_owned())+ // Up to the deadline, or briefly past it for a program that exited just before:+ // a process it left running (a wrapper's background job) can hold the pipes+ // open, or keep writing to them, after it exits.+ let until = deadline.max(Instant::now() + Duration::from_millis(100));+ let (mut out, mut err, mut open) = (Vec::new(), Vec::new(), 2);+ while open > 0 {+ let left = until.saturating_duration_since(Instant::now());+ if left.is_zero() {+ break;+ }+ match rx.recv_timeout(left) {+ Ok((is_out, Some(chunk))) => if is_out { &mut out } else { &mut err }.extend(chunk),+ Ok((_, None)) => open -= 1,+ Err(_) => break,+ }+ }+ let text = if out.trim_ascii().is_empty() { err } else { out };+ Some(decode_tool_output(&text).trim().to_owned())}/// Runs a command to completion, reporting every output line (stdout anddiff --git a/crates/ide-sdk/src/godot.rs b/crates/ide-sdk/src/godot.rsindex 31999cbe6..bdc888da3 100644--- a/crates/ide-sdk/src/godot.rs+++ b/crates/ide-sdk/src/godot.rs@@ -23,7 +23,7 @@ pub fn find(custom: Option<PathBuf>) -> Option<PathBuf> {if let Some(p) = custom {return Some(p);}- find_in(&crate::search_path(), &install_locations(crate::home_dir().as_deref()))+ find_in(&crate::exec::search_path(), &install_locations(crate::home_dir().as_deref()))}pub(crate) fn find_in(search: &OsStr, locations: &[PathBuf]) -> Option<PathBuf> {diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rsindex 66ebdbbf5..3d178c62c 100644--- a/crates/ide-sdk/src/lib.rs+++ b/crates/ide-sdk/src/lib.rs@@ -25,7 +25,6 @@ use specta::Type;use std::path::{Path, PathBuf};pub use discover::{detect, jdk_sdk};-pub use exec::search_path;/// What [`detect`] looks for.#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]diff --git a/crates/ide-sdk/src/npm.rs b/crates/ide-sdk/src/npm.rsindex 15a58ec2f..89c94edb1 100644--- a/crates/ide-sdk/src/npm.rs+++ b/crates/ide-sdk/src/npm.rs@@ -1,7 +1,9 @@//! Node-based language servers installed with npm: the package behind a command.+use std::collections::BTreeMap;use std::ffi::OsStr;use std::path::{Path, PathBuf};+use std::time::Duration;/// `command` as given (a path) or found on `path`, npm shims included.pub(crate) fn find_command(command: &str, path: &OsStr) -> Option<PathBuf> {@@ -9,15 +11,13 @@ pub(crate) fn find_command(command: &str, path: &OsStr) -> Option<PathBuf> {if p.is_absolute() {return p.is_file().then(|| p.to_path_buf());}- let exts: &[&str] = if cfg!(windows) { &[".cmd", ".exe", ""] } else { &[""] };- std::env::split_paths(path)- .flat_map(|d| exts.iter().map(move |e| d.join(format!("{command}{e}"))))- .find(|c| c.is_file())+ ide_core::process::find_executable(command, path)}/// The npm package an executable comes from: next to a `node_modules/.bin` shim/// (the IDE's tools dir, a project), a Windows global shim (`%APPDATA%\npm`), a-/// Unix global `<prefix>/bin` or a symlink into the package.+/// Unix global `<prefix>/bin`, a symlink into the package, Volta's package image+/// or the package a shim script runs (pnpm).pub(crate) fn package_dir(bin: &Path, package: &str) -> Option<PathBuf> {let dir = bin.parent()?;let mut candidates = vec![dir.join("node_modules").join(package)];@@ -31,6 +31,197 @@ pub(crate) fn package_dir(bin: &Path, package: &str) -> Option<PathBuf> {}if let Some(prefix) = dir.parent() {candidates.push(prefix.join("lib").join("node_modules").join(package));+ // Volta: `<home>/bin/<command>` runs `<home>/tools/image/packages/<package>`.+ let image = prefix.join("tools").join("image").join("packages").join(package);+ candidates.push(image.join("lib").join("node_modules").join(package));+ candidates.push(image.join("node_modules").join(package));+ }+ let installed = |c: &PathBuf| c.join("package.json").is_file();+ candidates.into_iter().find(installed).or_else(|| script_targets(bin, package).into_iter().find(installed))+}++/// How shim scripts name their own directory: sh and PowerShell `$basedir` (pnpm+/// 11's sh shims also `$basedir_abs` and `$basedir_win`), cmd `%~dp0` (pnpm's+/// `%dp0%` is set from it).+const SCRIPT_DIR: [&str; 8] =+ ["${basedir}", "$basedir", "${basedir_abs}", "$basedir_abs", "${basedir_win}", "$basedir_win", "%~dp0", "%dp0%"];++/// `path` after the [`SCRIPT_DIR`] it starts with. sh reads `$basedir_abs` as one+/// name, not as `$basedir` followed by `_abs`.+fn after_script_dir(path: &str) -> Option<&str> {+ SCRIPT_DIR.iter().find_map(|d| {+ let rest = path.strip_prefix(d)?;+ let longer_name = d.starts_with('$')+ && !d.ends_with('}')+ && rest.starts_with(|c: char| c == '_' || c.is_ascii_alphanumeric());+ (!longer_name).then_some(rest)+ })+}++/// The `package` directories a shim script runs from: relative to the script's+/// directory, e.g. pnpm's `"$basedir/../global/v11/<hash>/node_modules/<package>/bin/<command>"`+/// or `"%~dp0\..\global\..."`, or absolute.+fn script_targets(bin: &Path, package: &str) -> Vec<PathBuf> {+ const MAX_SCRIPT: u64 = 64 * 1024;+ if std::fs::metadata(bin).map_or(true, |m| m.len() > MAX_SCRIPT) {+ return Vec::new();+ }+ let Ok(bytes) = std::fs::read(bin) else { return Vec::new() };+ let text = String::from_utf8_lossy(&bytes).replace('\\', "/");+ let bases: Vec<PathBuf> = [+ bin.parent().map(Path::to_path_buf),+ dunce::canonicalize(bin).ok().and_then(|r| r.parent().map(Path::to_path_buf)),+ ]+ .into_iter()+ .flatten()+ .collect();+ let needle = format!("node_modules/{package}");+ // What sh and cmd split words on; a folder name may contain a no-break space.+ let separator = |c: char| c == '"' || c == '\'' || c.is_ascii_whitespace();+ let mut targets = Vec::new();+ for (at, _) in text.match_indices(&needle) {+ let end = at + needle.len();+ if !text[end..].chars().next().is_none_or(|c| c == '/' || separator(c)) {+ continue;+ }+ // Within quotes the path starts at the opening one and may contain spaces.+ let line = text[..at].rfind('\n').map_or(0, |i| i + 1);+ let start = match ['"', '\''].into_iter().find(|q| text[line..at].matches(*q).count() % 2 == 1) {+ Some(quote) => text[..at].rfind(quote),+ None => text[..at].rfind(separator),+ }+ .map_or(0, |i| i + 1);+ let path = &text[start..end];+ // `"$basedir"/../...`: the directory quoted on its own.+ let after_dir = text[..start]+ .strip_suffix(['"', '\''])+ .is_some_and(|before| SCRIPT_DIR.iter().any(|d| before.ends_with(d)));+ match after_script_dir(path).or(after_dir.then_some(path)) {+ Some(rest) => targets.extend(bases.iter().map(|b| b.join(rest.trim_start_matches('/')))),+ None if Path::new(path).is_absolute() => targets.push(PathBuf::from(path)),+ // `$HOME/...`, `%APPDATA%\...` or relative to wherever the script runs.+ None => {}+ }+ }+ targets.into_iter().map(|t| dunce::canonicalize(&t).unwrap_or(t)).collect()+}++/// For a version manager's shim (`~/.asdf/shims`, mise's `shims`), which names+/// only the command: `package` in the global `node_modules` of the manager's+/// npm shim, run as the server is (in `cwd`, with its `env` and `path`), so the+/// manager picks the same Node. The shims go first on `path`, as the manager's+/// shell setup puts them: npm (`#!/usr/bin/env node`) then runs on the manager's+/// Node, not on a system one earlier on `path` that has another global root.+pub(crate) fn shim_package(+ bin: &Path,+ package: &str,+ path: &OsStr,+ cwd: &Path,+ env: &BTreeMap<String, String>,+) -> Option<PathBuf> {+ let shims = bin.parent()?;+ if shims.file_name() != Some(OsStr::new("shims")) {+ return None;+ }+ // Only the npm shim next to it: any other npm may be another installation's.+ let exts: &[&str] = if cfg!(windows) { &[".cmd", ".exe"] } else { &[""] };+ let npm = exts.iter().map(|e| shims.join(format!("npm{e}"))).find(|p| p.is_file())?;+ let path = std::env::join_paths(std::iter::once(shims.to_path_buf()).chain(std::env::split_paths(path))).ok()?;+ // The login shell's variables (`ASDF_DATA_DIR`, `MISE_ENV`...) under the server's own.+ let shell_env: Vec<_> = ide_core::process::shell_env().collect();+ let mut env: Vec<(&str, &str)> = shell_env+ .iter()+ .filter_map(|(k, v)| Some((k.to_str()?, v.to_str()?)))+ .chain(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))+ .collect();+ env.push(("PATH", path.to_str()?));+ let root = crate::exec::query_in(&npm, &["root", "-g"], Some(cwd), &env, Duration::from_secs(10))?;+ let dir = PathBuf::from(root.lines().last()?.trim()).join(package);+ dir.join("package.json").is_file().then_some(dir)+}++#[cfg(test)]+mod tests {+ use super::*;++ const PACKAGE: &str = "@angular/language-server";++ /// `<dir>/bin/ngserver` running `script`.+ fn shim(dir: &Path, script: &str) -> PathBuf {+ std::fs::create_dir_all(dir.join("bin")).unwrap();+ let shim = dir.join("bin/ngserver");+ std::fs::write(&shim, script).unwrap();+ shim+ }++ /// The package installed in `<dir>/node_modules`.+ fn install(dir: &Path) -> PathBuf {+ let package = dir.join("node_modules").join(PACKAGE);+ std::fs::create_dir_all(&package).unwrap();+ std::fs::write(package.join("package.json"), "{}").unwrap();+ dunce::canonicalize(package).unwrap()+ }++ #[test]+ fn shim_scripts_name_the_package_relative_to_their_directory() {+ let tmp = tempfile::tempdir().unwrap();+ let package = install(&tmp.path().join("global/v11/abc"));+ for script in [+ "#!/bin/sh\nexec node \"$basedir/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n",+ "#!/bin/sh\nexec node \"${basedir}/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n",+ "#!/bin/sh\nexec node \"$basedir\"/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver \"$@\"\n",+ // pnpm 11.+ "#!/bin/sh\nexec \"$basedir/node\" \"$basedir_abs/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n",+ "#!/bin/sh\nexec node \"${basedir_abs}/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n",+ "#!/bin/sh\nexec node.exe \"$basedir_win/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n",+ "@\"%~dp0\\..\\global\\v11\\abc\\node_modules\\@angular\\language-server\\bin\\ngserver\" %*\r\n",+ "@\"%~dp0..\\global\\v11\\abc\\node_modules\\@angular\\language-server\\bin\\ngserver\" %*\r\n",+ "@SET dp0=%~dp0\r\n\"%dp0%\\..\\global\\v11\\abc\\node_modules\\@angular\\language-server\\bin\\ngserver\" %*\r\n",+ ] {+ assert_eq!(package_dir(&shim(tmp.path(), script), PACKAGE), Some(package.clone()), "{script}");+ }+ }++ #[test]+ fn quoted_shim_targets_keep_their_spaces() {+ let tmp = tempfile::tempdir().unwrap();+ let package = install(&tmp.path().join("Global Packages/abc"));+ let absolute = package.display().to_string();+ for script in [+ "#!/bin/sh\nexec node \"$basedir/../Global Packages/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n"+ .to_owned(),+ "@\"%~dp0\\..\\Global Packages\\abc\\node_modules\\@angular\\language-server\\bin\\ngserver\" %*\r\n".to_owned(),+ format!("#!/bin/sh\nexec node \"{absolute}/bin/ngserver\" \"$@\"\n"),+ format!("#!/bin/sh\nexec node '{absolute}/bin/ngserver' \"$@\"\n"),+ ] {+ assert_eq!(package_dir(&shim(tmp.path(), &script), PACKAGE), Some(package.clone()), "{script}");+ }+ }++ #[test]+ fn shim_scripts_with_an_absolute_path_and_non_ascii_spaces() {+ let tmp = tempfile::tempdir().unwrap();+ let package = install(&tmp.path().join("山田\u{3000}太郎\u{a0}x"));+ let script = format!("#!/bin/sh\nexec node \"{}/bin/ngserver\" \"$@\"\n", package.display());+ assert_eq!(package_dir(&shim(tmp.path(), &script), PACKAGE), Some(package));+ }++ #[test]+ fn shim_scripts_skip_other_packages_and_other_directories() {+ let tmp = tempfile::tempdir().unwrap();+ install(&tmp.path().join("home"));+ for script in [+ "exec node \"$basedir/../home/node_modules/@angular/language-server-next/bin/ngserver\"\n",+ "exec node \"$HOME/node_modules/@angular/language-server/bin/ngserver\"\n",+ "exec node \"$basedirx/../home/node_modules/@angular/language-server/bin/ngserver\"\n",+ "exec node ../home/node_modules/@angular/language-server/bin/ngserver\n",+ ] {+ assert_eq!(script_targets(&shim(tmp.path(), script), PACKAGE), Vec::<PathBuf>::new(), "{script}");+ }+ let large = format!(+ "{}\n\"$basedir/../home/node_modules/@angular/language-server/bin/ngserver\"\n",+ "#".repeat(64 * 1024)+ );+ assert_eq!(script_targets(&shim(tmp.path(), &large), PACKAGE), Vec::<PathBuf>::new());}- candidates.into_iter().find(|c| c.join("package.json").is_file())}diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rsindex 92fda6da0..7af792e02 100644--- a/crates/ide-sdk/src/tests.rs+++ b/crates/ide-sdk/src/tests.rs@@ -673,6 +673,160 @@ fn angular_language_server_probes_its_own_package_then_the_project() {assert_eq!((cfg.launch_error, cfg.args), (None, vec!["--stdio".to_owned()]));}+#[test]+fn angular_language_server_is_found_behind_version_manager_shims() {+ let tmp = tempfile::tempdir().unwrap();+ let project = tmp.path().join("app");+ std::fs::create_dir_all(&project).unwrap();+ let install = |node_modules: &Path| {+ let package = node_modules.join("@angular/language-server");+ std::fs::create_dir_all(&package).unwrap();+ std::fs::write(package.join("package.json"), "{}").unwrap();+ package+ };+ let probes = |command: &Path, s: &Settings, env: &[(&str, &str)]| {+ let mut cfg = server("angular-language-server");+ cfg.command = command.to_string_lossy().into_owned();+ cfg.env.extend(env.iter().map(|(k, v)| (k.to_string(), v.to_string())));+ configure_server(&mut cfg, &project, &project, s);+ cfg.args.iter().position(|a| a == "--ngProbeLocations").map(|i| cfg.args[i + 1].clone())+ };+ let with_project = |package: &Path| Some(format!("{},{}", package.to_string_lossy(), project.to_string_lossy()));++ // pnpm: the shim script runs the package from pnpm's global directory.+ let pnpm = tmp.path().join("pnpm");+ let package = install(&pnpm.join("global/v11/abc/node_modules"));+ let shim = npm_shim(&pnpm.join("bin"), "ngserver");+ let script = "exec node \"$basedir/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n";+ std::fs::write(&shim, format!("#!/bin/sh\n{script}")).unwrap();+ assert_eq!(probes(&shim, &Settings::default(), &[]), with_project(&dunce::canonicalize(&package).unwrap()));++ // Volta: the package's image, next to the shim's directory. Joined as the lookup+ // joins it: the probe locations compare as text, and Windows keeps a `/` as given.+ let volta = tmp.path().join("volta");+ let image = volta.join("tools").join("image").join("packages").join("@angular/language-server");+ let package = install(&image.join("lib").join("node_modules"));+ let shim = npm_shim(&volta.join("bin"), "ngserver");+ assert_eq!(probes(&shim, &Settings::default(), &[]), with_project(&package));++ // asdf, mise: the shim names only the command; the manager's npm shim knows+ // where global packages are, run as the server is: in the project (whose+ // `.tool-versions` picks the Node), with the login shell's and its own variables.+ let root_of = |package: &Path| package.parent().unwrap().parent().unwrap().display().to_string();+ let package = install(&tmp.path().join("asdf/installs/nodejs/24/lib/node_modules"));+ std::fs::write(project.join(".tool-versions"), "nodejs 24\n").unwrap();+ // The only writer in this test binary.+ ide_core::process::set_shell_env(vec![("OPENIDEA_TEST_SHELL".into(), "1".into())]);+ let shims = tmp.path().join(".asdf/shims");+ // The manager's npm runs on the first Node on PATH (`#!/usr/bin/env node`).+ std::fs::write(+ npm_shim(&shims, "npm"),+ if cfg!(windows) {+ "@if exist .tool-versions if \"%OPENIDEA_TEST_SHELL%\"==\"1\" call node\r\n"+ } else {+ "#!/bin/sh\n[ -f .tool-versions ] && [ \"$OPENIDEA_TEST_SHELL\" = 1 ] && exec node\n"+ },+ )+ .unwrap();+ std::fs::write(+ npm_shim(&shims, "node"),+ if cfg!(windows) {+ "@echo %OPENIDEA_TEST_NPM_ROOT%\r\n"+ } else {+ "#!/bin/sh\necho \"$OPENIDEA_TEST_NPM_ROOT\"\n"+ },+ )+ .unwrap();+ // Another installation's npm and Node, first on PATH.+ let node = tmp.path().join("node/bin");+ let other = root_of(&install(&tmp.path().join("node/lib/node_modules")));+ for name in ["npm", "node"] {+ std::fs::write(+ npm_shim(&node, name),+ if cfg!(windows) { format!("@echo {other}\r\n") } else { format!("#!/bin/sh\necho '{other}'\n") },+ )+ .unwrap();+ }+ let mut s = Settings::default();+ s.languages.node.interpreter = node.join("node").to_string_lossy().into_owned();+ let root = root_of(&package);+ let env = [("OPENIDEA_TEST_NPM_ROOT", root.as_str())];+ assert_eq!(probes(&npm_shim(&shims, "ngserver"), &s, &env), with_project(&package));+ // Not without the manager's own npm, nor for an executable elsewhere: the npm+ // on PATH may be another installation's.+ assert_eq!(probes(&npm_shim(&tmp.path().join("mise/shims"), "ngserver"), &s, &env), None);+ assert_eq!(probes(&npm_shim(&tmp.path().join("bin"), "ngserver"), &s, &env), None);+}++#[cfg(unix)]+#[test]+fn query_output_is_read_within_the_deadline() {+ // Keep process startup outside a tight timing budget even under workspace load.+ let timeout = std::time::Duration::from_secs(60);+ let env = [("PATH", "/usr/bin:/bin")];+ let started = std::time::Instant::now();+ let out = crate::exec::query_in(Path::new("/bin/sh"), &["-c", "printf /global/root"], None, &env, timeout);+ assert_eq!(out.as_deref(), Some("/global/root"));+ // EOF must return promptly, without waiting for the generous deadline.+ assert!(started.elapsed() < std::time::Duration::from_secs(30));+}++#[cfg(unix)]+#[test]+fn query_drains_both_pipes_before_the_child_exits() {+ let out = crate::exec::query_in(+ Path::new("/bin/sh"),+ &["-c", "head -c 262144 /dev/zero; head -c 262144 /dev/zero >&2"],+ None,+ &[("PATH", "/usr/bin:/bin")],+ std::time::Duration::from_secs(60),+ )+ .unwrap();+ assert_eq!(out.len(), 262144);+}++#[cfg(unix)]+#[test]+fn query_is_bounded_when_descendants_keep_pipes_open() {+ let tmp = tempfile::tempdir().unwrap();+ let pid = tmp.path().join("pid");+ // The descendant outlives the query; clean it up even if an assertion fails.+ struct Descendant(std::path::PathBuf);+ impl Drop for Descendant {+ fn drop(&mut self) {+ if let Ok(pid) = std::fs::read_to_string(&self.0) {+ let _ = std::process::Command::new("/bin/kill").arg(pid.trim()).status();+ }+ }+ }+ let _descendant = Descendant(pid.clone());+ let started = std::time::Instant::now();+ let out = crate::exec::query_in(+ Path::new("/bin/sh"),+ &["-c", "sleep 120 & echo $! > \"$1\"; printf /global/root", "wrapper", pid.to_str().unwrap()],+ None,+ &[("PATH", "/usr/bin:/bin")],+ std::time::Duration::from_secs(30),+ );+ assert_eq!(out.as_deref(), Some("/global/root"));+ // The descendant keeps both pipes open for longer than the query deadline.+ assert!(started.elapsed() < std::time::Duration::from_secs(90));+}++#[cfg(unix)]+#[test]+fn query_times_out_when_the_child_does_not_exit() {+ // exec avoids leaving a descendant behind when the timed-out child is killed.+ let out = crate::exec::query_in(+ Path::new("/bin/sh"),+ &["-c", "printf /global/root; exec sleep 120"],+ None,+ &[("PATH", "/usr/bin:/bin")],+ std::time::Duration::from_millis(100),+ );+ assert_eq!(out, None);+}+#[test]fn max_java_picks_an_older_jdk() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/ide-tools/src/jdk.rs b/crates/ide-tools/src/jdk.rsindex 279df197f..b5bcf6db8 100644--- a/crates/ide-tools/src/jdk.rs+++ b/crates/ide-tools/src/jdk.rs@@ -448,7 +448,7 @@ mod tests {_ => None,};if let Some(platform) = other {- let tools = Tools::with_paths(crate::tools_dir(tmp.path()), crate::default_search_path(), platform);+ let tools = Tools::with_paths(crate::tools_dir(tmp.path()), ide_core::tool_path::search_path(), platform);let jdk = tools.download_jdk(TEMURIN, feature, None, &CancellationToken::new(), &|_| {}).unwrap();let home = jdk.home.into_path_buf();eprintln!("{}", home.display());diff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rsindex ccbeb8902..e32d10027 100644--- a/crates/ide-tools/src/lib.rs+++ b/crates/ide-tools/src/lib.rs@@ -174,28 +174,6 @@ pub fn path_with_tools(app_data: &Path, path: &std::ffi::OsStr) -> OsString {std::env::join_paths(dirs).unwrap_or_else(|_| path.to_owned())}-/// `PATH` plus the usual per-user tool locations (GUI apps on macOS start with a minimal `PATH`).-pub fn default_search_path() -> OsString {- let mut dirs: Vec<PathBuf> =- ide_core::process::host_var_os("PATH").map(|p| std::env::split_paths(&p).collect()).unwrap_or_default();- if let Some(home) = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from) {- for rel in [".cargo/bin", ".local/bin", "go/bin", ".bun/bin", ".volta/bin", ".npm-global/bin", "Library/pnpm"] {- dirs.push(home.join(rel));- }- if let Ok(entries) = std::fs::read_dir(home.join(".nvm/versions/node")) {- let mut versions: Vec<PathBuf> = entries.flatten().map(|e| e.path().join("bin")).collect();- versions.sort();- dirs.extend(versions.into_iter().rev());- }- }- for d in ["/opt/homebrew/bin", "/usr/local/go/bin", "/usr/local/bin", "/usr/bin", "/bin"] {- dirs.push(PathBuf::from(d));- }- let mut seen = HashSet::new();- dirs.retain(|d| !d.as_os_str().is_empty() && seen.insert(d.clone()));- std::env::join_paths(dirs).unwrap_or_default()-}-static INSTALLING: Mutex<Option<HashSet<String>>> = Mutex::new(None);struct InstallGuard(String);@@ -331,12 +309,13 @@ pub struct Tools {custom: BTreeMap<String, PathBuf>,/// Executables found outside the search path (app bundles), by command.found: BTreeMap<String, PathBuf>,+ version_timeout: Duration,}impl Tools {- /// Tools under `<app_data>/tools` using [`default_search_path`].+ /// Tools under `<app_data>/tools` using [`ide_core::tool_path::search_path`].pub fn new(app_data: &Path) -> Self {- Self::with_paths(tools_dir(app_data), default_search_path(), Platform::current())+ Self::with_paths(tools_dir(app_data), ide_core::tool_path::search_path(), Platform::current())}pub fn with_paths(root: PathBuf, search_path: OsString, platform: Platform) -> Self {@@ -344,7 +323,15 @@ impl Tools {let system: Vec<PathBuf> = std::env::split_paths(&search_path).filter(|d| !ours.contains(d)).collect();let system_path = std::env::join_paths(&system).unwrap_or_default();let child_path = std::env::join_paths(ours.iter().chain(system.iter())).unwrap_or_default();- Self { root, system_path, child_path, platform, custom: BTreeMap::new(), found: BTreeMap::new() }+ Self {+ root,+ system_path,+ child_path,+ platform,+ custom: BTreeMap::new(),+ found: BTreeMap::new(),+ version_timeout: Duration::from_secs(4),+ }}/// Reports the executables chosen in settings (command → path) as the tools' location.@@ -364,7 +351,7 @@ impl Tools {}fn which(&self, cmd: &str) -> Option<PathBuf> {- which::which_in(cmd, Some(&self.system_path), &self.root).ok()+ ide_core::tool_path::find_command(cmd, &self.system_path, &self.root)}fn which_any(&self, cmds: &[&str]) -> Option<PathBuf> {@@ -428,7 +415,7 @@ impl Tools {let program = sibling.or_else(|| self.which(cmd))?;let mut c = self.command(program);c.args(args);- let (ok, out) = run_quiet(c, Duration::from_secs(4))?;+ let (ok, out) = run_quiet(c, self.version_timeout)?;if !ok {return None;}@@ -548,7 +535,7 @@ impl Tools {if cmd == spec.commands[0] { path.clone() } else { path.parent().and_then(|d| self.exe_in(d, cmd))? };let mut c = self.command(program);c.args(args);- let (ok, out) = run_quiet(c, Duration::from_secs(4))?;+ let (ok, out) = run_quiet(c, self.version_timeout)?;if ok { parse_version(&out) } else { None }});info.status = ToolStatus::Custom;diff --git a/crates/ide-tools/src/server.rs b/crates/ide-tools/src/server.rsindex 3e3481c41..d62f2af67 100644--- a/crates/ide-tools/src/server.rs+++ b/crates/ide-tools/src/server.rs@@ -2,7 +2,7 @@//! version publishes one per supported host platform (see `release.yml`).use crate::process::Http;-use crate::{InstallEvent, default_search_path, fetch_verified, sources};+use crate::{InstallEvent, fetch_verified, sources};use ide_core::CancellationToken;use ide_core::{IdeError, IdeResult};use std::path::{Path, PathBuf};@@ -46,7 +46,7 @@ pub fn fetch(std::fs::create_dir_all(dir)?;let staging = tempfile_dir(dir)?;let result = (|| {- let http = Http::new(&default_search_path())?;+ let http = Http::new(&ide_core::tool_path::search_path())?;// The binary runs on the remote host: never install it unverified.let checksum_url = format!("{url}.sha256");let sha256 = sources::parse_checksum(&http.get_text(&checksum_url, cancel)?, &name)diff --git a/crates/ide-tools/src/tests.rs b/crates/ide-tools/src/tests.rsindex b9a2ec488..02226cffc 100644--- a/crates/ide-tools/src/tests.rs+++ b/crates/ide-tools/src/tests.rs@@ -24,7 +24,10 @@ impl Env {fn tools(&self) -> Tools {let mut dirs = vec![self.sys.clone()];dirs.extend(bin_dirs_in(&self.root, Platform::current()));- Tools::with_paths(self.root.clone(), std::env::join_paths(dirs).unwrap(), Platform::current())+ let mut tools = Tools::with_paths(self.root.clone(), std::env::join_paths(dirs).unwrap(), Platform::current());+ // These fixtures test detection and version parsing, not process startup latency.+ tools.version_timeout = Duration::from_secs(60);+ tools}#[cfg(unix)]