Skip to main content

oxios_kernel/skill/clawhub/
client.rs

1//! ClawHub API client.
2//!
3//! Thin wrapper around ClawHub REST API — search, get detail, download archive.
4
5use std::path::PathBuf;
6
7use anyhow::Result;
8use sha2::Digest;
9use url::Url;
10
11use super::types::{ClawHubSearchResult, ClawHubSkillDetail, SearchResponse};
12
13const DEFAULT_BASE_URL: &str = "https://clawhub.ai";
14
15/// Result of a successful archive download.
16#[derive(Debug)]
17pub struct DownloadedArchive {
18    /// Temporary file containing the zip bytes.
19    pub path: PathBuf,
20    /// SHA-256 hex digest of the downloaded bytes.
21    pub sha256: String,
22}
23
24/// ClawHub API client.
25#[derive(Clone)]
26pub struct ClawHubClient {
27    base_url: Url,
28    client: reqwest::Client,
29}
30
31impl ClawHubClient {
32    /// Create a new client targeting the given base URL, or the public
33    /// ClawHub registry if `base_url` is `None`.
34    pub fn new(base_url: Option<String>) -> Result<Self> {
35        let base = base_url
36            .map(|s| Url::parse(&s))
37            .unwrap_or_else(|| Url::parse(DEFAULT_BASE_URL))?;
38        let base = base
39            .join("/")
40            .map_err(|e| anyhow::anyhow!("invalid base URL: {e}"))?;
41
42        Ok(Self {
43            base_url: base,
44            client: reqwest::Client::new(),
45        })
46    }
47
48    /// Returns the base URL of the registry this client targets.
49    pub fn base_url(&self) -> &Url {
50        &self.base_url
51    }
52
53    /// Search for skills by query string.
54    pub async fn search_skills(
55        &self,
56        query: &str,
57        limit: Option<usize>,
58    ) -> Result<Vec<ClawHubSearchResult>> {
59        let mut url = self.base_url.join("/api/v1/search")?;
60        url.query_pairs_mut()
61            .append_pair("q", query)
62            .append_pair("limit", &limit.unwrap_or(20).to_string());
63
64        let mut req = self.client.get(url);
65        if let Ok(token) = std::env::var("CLAWHUB_TOKEN") {
66            if !token.is_empty() {
67                req = req.header("Authorization", format!("Bearer {token}"));
68            }
69        }
70
71        let resp = req.send().await?;
72        let status = resp.status();
73        if !status.is_success() {
74            let body = resp.text().await.unwrap_or_default();
75            anyhow::bail!("ClawHub search failed ({status}): {body}");
76        }
77
78        let body: SearchResponse = resp.json().await?;
79        Ok(body.results)
80    }
81
82    /// Fetch full detail for a skill by slug.
83    pub async fn get_skill(&self, slug: &str) -> Result<ClawHubSkillDetail> {
84        let url = self.base_url.join(&format!("/api/v1/skills/{slug}"))?;
85
86        let mut req = self.client.get(url);
87        if let Ok(token) = std::env::var("CLAWHUB_TOKEN") {
88            if !token.is_empty() {
89                req = req.header("Authorization", format!("Bearer {token}"));
90            }
91        }
92
93        let resp = req.send().await?;
94        let status = resp.status();
95        if !status.is_success() {
96            let body = resp.text().await.unwrap_or_default();
97            anyhow::bail!("ClawHub get_skill {slug} failed ({status}): {body}");
98        }
99
100        let detail: ClawHubSkillDetail = resp.json().await?;
101        Ok(detail)
102    }
103
104    /// Download a skill archive (zip) returning the temp file path and sha256.
105    pub async fn download_skill(
106        &self,
107        slug: &str,
108        version: Option<&str>,
109    ) -> Result<DownloadedArchive> {
110        let mut url = self.base_url.join("/api/v1/download")?;
111        url.query_pairs_mut().append_pair("slug", slug);
112        if let Some(v) = version {
113            url.query_pairs_mut().append_pair("version", v);
114        }
115
116        let mut req = self.client.get(url);
117        if let Ok(token) = std::env::var("CLAWHUB_TOKEN") {
118            if !token.is_empty() {
119                req = req.header("Authorization", format!("Bearer {token}"));
120            }
121        }
122
123        let resp = req.send().await?;
124        let status = resp.status();
125        if !status.is_success() {
126            let body = resp.text().await.unwrap_or_default();
127            anyhow::bail!("ClawHub download {slug} failed ({status}): {body}");
128        }
129
130        let bytes = resp.bytes().await?;
131        let sha256 = sha2::Sha256::digest(&bytes)
132            .iter()
133            .map(|b| format!("{b:02x}"))
134            .collect::<String>();
135
136        // Write to a temp file (deleted when dropped)
137        let mut tmp = tempfile::Builder::new()
138            .prefix("clawhub-")
139            .suffix(".zip")
140            .tempfile()?;
141        std::io::Write::write_all(&mut tmp, &bytes)?;
142
143        let path = tmp
144            .into_temp_path()
145            .keep()
146            .map_err(|e| anyhow::anyhow!("failed to persist temp file: {e}"))?;
147
148        Ok(DownloadedArchive { path, sha256 })
149    }
150}
151
152// ─── Tests ─────────────────────────────────────────────────────────────────
153
154#[cfg(test)]
155mod tests {
156    use super::*;
157
158    #[test]
159    fn test_client_new_default() {
160        let client = ClawHubClient::new(None).unwrap();
161        assert_eq!(client.base_url.as_str(), "https://clawhub.ai/");
162    }
163
164    #[test]
165    fn test_client_new_custom_url() {
166        let client = ClawHubClient::new(Some("https://staging.clawhub.ai".to_string())).unwrap();
167        assert_eq!(client.base_url.as_str(), "https://staging.clawhub.ai/");
168    }
169
170    #[test]
171    fn test_client_new_invalid_url() {
172        assert!(ClawHubClient::new(Some("not-a-url".to_string())).is_err());
173    }
174}