feat(ubi): add support for self-hosted GitHub/GitLab

Author: roele

Cargo.lock

@@ -151,6 +151,7 @@ zip = { version = "=2.5.0", default-features = false, features = ["deflate"] }
 zstd = "0.13"
 gix = { version = "<1", features = ["worktree-mutation"] }
 jiff = "0.2"
+urlencoding = "2.1.3"
 
 [target.'cfg(unix)'.dependencies]
 exec = "0.3"

Cargo.toml

@@ -69,6 +69,26 @@ then this will be ignored.
 "ubi:BurntSushi/ripgrep" = { version = "latest", matching = "musl" }
 ```
 
+### `provider`
+
+Set the provider type to use for fetching assets and release information. Either `github` or `gitlab` (default is `github`).
+Ensure the `provider` is set to the correct type if you use `api_url` as the type probably cannot be derived correctly
+from the URL.
+
+```toml
+[tools]
+"ubi:gitlab-org/cli" = { version = "latest", exe = "glab", provider = "gitlab" }
+```
+
+### `api_url`
+
+Set the URL for the provider's API. This is useful when using a self-hosted instance.
+
+```toml
+[tools]
+"ubi:acme/my-tool" = { version = "latest", provider= "gitlab", api_url = "https://gitlab.acme.com/api/v4" }
+```
+
 ### `extract_all`
 
 Set to `true` to extract all files in the tarball instead of just the "bin". Not compatible with `exe` nor `rename_exe`.
@@ -100,6 +120,12 @@ releases.
 "ubi:cargo-bins/cargo-binstall" = { version = "latest", tag_regex = "^\d+\." }
 ```
 
+## Self-hosted GitHub/GitLab
+
+If you are using a self-hosted GitHub/GitLab instance, you can set the `provider` and `api_url` tool options.
+Additionally, you can set the `MISE_GITHUB_ENTERPRISE_TOKEN` or `MISE_GITLAB_ENTERPRISE_TOKEN` environment variable to
+authenticate with the API.
+
 ## Supported Ubi Syntax
 
 - **GitHub shorthand for latest release version:** `ubi:goreleaser/goreleaser`

docs/dev-tools/backends/ubi.md

@@ -2,12 +2,14 @@ use crate::backend::Backend;
 use crate::backend::backend_type::BackendType;
 use crate::cli::args::BackendArg;
 use crate::config::SETTINGS;
-use crate::env::GITHUB_TOKEN;
+use crate::env::{
+    GITHUB_TOKEN, GITLAB_TOKEN, MISE_GITHUB_ENTERPRISE_TOKEN, MISE_GITLAB_ENTERPRISE_TOKEN,
+};
 use crate::install_context::InstallContext;
 use crate::plugins::VERSION_REGEX;
 use crate::tokio::RUNTIME;
 use crate::toolset::ToolVersion;
-use crate::{file, github, hash};
+use crate::{file, github, gitlab, hash};
 use eyre::bail;
 use itertools::Itertools;
 use regex::Regex;
