Skip to content

Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows

17.7 KB
Raw Blame
//! CI platform identification.
//!
//! [`ForgeKind`] names the forge a repository's CI runs on (GitHub, GitLab,
//! Gitea, or Azure DevOps). It comes from the configured forge platform when
//! set — the repository's own `[forge].platform` (or the deprecated
//! `ci.platform`), else a matching user-config `[projects."…"].forge` entry —
//! otherwise from the remote URL host. See [`Repository::ci_platform`].

use crate::git::{GitRemoteUrl, RefType, Repository};

/// A known forge.
///
/// This is the canonical identity shared by configuration, remote-host
/// classification, remote-ref dispatch, and CI dispatch. Unknown hosts stay
/// outside the enum as `None`; callers that expose an explicit `unknown` value
/// add it only at that output boundary.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum ForgeKind {
    GitHub,
    GitLab,
    /// Experimental — Gitea CI status via the `tea` CLI.
    Gitea,
    #[strum(serialize = "azure-devops", serialize = "azuredevops")]
    AzureDevOps,
}

impl ForgeKind {
    /// Classify a forge from a remote hostname.
    ///
    /// GitHub, GitLab, and Gitea are brand names, and a self-hosted instance
    /// puts its brand in the hostname however it likes: `github.mycompany.com`,
    /// `github-enterprise.acme.com`, `mygithub.com`, the `github-personal` SSH
    /// alias. So any host carrying the name matches, first match winning. Azure
    /// DevOps is not a brand in the hostname but two fixed service domains, so
    /// it matches by domain suffix and takes precedence inside those domains —
    /// `evil-visualstudio.com` and `dev.azure.com.attacker.example` are outside
    /// them and do not match.
    ///
    /// Recall is what this optimizes, not resistance to a lookalike name. The
    /// hostname comes out of the user's own `.git/config`, and whoever can put
    /// a host there can put code there too, so the trust decision was made at
    /// clone time; all this picks is which forge CLI runs against a remote the
    /// user already builds from. A stricter name test would not hold anyway —
    /// an attacker controls their own DNS, so `github.attacker.example`
    /// satisfies one — while it does shut out the self-hoster who named a box
    /// `github-enterprise.acme.com` years ago. `[forge].platform` overrides the
    /// guess, and names the forge for a host that carries no brand at all.
    pub fn from_host(host: &str) -> Option<Self> {
        let host = normalized_hostname(host);
        if normalized_host_is_within(&host, "dev.azure.com")
            || normalized_host_is_within(&host, "visualstudio.com")
        {
            Some(Self::AzureDevOps)
        } else if host.contains("github") {
            Some(Self::GitHub)
        } else if host.contains("gitlab") {
            Some(Self::GitLab)
        } else if host.contains("gitea") {
            Some(Self::Gitea)
        } else {
            None
        }
    }

    /// The CLI worktrunk drives for this forge.
    pub const fn cli(self) -> &'static str {
        match self {
            Self::GitHub => "gh",
            Self::GitLab => "glab",
            Self::Gitea => "tea",
            Self::AzureDevOps => "az",
        }
    }

    /// PR/MR vocabulary for change requests on this forge.
    pub const fn ref_type(self) -> RefType {
        match self {
            Self::GitLab => RefType::Mr,
            Self::GitHub | Self::Gitea | Self::AzureDevOps => RefType::Pr,
        }
    }
}

/// Lowercase a hostname and remove transport-only syntax before classifying it.
///
/// `GitRemoteUrl` already strips ports from `ssh://` URLs, while HTTP(S) keeps
/// the authority intact. Treat a numeric suffix as a port so both transports
/// classify identically. A trailing DNS root dot is likewise identity-neutral.
pub(super) fn normalized_hostname(host: &str) -> String {
    let host = host.trim();
    let host = host
        .rsplit_once(':')
        .filter(|(_, port)| !port.is_empty() && port.bytes().all(|b| b.is_ascii_digit()))
        .map_or(host, |(hostname, _)| hostname);
    host.trim_end_matches('.').to_ascii_lowercase()
}

fn normalized_host_is_within(host: &str, domain: &str) -> bool {
    host == domain || host.strip_suffix(domain).is_some_and(|p| p.ends_with('.'))
}

