mecha10_cli/services/

binary_manager.rs

//! Binary Manager service for downloading and caching node binaries from GitHub releases
//!
//! This service implements the Node Binary Distribution architecture, providing:
//! - Downloading pre-built node binaries from GitHub releases
//! - Caching binaries to `~/.mecha10/bin/`
//! - Platform detection and target triple resolution
//! - Fallback to cargo install for unsupported platforms
//!
//! # Design
//!
//! - Binaries are downloaded from GitHub releases as tarballs
//! - Binary naming: `{node}-{version}-{target}.tar.gz`
//! - Cached to: `~/.mecha10/bin/{node}-{version}-{target}`
//! - Symlink created: `~/.mecha10/bin/{node}` -> latest version
//!
//! # Usage
//!
//! ```no_run
//! use mecha10_cli::services::BinaryManager;
//!
//! # async fn example() -> anyhow::Result<()> {
//! let manager = BinaryManager::new()?;
//!
//! // Resolve binary path (downloads if needed)
//! let path = manager.resolve("speaker").await?;
//!
//! // Execute the binary
//! std::process::Command::new(&path).spawn()?;
//! # Ok(())
//! # }
//! ```

use crate::paths;
use anyhow::{Context, Result};
use indicatif::{ProgressBar, ProgressStyle};
use std::path::PathBuf;

/// GitHub repository for node binaries (public distribution repo)
const GITHUB_REPO: &str = paths::urls::USER_TOOLS_REPO;

/// Framework version (should match workspace Cargo.toml)
const FRAMEWORK_VERSION: &str = env!("CARGO_PKG_VERSION");

/// Supported pre-built targets
/// Note: Linux uses gnu targets for better compatibility with system libraries
/// (audio, USB, etc.) since robots typically run Raspberry Pi OS / Ubuntu (glibc)
const SUPPORTED_TARGETS: &[&str] = &[
    "aarch64-apple-darwin",      // macOS Apple Silicon
    "x86_64-apple-darwin",       // macOS Intel
    "x86_64-unknown-linux-gnu",  // Linux x86_64 (glibc)
    "aarch64-unknown-linux-gnu", // Linux ARM64 (Pi, Jetson) - glibc
];

/// Service for managing node binary downloads and caching
pub struct BinaryManager {
    /// Binary cache directory (~/.mecha10/bin)
    cache_dir: PathBuf,
    /// Framework version for binary resolution
    version: String,
    /// Current platform target triple
    target: String,
}

impl BinaryManager {
    /// Create a new binary manager
    pub fn new() -> Result<Self> {
        let cache_dir = paths::user::bin_dir();
        let version = FRAMEWORK_VERSION.to_string();
        let target = Self::detect_target()?;

        Ok(Self {
            cache_dir,
            version,
            target,
        })
    }

    /// Create a binary manager with a specific version
    pub fn with_version(version: String) -> Result<Self> {
        let cache_dir = paths::user::bin_dir();
        let target = Self::detect_target()?;

        Ok(Self {
            cache_dir,
            version,
            target,
        })
    }

    /// Detect the current platform's target triple
    fn detect_target() -> Result<String> {
        let target = match (std::env::consts::OS, std::env::consts::ARCH) {
            ("macos", "aarch64") => "aarch64-apple-darwin",
            ("macos", "x86_64") => "x86_64-apple-darwin",
            // Linux uses gnu for compatibility with system libraries (audio, USB, etc.)
            ("linux", "x86_64") => "x86_64-unknown-linux-gnu",
            ("linux", "aarch64") => "aarch64-unknown-linux-gnu",
            (os, arch) => {
                return Err(anyhow::anyhow!(
                    "Unsupported platform: {}-{}. Pre-built binaries not available.",
                    os,
                    arch
                ))
            }
        };
        Ok(target.to_string())
    }

    /// Check if pre-built binaries are available for current platform
    pub fn is_prebuilt_available(&self) -> bool {
        SUPPORTED_TARGETS.contains(&self.target.as_str())
    }

    /// Get the binary cache directory
    pub fn cache_dir(&self) -> &PathBuf {
        &self.cache_dir
    }

    /// Get the current version
    pub fn version(&self) -> &str {
        &self.version
    }

    /// Get the current target
    pub fn target(&self) -> &str {
        &self.target
    }

