Self delete

Author: charliermarsh

Cargo.lock

@@ -184,6 +184,8 @@ impl InstalledTools {
             environment_path.user_display()
         );
 
+        // TODO(charlie): On Windows, if the current executable is in the directory,
+        // we need to use `safe_delete`.
         fs_err::remove_dir_all(environment_path)?;
 
         Ok(())

crates/uv-tool/src/lib.rs

@@ -85,6 +85,8 @@ pub(crate) fn create(
                 if allow_existing {
                     debug!("Allowing existing directory");
                 } else if location.join("pyvenv.cfg").is_file() {
+                    // TODO(charlie): On Windows, if the current executable is in the directory,
+                    // we need to use `safe_delete`.
                     debug!("Removing existing directory");
                     fs::remove_dir_all(location)?;
                     fs::create_dir_all(location)?;
@@ -142,7 +144,7 @@ pub(crate) fn create(
         )
     })?;
 
-    // Different names for the python interpreter
+    // Different enames for the python interpreter
     fs::create_dir_all(&scripts)?;
     let executable = scripts.join(format!("python{EXE_SUFFIX}"));
 

crates/uv-virtualenv/src/virtualenv.rs

@@ -98,6 +98,10 @@ walkdir = { workspace = true }
 which = { workspace = true }
 zip = { workspace = true }
 
+[target.'cfg(target_os = "windows")'.dependencies]
+same-file = { workspace = true }
+self-replace = { workspace = true }
+
 [dev-dependencies]
 assert_cmd = { version = "2.0.16" }
 assert_fs = { version = "1.1.2" }

crates/uv/Cargo.toml

@@ -123,47 +123,52 @@ pub(crate) fn install_executables(
         return Ok(ExitStatus::Failure);
     }
 
-    // Check if they exist, before installing
-    let mut existing_entry_points = target_entry_points
-        .iter()
-        .filter(|(_, _, target_path)| target_path.exists())
-        .peekable();
+    // Error if we're overwriting an existing entrypoint, unless the user passed `--force`.
+    if !force {
+        let mut existing_entry_points = target_entry_points
+            .iter()
+            .filter(|(_, _, target_path)| target_path.exists())
+            .peekable();
+        if existing_entry_points.peek().is_some() {
+            // Clean up the environment we just created
+            installed_tools.remove_environment(name)?;
 
-    // Ignore any existing entrypoints if the user passed `--force`, or the existing recept was
-    // broken.
-    if force {
-        for (name, _, target) in existing_entry_points {
-            debug!("Removing existing executable: `{name}`");
-            fs_err::remove_file(target)?;
+            let existing_entry_points = existing_entry_points
+                // SAFETY: We know the target has a filename because we just constructed it above
+                .map(|(_, _, target)| target.file_name().unwrap().to_string_lossy())
+                .collect::<Vec<_>>();
+            let (s, exists) = if existing_entry_points.len() == 1 {
+                ("", "exists")
+            } else {
+                ("s", "exist")
+            };
+            bail!(
+                "Executable{s} already {exists}: {} (use `--force` to overwrite)",
+                existing_entry_points
+                    .iter()
+                    .map(|name| name.bold())
+                    .join(", ")
+            )
         }
-    } else if existing_entry_points.peek().is_some() {
-        // Clean up the environment we just created
-        installed_tools.remove_environment(name)?;
-
-        let existing_entry_points = existing_entry_points
-            // SAFETY: We know the target has a filename because we just constructed it above
-            .map(|(_, _, target)| target.file_name().unwrap().to_string_lossy())
-            .collect::<Vec<_>>();
-        let (s, exists) = if existing_entry_points.len() == 1 {
-            ("", "exists")
-        } else {
-            ("s", "exist")
-        };
-        bail!(
-            "Executable{s} already {exists}: {} (use `--force` to overwrite)",
-            existing_entry_points
-                .iter()
-                .map(|name| name.bold())
-                .join(", ")
-        )
     }
 
+    #[cfg(windows)]
+    let itself = std::env::current_exe().ok();
+
     for (name, source_path, target_path) in &target_entry_points {
         debug!("Installing executable: `{name}`");
+
         #[cfg(unix)]
         replace_symlink(source_path, target_path).context("Failed to install executable")?;
+
         #[cfg(windows)]
-        fs_err::copy(source_path, target_path).context("Failed to install entrypoint")?;
+        if itself.as_ref().is_some_and(|itself| {
+            std::path::absolute(target_path).is_ok_and(|target| *itself == target)
+        }) {
+            self_replace::self_replace(source_path).context("Failed to install entrypoint")?;
+        } else {
+            fs_err::copy(source_path, target_path).context("Failed to install entrypoint")?;
+        }
     }
 
     let s = if target_entry_points.len() == 1 {

crates/uv/src/commands/tool/common.rs

@@ -180,13 +180,25 @@ async fn uninstall_tool(
     // Remove the tool itself.
     tools.remove_environment(name)?;
 
+    #[cfg(windows)]
+    let itself = std::env::current_exe().ok();
+
     // Remove the tool's entrypoints.
     let entrypoints = receipt.entrypoints();
     for entrypoint in entrypoints {
         debug!(
             "Removing executable: {}",
             entrypoint.install_path.user_display()
         );
+
+        #[cfg(windows)]
+        if itself.as_ref().is_some_and(|itself| {
+            std::path::absolute(&entrypoint.install_path).is_ok_and(|target| *itself == target)
+        }) {
+            self_replace::self_delete()?;
+            continue;
+        }
+
         match fs_err::tokio::remove_file(&entrypoint.install_path).await {
             Ok(()) => {}
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => {