dojo_cli/

config.rs

use aes_gcm::{
    aead::{Aead, KeyInit},
    Aes256Gcm, Nonce,
};
use base64::{engine::general_purpose, Engine as _};
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub enum Environment {
    Dev,
    Prod,
}

impl Environment {
    pub fn api_base_url(&self) -> &'static str {
        match self {
            Environment::Dev => "https://vkyme566n8.execute-api.us-east-1.amazonaws.com",
            Environment::Prod => "https://o7eumduni6.execute-api.us-east-1.amazonaws.com",
        }
    }

    pub fn display_name(&self) -> &'static str {
        match self {
            Environment::Dev => "development",
            Environment::Prod => "production",
        }
    }
}

impl std::str::FromStr for Environment {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "dev" | "development" => Ok(Environment::Dev),
            "prod" | "production" => Ok(Environment::Prod),
            _ => Err(format!("Unknown environment: {}. Use 'dev' or 'prod'", s)),
        }
    }
}

// Get the current environment at compile time
pub fn get_current_environment() -> Environment {
    #[cfg(debug_assertions)]
    {
        Environment::Dev
    }
    #[cfg(not(debug_assertions))]
    {
        Environment::Prod
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Config {
    pub workspace_directory: String,
    pub api_token: String,
    pub curriculum_version: String,
}

// Internal struct for serialization/deserialization with encrypted token
#[derive(Debug, Serialize, Deserialize)]
struct ConfigFile {
    workspace_directory: String,
    encrypted_api_token: String,
    curriculum_version: String,
}

impl Config {
    pub fn new(workspace_directory: String, api_token: String, curriculum_version: String) -> Self {
        Self {
            workspace_directory,
            api_token,
            curriculum_version,
        }
    }

    pub fn get_api_base_url(&self) -> String {
        get_current_environment().api_base_url().to_string()
    }

    pub fn get_environment(&self) -> Environment {
        get_current_environment()
    }

    pub fn get_curriculum_version(&self) -> &str {
        &self.curriculum_version
    }

    pub fn get_config_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
        let home_dir = dirs::home_dir().ok_or("Could not find home directory")?;

        let config_dir = home_dir.join(".dojo-cli");

        // Create the directory if it doesn't exist
        if !config_dir.exists() {
            fs::create_dir_all(&config_dir)?;
        }

        Ok(config_dir)
    }

    pub fn get_config_path() -> Result<PathBuf, Box<dyn std::error::Error>> {
        let config_dir = Self::get_config_dir()?;
        Ok(config_dir.join("config.toml"))
    }

    pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
        let config_path = Self::get_config_path()?;

        // Encrypt the API token before saving
        let encrypted_token = Self::encrypt_token(&self.api_token)?;

        let config_file = ConfigFile {
            workspace_directory: self.workspace_directory.clone(),
            encrypted_api_token: encrypted_token,
            curriculum_version: self.curriculum_version.clone(),
        };

        let toml_string = toml::to_string_pretty(&config_file)?;
        fs::write(config_path, toml_string)?;
        Ok(())
    }

    pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
        let config_path = Self::get_config_path()?;
        let content = fs::read_to_string(config_path)?;

        // Try to load as encrypted format first
        if let Ok(config_file) = toml::from_str::<ConfigFile>(&content) {
            // Decrypt the API token
            let decrypted_token = Self::decrypt_token(&config_file.encrypted_api_token)?;

            return Ok(Config {
                workspace_directory: config_file.workspace_directory,
                api_token: decrypted_token,
                curriculum_version: config_file.curriculum_version,
            });
        }

        // Try to parse as the new format without encryption (for testing)
        let config: Config = toml::from_str(&content)?;
        Ok(config)
    }

    pub fn exists() -> bool {
        Self::get_config_path()
            .map(|path| path.exists())
            .unwrap_or(false)
    }

    // Generate a key from a passphrase using a simple hash-based approach
    fn derive_key_from_passphrase(passphrase: &str) -> [u8; 32] {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let mut key = [0u8; 32];

        // Generate multiple hashes to fill the 32-byte key
        for i in 0..4 {
            let mut hasher = DefaultHasher::new();
            // Create a unique seed for each hash by appending the index
            let seed = format!("{}{}", passphrase, i);
            seed.hash(&mut hasher);
            let hash = hasher.finish();

            // Extract 8 bytes from each hash (64 bits = 8 bytes)
            for j in 0..8 {
                let byte_index = i * 8 + j;
                if byte_index < 32 {
                    key[byte_index] = ((hash >> (j * 8)) & 0xFF) as u8;
                }
            }
        }

        key
    }

    // Encrypt the API token
    fn encrypt_token(token: &str) -> Result<String, Box<dyn std::error::Error>> {
        // Use a simple passphrase based on the user's home directory
        let home_dir = dirs::home_dir()
            .ok_or("Could not find home directory")?
            .to_string_lossy()
            .to_string();

        let passphrase = format!("bitcoin-dojo-cli-{}", home_dir);
        let key = Self::derive_key_from_passphrase(&passphrase);

        let cipher = Aes256Gcm::new_from_slice(&key)
            .map_err(|e| format!("Failed to create cipher: {}", e))?;

        // Generate a random nonce
        let mut nonce_bytes = [0u8; 12];
        getrandom::getrandom(&mut nonce_bytes)
            .map_err(|e| format!("Failed to generate nonce: {}", e))?;
        let nonce = Nonce::from_slice(&nonce_bytes);

        let ciphertext = cipher
            .encrypt(nonce, token.as_bytes())
            .map_err(|e| format!("Failed to encrypt token: {}", e))?;

        // Combine nonce and ciphertext, then base64 encode
        let mut combined = Vec::new();
        combined.extend_from_slice(&nonce_bytes);
        combined.extend_from_slice(&ciphertext);

        Ok(general_purpose::STANDARD.encode(combined))
    }

    // Decrypt the API token
    fn decrypt_token(encrypted_token: &str) -> Result<String, Box<dyn std::error::Error>> {
        // Use the same passphrase as encryption
        let home_dir = dirs::home_dir()
            .ok_or("Could not find home directory")?
            .to_string_lossy()
            .to_string();

        let passphrase = format!("bitcoin-dojo-cli-{}", home_dir);
        let key = Self::derive_key_from_passphrase(&passphrase);

        let cipher = Aes256Gcm::new_from_slice(&key)
            .map_err(|e| format!("Failed to create cipher: {}", e))?;

        // Decode from base64
        let combined = general_purpose::STANDARD
            .decode(encrypted_token)
            .map_err(|e| format!("Failed to decode base64: {}", e))?;

        // Extract nonce (first 12 bytes) and ciphertext
        if combined.len() < 12 {
            return Err("Invalid encrypted token format".into());
        }

        let nonce = Nonce::from_slice(&combined[..12]);
        let ciphertext = &combined[12..];

        let plaintext = cipher
            .decrypt(nonce, ciphertext)
            .map_err(|e| format!("Failed to decrypt token: {}", e))?;
        Ok(String::from_utf8(plaintext)
            .map_err(|e| format!("Failed to convert to string: {}", e))?)
    }

    /// Initialize curriculum version by calling the backend API
    pub async fn init_curriculum_version(
        api_token: &str,
    ) -> Result<String, Box<dyn std::error::Error>> {
        let base_url = get_current_environment().api_base_url();
        let stage = match get_current_environment() {
            Environment::Dev => "dev",
            Environment::Prod => "prod",
        };

        let url = format!("{}/{}/curriculum_version/init", base_url, stage);

        let client = reqwest::Client::new();
        let response = client
            .patch(&url)
            .bearer_auth(api_token)
            .header("x-bdj-stage", stage)
            .send()
            .await?;

        // Debug: Print response details
        let status = response.status();
        println!("Response status: {}", status);
        let response_text = response.text().await?;
        println!("Response body: {}", response_text);

        if !status.is_success() {
            return Err(Self::parse_api_error(
                "Failed to initialize curriculum version",
                &response_text,
            )
            .into());
        }

        let json_response: serde_json::Value = serde_json::from_str(&response_text)?;
        let curriculum_version = json_response["curriculum_version"]
            .as_str()
            .ok_or("curriculum_version not found in response")?;

        Ok(curriculum_version.to_string())
    }

    /// Update curriculum version by calling the backend API
    pub async fn update_curriculum_version(
        api_token: &str,
        target_version: Option<&str>,
    ) -> Result<String, Box<dyn std::error::Error>> {
        let base_url = get_current_environment().api_base_url();
        let stage = match get_current_environment() {
            Environment::Dev => "dev",
            Environment::Prod => "prod",
        };

        let url = format!("{}/{}/curriculum_version/update", base_url, stage);

        // Load current config to get the current curriculum version
        let current_config = Config::load()?;
        let current_curriculum_version = current_config.get_curriculum_version();

        let client = reqwest::Client::new();
        let mut request = client
            .patch(&url)
            .bearer_auth(api_token)
            .header("x-bdj-stage", stage)
            .header("x-bdj-curriculum-version", current_curriculum_version);

        // Add target version header if specified
        if let Some(version) = target_version {
            request = request.header("x-bdj-target-version", version);
        }

        let response = request.send().await?;

        // Debug: Print response details
        let status = response.status();
        println!("Response status: {}", status);
        let response_text = response.text().await?;
        println!("Response body: {}", response_text);

        if !status.is_success() {
            return Err(Self::parse_api_error(
                "Failed to update curriculum version",
                &response_text,
            )
            .into());
        }

        let json_response: serde_json::Value = serde_json::from_str(&response_text)?;
        let new_curriculum_version = json_response["curriculum_version"]
            .as_str()
            .ok_or("curriculum_version not found in response")?;

        // Check if the version was actually updated
        let updated = json_response["updated"].as_bool().unwrap_or(false);

        if updated {
            // Update the config file with the new curriculum version
            let mut updated_config = current_config;
            updated_config.curriculum_version = new_curriculum_version.to_string();
            updated_config.save()?;
            println!("📝 Config file updated with new curriculum version");
        } else if target_version.is_some() {
            println!("ℹ️  Curriculum version is already at the requested version");
        } else {
            println!("ℹ️  Curriculum version is already up to date");
        }

        Ok(new_curriculum_version.to_string())
    }

    /// Parse API error responses and return appropriate error messages
    fn parse_api_error(context: &str, response_text: &str) -> String {
        // Try to parse as JSON to extract structured error messages
        if let Ok(error_json) = serde_json::from_str::<serde_json::Value>(response_text) {
            if let Some(error_msg) = error_json["message"].as_str() {
                if error_msg == "Forbidden" {
                    return "❌ Authorization Error: Access forbidden".to_string();
                } else {
                    return format!("❌ API Error: {}", error_msg);
                }
            }
        }

        // Fallback to generic error message
        format!("❌ {}: {}", context, response_text)
    }
}