ecr-cli 0.2.1

The ecr command line: setup, diagnostics, server lifecycle and pairing
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
146
147
148

use anyhow::Result;
use ecr_store::oauth::{self, Flow, InitOptions, Profiles, Prompt};
use std::time::Duration;

pub struct Init {
    pub profile: String,
    pub provider: String,
    pub email: String,
    pub client: Option<String>,
    pub client_id: Option<String>,
    pub client_secret: Option<String>,
    pub tenant: Option<String>,
    pub scope: Vec<String>,
    pub redirect_port: Option<u16>,
    pub force: bool,
}

impl From<Init> for InitOptions {
    fn from(init: Init) -> Self {
        InitOptions {
            profile: init.profile,
            provider: init.provider,
            email: init.email,
            client_preset: init.client,
            client_id: init.client_id,
            client_secret: init.client_secret,
            tenant: init.tenant,
            scopes: init.scope,
            redirect_port: init.redirect_port,
            force: init.force,
        }
    }
}

pub struct Authorize {
    pub flow: Flow,
    pub timeout: u64,
    pub no_open: bool,
}

pub async fn init(options: Init) -> Result<()> {
    let profiles = Profiles::from_process();
    let path = oauth::init(&profiles, options.into()).await?;
    println!("{}", path.display());
    Ok(())
}

/// Create the profile and walk straight into the browser: the two things
/// nobody wants to do separately when adding an account.
pub async fn setup(init_options: Init, auth: Authorize) -> Result<()> {
    let profile = init_options.profile.clone();
    let profiles = Profiles::from_process();
    let path = oauth::init(&profiles, init_options.into()).await?;
    eprintln!("wrote {}", path.display());
    run_authorize(&profiles, &profile, auth).await
}

pub async fn authorize(profile: &str, auth: Authorize) -> Result<()> {
    let profiles = Profiles::from_process();
    adopt(&profiles, profile);
    run_authorize(&profiles, profile, auth).await
}

async fn run_authorize(profiles: &Profiles, profile: &str, auth: Authorize) -> Result<()> {
    let path = oauth::authorize(
        profiles,
        profile,
        auth.flow,
        Duration::from_secs(auth.timeout),
        !auth.no_open,
        announce,
    )
    .await?;
    println!("{}", path.display());
    Ok(())
}

/// Everything the user has to act on goes to stderr, so `authorize` still
/// prints exactly one line — the token path — on stdout.
fn announce(prompt: Prompt) {
    match prompt {
        Prompt::Browser { url, opened } => {
            if opened {
                eprintln!("opened a browser to authorize this account.");
                eprintln!("if nothing appeared, open this:\n\n  {url}\n");
            } else {
                eprintln!("open this to authorize this account:\n\n  {url}\n");
            }
        }
        Prompt::Device {
            user_code,
            verification_uri,
            message,
        } => match message {
            Some(message) => eprintln!("{message}"),
            None => eprintln!("open {verification_uri} and enter the code {user_code}"),
        },
    }
}

pub async fn token(profile: &str) -> Result<()> {
    let profiles = Profiles::from_process();
    adopt(&profiles, profile);
    println!("{}", oauth::access_token(&profiles, profile).await?);
    Ok(())
}

pub async fn xoauth2(profile: &str) -> Result<()> {
    let profiles = Profiles::from_process();
    adopt(&profiles, profile);
    println!("{}", oauth::xoauth2(&profiles, profile).await?);
    Ok(())
}

pub fn status(profile: &str) -> Result<()> {
    let profiles = Profiles::from_process();
    adopt(&profiles, profile);
    let status = oauth::status(&profiles, profile)?;
    println!("{}", serde_json::to_string_pretty(&status)?);
    Ok(())
}

pub fn client_id(provider: &str, client: Option<&str>) -> Result<()> {
    println!("{}", oauth::providers::client(provider, client)?.client_id);
    Ok(())
}

pub fn client_secret(provider: &str, client: Option<&str>) -> Result<()> {
    let client = oauth::providers::client(provider, client)?;
    match client.client_secret {
        Some(secret) => {
            println!("{secret}");
            Ok(())
        }
        None => anyhow::bail!("the {provider} client preset has no client secret"),
    }
}

/// Say so when a profile is adopted from oauthman, once.
///
/// Silence would be worse than noise here: the files ecr reads from then on are
/// not the ones the user has been editing, and nothing else would ever mention
/// the move.
fn adopt(profiles: &Profiles, profile: &str) {
    for from in profiles.migrate(profile) {
        eprintln!("adopted profile {profile:?} from {}", from.display());
    }
}