feat(ls-remote): add created_at timestamps to ls-remote --json for core plugins

e2e/cli/test_ls_cache

@@ -4,6 +4,6 @@ export MISE_USE_VERSIONS_HOST=1
 # verify that cache is reused for `mise ls`
 # see https://github.com/jdx/mise/discussions/6736
 
-assert_contains "mise -v use bat 2>&1" "GET https://mise-versions.jdx.dev/bat 200 OK"
+assert_contains "mise -v use bat 2>&1" "GET https://mise-versions.jdx.dev/bat.toml 200 OK"
 touch -t 202001010000 "$MISE_CACHE_DIR/bat/"*
-assert_not_contains "mise -v ls bat 2>&1" "GET https://mise-versions.jdx.dev/bat 200 OK"
+assert_not_contains "mise -v ls bat 2>&1" "GET https://mise-versions.jdx.dev/bat.toml 200 OK"

src/backend/mod.rs

@@ -17,7 +17,7 @@ use crate::lockfile::PlatformInfo;
 use crate::platform::Platform;
 use crate::plugins::core::CORE_PLUGINS;
 use crate::plugins::{PluginType, VERSION_REGEX};
-use crate::registry::{REGISTRY, tool_enabled};
+use crate::registry::{REGISTRY, full_to_url, normalize_remote, tool_enabled};
 use crate::runtime_symlinks::is_runtime_symlink;
 use crate::toolset::outdated_info::OutdatedInfo;
 use crate::toolset::{ToolRequest, ToolVersion, Toolset, install_state, is_outdated_version};
