auc-tool 0.1.0

Machine-local software passkey authenticator exposed through Linux UHID.
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
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

use std::time::Duration;

use anyhow::{Context, Result, anyhow, bail};
use capulus::managed::{CargoRegistry, ReleaseSource, ResolvedRelease, VersionTarget};
use semver::Version;
use serde::Deserialize;

const CRATE_API: &str = "https://crates.io/api/v1/crates/auc-tool";

#[derive(Clone)]
pub struct AucReleaseSource {
    client: reqwest::Client,
}

impl AucReleaseSource {
    pub fn new() -> Result<Self> {
        Ok(Self {
            client: reqwest::Client::builder()
                .timeout(Duration::from_secs(30))
                .user_agent(concat!("auc/", env!("CARGO_PKG_VERSION")))
                .build()
                .context("failed to construct the auc release HTTP client")?,
        })
    }

    async fn published_versions(&self) -> Result<Vec<PublishedVersion>> {
        let response: CrateResponse = self
            .client
            .get(CRATE_API)
            .send()
            .await
            .context("failed to query crates.io for auc-tool releases")?
            .error_for_status()
            .context("crates.io rejected the auc-tool release query")?
            .json()
            .await
            .context("crates.io returned malformed auc-tool release metadata")?;
        if response.versions.len() > 10_000 {
            bail!("crates.io returned an unreasonable auc-tool release list");
        }
        response
            .versions
            .into_iter()
            .map(|published| {
                Ok(PublishedVersion {
                    version: Version::parse(&published.num).with_context(|| {
                        format!(
                            "crates.io returned invalid auc-tool version {:?}",
                            published.num
                        )
                    })?,
                    yanked: published.yanked,
                })
            })
            .collect()
    }
}

impl ReleaseSource for AucReleaseSource {
    async fn resolve(&self, target: VersionTarget) -> Result<ResolvedRelease> {
        let versions = self.published_versions().await?;
        let version = match target {
            VersionTarget::Latest => versions
                .into_iter()
                .filter(|published| published.is_installable())
                .map(|published| published.version)
                .max()
                .ok_or_else(|| anyhow!("auc-tool has no non-yanked stable release on crates.io"))?,
            VersionTarget::Exact(value) => {
                let version = Version::parse(&value)
                    .with_context(|| format!("requested auc-tool version {value:?} is invalid"))?;
                if !version.pre.is_empty() || !version.build.is_empty() {
                    bail!("requested auc-tool release must be a stable semantic version");
                }
                versions
                    .into_iter()
                    .find(|published| published.version == version && published.is_installable())
                    .map(|published| published.version)
                    .ok_or_else(|| {
                        anyhow!("auc-tool {version} is not a published non-yanked release")
                    })?
            }
        };
        let release = ResolvedRelease {
            version,
            registry: CargoRegistry::CratesIo,
        };
        release.validate()?;
        Ok(release)
    }
}

#[derive(Deserialize)]
struct CrateResponse {
    versions: Vec<CratesIoVersion>,
}

#[derive(Deserialize)]
struct CratesIoVersion {
    num: String,
    yanked: bool,
}

struct PublishedVersion {
    version: Version,
    yanked: bool,
}

impl PublishedVersion {
    fn is_installable(&self) -> bool {
        !self.yanked && self.version.pre.is_empty() && self.version.build.is_empty()
    }
}