htb_cli/

config.rs

use std::fs;
use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct HtbConfig {
    #[serde(default = "default_output")]
    pub output: String,

    #[serde(default)]
    pub vpn_server: Option<u32>,

    #[serde(default)]
    pub no_color: bool,

    #[serde(default)]
    pub cache: CacheConfig,

    #[serde(default)]
    pub ctf_event: Option<u64>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CacheConfig {
    #[serde(default = "default_cache_enabled")]
    pub enabled: bool,
}

fn default_cache_enabled() -> bool {
    true
}

impl Default for CacheConfig {
    fn default() -> Self {
        Self {
            enabled: default_cache_enabled(),
        }
    }
}

fn default_output() -> String {
    "table".into()
}

impl Default for HtbConfig {
    fn default() -> Self {
        Self {
            output: default_output(),
            vpn_server: None,
            no_color: false,
            cache: CacheConfig::default(),
            ctf_event: None,
        }
    }
}

impl HtbConfig {
    pub fn load(path: Option<&Path>) -> anyhow::Result<Self> {
        let config_path = match path {
            Some(p) => p.to_path_buf(),
            None => config_dir()?.join("config.toml"),
        };

        if config_path.exists() {
            let contents = fs::read_to_string(&config_path)?;
            Ok(toml::from_str(&contents)?)
        } else {
            Ok(Self::default())
        }
    }
}

pub fn config_dir() -> Result<PathBuf, crate::error::HtbError> {
    dirs::home_dir()
        .ok_or_else(|| crate::error::HtbError::Config("could not determine home directory".into()))
        .map(|d| d.join(".htb-cli"))
}

pub fn cache_dir() -> PathBuf {
    config_dir()
        .map(|d| d.join("cache"))
        .unwrap_or_else(|_| std::env::temp_dir().join("htb-cli-cache"))
}

pub fn token_path() -> Result<PathBuf, crate::error::HtbError> {
    Ok(config_dir()?.join(".token"))
}

pub fn read_token() -> Result<String, crate::error::HtbError> {
    let path = token_path()?;
    if !path.exists() {
        return Err(crate::error::HtbError::NotAuthenticated);
    }
    let token = fs::read_to_string(&path)?.trim().to_string();
    if token.is_empty() {
        return Err(crate::error::HtbError::NotAuthenticated);
    }
    Ok(token)
}

pub fn save_token(token: &str) -> anyhow::Result<()> {
    let dir = config_dir()?;
    fs::create_dir_all(&dir)?;

    let path = token_path()?;

    #[cfg(unix)]
    {
        use std::io::Write;
        use std::os::unix::fs::OpenOptionsExt;
        let mut f = fs::OpenOptions::new()
            .write(true)
            .create(true)
            .truncate(true)
            .mode(0o600)
            .open(&path)?;
        f.write_all(token.as_bytes())?;
    }

    #[cfg(not(unix))]
    {
        fs::write(&path, token)?;
    }

    Ok(())
}

pub fn remove_token() -> anyhow::Result<()> {
    let path = token_path()?;
    if path.exists() {
        fs::remove_file(&path)?;
    }
    Ok(())
}

pub fn ctf_token_path() -> Result<PathBuf, crate::error::HtbError> {
    Ok(config_dir()?.join(".ctf-token"))
}

pub fn read_ctf_token() -> Result<String, crate::error::HtbError> {
    let path = ctf_token_path()?;
    if !path.exists() {
        return Err(crate::error::HtbError::NotAuthenticated);
    }
    let token = fs::read_to_string(&path)?.trim().to_string();
    if token.is_empty() {
        return Err(crate::error::HtbError::NotAuthenticated);
    }
    Ok(token)
}

pub fn save_ctf_token(token: &str) -> anyhow::Result<()> {
    let dir = config_dir()?;
    fs::create_dir_all(&dir)?;

    let path = ctf_token_path()?;

    #[cfg(unix)]
    {
        use std::io::Write;
        use std::os::unix::fs::OpenOptionsExt;
        let mut f = fs::OpenOptions::new()
            .write(true)
            .create(true)
            .truncate(true)
            .mode(0o600)
            .open(&path)?;
        f.write_all(token.as_bytes())?;
    }

    #[cfg(not(unix))]
    {
        fs::write(&path, token)?;
    }

    Ok(())
}

pub fn remove_ctf_token() -> anyhow::Result<()> {
    let path = ctf_token_path()?;
    if path.exists() {
        fs::remove_file(&path)?;
    }
    Ok(())
}

pub fn read_ctf_event() -> Option<u64> {
    let path = config_dir().ok()?.join("config.toml");
    let contents = fs::read_to_string(path).ok()?;
    let config: HtbConfig = toml::from_str(&contents).ok()?;
    config.ctf_event
}

pub fn save_ctf_event(event_id: Option<u64>) -> anyhow::Result<()> {
    let dir = config_dir()?;
    fs::create_dir_all(&dir)?;
    let path = dir.join("config.toml");

    let mut config: HtbConfig = if path.exists() {
        let contents = fs::read_to_string(&path)?;
        toml::from_str(&contents)?
    } else {
        HtbConfig::default()
    };

    config.ctf_event = event_id;
    fs::write(&path, toml::to_string_pretty(&config)?)?;
    Ok(())
}

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

    #[test]
    fn default_config() {
        let config = HtbConfig::default();
        assert_eq!(config.output, "table");
        assert_eq!(config.vpn_server, None);
        assert!(!config.no_color);
    }

    #[test]
    fn toml_round_trip() {
        let config = HtbConfig {
            output: "json".into(),
            vpn_server: Some(1),
            no_color: true,
            cache: CacheConfig::default(),
            ctf_event: Some(1434),
        };
        let serialized = toml::to_string(&config).unwrap();
        let deserialized: HtbConfig = toml::from_str(&serialized).unwrap();
        assert_eq!(deserialized.output, "json");
        assert_eq!(deserialized.vpn_server, Some(1));
        assert!(deserialized.no_color);
        assert_eq!(deserialized.ctf_event, Some(1434));
    }

    #[test]
    fn partial_toml_uses_defaults() {
        let input = r#"output = "json""#;
        let config: HtbConfig = toml::from_str(input).unwrap();
        assert_eq!(config.output, "json");
        assert_eq!(config.vpn_server, None);
        assert!(!config.no_color);
    }

    #[test]
    fn empty_toml_uses_defaults() {
        let config: HtbConfig = toml::from_str("").unwrap();
        assert_eq!(config.output, "table");
    }

    #[test]
    fn token_round_trip() {
        let dir = std::env::temp_dir().join("htb-cli-test-token");
        let _ = std::fs::create_dir_all(&dir);
        let path = dir.join(".token");

        std::fs::write(&path, "test-token-123").unwrap();
        let read_back = std::fs::read_to_string(&path).unwrap();
        assert_eq!(read_back.trim(), "test-token-123");

        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn ctf_token_path_ends_with_ctf_token() {
        let path = ctf_token_path().unwrap();
        assert!(path.ends_with(".ctf-token"));
    }

    #[test]
    fn ctf_token_path_differs_from_labs_token() {
        let labs = token_path().unwrap();
        let ctf = ctf_token_path().unwrap();
        assert_ne!(labs, ctf);
    }
}