Merge pull request #2 from nikomatsakis/ci

fmt, create CI

Author: nikomatsakis

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: rustfmt
+    - run: cargo fmt --all -- --check
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: Swatinem/rust-cache@v2
+    - run: cargo build
+    - run: cargo test

src/agent.rs

@@ -1,13 +1,17 @@
+use crate::cli::ForceOption;
+use crate::registry::{Agent, BinaryDist};
 use std::path::PathBuf;
 use std::process::Stdio;
 use tokio::process::Command;
-use crate::cli::ForceOption;
-use crate::registry::{Agent, BinaryDist};
 use tracing::{debug, info};
 
-pub async fn run_agent(agent: &Agent, cache_dir: &PathBuf, force: Option<&ForceOption>) -> Result<(), Box<dyn std::error::Error>> {
+pub async fn run_agent(
+    agent: &Agent,
+    cache_dir: &PathBuf,
+    force: Option<&ForceOption>,
+) -> Result<(), Box<dyn std::error::Error>> {
     debug!("Running agent: {}", agent.id);
-    
+
     if let Some(npx) = &agent.distribution.npx {
         info!("Executing npx package: {}", npx.package);
         let mut cmd = Command::new("npx");
@@ -19,14 +23,18 @@ pub async fn run_agent(agent: &Agent, cache_dir: &PathBuf, force: Option<&ForceO
         };
         cmd.arg(package_arg);
         cmd.args(&npx.args);
-        cmd.stdin(Stdio::inherit()).stdout(Stdio::inherit()).stderr(Stdio::inherit());
+        cmd.stdin(Stdio::inherit())
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit());
         cmd.status().await?;
     } else if let Some(uvx) = &agent.distribution.uvx {
         info!("Executing uvx package: {}", uvx.package);
         let mut cmd = Command::new("uvx");
         cmd.arg(format!("{}@latest", uvx.package));
         cmd.args(&uvx.args);
-        cmd.stdin(Stdio::inherit()).stdout(Stdio::inherit()).stderr(Stdio::inherit());
+        cmd.stdin(Stdio::inherit())
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit());
         cmd.status().await?;
     } else if !agent.distribution.binary.is_empty() {
         let platform = get_platform();
@@ -36,7 +44,9 @@ pub async fn run_agent(agent: &Agent, cache_dir: &PathBuf, force: Option<&ForceO
             info!("Executing binary: {:?}", binary_path);
             let mut cmd = Command::new(&binary_path);
             cmd.args(&binary_dist.args);
-            cmd.stdin(Stdio::inherit()).stdout(Stdio::inherit()).stderr(Stdio::inherit());
+            cmd.stdin(Stdio::inherit())
+                .stdout(Stdio::inherit())
+                .stderr(Stdio::inherit());
             cmd.status().await?;
         } else {
             return Err(format!("No binary available for platform: {}", platform).into());
@@ -58,45 +68,52 @@ pub fn get_platform() -> String {
         ("windows", "aarch64") => "windows-aarch64",
         ("windows", "x86_64") => "windows-x86_64",
         _ => "unknown",
-    }.to_string()
+    }
+    .to_string()
 }
 
-pub async fn download_binary(agent: &Agent, binary_dist: &BinaryDist, cache_dir: &PathBuf, force: Option<&ForceOption>) -> Result<PathBuf, Box<dyn std::error::Error>> {
+pub async fn download_binary(
+    agent: &Agent,
+    binary_dist: &BinaryDist,
+    cache_dir: &PathBuf,
+    force: Option<&ForceOption>,
+) -> Result<PathBuf, Box<dyn std::error::Error>> {
     let agent_cache_dir = cache_dir.join(&agent.id);
     tokio::fs::create_dir_all(&agent_cache_dir).await?;
-    
+
     let binary_name = binary_dist.cmd.trim_start_matches("./");
     let binary_path = agent_cache_dir.join(binary_name);
-    
+
     let should_download = match force {
         Some(ForceOption::All | ForceOption::Binary) => {
             debug!("Force download requested for binary");
             true
-        },
+        }
         _ => {
             let exists = binary_path.exists();
             debug!("Binary exists at {:?}: {}", binary_path, exists);
             !exists
-        },
+        }
     };
