feat: add --list-releases to show available versions

QaidVoid · QaidVoid · commit 78d3b892740b · 2026-04-14T10:00:22.000+05:45
diff --git a/src/main.rs b/src/main.rs
@@ -37,6 +37,9 @@ struct Cli {
     #[arg(short = 'j', long)]
     check_for_update: bool,
 
+    #[arg(short = 'l', long)]
+    list_releases: bool,
+
     #[arg(short = 't', long, value_name = "TAG")]
     target_tag: Option<String>,
 
@@ -161,6 +164,35 @@ fn run(cli: Cli) -> Result<(), Error> {
         return Ok(());
     }
 
+    if cli.list_releases {
+        for path in &appimages {
+            let updater = create_updater(&cli, path)?;
+            let name = path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or("unknown");
+            match updater.list_releases() {
+                Ok(releases) => {
+                    if appimages.len() > 1 {
+                        eprintln!("{}:", name);
+                    }
+                    let max_tag = releases.iter().map(|r| r.tag().len()).max().unwrap_or(0);
+                    for r in &releases {
+                        let date = r.published_at().split('T').next().unwrap_or("");
+                        let pre = if r.is_prerelease() {
+                            "  [pre-release]"
+                        } else {
+                            ""
+                        };
+                        eprintln!("  {:<width$}  {}{}", r.tag(), date, pre, width = max_tag);
+                    }
+                }
+                Err(e) => eprintln!("  {} Error: {}", name, e),
+            }
+        }
+        return Ok(());
+    }
+
     let totals: Arc<Mutex<Totals>> = Arc::new(Mutex::new(Totals::default()));
     let errors: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
 
diff --git a/src/update_info/forge.rs b/src/update_info/forge.rs
@@ -1,5 +1,6 @@
 use std::cell::OnceCell;
 
+pub use releasekit::Release as ReleaseInfo;
 use releasekit::client::UreqClient;
 use releasekit::platform::{GitHub, GitLab, Gitea};
 use releasekit::{Filter, Forge, Release};
@@ -56,64 +57,83 @@ impl ForgeUpdateInfo {
         Ok(self.resolved_url.get().unwrap())
     }
 
+    pub fn list_releases(&self) -> Result<Vec<Release>> {
+        let project = format!("{}/{}", self.owner, self.repo);
+        self.with_forge(|forge| {
+            forge
+                .fetch_releases(&project, None)
+                .map_err(|e| Error::ForgeApi(e.to_string()))
+        })
+    }
+
     fn resolve_url(&self) -> Result<String> {
+        self.with_forge(|forge| self.fetch_with_forge(forge))
+    }
+
+    fn with_forge<T>(&self, action: impl Fn(&dyn Forge) -> Result<T>) -> Result<T> {
         match &self.kind {
-            ForgeKind::GitHub => self.resolve_with_proxies(
+            ForgeKind::GitHub => self.with_forge_proxied(
                 config::get_github_proxies(),
                 |base| {
                     GitHub::new(UreqClient)
                         .with_base_url(base)
                         .with_token_from_env(&["GITHUB_TOKEN", "GH_TOKEN"])
                 },
                 || GitHub::new(UreqClient).with_token_from_env(&["GITHUB_TOKEN", "GH_TOKEN"]),
+                &action,
             ),
-            ForgeKind::GitLab => self.resolve_with_proxies(
+            ForgeKind::GitLab => self.with_forge_proxied(
                 config::get_gitlab_proxies(),
                 |base| {
                     GitLab::new(UreqClient)
                         .with_base_url(base)
                         .with_token_from_env(&["GITLAB_TOKEN", "GL_TOKEN"])
                 },
                 || GitLab::new(UreqClient).with_token_from_env(&["GITLAB_TOKEN", "GL_TOKEN"]),
+                &action,
             ),
-            ForgeKind::Codeberg => self.resolve_with_proxies(
+            ForgeKind::Codeberg => self.with_forge_proxied(
                 config::get_codeberg_proxies(),
                 |base| Gitea::new(UreqClient, base).with_token_from_env(&["CODEBERG_TOKEN"]),
                 || {
                     Gitea::new(UreqClient, "https://codeberg.org")
                         .with_token_from_env(&["CODEBERG_TOKEN"])
                 },
+                &action,
             ),
             ForgeKind::Gitea { instance } => {
                 let gt = Gitea::new(UreqClient, format!("https://{instance}"))
                     .with_token_from_env(&["GITEA_TOKEN"]);
-                self.fetch_with_forge(gt)
+                action(&gt)
             }
         }
     }
 
-    fn resolve_with_proxies<F: Forge>(
+    fn with_forge_proxied<F: Forge, T>(
         &self,
         proxies: Vec<String>,
         make_proxy: impl Fn(&str) -> F,
         make_default: impl FnOnce() -> F,
-    ) -> Result<String> {
+        action: &impl Fn(&dyn Forge) -> Result<T>,
+    ) -> Result<T> {
         if proxies.is_empty() {
-            return self.fetch_with_forge(make_default());
+            let forge = make_default();
+            return action(&forge);
         }
 
         let mut last_error = None;
         for proxy in &proxies {
-            match self.fetch_with_forge(make_proxy(proxy)) {
-                Ok(url) => return Ok(url),
+            let forge = make_proxy(proxy);
+            match action(&forge) {
+                Ok(v) => return Ok(v),
                 Err(e) => last_error = Some(e),
             }
         }
 
         Err(last_error.unwrap_or_else(|| Error::ForgeApi("All proxies failed".into())))
     }
 
-    fn fetch_with_forge(&self, forge: impl Forge) -> Result<String> {
+    fn fetch_with_forge(&self, forge: &dyn Forge) -> Result<String> {
         let project = format!("{}/{}", self.owner, self.repo);
 
         let (tag, find_prerelease) = match self.tag.as_str() {
diff --git a/src/update_info/mod.rs b/src/update_info/mod.rs
@@ -3,6 +3,7 @@ mod generic;
 mod parser;
 
 pub use forge::ForgeUpdateInfo;
+pub use forge::ReleaseInfo;
 pub use generic::GenericUpdateInfo;
 
 use crate::error::Result;
@@ -43,6 +44,15 @@ impl UpdateInfo {
         matches!(self.inner, UpdateInfoInner::Forge(_))
     }
 
+    pub fn list_releases(&self) -> Result<Vec<ReleaseInfo>> {
+        match &self.inner {
+            UpdateInfoInner::Generic(_) => Err(crate::error::Error::InvalidUpdateInfo(
+                "--list-releases is only supported for forge-based update info".into(),
+            )),
+            UpdateInfoInner::Forge(f) => f.list_releases(),
+        }
+    }
+
     pub fn zsync_url(&self) -> Result<String> {
         match &self.inner {
             UpdateInfoInner::Generic(g) => Ok(g.zsync_url().to_owned()),
diff --git a/src/updater.rs b/src/updater.rs
@@ -172,6 +172,10 @@ impl Updater {
         self.update_info.raw()
     }
 
+    pub fn list_releases(&self) -> Result<Vec<crate::update_info::ReleaseInfo>> {
+        self.update_info.list_releases()
+    }
+
     pub fn zsync_url(&self) -> Result<String> {
         self.update_info.zsync_url()
     }

Original file line number	Diff line number	Diff line change
`@@ -172,6 +172,10 @@ impl Updater {`
`172`	`172`	`self.update_info.raw()`
`173`	`173`	`}`
`174`	`174`
	`175`	`+ pub fn list_releases(&self) -> Result<Vec<crate::update_info::ReleaseInfo>> {`
	`176`	`+ self.update_info.list_releases()`
	`177`	`+ }`
	`178`	`+`
`175`	`179`	`pub fn zsync_url(&self) -> Result<String> {`
`176`	`180`	`self.update_info.zsync_url()`
`177`	`181`	`}`