ghtool 0.6.0

A command-line tool for interacting with Github API with some specialized features oriented around Checks
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

use eyre::Result;
use http::HeaderMap;
use serde::Deserialize;
use tracing::{error, info};

pub struct GithubAuthClient {
    client: reqwest::Client,
}

const GITHUB_BASE_URI: &str = "https://github.com";
// const CLIENT_ID: &str = "Iv1.1bbd5e03617adebb";
const CLIENT_ID: &str = "32a2525cc736ee9b63ae";
const USER_AGENT: &str = "ghtool";
const GRANT_TYPE: &str = "urn:ietf:params:oauth:grant-type:device_code";

#[derive(Deserialize, Debug)]
pub struct CodeResponse {
    pub device_code: String,
    pub user_code: String,
    pub verification_uri: String,
    pub expires_in: u32,
    pub interval: u32,
}

#[derive(Deserialize, Debug)]
pub struct AccessToken {
    pub access_token: String,
    pub scope: String,
    pub token_type: String,
}

#[derive(Deserialize, Debug)]
pub struct Error {
    pub error: String,
    pub error_description: String,
    pub error_uri: String,
}

pub enum AccessTokenResponse {
    AuthorizationPending(Error),
    AccessToken(AccessToken),
}

impl GithubAuthClient {
    pub fn new() -> Result<Self> {
        let client = reqwest::Client::builder()
            .user_agent(USER_AGENT)
            .default_headers(make_headers())
            .build()
            .map_err(|e| eyre::eyre!("Failed to build client: {}", e))?;

        Ok(Self { client })
    }

    pub async fn get_device_code(&self) -> Result<CodeResponse> {
        let params = [("client_id", CLIENT_ID), ("scope", "repo")];
        let url = format!("{}/login/device/code", GITHUB_BASE_URI);
        info!("Requesting device code from {}", url);
        let res = self.client.post(url).form(&params).send().await?;
        let code_response: CodeResponse = res.json().await?;
        info!("Received device code: {:?}", code_response);
        Ok(code_response)
    }

    pub async fn get_access_token(&self, device_code: &str) -> Result<AccessTokenResponse> {
        let params = [
            ("client_id", CLIENT_ID),
            ("device_code", device_code),
            ("grant_type", GRANT_TYPE),
        ];
        let url = format!("{}/login/oauth/access_token", GITHUB_BASE_URI);
        info!("Requesting access token from {}", url);
        let res = self.client.post(url).form(&params).send().await?;

        if res.status().is_success() {
            let bytes = res.bytes().await?;
            let token_response: Result<AccessToken, _> = serde_json::from_slice(&bytes);
            info!("Received response: {:?}", token_response);
            match token_response {
                Ok(token) => Ok(AccessTokenResponse::AccessToken(token)),
                Err(_) => {
                    let error_response: Error = serde_json::from_slice(&bytes)?;
                    if error_response.error == "authorization_pending" {
                        info!(?error_response, "Authorization pending");
                        Ok(AccessTokenResponse::AuthorizationPending(error_response))
                    } else {
                        error!(?error_response, "Unexpected error");
                        Err(eyre::eyre!(
                            "Unexpected error: {} - {}",
                            error_response.error,
                            error_response.error_description
                        ))
                    }
                }
            }
        } else {
            Err(eyre::eyre!("Failed to get access token"))
        }
    }
}

fn make_headers() -> HeaderMap {
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert(reqwest::header::ACCEPT, "application/json".parse().unwrap());
    headers
}