    /// Resolve binary path for a node, downloading if needed
    ///
    /// Resolution strategy:
    /// 1. Check if cached binary exists for current version/target
    /// 2. If not, try to download from GitHub releases
    /// 3. If download fails and platform unsupported, fall back to cargo install
    ///
    /// # Arguments
    ///
    /// * `node_name` - Name of the node (e.g., "speaker", "motor")
    ///
    /// # Returns
    ///
    /// Path to the executable binary
    pub async fn resolve(&self, node_name: &str) -> Result<PathBuf> {
        // Check cache first
        if let Some(cached) = self.find_cached(node_name) {
            tracing::debug!("Using cached binary: {}", cached.display());
            return Ok(cached);
        }

        // Try to download
        if self.is_prebuilt_available() {
            match self.download(node_name).await {
                Ok(path) => {
                    tracing::info!("Downloaded binary for {}: {}", node_name, path.display());
                    return Ok(path);
                }
                Err(e) => {
                    tracing::warn!("Failed to download binary for {}: {}", node_name, e);
                    // Fall through to cargo install
                }
            }
        } else {
            tracing::info!("Pre-built binary not available for {} on {}", node_name, self.target);
        }

        // Fallback: cargo install
        self.cargo_install(node_name).await
    }

    /// Check for cached binary
    ///
    /// Looks for `{node}-{version}-{target}` in the cache directory
    fn find_cached(&self, node_name: &str) -> Option<PathBuf> {
        let binary_name = self.binary_name(node_name);
        let path = self.cache_dir.join(&binary_name);

        if path.exists() && path.is_file() {
            // Verify it's executable
            #[cfg(unix)]
            {
                use std::os::unix::fs::PermissionsExt;
                if let Ok(metadata) = path.metadata() {
                    if metadata.permissions().mode() & 0o111 != 0 {
                        return Some(path);
                    }
                }
            }

            #[cfg(not(unix))]
            {
                return Some(path);
            }
        }

        // Also check symlink without version
        let symlink_path = self.cache_dir.join(node_name);
        if symlink_path.exists() {
            if let Ok(resolved) = std::fs::canonicalize(&symlink_path) {
                if resolved.exists() {
                    return Some(resolved);
                }
            }
        }

        None
    }

    /// Build the binary name for a node
    fn binary_name(&self, node_name: &str) -> String {
        format!("{}-{}-{}", node_name, self.version, self.target)
    }

    /// Build the tarball name for a node
    fn tarball_name(&self, node_name: &str) -> String {
        format!("{}-{}-{}.tar.gz", node_name, self.version, self.target)
    }

    /// Download binary from GitHub releases
    async fn download(&self, node_name: &str) -> Result<PathBuf> {
        let client = Self::build_client()?;
        let token = Self::github_token();

        // Build release asset URL
        let tarball_name = self.tarball_name(node_name);
        let release_tag = format!("v{}", self.version);

        // Try to get release info
        let release_url = format!(
            "https://api.github.com/repos/{}/releases/tags/{}",
            GITHUB_REPO, release_tag
        );

        println!("📦 Downloading {} (v{})...", node_name, self.version);

        let mut request = client.get(&release_url);
        if let Some(ref token) = token {
            request = request.header("Authorization", format!("Bearer {}", token));
        }

        let response = request
            .send()
            .await
            .context("Failed to fetch release info from GitHub")?;

        if !response.status().is_success() {
            let status = response.status();
            if status.as_u16() == 404 {
                return Err(anyhow::anyhow!(
                    "Release v{} not found. The node binary may not be published yet.\n\
                     Falling back to cargo install...",
                    self.version
                ));
            }
            return Err(anyhow::anyhow!("Failed to get release info: HTTP {}", status));
        }

        let release: serde_json::Value = response.json().await?;

        // Find the asset
        let assets = release["assets"]
            .as_array()
            .ok_or_else(|| anyhow::anyhow!("No assets in release"))?;

        let asset = assets
            .iter()
            .find(|a| a["name"].as_str().map(|n| n == tarball_name).unwrap_or(false))
            .ok_or_else(|| {
                anyhow::anyhow!(
                    "Binary '{}' not found in release v{}.\n\
                     Available binaries may not include this node or platform.",
                    tarball_name,
                    self.version
                )
            })?;

        // Get download URL
        let download_url = if token.is_some() {
            asset["url"]
                .as_str()
                .ok_or_else(|| anyhow::anyhow!("No API URL for asset"))?
        } else {
            asset["browser_download_url"]
                .as_str()
                .ok_or_else(|| anyhow::anyhow!("No download URL for asset"))?
        };

        let size = asset["size"].as_u64().unwrap_or(0);

        // Download and extract
        self.download_and_extract(node_name, download_url, size, token).await
    }

