sparrow-cli 0.8.0

A local-first Rust agent cockpit — route, run, replay, rewind
Documentation 
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

// src/cmd_handlers/handle_auth_login_cmd.rs

pub async fn handle_auth_login(
    provider: &str,
    client_id: Option<String>,
    auth: &sparrow::auth::store::ChainedAuthStore,
) -> anyhow::Result<()> {
    use sparrow::auth::AuthStore;
    use sparrow::config::providers::{AuthFlow, find_provider, list_oauth_providers};
    use sparrow::extras::OAuthFlow;

    let def = find_provider(provider).ok_or_else(|| {
        let oauth_ids: Vec<String> = list_oauth_providers().into_iter().map(|p| p.id).collect();
        anyhow::anyhow!(
            "Unknown provider '{}'. OAuth-capable providers: {}.\nFor API-key providers use 'sparrow auth add {}'.",
            provider,
            oauth_ids.join(", "),
            provider,
        )
    })?;

    let (device_ep, token_ep, scope, cid_env) = match &def.auth_flow {
        AuthFlow::DeviceOAuth {
            device_endpoint,
            token_endpoint,
            scope,
            client_id_env,
        } => (
            device_endpoint.clone(),
            token_endpoint.clone(),
            scope.clone(),
            client_id_env.clone(),
        ),
        AuthFlow::ApiKey => {
            anyhow::bail!(
                "Provider '{}' uses API-key auth, not OAuth.\nUse 'sparrow auth add {}' instead.",
                provider,
                provider
            )
        }
    };

    let cid = client_id
        .or_else(|| std::env::var(&cid_env).ok())
        .ok_or_else(|| {
            anyhow::anyhow!(
                "No OAuth client id for '{}'.\nPass --client-id <id> or set {}.\nRegister an OAuth app with your provider to obtain one.",
                provider, cid_env
            )
        })?;

    println!(
        "Starting OAuth device flow for {} ({})...",
        def.label, provider
    );
    let (verification_uri, user_code, device_code) =
        OAuthFlow::start_device_flow(&device_ep, &token_ep, &cid, &scope).await?;
    println!("\n  1. Open: {}", verification_uri);
    println!("  2. Enter code: {}\n", user_code);
    println!("Waiting for authorization (up to 5 min)...");

    let token = OAuthFlow::poll_token(&token_ep, &cid, &device_code, 300).await?;
    auth.set(provider, sparrow::auth::Credential::api_key(token))?;
    println!("Authenticated. Credential stored for {}.", provider);
    Ok(())
}

// `RunFlags` and `SessionMode` previously had duplicate private copies here;
// they now live in `super::prelude` so every handler shares one definition.