Add --dry-run support to uv self update

crates/uv-cli/src/lib.rs

@@ -511,6 +511,12 @@ pub struct SelfUpdateArgs {
     /// A token is not required but can be used to reduce the chance of encountering rate limits.
     #[arg(long, env = EnvVars::UV_GITHUB_TOKEN)]
     pub token: Option<String>,
+
+    /// Run without performing the update.
+    ///
+    /// uv will report if it would upgrade or not.
+    #[arg(long)]
+    pub dry_run: bool,
 }
 
 #[derive(Args)]

crates/uv/src/commands/self_update.rs

@@ -15,6 +15,7 @@ use crate::printer::Printer;
 pub(crate) async fn self_update(
     version: Option<String>,
     token: Option<String>,
+    dry_run: bool,
     printer: Printer,
 ) -> Result<ExitStatus> {
     let mut updater = AxoUpdater::new_for("uv");
@@ -87,7 +88,38 @@ pub(crate) async fn self_update(
         UpdateRequest::Latest
     };
 
-    updater.configure_version_specifier(update_request);
+    updater.configure_version_specifier(update_request.clone());
+
+    if dry_run {
+        // TODO: `updater.fetch_release` is not public, we can't say what the latest version is
+        if updater.is_update_needed().await? {
+            // TODO: `updater.version_specifier` is not public
+            let version = match update_request {
+                UpdateRequest::Latest | UpdateRequest::LatestMaybePrerelease => {
+                    "the latest version".to_string()
+                }
+                UpdateRequest::SpecificTag(version) | UpdateRequest::SpecificVersion(version) => {
+                    format!("v{version}")
+                }
+            };
+            writeln!(
+                printer.stderr(),
+                "Would update uv from {} to {}",
+                format!("v{}", env!("CARGO_PKG_VERSION")).bold().white(),
+                version.bold().white(),
+            )?;
+        } else {
+            writeln!(
+                printer.stderr(),
+                "{}",
+                format_args!(
+                    "Nothing to do. You're on the latest version of uv ({})",
+                    format!("v{}", env!("CARGO_PKG_VERSION")).bold().white()
+                )
+            )?;
+        }
+        return Ok(ExitStatus::Success);
+    }
 
     // Run the updater. This involves a network request, since we need to determine the latest
     // available version of uv.

crates/uv/src/lib.rs

@@ -838,8 +838,9 @@ async fn run(mut cli: Cli) -> Result<ExitStatus> {
                 SelfCommand::Update(SelfUpdateArgs {
                     target_version,
                     token,
+                    dry_run,
                 }),
-        }) => commands::self_update(target_version, token, printer).await,
+        }) => commands::self_update(target_version, token, dry_run, printer).await,
         #[cfg(not(feature = "self-update"))]
         Commands::Self_(_) => {
             anyhow::bail!(