-    
+
     if should_download {
         info!("Downloading binary from: {}", binary_dist.archive);
         let response = reqwest::get(&binary_dist.archive).await?;
         let archive_data = response.bytes().await?;
         debug!("Downloaded {} bytes", archive_data.len());
-        
+
         if binary_dist.archive.ends_with(".zip") {
             debug!("Extracting zip archive");
             extract_zip(&archive_data, &agent_cache_dir).await?;
-        } else if binary_dist.archive.ends_with(".tar.gz") || binary_dist.archive.ends_with(".tgz") {
+        } else if binary_dist.archive.ends_with(".tar.gz") || binary_dist.archive.ends_with(".tgz")
+        {
             debug!("Extracting tar.gz archive");
             extract_tar_gz(&archive_data, &agent_cache_dir).await?;
         } else {
             debug!("Writing raw binary");
             tokio::fs::write(&binary_path, &archive_data).await?;
         }
-        
+
         #[cfg(unix)]
         {
             use std::os::unix::fs::PermissionsExt;
@@ -105,27 +122,27 @@ pub async fn download_binary(agent: &Agent, binary_dist: &BinaryDist, cache_dir:
             tokio::fs::set_permissions(&binary_path, perms).await?;
             debug!("Set executable permissions on binary");
         }
-        
+
         info!("Binary ready at: {:?}", binary_path);
     } else {
         debug!("Using cached binary: {:?}", binary_path);
     }
-    
+
     Ok(binary_path)
 }
 
 async fn extract_zip(data: &[u8], dest: &PathBuf) -> Result<(), Box<dyn std::error::Error>> {
     let data = data.to_vec();
     let dest = dest.clone();
-    
+
     tokio::task::spawn_blocking(move || -> Result<(), String> {
         let cursor = std::io::Cursor::new(data);
         let mut archive = zip::ZipArchive::new(cursor).map_err(|e| e.to_string())?;
-        
+
         for i in 0..archive.len() {
             let mut file = archive.by_index(i).map_err(|e| e.to_string())?;
             let outpath = dest.join(file.name());
-            
+
             if file.is_dir() {
                 std::fs::create_dir_all(&outpath).map_err(|e| e.to_string())?;
             } else {
@@ -137,21 +154,25 @@ async fn extract_zip(data: &[u8], dest: &PathBuf) -> Result<(), Box<dyn std::err
             }
         }
         Ok(())
-    }).await.map_err(|e| e.to_string())??;
-    
+    })
+    .await
+    .map_err(|e| e.to_string())??;
+
     Ok(())
 }
 
 async fn extract_tar_gz(data: &[u8], dest: &PathBuf) -> Result<(), Box<dyn std::error::Error>> {
     let data = data.to_vec();
     let dest = dest.clone();
-    
+
     tokio::task::spawn_blocking(move || -> Result<(), String> {
         let decoder = flate2::read::GzDecoder::new(&data[..]);
         let mut archive = tar::Archive::new(decoder);
         archive.unpack(&dest).map_err(|e| e.to_string())?;
         Ok(())
-    }).await.map_err(|e| e.to_string())??;
-    
+    })
+    .await
+    .map_err(|e| e.to_string())??;
+
     Ok(())
-}
+}

src/cli.rs

@@ -22,4 +22,4 @@ pub enum ForceOption {
     All,
     Registry,
     Binary,
-}
+}

src/lib.rs

@@ -1,7 +1,7 @@
+pub mod agent;
 pub mod cli;
 pub mod registry;
-pub mod agent;
 
+pub use agent::*;
 pub use cli::*;
 pub use registry::*;
-pub use agent::*;

src/main.rs

@@ -1,38 +1,42 @@
+use acpr::{Cli, fetch_registry, list_agents, run_agent};
 use clap::Parser;
-use acpr::{Cli, fetch_registry, run_agent, list_agents};
 use tracing_subscriber;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let cli = Cli::parse();
-    
+
     if cli.debug {
         tracing_subscriber::fmt()
             .with_writer(std::io::stderr)
             .with_max_level(tracing::Level::DEBUG)
             .init();
     }
-    
+
     let cache_dir = cli.cache_dir.unwrap_or_else(|| {
         dirs::cache_dir()
             .expect("No cache directory found")
             .join("acpr")
     });
-    
+
     tokio::fs::create_dir_all(&cache_dir).await?;
-    
+
     let registry = fetch_registry(&cache_dir, cli.force.as_ref(), cli.registry.as_ref()).await?;
-    
+
     if cli.list {
         list_agents(&registry);
         return Ok(());
     }
-    
-    let agent_name = cli.agent_name.ok_or("Agent name is required when not using --list")?;
-    let agent = registry.agents.iter()
+
+    let agent_name = cli
+        .agent_name
+        .ok_or("Agent name is required when not using --list")?;
+    let agent = registry
+        .agents
+        .iter()
         .find(|a| a.id == agent_name)
         .ok_or("Agent not found")?;
-    
+
     run_agent(agent, &cache_dir, cli.force.as_ref()).await?;
     Ok(())
-}
+}