ghtui 0.1.0

A keyboard-driven terminal client for GitHub, with a pull request diff viewer that goes further than GitHub's
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Token resolution: `GH_TOKEN`, then `GITHUB_TOKEN`, then `gh auth token`.
//!
//! The token is never logged or written anywhere; [`Token`]'s `Debug` output
//! is redacted.

use std::process::Command;

#[derive(Clone)]
pub struct Token(String);

impl Token {
    pub fn new(token: impl Into<String>) -> Self {
        Self(token.into())
    }

    pub fn expose(&self) -> &str {
        &self.0
    }
}

impl std::fmt::Debug for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("Token(<redacted>)")
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TokenSource {
    GhTokenEnv,
    GithubTokenEnv,
    GhCli,
}

impl std::fmt::Display for TokenSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            TokenSource::GhTokenEnv => "GH_TOKEN",
            TokenSource::GithubTokenEnv => "GITHUB_TOKEN",
            TokenSource::GhCli => "gh auth token",
        })
    }
}

#[derive(Debug, thiserror::Error)]
pub enum AuthError {
    #[error("no GitHub token found.\n\nRun `gh auth login` to sign in, or set GH_TOKEN.\n({0})")]
    NoToken(String),
}

/// Resolves a token from the real environment and `gh`.
pub fn resolve_token() -> Result<(Token, TokenSource), AuthError> {
    resolve_with(|k| std::env::var(k).ok(), run_gh_auth_token)
}

/// Testable core of [`resolve_token`].
pub fn resolve_with(
    env: impl Fn(&str) -> Option<String>,
    gh: impl FnOnce() -> Result<Option<String>, String>,
) -> Result<(Token, TokenSource), AuthError> {
    for (var, source) in [
        ("GH_TOKEN", TokenSource::GhTokenEnv),
        ("GITHUB_TOKEN", TokenSource::GithubTokenEnv),
    ] {
        if let Some(value) = env(var).map(|v| v.trim().to_owned())
            && !value.is_empty()
        {
            return Ok((Token(value), source));
        }
    }
    match gh() {
        Ok(Some(token)) => Ok((Token(token), TokenSource::GhCli)),
        Ok(None) => Err(AuthError::NoToken(
            "`gh auth token` returned nothing".into(),
        )),
        Err(why) => Err(AuthError::NoToken(why)),
    }
}

fn run_gh_auth_token() -> Result<Option<String>, String> {
    let output = Command::new("gh")
        .args(["auth", "token", "--hostname", "github.com"])
        .output()
        .map_err(|err| match err.kind() {
            std::io::ErrorKind::NotFound => "the `gh` CLI is not installed".to_owned(),
            _ => format!("could not run `gh auth token`: {err}"),
        })?;
    if !output.status.success() {
        // gh's stderr says "not logged in" etc. It never contains the token.
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("`gh auth token` failed: {}", stderr.trim()));
    }
    let token = String::from_utf8_lossy(&output.stdout).trim().to_owned();
    Ok((!token.is_empty()).then_some(token))
}

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

    fn env(pairs: &'static [(&'static str, &'static str)]) -> impl Fn(&str) -> Option<String> {
        move |k| {
            pairs
                .iter()
                .find(|(name, _)| *name == k)
                .map(|(_, v)| v.to_string())
        }
    }

    #[test]
    fn prefers_gh_token_env() {
        let (token, source) =
            resolve_with(env(&[("GH_TOKEN", "a"), ("GITHUB_TOKEN", "b")]), || {
                panic!("gh must not run")
            })
            .unwrap();
        assert_eq!(token.expose(), "a");
        assert_eq!(source, TokenSource::GhTokenEnv);
    }

    #[test]
    fn falls_back_to_github_token_then_gh() {
        let (token, source) =
            resolve_with(env(&[("GH_TOKEN", "  "), ("GITHUB_TOKEN", "b")]), || {
                panic!("gh must not run")
            })
            .unwrap();
        assert_eq!((token.expose(), source), ("b", TokenSource::GithubTokenEnv));

        let (token, source) = resolve_with(env(&[]), || Ok(Some("c".into()))).unwrap();
        assert_eq!((token.expose(), source), ("c", TokenSource::GhCli));
    }

    #[test]
    fn missing_token_mentions_gh_auth_login() {
        let err = resolve_with(env(&[]), || Err("not logged in".into())).unwrap_err();
        let msg = err.to_string();
        assert!(msg.contains("gh auth login"), "{msg}");
        assert!(msg.contains("not logged in"), "{msg}");
    }

    #[test]
    fn debug_is_redacted() {
        assert_eq!(format!("{:?}", Token::new("secret")), "Token(<redacted>)");
    }
}