    /// Download and extract a binary tarball
    async fn download_and_extract(
        &self,
        node_name: &str,
        url: &str,
        size: u64,
        token: Option<String>,
    ) -> Result<PathBuf> {
        let client = Self::build_client()?;

        // Create progress bar
        let pb = ProgressBar::new(size);
        pb.set_style(
            ProgressStyle::default_bar()
                .template("{spinner:.green} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})")
                .unwrap()
                .progress_chars("#>-"),
        );

        let mut request = client.get(url);

        // Add auth and accept headers for API downloads
        if let Some(ref token) = token {
            request = request
                .header("Authorization", format!("Bearer {}", token))
                .header("Accept", "application/octet-stream");
        }

        let response = request.send().await.context("Failed to download binary")?;

        if !response.status().is_success() {
            return Err(anyhow::anyhow!("Download failed: HTTP {}", response.status()));
        }

        // Download to temp file
        let temp_dir = tempfile::tempdir()?;
        let temp_file = temp_dir.path().join("binary.tar.gz");

        let mut file = tokio::fs::File::create(&temp_file).await?;
        let mut stream = response.bytes_stream();

        use futures_util::StreamExt;
        use tokio::io::AsyncWriteExt;

        while let Some(chunk) = stream.next().await {
            let chunk = chunk.context("Error downloading chunk")?;
            file.write_all(&chunk).await?;
            pb.inc(chunk.len() as u64);
        }

        file.flush().await?;
        pb.finish_with_message("Download complete");

        // Create cache directory
        tokio::fs::create_dir_all(&self.cache_dir).await?;

        // Extract tarball
        let tar_gz = std::fs::File::open(&temp_file)?;
        let tar = flate2::read::GzDecoder::new(tar_gz);
        let mut archive = tar::Archive::new(tar);

        // Extract to temp, then move to cache
        let extract_dir = temp_dir.path().join("extract");
        std::fs::create_dir_all(&extract_dir)?;
        archive.unpack(&extract_dir)?;

        // Find the binary in the extracted files (should be just the node name)
        let extracted_binary = extract_dir.join(node_name);
        if !extracted_binary.exists() {
            return Err(anyhow::anyhow!("Binary '{}' not found in tarball", node_name));
        }

        // Move to cache with versioned name
        let binary_name = self.binary_name(node_name);
        let dest_path = self.cache_dir.join(&binary_name);

        tokio::fs::copy(&extracted_binary, &dest_path).await?;

        // Make executable
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let mut perms = tokio::fs::metadata(&dest_path).await?.permissions();
            perms.set_mode(0o755);
            tokio::fs::set_permissions(&dest_path, perms).await?;
        }

        // Create/update symlink
        let symlink_path = self.cache_dir.join(node_name);
        if symlink_path.exists() || symlink_path.is_symlink() {
            tokio::fs::remove_file(&symlink_path).await.ok();
        }

        #[cfg(unix)]
        {
            std::os::unix::fs::symlink(&binary_name, &symlink_path)?;
        }

        #[cfg(windows)]
        {
            std::os::windows::fs::symlink_file(&dest_path, &symlink_path)?;
        }

        println!("✅ Installed {} to {}", node_name, dest_path.display());

