From 4f2fc3ecb1499e468749a2bbcde41388a245b700 Mon Sep 17 00:00:00 2001 From: l0ng-ai Date: Mon, 16 Nov 2026 13:31:40 +0800 Subject: [PATCH] fix(tools): reinstall Python tool environments moved from where they were created (#3674) uv's launchers and venv script shebangs name the interpreter by absolute path, so a managed virtual environment copied to another location (a data directory moved outside the IDE, a relocated AppData) fails with "uv trampoline failed to canonicalize script path". At start-up, a PipVenv tool whose activation script names another location is removed, so it is installed again when needed. The IDE's own data migrations already leave these environments behind. Fixes #3581 --- crates/ide-host/src/data_dirs.rs | 4 +- crates/ide-tools/src/lib.rs | 3 + crates/ide-tools/src/moved_venv.rs | 124 +++++++++++++++++++++++++++++ 3 files changed, 130 insertions(+), 1 deletion(-) create mode 100644 crates/ide-tools/src/moved_venv.rs diff --git a/crates/ide-host/src/data_dirs.rs b/crates/ide-host/src/data_dirs.rs index d51d92943..3f2bea522 100644 --- a/crates/ide-host/src/data_dirs.rs +++ b/crates/ide-host/src/data_dirs.rs @@ -320,7 +320,8 @@ fn rename_failure(error: &io::Error) -> RenameFailure { } /// Only Windows splits these paths. Renames are cheap; cross-volume copies run in -/// the background. Consumers always use Local, even when migration fails. +/// the background. Consumers always use Local, even when migration fails. On every +/// system, tool virtual environments moved from elsewhere are dropped (#3581). pub fn migrate(data: &Path, local: &Path) { if cfg!(target_os = "windows") && data != local { migrate_entries(data, local); @@ -328,6 +329,7 @@ pub fn migrate(data: &Path, local: &Path) { if cfg!(target_os = "windows") { relative_tool_shims(&local.join("tools")); } + ide_tools::drop_moved_venvs(&local.join("tools")); } /// Wrappers written before they named their tool relative to themselves hold its absolute diff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rs index 6804c6176..439772b90 100644 --- a/crates/ide-tools/src/lib.rs +++ b/crates/ide-tools/src/lib.rs @@ -19,6 +19,7 @@ pub mod archive; mod bundled; pub mod formatter; pub mod jdk; +mod moved_venv; pub mod platform; #[cfg(any(windows, test))] pub mod portable_update; @@ -47,6 +48,8 @@ use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::mpsc; use std::time::Duration; +pub use moved_venv::drop_moved_venvs; + #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Type)] #[serde(rename_all = "camelCase")] pub enum ToolStatus { diff --git a/crates/ide-tools/src/moved_venv.rs b/crates/ide-tools/src/moved_venv.rs new file mode 100644 index 000000000..1a907873f --- /dev/null +++ b/crates/ide-tools/src/moved_venv.rs @@ -0,0 +1,124 @@ +//! Managed virtual environments only work where they were created: their launchers +//! (uv's `.exe` trampolines, script shebangs) name the interpreter by absolute path. +//! One moved from outside the IDE (a copied data directory, a relocated AppData) fails +//! to start, so it is removed and installed afresh when next needed. + +use crate::registry::{Method, TOOLS}; +use std::path::{Path, PathBuf}; + +/// Removes the managed virtual-environment tools under `tools_root` that no longer sit +/// where they were created. Call at start-up, before language servers start. +pub fn drop_moved_venvs(tools_root: &Path) { + for spec in TOOLS.iter().filter(|spec| matches!(spec.method, Method::PipVenv { .. })) { + let dir = tools_root.join(spec.name); + if !venv_moved(&dir.join("venv")) { + continue; + } + tracing::info!(?dir, "virtual environment was moved from where it was created; removing it to reinstall"); + if let Err(error) = std::fs::remove_dir_all(&dir) { + tracing::warn!(?dir, %error, "cannot remove the moved virtual environment"); + } + } +} + +fn venv_moved(venv: &Path) -> bool { + let Some(created) = venv_origin(venv) else { return false }; + match (std::fs::canonicalize(&created), std::fs::canonicalize(venv)) { + (Ok(created), Ok(venv)) => created != venv, + // The interpreter path its launchers hold is gone. + (Err(_), Ok(_)) => true, + _ => false, + } +} + +/// Where a virtual environment was created: the `VIRTUAL_ENV` its activation script sets. +fn venv_origin(venv: &Path) -> Option { + let script = + if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") }; + let text = std::fs::read_to_string(script).ok()?; + text.lines().find_map(virtual_env).map(PathBuf::from) +} + +/// The path a line of an activation script assigns to `VIRTUAL_ENV`, as uv and CPython write them: +/// `VIRTUAL_ENV='/v'`, `VIRTUAL_ENV="/v"`, `export VIRTUAL_ENV=$(cygpath "/v")`, +/// `set "VIRTUAL_ENV=C:\v"`, and uv's `@for %%i in ("C:\v") do @set "VIRTUAL_ENV=%%~fi"`. +fn virtual_env(line: &str) -> Option<&str> { + let at = line.find("VIRTUAL_ENV=")?; + if let Some(start) = line[..at].find("in (\"") { + let rest = &line[start + 5..]; + return rest.find('"').map(|end| &rest[..end]).filter(|value| !value.is_empty()); + } + let rest = line[at + "VIRTUAL_ENV=".len()..].trim_start_matches("$(cygpath "); + let value = match rest.chars().next()? { + quote @ ('"' | '\'') => rest[1..].split(quote).next()?, + _ if line[..at].ends_with('"') => rest.split('"').next()?, + _ => rest.split_whitespace().next()?.trim_end_matches(')'), + }; + (!value.is_empty() && !value.starts_with(['$', '%'])).then_some(value) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn reads_virtual_env_as_uv_and_cpython_write_it() { + assert_eq!(virtual_env("VIRTUAL_ENV='/data/tools/ty/venv'"), Some("/data/tools/ty/venv")); + assert_eq!(virtual_env("VIRTUAL_ENV=\"/a b/venv\""), Some("/a b/venv")); + assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath \"/a/venv\")"), Some("/a/venv")); + assert_eq!(virtual_env(" export VIRTUAL_ENV=$(cygpath /a/venv)"), Some("/a/venv")); + assert_eq!(virtual_env(r#"set "VIRTUAL_ENV=E:\App Data\tools\ty\venv""#), Some(r"E:\App Data\tools\ty\venv")); + assert_eq!( + virtual_env(r#"@for %%i in ("E:\data\tools\ty\venv") do @set "VIRTUAL_ENV=%%~fi""#), + Some(r"E:\data\tools\ty\venv") + ); + assert_eq!(virtual_env(" export VIRTUAL_ENV"), None); + assert_eq!(virtual_env("unset VIRTUAL_ENV_PROMPT"), None); + assert_eq!(virtual_env("set VIRTUAL_ENV=%~dp0.."), None); + } + + fn venv_created_at(tools: &Path, name: &str, origin: &Path) { + let venv = tools.join(name).join("venv"); + let script = + if cfg!(windows) { venv.join("Scripts").join("activate.bat") } else { venv.join("bin").join("activate") }; + std::fs::create_dir_all(script.parent().unwrap()).unwrap(); + let line = if cfg!(windows) { + format!("@for %%i in (\"{}\") do @set \"VIRTUAL_ENV=%%~fi\"\r\n", origin.display()) + } else { + format!("VIRTUAL_ENV='{}'\nexport VIRTUAL_ENV\n", origin.display()) + }; + std::fs::write(script, line).unwrap(); + } + + #[test] + fn removes_only_virtual_environments_moved_from_where_they_were_created() { + let tmp = tempfile::tempdir().unwrap(); + let tools = tmp.path().join("tools"); + // Created here. + venv_created_at(&tools, "ty", &tools.join("ty").join("venv")); + // Copied from another data directory that is gone. + venv_created_at(&tools, "basedpyright", &tmp.path().join("old/tools/basedpyright/venv")); + // Copied, the original still in place. + let old_ruff = tmp.path().join("old-kept/tools/ruff/venv"); + std::fs::create_dir_all(&old_ruff).unwrap(); + venv_created_at(&tools, "ruff", &old_ruff); + // No activation script to tell. + std::fs::create_dir_all(tools.join("pyrefly").join("venv")).unwrap(); + // Not a virtual-environment tool. + std::fs::create_dir_all(tools.join("gopls").join("bin")).unwrap(); + + drop_moved_venvs(&tools); + + assert!(tools.join("ty").exists()); + assert!(!tools.join("basedpyright").exists()); + assert!(!tools.join("ruff").exists()); + assert!(tools.join("pyrefly").exists()); + assert!(tools.join("gopls").exists()); + } + + #[test] + fn a_missing_tools_directory_is_left_alone() { + let tmp = tempfile::tempdir().unwrap(); + drop_moved_venvs(&tmp.path().join("missing")); + } +}