use std::collections::HashSet;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use crate::backend::pipx::PIPXBackend;
use crate::cli::args::{BackendArg, ToolArg};
use crate::config::{Config, Settings, config_file};
use crate::errors::split_install_result;
use crate::file::display_path;
use crate::install_before::{
effective_minimum_release_age_for_tool, resolve_cli_minimum_release_age,
};
use crate::semver::split_version_prefix;
use crate::toolset::is_outdated_version;
use crate::toolset::outdated_info::OutdatedInfo;
use crate::toolset::outdated_info::prefixed_latest_query;
use crate::toolset::{
ConfigScope, InstallOptions, NeededVersions, ResolveOptions, ToolSource, ToolVersion,
ToolsetBuilder, get_versions_needed_by_tracked_configs_excluding_locks,
get_versions_needed_by_tracked_stubs,
};
use crate::ui::multi_progress_report::MultiProgressReport;
use crate::ui::progress_report::SingleReport;
use crate::{config, env, exit, runtime_symlinks, ui};
use console::Term;
use demand::DemandOption;
use eyre::{Context, Result, eyre};
use indexmap::IndexMap;
use jiff::{Span, Timestamp, civil::date};
const MAX_OUT_OF_RANGE_UPDATES: usize = 5;
#[derive(Debug, usage_rs::Args)]
#[usage(visible_alias = "up", verbatim_doc_comment, after_long_help = AFTER_LONG_HELP)]
pub(crate) struct Upgrade {
#[usage(value_name = "INSTALLED_TOOL@VERSION", verbatim_doc_comment)]
tool: Vec<ToolArg>,
#[usage(long, short = 'b', verbatim_doc_comment)]
bump: bool,
#[usage(long, short, verbatim_doc_comment, conflicts = "tool")]
interactive: bool,
#[usage(long, short, env = "MISE_JOBS", verbatim_doc_comment)]
jobs: Option<usize>,
#[usage(short = 'l', hide = true)]
legacy_bump: bool,
#[usage(long, short = 'n', verbatim_doc_comment)]
dry_run: bool,
#[usage(long, short = 'x', value_name = "INSTALLED_TOOL", verbatim_doc_comment)]
exclude: Vec<ToolArg>,
#[usage(long, verbatim_doc_comment)]
dry_run_code: bool,
#[usage(long, verbatim_doc_comment, conflicts = "local")]
inactive: bool,
#[usage(long, verbatim_doc_comment)]
local: bool,
#[usage(long, alias = "before", verbatim_doc_comment)]
minimum_release_age: Option<String>,
#[usage(long, verbatim_doc_comment)]
monorepo: bool,
#[usage(long, verbatim_doc_comment, overrides = "prune")]
no_prune: bool,
#[usage(long, verbatim_doc_comment, overrides = "no_prune")]
prune: bool,
#[usage(long, overrides = "jobs")]
raw: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum PruneMode {
None,
Immediate,
Deferred(Duration),
}
impl Upgrade {
pub(super) fn is_dry_run(&self) -> bool {
self.dry_run || self.dry_run_code
}
fn prune_mode(&self) -> Result<PruneMode> {
if self.prune {
return Ok(PruneMode::Immediate);
}
if self.no_prune || !Settings::get().upgrade.auto_prune {
return Ok(PruneMode::None);
}
Ok(PruneMode::Deferred(
Settings::get().upgrade_prune_after_duration()?,
))
}
fn scope(&self) -> ConfigScope {
if self.local {
ConfigScope::LocalOnly
} else {
ConfigScope::All
}
}
pub(crate) async fn run(mut self) -> Result<()> {
if self.legacy_bump {
deprecated_at!(
"2026.8.5",
"2027.8.5",
"cli.upgrade.bump-l",
"`mise upgrade -l` is deprecated. Use `mise upgrade -b` or `mise upgrade --bump` instead. After removal, `-l` will become shorthand for `--local`."
);
self.bump = true;
}
if self.monorepo {
unimplemented!("mise upgrade --monorepo is not implemented yet");
}
let mut config = Config::get().await?;
if !self.is_dry_run() {
crate::lockfile::migrate_monorepo_lockfiles(&config, false)?;
}
let ts = ToolsetBuilder::new()
.with_args(&self.tool)
.with_scope(self.scope())
.build(&config)
.await?;
let before_date = self.get_before_date()?;
let opts = ResolveOptions {
use_locked_version: false,
latest_versions: true,
resolve_rolling_channels: false,
prefer_exact_version: false,
before_date,
before_date_from_default: false,
filter_installed_versions_by_release_date: false,
offline: false,
refresh_remote_versions: false,
inactive: self.inactive,
};
let filter_tools = if !self.interactive && !self.tool.is_empty() {
Some(self.tool.as_slice())
} else {
None
};
let exclude_tools = if !self.exclude.is_empty() {
Some(self.exclude.as_slice())
} else {
None
};
let mut outdated = ts
.list_outdated_versions_filtered(&config, self.bump, &opts, filter_tools, exclude_tools)
.await;
self.warn_if_newer_versions_hidden_by_minimum_release_age(
&config,
&ts,
&opts,
filter_tools,
exclude_tools,
)
.await;
if self.interactive && !outdated.is_empty() {
outdated = self.get_interactive_tool_set(&outdated)?;
if outdated.is_empty() {
return Ok(());
}
}
if outdated.is_empty() {
let bump_outdated = if self.bump {
Vec::new()
} else {
ts.list_outdated_versions_filtered(
&config,
true,
&opts,
filter_tools,
exclude_tools,
)
.await
.into_iter()
.filter(|o| o.bump.is_some())
.collect::<Vec<_>>()
};
if bump_outdated.is_empty() {
info!("All tools are up to date");
} else {
let hidden = bump_outdated.len().saturating_sub(MAX_OUT_OF_RANGE_UPDATES);
let mut updates = bump_outdated
.iter()
.take(MAX_OUT_OF_RANGE_UPDATES)
.map(|o| {
let current = o.current.as_deref().unwrap_or("MISSING");
format!(" {} {} → {} ({})", o.name, current, o.latest, o.source)
})
.collect::<Vec<_>>()
.join("\n");
if hidden > 0 {
updates.push_str(&format!("\n … and {hidden} more"));
}
info!(
"Newer versions are available but do not match the configured version ranges:\n{updates}\nRun `mise outdated --bump` to view all, or `mise upgrade --bump` to update the configuration and upgrade."
);
}
} else {
self.upgrade(&mut config, outdated, before_date).await?;
}
Ok(())
}
async fn upgrade(
&self,
config: &mut Arc<Config>,
outdated: Vec<OutdatedInfo>,
before_date: Option<Timestamp>,
) -> Result<()> {
let mpr = MultiProgressReport::get();
let prune_mode = self.prune_mode()?;
let mut ts = ToolsetBuilder::new()
.with_args(&self.tool)
.with_scope(self.scope())
.build(config)
.await?;
let mut parsed_config_files: IndexMap<PathBuf, Arc<dyn config_file::ConfigFile>> =
IndexMap::new();
let mut failed_config_files = HashSet::new();
let mut outdated_with_config_files = vec![];
for o in outdated.iter() {
if let (Some(path), Some(_bump)) = (o.source.path(), &o.bump) {
let cf = if let Some(cf) = parsed_config_files.get(path) {
Some(Arc::clone(cf))
} else if failed_config_files.contains(path) {
None
} else {
match config_file::parse(path).await {
Ok(cf) => {
parsed_config_files.insert(path.to_path_buf(), Arc::clone(&cf));
Some(cf)
}
Err(e) => {
warn!("failed to parse {}: {e}", display_path(path));
failed_config_files.insert(path.to_path_buf());
None
}
}
};
if let Some(cf) = cf {
outdated_with_config_files.push((o, cf));
}
}
}
let config_file_updates = outdated_with_config_files
.iter()
.filter_map(|(o, cf)| {
if let Ok(trs) = cf.to_tool_request_set()
&& let Some(versions) = trs.tools.get(o.tool_request.ba())
&& versions.len() != 1
{
warn!("upgrading multiple versions with --bump is not yet supported");
return None;
}
Some((*o, Arc::clone(cf)))
})
.collect::<Vec<_>>();
let to_remove: Vec<_> = if prune_mode == PruneMode::None {
vec![]
} else {
outdated
.iter()
.filter_map(|o| {
o.current.as_ref().and_then(|current| {
if &o.latest == current {
return None;
}
Some((o, current.clone()))
})
})
.collect()
};
if self.is_dry_run() {
for (o, current) in &to_remove {
match prune_mode {
PruneMode::Immediate => {
miseprintln!("Would uninstall {}@{}", o.name, current);
}
PruneMode::Deferred(_) => miseprintln!(
"Would schedule {}@{} for pruning after {}",
o.name,
current,
Settings::get().upgrade.prune_after
),
PruneMode::None => unreachable!(),
}
}
for o in &outdated {
miseprintln!("Would install {}@{}", o.name, o.latest);
}
for (o, cf) in &config_file_updates {
miseprintln!(
"Would bump {}@{} in {}",
o.name,
o.tool_request.version(),
display_path(cf.get_path())
);
}
if !self.bump {
use crate::toolset::outdated_info::compute_config_bumps;
let tool_versions: Vec<(String, String)> = self
.tool
.iter()
.filter_map(|t| {
t.tvr
.as_ref()
.map(|tvr| (t.ba.short.clone(), tvr.version()))
})
.collect();
let refs: Vec<(&str, &str)> = tool_versions
.iter()
.map(|(n, v)| (n.as_str(), v.as_str()))
.collect();
let bumps = compute_config_bumps(config, &refs);
for bump in &bumps {
miseprintln!(
"Would update {} from {} to {} in {}",
bump.tool_name,
bump.old_version,
bump.new_version,
display_path(&bump.config_path)
);
}
}
if self.dry_run_code {
return Err(exit::request(1));
}
return Ok(());
}
let opts = InstallOptions {
reason: "upgrade".to_string(),
force: false,
jobs: self.jobs,
raw: self.raw,
resolve_options: ResolveOptions {
use_locked_version: false,
latest_versions: true,
resolve_rolling_channels: false,
prefer_exact_version: false,
before_date,
before_date_from_default: false,
filter_installed_versions_by_release_date: false,
offline: false,
refresh_remote_versions: false,
inactive: self.inactive,
},
locked: false,
..Default::default()
};
let (system_outdated, user_outdated): (Vec<_>, Vec<_>) =
outdated.iter().partition(|outdated| {
env::install_path_category(&outdated.tool_version.install_path())
== env::InstallPathCategory::System
});
let user_requests = user_outdated
.into_iter()
.map(|outdated| outdated.tool_request.clone())
.collect::<Vec<_>>();
let system_requests = system_outdated
.into_iter()
.map(|outdated| outdated.tool_request.clone())
.collect::<Vec<_>>();
let mut successful_versions = vec![];
let mut install_errors = vec![];
if !user_requests.is_empty() {
let (installed, result) =
split_install_result(ts.install_all_versions(config, user_requests, &opts).await);
successful_versions.extend(installed);
if let Err(err) = result {
install_errors.push(err);
}
}
if !system_requests.is_empty() {
let system_opts = InstallOptions {
install_dir: Some(Settings::get().system_installs_dir().to_path_buf()),
..opts.clone()
};
let (installed, result) = split_install_result(
ts.install_all_versions(config, system_requests, &system_opts)
.await,
);
successful_versions.extend(installed);
if let Err(err) = result {
install_errors.push(err);
}
}
let install_error = if install_errors.is_empty() {
Ok(())
} else {
Err(eyre!(
"{}",
install_errors
.into_iter()
.map(|err| format!("{err:#}"))
.collect::<Vec<_>>()
.join("\n")
))
};
let mut config_file_updates_by_path = IndexMap::new();
for (o, cf) in config_file_updates {
if successful_versions
.iter()
.any(|v| v.ba() == o.tool_version.ba())
{
config_file_updates_by_path
.entry(cf.get_path().to_path_buf())
.or_insert_with(|| (cf, vec![]))
.1
.push(o);
}
}
let mut config_file_errors = vec![];
for (path, (cf, updates)) in config_file_updates_by_path {
let mut update_failed = false;
for o in updates {
if let Err(e) =
cf.replace_versions(o.tool_request.ba(), vec![o.tool_request.clone()])
{
config_file_errors.push(eyre!("Failed to update config for {}: {}", o.name, e));
update_failed = true;
break;
}
}
if update_failed {
continue;
}
if let Err(e) = cf.save() {
config_file_errors.push(eyre!(
"Failed to save config {}: {}",
display_path(&path),
e
));
}
}
if config_file_errors.len() == 1 {
return Err(config_file_errors.pop().unwrap());
}
if !config_file_errors.is_empty() {
let errors = config_file_errors
.into_iter()
.map(|e| format!("{e:#}"))
.collect::<Vec<_>>()
.join("\n");
return Err(eyre!("Failed to update config files:\n{errors}"));
}
if !self.bump {
use crate::toolset::outdated_info::{apply_config_bumps, compute_config_bumps};
let tool_versions: Vec<(String, String)> = self
.tool
.iter()
.filter_map(|t| {
t.tvr.as_ref().and_then(|tvr| {
let name = t.ba.short.clone();
if successful_versions.iter().any(|v| v.ba().short == name) {
Some((name, tvr.version()))
} else {
None
}
})
})
.collect();
let refs: Vec<(&str, &str)> = tool_versions
.iter()
.map(|(n, v)| (n.as_str(), v.as_str()))
.collect();
let bumps = compute_config_bumps(config, &refs);
apply_config_bumps(config, &bumps)?;
}
*config = Config::reset().await?;
let ts = config.get_toolset().await?;
runtime_symlinks::rebuild_for_toolset(config, ts)
.await
.wrap_err("failed to rebuild runtime symlinks")?;
let successful_backends: HashSet<_> = successful_versions
.iter()
.flat_map(|v| {
[
v.ba().short.clone(),
v.ba().tool_name.clone(),
v.ba().full(),
v.ba().full_without_opts(),
]
})
.collect();
let mut upgraded_config_paths: HashSet<_> = outdated
.iter()
.filter(|o| backend_matches(&successful_backends, o.tool_version.ba()))
.filter_map(|o| o.source.path().map(|path| path.to_path_buf()))
.collect();
for tvl in ts.versions.values() {
if backend_matches(&successful_backends, &tvl.backend)
&& let Some(path) = tvl.source.path()
{
upgraded_config_paths.insert(path.to_path_buf());
}
}
for (path, cf) in config.config_files.iter() {
let Ok(trs) = cf.to_tool_request_set() else {
continue;
};
if trs
.tools
.keys()
.any(|ba| backend_matches(&successful_backends, ba))
{
upgraded_config_paths.insert(path.clone());
}
}
let versions_needed_by_tracked = if to_remove.is_empty() {
NeededVersions::new()
} else {
let mut needed = get_versions_needed_by_tracked_configs_excluding_locks(
config,
true,
false,
&upgraded_config_paths,
)
.await?;
needed.extend(get_versions_needed_by_tracked_stubs(config).await?);
needed
};
for (o, old_version) in to_remove {
if successful_versions
.iter()
.any(|v| v.ba() == o.tool_version.ba())
{
let old_tv = ToolVersion::new(o.tool_version.request.clone(), old_version.clone());
let version_key = (old_tv.ba().short.to_string(), old_tv.tv_pathname());
if versions_needed_by_tracked.contains_key(&version_key) {
debug!(
"Keeping {}@{} because it's still needed by a tracked config or tool stub",
o.name, old_version
);
continue;
}
match prune_mode {
PruneMode::Immediate => {
let pr = mpr.add(&format!("uninstall {}@{}", o.name, old_version));
if let Err(e) = self
.uninstall_old_version(config, &old_tv, pr.as_ref())
.await
{
warn!("Failed to uninstall old version of {}: {}", o.name, e);
} else if let Err(err) =
crate::tool_purgatory::forget_path(&old_tv.install_path())
{
warn!("failed to clear tool purgatory entry: {err:#}");
}
}
PruneMode::Deferred(after) => {
if let Err(err) = crate::tool_purgatory::schedule(&old_tv, after) {
warn!(
"failed to schedule {}@{} for pruning: {err:#}",
o.name, old_version
);
} else {
info!(
"{}@{} will be pruned after {}",
o.name,
old_version,
Settings::get().upgrade.prune_after
);
}
}
PruneMode::None => unreachable!(),
}
}
}
mpr.finish_progress();
for tv in &mut successful_versions {
if matches!(tv.request.source(), ToolSource::Argument)
&& let Some(tvl) = ts.versions.get(tv.ba())
&& matches!(&tvl.source, ToolSource::MiseToml(_))
{
if let Some(config_tv) = tvl.versions.first() {
tv.request = config_tv.request.clone();
} else {
tv.request.set_source(tvl.source.clone());
}
}
}
config::rebuild_shims_and_runtime_symlinks(
config,
ts,
&successful_versions,
crate::lockfile::LockfileUpdateMode::AllowLocked,
)
.await?;
if successful_versions.iter().any(|v| v.short() == "python") {
PIPXBackend::reinstall_all(config)
.await
.unwrap_or_else(|err| {
warn!("failed to reinstall pipx tools: {err}");
});
}
mpr.finish_progress();
Self::print_summary(&outdated, &successful_versions)?;
install_error
}
async fn uninstall_old_version(
&self,
config: &Arc<Config>,
tv: &ToolVersion,
pr: &dyn SingleReport,
) -> Result<()> {
tv.backend()?
.uninstall_version(config, tv, pr, self.dry_run)
.await
.wrap_err_with(|| format!("failed to uninstall {tv}"))?;
pr.finish();
Ok(())
}
fn print_summary(outdated: &[OutdatedInfo], successful_versions: &[ToolVersion]) -> Result<()> {
let upgraded: Vec<_> = outdated
.iter()
.filter(|o| {
successful_versions
.iter()
.any(|v| v.ba() == o.tool_version.ba() && v.version == o.latest)
})
.collect();
if !upgraded.is_empty() {
let s = if upgraded.len() == 1 { "" } else { "s" };
miseprintln!("\nUpgraded {} tool{}:", upgraded.len(), s);
for o in &upgraded {
let from = o.current.as_deref().unwrap_or("(none)");
miseprintln!(" {} {} → {}", o.name, from, o.latest);
}
}
Ok(())
}
fn get_interactive_tool_set(&self, outdated: &Vec<OutdatedInfo>) -> Result<Vec<OutdatedInfo>> {
ui::ctrlc::show_cursor_after_ctrl_c();
let theme = crate::ui::theme::get_theme();
let mut ms = demand::MultiSelect::new("mise upgrade")
.description("Select tools to upgrade")
.filterable(true)
.theme(&theme);
for out in outdated {
ms = ms.option(DemandOption::new(out.clone()));
}
match ms.run() {
Ok(selected) => Ok(selected.into_iter().collect()),
Err(e) => {
Term::stderr().show_cursor()?;
Err(eyre!(e))
}
}
}
fn get_before_date(&self) -> Result<Option<Timestamp>> {
resolve_cli_minimum_release_age(self.minimum_release_age.as_deref())
}
async fn warn_if_newer_versions_hidden_by_minimum_release_age(
&self,
config: &Arc<Config>,
ts: &crate::toolset::Toolset,
opts: &ResolveOptions,
filter_tools: Option<&[ToolArg]>,
exclude_tools: Option<&[ToolArg]>,
) {
let list_versions = if opts.inactive {
match ts.list_all_versions(config).await {
Ok(v) => v,
Err(err) => {
warn!("Failed to list all versions: {err:#}");
vec![]
}
}
} else {
ts.list_current_versions()
};
let mut warned = HashSet::new();
for (_, tv) in list_versions {
if let Some(exclude) = exclude_tools
&& exclude.iter().any(|t| t.ba.as_ref() == tv.ba())
{
continue;
}
if let Some(tools) = filter_tools
&& !tools.iter().any(|t| t.ba.as_ref() == tv.ba())
{
continue;
}
let warning_key = format!("{}@{}", tv.ba().short, tv.request.version());
if !warned.insert(warning_key) {
continue;
}
let mut opts_with_effective_before_date = opts.clone();
if let Err(err) = opts_with_effective_before_date
.apply_before_date_for_tool(tv.ba(), tv.request.options().minimum_release_age())
{
warn!(
"Error resolving minimum_release_age for {}: {err:#}",
tv.ba()
);
continue;
}
if opts_with_effective_before_date.before_date.is_none() {
continue;
}
let age = if opts.before_date.is_some() {
self.minimum_release_age.clone()
} else {
effective_minimum_release_age_for_tool(
tv.ba(),
tv.request.options().minimum_release_age(),
)
};
let eligible_latest = self
.latest_for_upgrade(config, &tv, &opts_with_effective_before_date)
.await;
let eligible_latest = match eligible_latest {
Ok(latest) => latest,
Err(err) => {
warn!("Error getting latest version for {}: {err:#}", tv.ba());
continue;
}
};
let baseline_latest = match self.baseline_latest_for_upgrade(config, &tv, opts).await {
Ok(latest) => latest,
Err(err) => {
warn!("Error getting latest version for {}: {err:#}", tv.ba());
continue;
}
};
match (eligible_latest, baseline_latest) {
(Some(eligible), Some(baseline)) if is_outdated_version(&eligible, &baseline) => {
if current_satisfies_hidden_release(config, &tv, &baseline) {
continue;
}
let suffix = format!("latest eligible release is {eligible}");
warn_hidden_release_ignored_by_minimum_release_age(
config,
&tv,
&baseline,
age.as_deref(),
&suffix,
)
.await;
}
(None, Some(baseline)) => {
if current_satisfies_hidden_release(config, &tv, &baseline) {
continue;
}
warn_hidden_release_ignored_by_minimum_release_age(
config,
&tv,
&baseline,
age.as_deref(),
"no eligible release found",
)
.await;
}
_ => {}
}
}
}
async fn latest_for_upgrade(
&self,
config: &Arc<Config>,
tv: &ToolVersion,
opts: &ResolveOptions,
) -> Result<Option<String>> {
let backend = tv.backend()?;
if self.bump || (opts.inactive && tv.request.source() == &ToolSource::Unknown) {
let (prefix, prefix_version) = split_version_prefix(&tv.request.version());
backend
.latest_version(
config,
prefixed_latest_query(&prefix, &prefix_version),
opts.before_date,
)
.await
} else {
tv.latest_version_with_opts(config, opts).await.map(Some)
}
}
async fn baseline_latest_for_upgrade(
&self,
config: &Arc<Config>,
tv: &ToolVersion,
opts: &ResolveOptions,
) -> Result<Option<String>> {
let backend = tv.backend()?;
let query = if self.bump || (opts.inactive && tv.request.source() == &ToolSource::Unknown) {
let (prefix, prefix_version) = split_version_prefix(&tv.request.version());
prefixed_latest_query(&prefix, &prefix_version)
} else {
Some(tv.request.version())
};
backend.latest_version_unfiltered(config, query).await
}
}
fn current_satisfies_hidden_release(
config: &Arc<Config>,
tv: &ToolVersion,
hidden_version: &str,
) -> bool {
OutdatedInfo::new(config, tv.clone(), hidden_version.to_string())
.ok()
.and_then(|info| info.current)
.as_deref()
.is_some_and(|current| current_version_satisfies_hidden_release(current, hidden_version))
}
fn current_version_satisfies_hidden_release(current: &str, hidden_version: &str) -> bool {
!is_outdated_version(current, hidden_version)
}
fn backend_matches(backends: &HashSet<String>, ba: &BackendArg) -> bool {
backends.contains(&ba.short)
|| backends.contains(&ba.tool_name)
|| backends.contains(&ba.full())
|| backends.contains(&ba.full_without_opts())
}
async fn warn_hidden_release_ignored_by_minimum_release_age(
config: &Arc<Config>,
tv: &ToolVersion,
hidden_version: &str,
age: Option<&str>,
suffix: &str,
) {
let (released, age) = hidden_release_details(config, tv, hidden_version, age).await;
warn!(
"newer {} release {hidden_version}{released} ignored by minimum_release_age{age}; {suffix}",
tv.ba().short
);
}
async fn hidden_release_details(
config: &Arc<Config>,
tv: &ToolVersion,
hidden_version: &str,
age: Option<&str>,
) -> (String, String) {
let created_at = match tv.backend() {
Ok(backend) => backend
.list_remote_versions_with_info(config)
.await
.ok()
.and_then(|versions| {
versions
.iter()
.find(|v| v.version == hidden_version)
.and_then(|v| v.created_at_timestamp())
}),
Err(_) => None,
};
format_hidden_release_details(created_at, age, jiff::tz::TimeZone::system())
}
fn format_hidden_release_details(
created_at: Option<Timestamp>,
age: Option<&str>,
tz: jiff::tz::TimeZone,
) -> (String, String) {
let age_fragment = age.map(|age| format!(" ({age})")).unwrap_or_default();
let released_fragment = match created_at {
Some(created) => {
let eligible_at = age.and_then(|age| release_eligible_at(created, age));
let released = created.to_zoned(tz.clone()).strftime("%Y-%m-%d");
match eligible_at {
Some(at) => format!(
" (released {released}, eligible {})",
at.to_zoned(tz).strftime("%Y-%m-%d %H:%M %Z")
),
None => format!(" (released {released})"),
}
}
None => String::new(),
};
(released_fragment, age_fragment)
}
fn release_eligible_at(created_at: Timestamp, age: &str) -> Option<Timestamp> {
const DAY_NANOS: i128 = 86_400 * 1_000_000_000;
let span = age.parse::<Span>().ok()?;
let duration = span.to_duration(date(2025, 1, 1)).ok()?;
if duration.is_negative() {
return None;
}
let mut high = created_at
.to_zoned(jiff::tz::TimeZone::UTC)
.checked_add(span)
.ok()
.map(|eligible| eligible.timestamp())?;
for _ in 0..370 {
if release_is_eligible_at(created_at, high, &span) {
let mut low_nanos = created_at.as_nanosecond();
let mut high_nanos = high.as_nanosecond();
while low_nanos < high_nanos {
let mid_nanos = low_nanos + (high_nanos - low_nanos) / 2;
let mid = Timestamp::from_nanosecond(mid_nanos).ok()?;
if release_is_eligible_at(created_at, mid, &span) {
high_nanos = mid_nanos;
} else {
low_nanos = mid_nanos + 1;
}
}
return Timestamp::from_nanosecond(high_nanos).ok();
}
high = Timestamp::from_nanosecond(high.as_nanosecond().checked_add(DAY_NANOS)?).ok()?;
}
None
}
fn release_is_eligible_at(created_at: Timestamp, now: Timestamp, age: &Span) -> bool {
now.to_zoned(jiff::tz::TimeZone::UTC)
.checked_sub(age)
.is_ok_and(|cutoff| cutoff.timestamp() > created_at)
}
static AFTER_LONG_HELP: &str = color_print::cstr!(
r#"<bold><underline>Deprecation:</underline></bold>
The `-l` shorthand for `--bump` is deprecated and will be removed in mise 2027.8.5.
After removal, `-l` will become shorthand for `--local`. Use `-b` or `--bump` instead.
<bold><underline>Examples:</underline></bold>
# Upgrades node to the latest version matching the range in mise.toml
$ <bold>mise upgrade node</bold>
# Upgrades node to the latest version and bumps the version in mise.toml
$ <bold>mise upgrade node --bump</bold>
# Upgrades all tools to the latest versions
$ <bold>mise upgrade</bold>
# Upgrades all tools to the latest versions and bumps the version in mise.toml
$ <bold>mise upgrade --bump</bold>
# Just print what would be done, don't actually do it
$ <bold>mise upgrade --dry-run</bold>
# Upgrades node and python to the latest versions
$ <bold>mise upgrade node python</bold>
# Upgrade all tools except go
$ <bold>mise upgrade --exclude go</bold>
# Show a multiselect menu to choose which tools to upgrade
$ <bold>mise upgrade --interactive</bold>
# Only upgrade tools defined in local mise.toml, not global ones
$ <bold>mise upgrade --local</bold>
"#
);
#[cfg(test)]
mod tests {
use super::{
current_version_satisfies_hidden_release, format_hidden_release_details,
release_is_eligible_at,
};
use jiff::tz::TimeZone;
#[test]
fn test_current_version_satisfies_hidden_release() {
assert!(!current_version_satisfies_hidden_release("1.0.0", "1.1.0"));
assert!(current_version_satisfies_hidden_release("1.1.0", "1.1.0"));
assert!(current_version_satisfies_hidden_release("1.2.0", "1.1.0"));
}
#[test]
fn test_format_hidden_release_details_with_duration_age() {
let created = "2026-06-26T14:03:00Z".parse().unwrap();
let (released, age) =
format_hidden_release_details(Some(created), Some("3d"), TimeZone::UTC);
assert_eq!(
released,
" (released 2026-06-26, eligible 2026-06-29 14:03 UTC)"
);
assert_eq!(age, " (3d)");
}
#[test]
fn test_format_hidden_release_details_with_calendar_age() {
let created = "2023-03-01T14:03:00Z".parse().unwrap();
let (released, age) =
format_hidden_release_details(Some(created), Some("1y"), TimeZone::UTC);
assert_eq!(
released,
" (released 2023-03-01, eligible 2024-03-01 14:03 UTC)"
);
assert_eq!(age, " (1y)");
}
#[test]
fn test_format_hidden_release_details_with_non_reversible_calendar_age() {
let created = "2019-01-31T15:30:00Z".parse().unwrap();
let (released, age) =
format_hidden_release_details(Some(created), Some("1mo"), TimeZone::UTC);
assert_eq!(
released,
" (released 2019-01-31, eligible 2019-03-01 00:00 UTC)"
);
assert_eq!(age, " (1mo)");
}
#[test]
fn test_release_is_eligible_at_uses_strict_cutoff() {
let created = "2024-01-01T00:00:00Z".parse().unwrap();
let age = "24h".parse().unwrap();
let exact_cutoff = "2024-01-02T00:00:00Z".parse().unwrap();
let after_cutoff = "2024-01-02T00:00:00.000000001Z".parse().unwrap();
assert!(!release_is_eligible_at(created, exact_cutoff, &age));
assert!(release_is_eligible_at(created, after_cutoff, &age));
}
#[test]
fn test_format_hidden_release_details_with_absolute_age() {
let created = "2026-06-26T14:03:00Z".parse().unwrap();
let (released, age) =
format_hidden_release_details(Some(created), Some("2026-01-01"), TimeZone::UTC);
assert_eq!(released, " (released 2026-06-26)");
assert_eq!(age, " (2026-01-01)");
}
#[test]
fn test_format_hidden_release_details_without_release_date() {
let (released, age) = format_hidden_release_details(None, Some("24h"), TimeZone::UTC);
assert_eq!(released, "");
assert_eq!(age, " (24h)");
}
#[test]
fn test_format_hidden_release_details_without_age() {
let created = "2026-06-26T14:03:00Z".parse().unwrap();
let (released, age) = format_hidden_release_details(Some(created), None, TimeZone::UTC);
assert_eq!(released, " (released 2026-06-26)");
assert_eq!(age, "");
}
}