        Ok(dest_path)
    }

    /// Fallback: install via cargo
    async fn cargo_install(&self, node_name: &str) -> Result<PathBuf> {
        println!(
            "⚠️  Pre-built binary not available for {} on {}",
            self.target, node_name
        );
        println!("🔨 Compiling via cargo install...");

        let crate_name = format!("mecha10-nodes-{}", node_name);

        let output = tokio::process::Command::new("cargo")
            .args([
                "install",
                &crate_name,
                "--version",
                &self.version,
                "--root",
                &self.cache_dir.to_string_lossy(),
            ])
            .output()
            .await
            .context("Failed to run cargo install")?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(anyhow::anyhow!("cargo install failed for {}: {}", crate_name, stderr));
        }

        // cargo install puts binary in {root}/bin/{name}
        let binary_path = self.cache_dir.join("bin").join(node_name);
        if !binary_path.exists() {
            return Err(anyhow::anyhow!(
                "Binary not found after cargo install: {}",
                binary_path.display()
            ));
        }

        println!("✅ Compiled {} via cargo install", node_name);

        Ok(binary_path)
    }

    /// Build an HTTP client
    fn build_client() -> Result<reqwest::Client> {
        reqwest::Client::builder()
            .user_agent("mecha10-cli")
            .build()
            .context("Failed to build HTTP client")
    }

    /// Get GitHub token from environment or gh CLI
    fn github_token() -> Option<String> {
        // Try environment variables
        if let Ok(token) = std::env::var("GITHUB_TOKEN") {
            return Some(token);
        }
        if let Ok(token) = std::env::var("GH_TOKEN") {
            return Some(token);
        }

        // Try gh CLI
        let output = std::process::Command::new("gh").args(["auth", "token"]).output().ok()?;

        if output.status.success() {
            let token = String::from_utf8(output.stdout).ok()?;
            let token = token.trim();
            if !token.is_empty() {
                return Some(token.to_string());
            }
        }

        None
    }

    /// List all cached binaries
    pub fn list_cached(&self) -> Result<Vec<(String, String, String)>> {
        let mut binaries = Vec::new();

        if !self.cache_dir.exists() {
            return Ok(binaries);
        }

        for entry in std::fs::read_dir(&self.cache_dir)? {
            let entry = entry?;
            let name = entry.file_name().to_string_lossy().to_string();

            // Skip symlinks (they don't have version info)
            if entry.file_type()?.is_symlink() {
                continue;
            }

            // Parse name: {node}-{version}-{target}
            let parts: Vec<&str> = name.rsplitn(3, '-').collect();
            if parts.len() >= 3 {
                // Note: rsplitn reverses order
                let target_parts = format!("{}-{}", parts[1], parts[0]);
                let version = parts.get(2).map(|s| s.to_string()).unwrap_or_default();

                // Extract node name from remaining parts
                let remaining: String = parts.iter().skip(2).rev().map(|s| *s).collect::<Vec<_>>().join("-");
                if !remaining.is_empty() {
                    binaries.push((remaining, version, target_parts));
                }
            }
        }

        Ok(binaries)
    }

    /// Remove a cached binary
    pub async fn remove(&self, node_name: &str) -> Result<()> {
        let binary_name = self.binary_name(node_name);
        let binary_path = self.cache_dir.join(&binary_name);
        let symlink_path = self.cache_dir.join(node_name);

        if binary_path.exists() {
            tokio::fs::remove_file(&binary_path).await?;
            println!("Removed {}", binary_path.display());
        }

        if symlink_path.exists() || symlink_path.is_symlink() {
            tokio::fs::remove_file(&symlink_path).await?;
            println!("Removed symlink {}", symlink_path.display());
        }

        Ok(())
    }

    /// Clear all cached binaries
    pub async fn clear_cache(&self) -> Result<()> {
        if self.cache_dir.exists() {
            tokio::fs::remove_dir_all(&self.cache_dir).await?;
            println!("Cleared binary cache at {}", self.cache_dir.display());
        }
        Ok(())
    }
}

impl Default for BinaryManager {
    fn default() -> Self {
        Self::new().expect("Failed to create BinaryManager")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_binary_name() {
        let manager = BinaryManager {
            cache_dir: PathBuf::from("/tmp"),
            version: "0.1.44".to_string(),
            target: "aarch64-apple-darwin".to_string(),
        };

        assert_eq!(manager.binary_name("speaker"), "speaker-0.1.44-aarch64-apple-darwin");
    }

    #[test]
    fn test_tarball_name() {
        let manager = BinaryManager {
            cache_dir: PathBuf::from("/tmp"),
            version: "0.1.44".to_string(),
            target: "x86_64-apple-darwin".to_string(),
        };

        assert_eq!(manager.tarball_name("motor"), "motor-0.1.44-x86_64-apple-darwin.tar.gz");
    }

    #[test]
    fn test_prebuilt_available() {
        let manager = BinaryManager {
            cache_dir: PathBuf::from("/tmp"),
            version: "0.1.44".to_string(),
            target: "aarch64-apple-darwin".to_string(),
        };
        assert!(manager.is_prebuilt_available());

        // aarch64-unknown-linux-gnu is now supported (for Pi, Jetson with glibc)
        let manager_arm_linux = BinaryManager {
            cache_dir: PathBuf::from("/tmp"),
            version: "0.1.44".to_string(),
            target: "aarch64-unknown-linux-gnu".to_string(),
        };
        assert!(manager_arm_linux.is_prebuilt_available());

        // musl variant is not supported (we use gnu for system library compatibility)
        let manager_unsupported = BinaryManager {
            cache_dir: PathBuf::from("/tmp"),
            version: "0.1.44".to_string(),
            target: "aarch64-unknown-linux-musl".to_string(),
        };
        assert!(!manager_unsupported.is_prebuilt_available());
    }
}