pub(super) fn host_is_within(host: &str, domain: &str) -> bool {
    normalized_host_is_within(&normalized_hostname(host), domain)
}

/// Identify the CI platform from a remote URL host ("github" / "gitlab" /
/// "gitea" / Azure DevOps).
fn platform_from_url(url: &str) -> Option<ForgeKind> {
    GitRemoteUrl::parse(url)?.forge_kind()
}

impl Repository {
    /// The CI platform for this repository, or `None` if it can't be determined.
    ///
    /// Priority order:
    /// 1. The configured forge platform — the repository's `[forge].platform`
    ///    (or the deprecated `ci.platform`), else a matching user-config
    ///    `[projects."…"].forge.platform`
    /// 2. `remote_hint`'s effective URL host, when `remote_hint` is given
    /// 3. The primary remote's effective URL host
    ///
    /// For a remote branch, pass its remote as `remote_hint` so the right
    /// platform is picked in mixed-remote repos (e.g. GitHub + GitLab).
    /// Effective URLs are used so `url.insteadOf` aliases resolve.
    pub fn ci_platform(&self, remote_hint: Option<&str>) -> Option<ForgeKind> {
        if let Some(platform) = self.configured_ci_platform() {
            return Some(platform);
        }

        if let Some(remote) = remote_hint
            && let Some(url) = self.effective_remote_url(remote)
            && let Some(platform) = platform_from_url(&url)
        {
            tracing::debug!(platform = %platform, remote = %remote, "Detected CI platform {platform} from remote '{remote}' (hint)");
            return Some(platform);
        }

        if let Ok(remote) = self.primary_remote()
            && let Some(url) = self.effective_remote_url(&remote)
            && let Some(platform) = platform_from_url(&url)
        {
            tracing::debug!(platform = %platform, remote = %remote, "Detected CI platform {platform} from remote '{remote}'");
            return Some(platform);
        }

        None
    }

