lazygocd 0.6.1

A fast, keyboard-driven terminal UI for GoCD pipelines
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use anyhow::{Context, Result};
use reqwest::blocking::Client;
use serde::Deserialize;

#[derive(Clone)]
pub struct GitHubClient {
    client: Client,
    token: Option<String>,
    /// API root, e.g. "https://api.github.com" or a GHE instance's ".../api/v3".
    api_base: String,
}

#[derive(Deserialize)]
struct CommitResponse {
    sha: String,
}

/// Token precedence: explicit config/env token, then whatever `gh auth token`
/// yields for users who already have the GitHub CLI signed in - no PAT pasting.
pub fn resolve_token(configured: Option<String>) -> Option<String> {
    if configured.as_deref().is_some_and(|t| !t.trim().is_empty()) {
        return configured;
    }
    let out = std::process::Command::new("gh")
        .args(["auth", "token"])
        .output()
        .ok()?;
    if !out.status.success() {
        return None;
    }
    let token = String::from_utf8(out.stdout).ok()?.trim().to_string();
    (!token.is_empty()).then_some(token)
}

impl GitHubClient {
    pub fn new(token: Option<String>, api_base: &str) -> Result<Self> {
        let client = Client::builder()
            .timeout(std::time::Duration::from_secs(15))
            .connect_timeout(std::time::Duration::from_secs(8))
            .build()
            .context("building GitHub HTTP client")?;
        Ok(GitHubClient {
            client,
            token: resolve_token(token),
            api_base: api_base.trim_end_matches('/').to_string(),
        })
    }

    /// Latest commit SHA on a branch. Works unauthenticated for public repos
    /// (rate-limited); private repos need a token with repo read access.
    pub fn latest_commit(&self, owner: &str, repo: &str, branch: &str) -> Result<String> {
        let url = format!("{}/repos/{owner}/{repo}/commits/{branch}", self.api_base);
        let mut rb = self
            .client
            .get(&url)
            .header("Accept", "application/vnd.github+json")
            .header("User-Agent", "lazygocd");
        if let Some(token) = &self.token {
            rb = rb.bearer_auth(token);
        }
        let resp = rb
            .send()
            .with_context(|| format!("requesting latest commit for {owner}/{repo}@{branch}"))?;
        let status = resp.status();
        let body = resp.text().context("reading GitHub response body")?;
        if !status.is_success() {
            anyhow::bail!(
                "GitHub returned {status} for {owner}/{repo}@{branch}: {}",
                truncate(&body)
            );
        }
        let parsed: CommitResponse = serde_json::from_str(&body)
            .with_context(|| format!("parsing GitHub commit response: {}", truncate(&body)))?;
        Ok(parsed.sha)
    }
}

fn truncate(s: &str) -> String {
    s.chars().take(300).collect()
}