@@ -312,6 +312,10 @@ pub trait Backend: Debug + Send + Sync {
     /// List remote versions with additional metadata like created_at timestamps.
     /// Results are cached. Backends can override `_list_remote_versions_with_info`
     /// to provide timestamp information.
+    ///
+    /// This method first tries the versions host (mise-versions.jdx.dev) which provides
+    /// version info with created_at timestamps. If that fails, it falls back to the
+    /// backend's `_list_remote_versions_with_info` implementation.
     async fn list_remote_versions_with_info(
         &self,
         config: &Arc<Config>,
@@ -320,25 +324,51 @@ pub trait Backend: Debug + Send + Sync {
         let remote_versions = remote_versions.lock().await;
         let ba = self.ba().clone();
         let id = self.id();
+
+        // Check if this is an external plugin with a custom remote - skip versions host if so
+        let use_versions_host = if let Some(plugin) = self.plugin()
+            && let Ok(Some(remote_url)) = plugin.get_remote_url()
+        {
+            // Check if remote matches the registry default
+            let normalized_remote =
+                normalize_remote(&remote_url).unwrap_or_else(|_| "INVALID_URL".into());
+            let shorthand_remote = REGISTRY
+                .get(plugin.name())
+                .and_then(|rt| rt.backends().first().map(|b| full_to_url(b)))
+                .unwrap_or_default();
+            let matches =
+                normalized_remote == normalize_remote(&shorthand_remote).unwrap_or_default();
+            if !matches {
+                trace!(
+                    "Skipping versions host for {} because it has a non-default remote",
+                    ba.short
+                );
+            }
+            matches
+        } else {
+            true // Core plugins and plugins without remote URLs can use versions host
+        };
+
         let versions = remote_versions
             .get_or_try_init_async(|| async {
                 trace!("Listing remote versions for {}", ba.to_string());
-                // Try versions host first (returns just version strings)
-                match versions_host::list_versions(&ba).await {
-                    Ok(Some(versions)) => {
-                        return Ok(versions
-                            .into_iter()
-                            .map(|v| VersionInfo {
-                                version: v,
-                                created_at: None,
-                            })
-                            .collect());
-                    }
-                    Ok(None) => {}
-                    Err(e) => {
-                        debug!("Error getting versions from versions host: {:#}", e);
+                // Try versions host first (now returns VersionInfo with timestamps)
+                if use_versions_host {
+                    match versions_host::list_versions(&ba.short).await {
+                        Ok(Some(versions)) => {
+                            trace!(
+                                "Got {} versions from versions host for {}",
+                                versions.len(),
+                                ba.to_string()
+                            );
+                            return Ok(versions);
+                        }
+                        Ok(None) => {}
+                        Err(e) => {
+                            debug!("Error getting versions from versions host: {:#}", e);
+                        }
                     }
-                };
+                }
                 trace!(
                     "Calling backend to list remote versions for {}",
                     ba.to_string()

src/plugins/core/bun.rs

@@ -18,7 +18,9 @@ use crate::lockfile::PlatformInfo;
 use crate::toolset::ToolVersion;
 use crate::ui::progress_report::SingleReport;
 use crate::{
-    backend::{Backend, GitHubReleaseInfo, ReleaseType, platform_target::PlatformTarget},
+    backend::{
+        Backend, GitHubReleaseInfo, ReleaseType, VersionInfo, platform_target::PlatformTarget,
+    },
     config::{Config, Settings},
     platform::Platform,
 };
@@ -111,14 +113,24 @@ impl Backend for BunPlugin {
         }
     }
 
-    async fn _list_remote_versions(&self, _config: &Arc<Config>) -> Result<Vec<String>> {
+    async fn _list_remote_versions_with_info(
+        &self,
+        _config: &Arc<Config>,
+    ) -> Result<Vec<VersionInfo>> {
         let versions = github::list_releases("oven-sh/bun")
             .await?
             .into_iter()
-            .map(|r| r.tag_name)
-            .filter_map(|v| v.strip_prefix("bun-v").map(|v| v.to_string()))
-            .unique()
-            .sorted_by_cached_key(|s| (Versioning::new(s), s.to_string()))
+            .filter_map(|r| {
+                r.tag_name
+                    .strip_prefix("bun-v")
+                    .map(|v| (v.to_string(), r.created_at))
+            })
+            .unique_by(|(v, _)| v.clone())
+            .sorted_by_cached_key(|(s, _)| (Versioning::new(s), s.to_string()))
+            .map(|(version, created_at)| VersionInfo {
+                version,
+                created_at: Some(created_at),
+            })
             .collect();
         Ok(versions)
     }

src/plugins/core/elixir.rs

@@ -11,7 +11,7 @@ use crate::install_context::InstallContext;
 use crate::plugins::VERSION_REGEX;
 use crate::toolset::{ToolVersion, Toolset};
 use crate::ui::progress_report::SingleReport;
-use crate::{backend::Backend, config::Config};
+use crate::{backend::Backend, backend::VersionInfo, config::Config};
 use crate::{env, file, plugins};
 use async_trait::async_trait;
 use eyre::Result;
@@ -89,15 +89,29 @@ impl Backend for ElixirPlugin {
         &self.ba
     }
 
-    async fn _list_remote_versions(&self, _config: &Arc<Config>) -> Result<Vec<String>> {
-        let versions: Vec<String> = HTTP_FETCH
+    async fn _list_remote_versions_with_info(
+        &self,
+        _config: &Arc<Config>,
+    ) -> Result<Vec<VersionInfo>> {
+        // Format: "version hash timestamp checksum"
+        // Example: "v1.17.3 abc123 2024-12-01T00:00:00Z def456"
+        let versions: Vec<VersionInfo> = HTTP_FETCH
             .get_text("https://builds.hex.pm/builds/elixir/builds.txt")
             .await?
             .lines()
             .unique()
-            .filter_map(|s| s.split_once(' ').map(|(v, _)| v.trim_start_matches('v')))
-            .filter(|s| regex!(r"^[0-9]+\.[0-9]+\.[0-9]").is_match(s))
-            .sorted_by_cached_key(|s| {
+            .filter_map(|s| {
+                let parts: Vec<&str> = s.split_whitespace().collect();
+                if parts.len() >= 3 {
+                    let version = parts[0].trim_start_matches('v');
+                    let timestamp = parts[2]; // Third field is the timestamp
+                    Some((version.to_string(), timestamp.to_string()))
+                } else {
+                    None
+                }
+            })
+            .filter(|(v, _)| regex!(r"^[0-9]+\.[0-9]+\.[0-9]").is_match(v))
+            .sorted_by_cached_key(|(s, _)| {
                 (
                     Versioning::new(s.split_once('-').map(|(v, _)| v).unwrap_or(s)),
                     !VERSION_REGEX.is_match(s),
@@ -106,7 +120,10 @@ impl Backend for ElixirPlugin {
                     s.to_string(),
                 )
             })
-            .map(|s| s.to_string())
+            .map(|(version, created_at)| VersionInfo {
+                version,
+                created_at: Some(created_at),
+            })
             .collect();
         Ok(versions)
     }

src/plugins/core/erlang.rs

@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 use std::{path::PathBuf, sync::Arc};
 
 use crate::backend::Backend;
+use crate::backend::VersionInfo;
 use crate::backend::platform_target::PlatformTarget;
 use crate::cli::args::BackendArg;
 use crate::config::{Config, Settings};
@@ -305,12 +306,23 @@ impl Backend for ErlangPlugin {
         &self.ba
     }
 
-    async fn _list_remote_versions(&self, _config: &Arc<Config>) -> Result<Vec<String>> {
+    async fn _list_remote_versions_with_info(
+        &self,
+        _config: &Arc<Config>,
+    ) -> Result<Vec<VersionInfo>> {
         let versions = if Settings::get().erlang.compile == Some(false) {
             github::list_releases("erlef/otp_builds")
                 .await?
                 .into_iter()
-                .filter_map(|r| r.tag_name.strip_prefix("OTP-").map(|s| s.to_string()))
+                .filter_map(|r| {
+                    r.tag_name
+                        .strip_prefix("OTP-")
+                        .map(|s| (s.to_string(), Some(r.created_at)))
+                })
+                .map(|(version, created_at)| VersionInfo {
+                    version,
+                    created_at,
+                })
                 .collect()
         } else {
             self.update_kerl().await?;
@@ -321,7 +333,10 @@ impl Backend for ErlangPlugin {
                 let versions = output
                     .split('\n')
                     .filter(|s| regex!(r"^[0-9].+$").is_match(s))
-                    .map(|s| s.to_string())
+                    .map(|s| VersionInfo {
+                        version: s.to_string(),
+                        created_at: None,
+                    })
                     .collect();
                 Ok(versions)
             })?

src/plugins/core/node.rs

@@ -1,3 +1,4 @@
+use crate::backend::VersionInfo;
 use crate::backend::static_helpers::fetch_checksum_from_shasums;
 use crate::backend::{Backend, VersionCacheManager, platform_target::PlatformTarget};
 use crate::build_time::built_info;
@@ -403,7 +404,10 @@ impl Backend for NodePlugin {
         &self.ba
     }
 
-    async fn _list_remote_versions(&self, _config: &Arc<Config>) -> Result<Vec<String>> {
+    async fn _list_remote_versions_with_info(
+        &self,
+        _config: &Arc<Config>,
+    ) -> Result<Vec<VersionInfo>> {
         let settings = Settings::get();
         let base = Settings::get().node.mirror_url();
         let versions = HTTP_FETCH
@@ -420,10 +424,14 @@ impl Backend for NodePlugin {
                 }
             })
             .map(|v| {
-                if regex!(r"^v\d+\.").is_match(&v.version) {
+                let version = if regex!(r"^v\d+\.").is_match(&v.version) {
                     v.version.strip_prefix('v').unwrap().to_string()
                 } else {
                     v.version
+                };
+                VersionInfo {
+                    version,
+                    created_at: v.date,
                 }
             })
             .rev()
@@ -792,5 +800,6 @@ fn slug(v: &str) -> String {
 #[derive(Debug, Deserialize)]
 struct NodeVersion {
     version: String,
+    date: Option<String>,
     files: Vec<String>,
 }

src/plugins/core/ruby.rs

@@ -592,15 +592,6 @@ impl Backend for RubyPlugin {
     fn ba(&self) -> &Arc<BackendArg> {
         &self.ba
     }
-    async fn _list_remote_versions(&self, config: &Arc<Config>) -> Result<Vec<String>> {
-        Ok(self
-            ._list_remote_versions_with_info(config)
-            .await?
-            .into_iter()
-            .map(|v| v.version)
-            .collect())
-    }
-
     async fn _list_remote_versions_with_info(
         &self,
         _config: &Arc<Config>,

src/plugins/core/rust.rs

@@ -2,6 +2,7 @@ use std::path::{Path, PathBuf};
 use std::{collections::BTreeMap, sync::Arc};
 
 use crate::backend::Backend;
+use crate::backend::VersionInfo;
 use crate::build_time::TARGET;
 use crate::cli::args::BackendArg;
 use crate::cmd::CmdLineRunner;
@@ -73,13 +74,32 @@ impl Backend for RustPlugin {
         &self.ba
     }
 
-    async fn _list_remote_versions(&self, _config: &Arc<Config>) -> Result<Vec<String>> {
-        let versions = github::list_releases("rust-lang/rust")
+    async fn _list_remote_versions_with_info(
+        &self,
+        _config: &Arc<Config>,
+    ) -> Result<Vec<VersionInfo>> {
+        let versions: Vec<VersionInfo> = github::list_releases("rust-lang/rust")
             .await?
             .into_iter()
-            .map(|r| r.tag_name)
+            .map(|r| VersionInfo {
+                version: r.tag_name,
+                created_at: Some(r.created_at),
+            })
             .rev()
-            .chain(vec!["nightly".into(), "beta".into(), "stable".into()])
+            .chain(vec![
+                VersionInfo {
+                    version: "nightly".into(),
+                    created_at: None,
+                },
+                VersionInfo {
+                    version: "beta".into(),
+                    created_at: None,
+                },
+                VersionInfo {
+                    version: "stable".into(),
+                    created_at: None,
+                },
+            ])
             .collect();
         Ok(versions)
     }

src/plugins/core/swift.rs

@@ -5,7 +5,7 @@ use crate::http::HTTP;
 use crate::install_context::InstallContext;
 use crate::toolset::ToolVersion;
 use crate::ui::progress_report::SingleReport;
-use crate::{backend::Backend, config::Config};
+use crate::{backend::Backend, backend::VersionInfo, config::Config};
 use crate::{file, github, gpg, plugins};
 use async_trait::async_trait;
 use eyre::Result;
@@ -159,14 +159,24 @@ impl Backend for SwiftPlugin {
         &self.ba
     }
 
-    async fn _list_remote_versions(&self, _config: &Arc<Config>) -> Result<Vec<String>> {
+    async fn _list_remote_versions_with_info(
+        &self,
+        _config: &Arc<Config>,
+    ) -> Result<Vec<VersionInfo>> {
         let versions = github::list_releases("swiftlang/swift")
             .await?
             .into_iter()
-            .map(|r| r.tag_name)
-            .filter_map(|v| v.strip_prefix("swift-").map(|v| v.to_string()))
-            .filter_map(|v| v.strip_suffix("-RELEASE").map(|v| v.to_string()))
+            .filter_map(|r| {
+                r.tag_name
+                    .strip_prefix("swift-")
+                    .and_then(|v| v.strip_suffix("-RELEASE"))
+                    .map(|v| (v.to_string(), r.created_at))
+            })
             .rev()
+            .map(|(version, created_at)| VersionInfo {
+                version,
+                created_at: Some(created_at),
+            })
             .collect();
         Ok(versions)
     }