    /// The configured CI platform: the repository's `[forge].platform` (or the
    /// deprecated `ci.platform`), else a matching user-config
    /// `[projects."…"].forge.platform`.
    ///
    /// The repository's own block wins because it is the more specific of the
    /// two — a user entry keyed `git.company.example/*` states what the host
    /// is, and a repository that disagrees knows better.
    ///
    /// `None` when unset or unrecognized. Resolved once per repository handle,
    /// so an unrecognized value warns a single time rather than once per branch
    /// `wt list` probes.
    fn configured_ci_platform(&self) -> Option<ForgeKind> {
        *self.cache.configured_ci_platform.get_or_init(|| {
            let raw = self.configured_forge_platform()?;
            match raw.parse::<ForgeKind>() {
                Ok(platform) => {
                    tracing::debug!(platform = %platform, "Using CI platform from config: {platform}");
                    Some(platform)
                }
                Err(_) => {
                    tracing::warn!(
                        value = %raw,
                        "Invalid CI platform '{raw}' (from `[forge]` in project config or a `[projects]` entry in user config). Expected 'github', 'gitlab', 'gitea', or 'azure-devops'."
                    );
                    None
                }
            }
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ci_platform_string_roundtrip() {
        for (forge, spelling) in [
            (ForgeKind::GitHub, "github"),
            (ForgeKind::GitLab, "gitlab"),
            (ForgeKind::Gitea, "gitea"),
            (ForgeKind::AzureDevOps, "azure-devops"),
        ] {
            assert_eq!(forge.to_string(), spelling);
            assert_eq!(spelling.parse::<ForgeKind>().ok(), Some(forge));
        }

        // Azure DevOps accepts both spellings; `azure-devops` is canonical.
        assert_eq!(
            "azuredevops".parse::<ForgeKind>().ok(),
            Some(ForgeKind::AzureDevOps)
        );

        // Unrecognized values, including wrong case, must not parse.
        assert!("invalid".parse::<ForgeKind>().is_err());
        assert!("GITHUB".parse::<ForgeKind>().is_err());
        assert!("GitHub".parse::<ForgeKind>().is_err());
    }

    #[test]
    fn test_platform_from_url() {
        // GitHub — various URL formats, plus GitHub Enterprise.
        for url in [
            "https://github.com/owner/repo.git",
            "[email protected]:owner/repo.git",
            "ssh://[email protected]/owner/repo.git",
            "https://github.mycompany.com/owner/repo.git",
            "http://github.com/owner/repo.git",
            "git://github.com/owner/repo.git",
        ] {
            assert_eq!(platform_from_url(url), Some(ForgeKind::GitHub), "{url}");
        }

        // GitLab — various URL formats, plus self-hosted instances.
        for url in [
            "https://gitlab.com/owner/repo.git",
            "[email protected]:owner/repo.git",
            "https://gitlab.example.com/owner/repo.git",
            "http://gitlab.example.com/owner/repo.git",
            "git://gitlab.mycompany.com/owner/repo.git",
        ] {
            assert_eq!(platform_from_url(url), Some(ForgeKind::GitLab), "{url}");
        }

        // Gitea — gitea.com and self-hosted instances with "gitea" in the host.
        for url in [
            "https://gitea.com/owner/repo.git",
            "[email protected]:owner/repo.git",
        ] {
            assert_eq!(platform_from_url(url), Some(ForgeKind::Gitea), "{url}");
        }

        // Azure DevOps — HTTPS, SSH, and the legacy visualstudio.com host.
        for url in [
            "https://dev.azure.com/myorg/myproject/_git/myrepo",
            "[email protected]:v3/myorg/myproject/myrepo",
            "https://myorg.visualstudio.com/myproject/_git/myrepo",
        ] {
            assert_eq!(
                platform_from_url(url),
                Some(ForgeKind::AzureDevOps),
                "{url}"
            );
        }

        // Unknown forges (a Gitea/Forgejo host without "gitea" in the name
        // needs an explicit `forge.platform` override).
        assert_eq!(
            platform_from_url("https://bitbucket.org/owner/repo.git"),
            None
        );
        assert_eq!(
            platform_from_url("https://codeberg.org/owner/repo.git"),
            None
        );
    }

    #[test]
    fn test_platform_from_url_uses_network_host_after_userinfo() {
        for url in [
            "https://[email protected]/owner/repo.git",
            "http://[email protected]/owner/repo.git",
            "git://[email protected]/owner/repo.git",
            "ssh://[email protected]/owner/repo.git",
        ] {
            assert_eq!(platform_from_url(url), None, "{url}");
        }
    }

    #[test]
    fn test_fixed_azure_domains_take_precedence_over_brand_names() {
        for host in [
            "github.dev.azure.com",
            "gitlab.visualstudio.com",
            "gitea.visualstudio.com:443",
            "GITHUB.DEV.AZURE.COM.",
        ] {
            assert_eq!(
                ForgeKind::from_host(host),
                Some(ForgeKind::AzureDevOps),
                "{host}"
            );
        }
    }

    #[test]
    fn test_branded_hosts_classify_however_the_instance_is_named() {
        // A self-hosted instance carries its brand wherever it likes: its own
        // label, a hyphenated label, inside a word, or a single-label SSH
        // alias. All of them resolve without config.
        for (url, platform) in [
            (
                "https://github-enterprise.acme.com/owner/repo.git",
                ForgeKind::GitHub,
            ),
            ("https://mygithub.com/owner/repo.git", ForgeKind::GitHub),
            ("git@github-personal:owner/repo.git", ForgeKind::GitHub),
            (
                "https://gitlab-internal.company.com/owner/repo.git",
                ForgeKind::GitLab,
            ),
            ("ssh://git@gitlab-work/owner/repo.git", ForgeKind::GitLab),
            (
                "[email protected]:owner/repo.git",
                ForgeKind::Gitea,
            ),
            // Case and port are normalized away before the name is read.
            (
                "https://GitHub-Enterprise.ACME.com:8443/owner/repo.git",
                ForgeKind::GitHub,
            ),
        ] {
            assert_eq!(platform_from_url(url), Some(platform), "{url}");
        }

        // A host carrying no brand still needs `forge.platform`.
        for url in [
            "https://bitbucket.org/owner/repo.git",
            "https://codeberg.org/owner/repo.git",
            "https://git.example.com/owner/repo.git",
            "git@work:owner/repo.git",
        ] {
            assert_eq!(platform_from_url(url), None, "{url}");
        }
    }

    #[test]
    fn test_configured_platform_overrides_host_inference() {
        // The remote's own name says GitLab; config says GitHub and wins.
        let test = crate::testing::TestRepo::new();
        test.run_git(&[
            "remote",
            "add",
            "origin",
            "https://gitlab-internal.company.com/owner/repo.git",
        ]);
        test.write_project_config("[forge]\nplatform = \"github\"\n");

        let repo = Repository::at(test.root_path().to_path_buf()).unwrap();
        assert_eq!(repo.ci_platform(None), Some(ForgeKind::GitHub));
    }

    /// Build a repo with `remote_url` and a user config carrying the given
    /// `[projects."<key>"].forge.platform` entries.
    ///
    /// Returns the `TestRepo` alongside the `Repository` so the caller keeps
    /// the checkout's tempdir alive for the duration of the test.
    fn repo_with_user_forge(
        remote_url: &str,
        entries: &[(&str, &str)],
    ) -> (crate::testing::TestRepo, Repository) {
        let test = crate::testing::TestRepo::new();
        test.run_git(&["remote", "add", "origin", remote_url]);

        let mut user_config = crate::config::UserConfig::default();
        for (key, platform) in entries {
            user_config
                .projects
                .entry((*key).to_string())
                .or_default()
                .forge = crate::config::ProjectForgeConfig {
                platform: Some((*platform).to_string()),
                hostname: None,
            };
        }

        let repo = Repository::at(test.root_path().to_path_buf()).unwrap();
        repo.cache
            .user_config
            .set(user_config)
            .expect("user config not yet initialized");
        (test, repo)
    }

    #[test]
    fn test_user_project_pattern_names_platform_for_a_whole_host() {
        // The motivating case: a self-hosted forge whose hostname carries no
        // brand resolves for every repo on it, with no `[forge]` block in any
        // of them. Built-in inference alone gives `None` here.
        let (_test, repo) = repo_with_user_forge(
            "https://git.company.example/owner/repo.git",
            &[("git.company.example/*", "gitlab")],
        );
        assert_eq!(repo.ci_platform(None), Some(ForgeKind::GitLab));
    }

    #[test]
    fn test_user_project_pattern_covers_nested_groups() {
        let (_test, repo) = repo_with_user_forge(
            "https://git.company.example/group/team/repo.git",
            &[("git.company.example/*", "gitlab")],
        );
        assert_eq!(repo.ci_platform(None), Some(ForgeKind::GitLab));
    }

    #[test]
    fn test_more_specific_user_pattern_wins() {
        // The Gitea instance lives under one namespace on an otherwise-GitLab
        // host, and the narrower entry is the one that applies.
        let (_test, repo) = repo_with_user_forge(
            "https://git.company.example/tools/repo.git",
            &[
                ("git.company.example/*", "gitlab"),
                ("git.company.example/tools/*", "gitea"),
            ],
        );
        assert_eq!(repo.ci_platform(None), Some(ForgeKind::Gitea));
    }

    #[test]
    fn test_project_forge_overrides_user_pattern() {
        // A repository that names its own forge is more specific than an entry
        // describing the host.
        let test = crate::testing::TestRepo::new();
        test.run_git(&[
            "remote",
            "add",
            "origin",
            "https://git.company.example/owner/repo.git",
        ]);
        test.write_project_config("[forge]\nplatform = \"github\"\n");

        let mut user_config = crate::config::UserConfig::default();
        user_config
            .projects
            .entry("git.company.example/*".to_string())
            .or_default()
            .forge
            .platform = Some("gitlab".to_string());

        let repo = Repository::at(test.root_path().to_path_buf()).unwrap();
        repo.cache.user_config.set(user_config).unwrap();
        assert_eq!(repo.ci_platform(None), Some(ForgeKind::GitHub));
    }

    #[test]
    fn test_unmatched_user_pattern_falls_through_to_inference() {
        let (_test, repo) = repo_with_user_forge(
            "https://gitlab.com/owner/repo.git",
            &[("git.company.example/*", "github")],
        );
        assert_eq!(repo.ci_platform(None), Some(ForgeKind::GitLab));
    }

    #[test]
    fn test_invalid_user_platform_leaves_the_host_unresolved() {
        // An unrecognized value warns once and is dropped, rather than
        // resolving the host to a forge that doesn't exist.
        let (_test, repo) = repo_with_user_forge(
            "https://git.company.example/owner/repo.git",
            &[("git.company.example/*", "bitbucket")],
        );
        assert_eq!(repo.ci_platform(None), None);
    }
}