@@ -39,14 +41,43 @@ impl Backend for UbiBackend {
             Ok(vec!["latest".to_string()])
         } else {
             let opts = self.ba.opts();
+            let forge = match opts.get("provider") {
+                Some(forge) => ForgeType::from_str(forge)?,
+                None => ForgeType::default(),
+            };
+            let api_url = match opts.get("api_url") {
+                Some(api_url) => api_url,
+                None => match forge {
+                    ForgeType::GitHub => github::API_URL,
+                    ForgeType::GitLab => gitlab::API_URL,
+                },
+            };
             let tag_regex = OnceLock::new();
-            let mut versions = github::list_releases(&self.tool_name())?
-                .into_iter()
-                .map(|r| r.tag_name)
-                .collect::<Vec<String>>();
+            let mut versions = match forge {
+                ForgeType::GitHub => github::list_releases_from_url(api_url, &self.tool_name())?
+                    .into_iter()
+                    .map(|r| r.tag_name)
+                    .collect::<Vec<String>>(),
+                ForgeType::GitLab => gitlab::list_releases_from_url(api_url, &self.tool_name())?
+                    .into_iter()
+                    .map(|r| r.tag_name)
+                    .collect::<Vec<String>>(),
+            };
             if versions.is_empty() {
-                versions = github::list_tags(&self.tool_name())?.into_iter().collect();
+                match forge {
+                    ForgeType::GitHub => {
+                        versions = github::list_tags_from_url(api_url, &self.tool_name())?
+                            .into_iter()
+                            .collect();
+                    }
+                    ForgeType::GitLab => {
+                        versions = gitlab::list_tags_from_url(api_url, &self.tool_name())?
+                            .into_iter()
+                            .collect();
+                    }
+                }
             }
+
             Ok(versions
                 .into_iter()
                 // trim 'v' prefixes if they exist
@@ -75,10 +106,29 @@ impl Backend for UbiBackend {
     ) -> eyre::Result<ToolVersion> {
         let mut v = tv.version.to_string();
         let opts = tv.request.options();
+        let forge = match opts.get("provider") {
+            Some(forge) => ForgeType::from_str(forge)?,
+            None => ForgeType::default(),
+        };
+        let api_url = match opts.get("api_url") {
+            Some(api_url) => api_url,
+            None => match forge {
+                ForgeType::GitHub => github::API_URL,
+                ForgeType::GitLab => gitlab::API_URL,
+            },
+        };
         let extract_all = opts.get("extract_all").is_some_and(|v| v == "true");
         let bin_dir = tv.install_path();
 
-        if let Err(err) = github::get_release(&self.tool_name(), &tv.version) {
+        let release: Result<_, eyre::Report> = match forge {
+            ForgeType::GitHub => {
+                github::get_release_for_url(api_url, &self.tool_name(), &v).map(|_| "github")
+            }
+            ForgeType::GitLab => {
+                gitlab::get_release_for_url(api_url, &self.tool_name(), &v).map(|_| "gitlab")
+            }
+        };
+        if let Err(err) = release {
             // this can fail with a rate limit error or 404, either way, try prefixing and if it fails, try without the prefix
             // if http::error_code(&err) == Some(404) {
             debug!(
@@ -95,10 +145,6 @@ impl Backend for UbiBackend {
 
             let mut builder = UbiBuilder::new().project(&name).install_dir(&bin_dir);
 
-            if let Some(token) = &*GITHUB_TOKEN {
-                builder = builder.token(token);
-            }
-
             if v != "latest" {
                 builder = builder.tag(v);
             }
@@ -116,8 +162,19 @@ impl Backend for UbiBackend {
             if let Some(matching) = opts.get("matching") {
                 builder = builder.matching(matching);
             }
-            if let Some(forge) = opts.get("forge") {
-                builder = builder.forge(ForgeType::from_str(forge)?);
+
+            let forge = match opts.get("provider") {
+                Some(forge) => ForgeType::from_str(forge)?,
+                None => ForgeType::default(),
+            };
+            builder = builder.forge(forge.clone());
+            builder = set_token(builder, &forge);
+
+            if let Some(api_url) = opts.get("api_url") {
+                if !api_url.contains("github.com") && !api_url.contains("gitlab.com") {
+                    builder = builder.api_base_url(api_url);
+                    builder = set_enterprise_token(builder, &forge);
+                }
             }
 
             let mut ubi = builder.build().map_err(|e| eyre::eyre!(e))?;
@@ -247,3 +304,37 @@ impl UbiBackend {
 fn name_is_url(n: &str) -> bool {
     n.starts_with("http")
 }
+
+fn set_token<'a>(mut builder: UbiBuilder<'a>, forge: &ForgeType) -> UbiBuilder<'a> {
+    match forge {
+        ForgeType::GitHub => {
+            if let Some(token) = &*GITHUB_TOKEN {
+                builder = builder.token(token)
+            }
+            builder
+        }
+        ForgeType::GitLab => {
+            if let Some(token) = &*GITLAB_TOKEN {
+                builder = builder.token(token)
+            }
+            builder
+        }
+    }
+}
+
+fn set_enterprise_token<'a>(mut builder: UbiBuilder<'a>, forge: &ForgeType) -> UbiBuilder<'a> {
+    match forge {
+        ForgeType::GitHub => {
+            if let Some(token) = &*MISE_GITHUB_ENTERPRISE_TOKEN {
+                builder = builder.token(token);
+            }
+            builder
+        }
+        ForgeType::GitLab => {
+            if let Some(token) = &*MISE_GITLAB_ENTERPRISE_TOKEN {
+                builder = builder.token(token);
+            }
+            builder
+        }
+    }
+}

src/backend/ubi.rs

@@ -177,6 +177,10 @@ impl BackendArg {
         })
     }
 
+    pub fn set_opts(&mut self, opts: ToolVersionOptions) {
+        self.opts = Some(opts);
+    }
+
     pub fn tool_name(&self) -> String {
         let full = self.full();
         let (_backend, tool_name) = full.split_once(':').unwrap_or(("", &full));

src/cli/args/backend_arg.rs

@@ -223,6 +223,43 @@ pub static GITHUB_TOKEN: Lazy<Option<String>> = Lazy::new(|| {
 
     token
 });
+pub static MISE_GITHUB_ENTERPRISE_TOKEN: Lazy<Option<String>> =
+    Lazy::new(|| match var("MISE_GITHUB_ENTERPRISE_TOKEN") {
+        Ok(v) if v.trim() != "" => {
+            set_var("MISE_GITHUB_ENTERPRISE_TOKEN", &v);
+            Some(v)
+        }
+        _ => {
+            remove_var("MISE_GITHUB_ENTERPRISE_TOKEN");
+            None
+        }
+    });
+pub static GITLAB_TOKEN: Lazy<Option<String>> =
+    Lazy::new(
+        || match var("MISE_GITLAB_TOKEN").or_else(|_| var("GITLAB_TOKEN")) {
+            Ok(v) if v.trim() != "" => {
+                set_var("MISE_GITLAB_TOKEN", &v);
+                set_var("GITLAB_TOKEN", &v);
+                Some(v)
+            }
+            _ => {
+                remove_var("MISE_GITLAB_TOKEN");
+                remove_var("GITLAB_TOKEN");
+                None
+            }
+        },
+    );
+pub static MISE_GITLAB_ENTERPRISE_TOKEN: Lazy<Option<String>> =
+    Lazy::new(|| match var("MISE_GITLAB_ENTERPRISE_TOKEN") {
+        Ok(v) if v.trim() != "" => {
+            set_var("MISE_GITLAB_ENTERPRISE_TOKEN", &v);
+            Some(v)
+        }
+        _ => {
+            remove_var("MISE_GITLAB_ENTERPRISE_TOKEN");
+            None
+        }
+    });
 
 pub static TEST_TRANCHE: Lazy<usize> = Lazy::new(|| var_u8("TEST_TRANCHE") as usize);
 pub static TEST_TRANCHE_COUNT: Lazy<usize> = Lazy::new(|| var_u8("TEST_TRANCHE_COUNT") as usize);

src/env.rs

@@ -42,6 +42,8 @@ static RELEASE_CACHE: Lazy<RwLock<CacheGroup<GithubRelease>>> = Lazy::new(Defaul
 
 static TAGS_CACHE: Lazy<RwLock<CacheGroup<Vec<String>>>> = Lazy::new(Default::default);
 
+pub static API_URL: &str = "https://api.github.com/repos";
+
 fn get_tags_cache(key: &str) -> RwLockReadGuard<'_, CacheGroup<Vec<String>>> {
     TAGS_CACHE
         .write()
@@ -85,11 +87,22 @@ pub fn list_releases(repo: &str) -> Result<Vec<GithubRelease>> {
     let key = repo.to_kebab_case();
     let cache = get_releases_cache(&key);
     let cache = cache.get(&key).unwrap();
-    Ok(cache.get_or_try_init(|| list_releases_(repo))?.to_vec())
+    Ok(cache
+        .get_or_try_init(|| list_releases_(API_URL, repo))?
+        .to_vec())
 }
 
-fn list_releases_(repo: &str) -> Result<Vec<GithubRelease>> {
-    let url = format!("https://api.github.com/repos/{repo}/releases");
+pub fn list_releases_from_url(api_url: &str, repo: &str) -> Result<Vec<GithubRelease>> {
+    let key = format!("{api_url}-{repo}").to_kebab_case();
+    let cache = get_releases_cache(&key);
+    let cache = cache.get(&key).unwrap();
+    Ok(cache
+        .get_or_try_init(|| list_releases_(api_url, repo))?
+        .to_vec())
+}
+
+fn list_releases_(api_url: &str, repo: &str) -> Result<Vec<GithubRelease>> {
+    let url = format!("{api_url}/{repo}/releases");
     let (mut releases, mut headers) =
         crate::http::HTTP_FETCH.json_headers::<Vec<GithubRelease>, _>(url)?;
 
@@ -109,11 +122,22 @@ pub fn list_tags(repo: &str) -> Result<Vec<String>> {
     let key = repo.to_kebab_case();
     let cache = get_tags_cache(&key);
     let cache = cache.get(&key).unwrap();
-    Ok(cache.get_or_try_init(|| list_tags_(repo))?.to_vec())
+    Ok(cache
+        .get_or_try_init(|| list_tags_(API_URL, repo))?
+        .to_vec())
 }
 
-fn list_tags_(repo: &str) -> Result<Vec<String>> {
-    let url = format!("https://api.github.com/repos/{}/tags", repo);
+pub fn list_tags_from_url(api_url: &str, repo: &str) -> Result<Vec<String>> {
+    let key = format!("{api_url}-{repo}").to_kebab_case();
+    let cache = get_tags_cache(&key);
+    let cache = cache.get(&key).unwrap();
+    Ok(cache
+        .get_or_try_init(|| list_tags_(api_url, repo))?
+        .to_vec())
+}
+
+fn list_tags_(api_url: &str, repo: &str) -> Result<Vec<String>> {
+    let url = format!("{api_url}/{repo}/tags");
     let (mut tags, mut headers) = crate::http::HTTP_FETCH.json_headers::<Vec<GithubTag>, _>(url)?;
 
     if *env::MISE_LIST_ALL_VERSIONS {
@@ -131,11 +155,22 @@ pub fn get_release(repo: &str, tag: &str) -> Result<GithubRelease> {
     let key = format!("{repo}-{tag}").to_kebab_case();
     let cache = get_release_cache(&key);
     let cache = cache.get(&key).unwrap();
-    Ok(cache.get_or_try_init(|| get_release_(repo, tag))?.clone())
+    Ok(cache
+        .get_or_try_init(|| get_release_(API_URL, repo, tag))?
+        .clone())
+}
+
+pub fn get_release_for_url(api_url: &str, repo: &str, tag: &str) -> Result<GithubRelease> {
+    let key = format!("{api_url}-{repo}-{tag}").to_kebab_case();
+    let cache = get_release_cache(&key);
+    let cache = cache.get(&key).unwrap();
+    Ok(cache
+        .get_or_try_init(|| get_release_(api_url, repo, tag))?
+        .clone())
 }
 
-fn get_release_(repo: &str, tag: &str) -> Result<GithubRelease> {
-    let url = format!("https://api.github.com/repos/{repo}/releases/tags/{tag}");
+fn get_release_(api_url: &str, repo: &str, tag: &str) -> Result<GithubRelease> {
+    let url = format!("{api_url}/{repo}/releases/tags/{tag}");
     crate::http::HTTP_FETCH.json(url)
 }