feat: add command hbox config

Author: helton

ROADMAP.md

@@ -30,8 +30,6 @@ List of ideas I want to implement in the future.
   - Add version to config files to specify their formats to allow check for future compatibility
   - [Experimental] Allow forced flags in docker run, based on pattern matching
 - New commands
-  - Add `hbox config` to support all `config.json` options
-    - example: `hbox config logs.enabled true`
   - Add auto update `hbox upgrade`
   - Add `hbox update` to update index
   - Add `hbox register` to register a package, even with custom image

src/cli.rs

@@ -71,6 +71,16 @@ enum Commands {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         subcommand: Vec<String>,
     },
+
+    /// Configure settings
+    #[command(alias = "configure")]
+    Config {
+        /// Configuration path
+        path: String,
+
+        /// Configuration value
+        value: Option<String>,
+    },
 }
 
 pub fn run() {
@@ -97,6 +107,7 @@ pub fn run() {
         Commands::Remove { name, version } => remove_package(name.clone(), version.clone()),
         Commands::Use { name, version } => use_package_version(name.clone(), version.clone()),
         Commands::Run { name, subcommand } => run_package(name.clone(), subcommand.clone()),
+        Commands::Config { path, value } => configure_setting(path.clone(), value.clone()),
     };
 
     if let Err(e) = result {

src/commands.rs

@@ -179,6 +179,16 @@ pub fn run_package(name: String, subcommand: Vec<String>) -> Result<(), Box<dyn
     }
 }
 
+pub fn configure_setting(path: String, value: Option<String>) -> Result<(), Box<dyn Error>> {
+    if let Some(value) = value {
+        UserConfig::write_config_value(&path, &value)?;
+    } else {
+        UserConfig::read_config_value(&path)?;
+    }
+
+    Ok(())
+}
+
 fn do_add_package(name: &String, version: &String, package: Package) -> Result<(), Box<dyn Error>> {
     let mut new_package = package.clone();
     new_package.versions.current = version.clone();

src/configs/user.rs

@@ -1,5 +1,6 @@
 use log::LevelFilter;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use std::error::Error;
 use std::str::FromStr;
 
@@ -19,6 +20,81 @@ impl UserConfig {
             Ok(root)
         }
     }
+
+    pub fn save(root: Root) -> Result<(), Box<dyn Error>> {
+        let config = AppConfig::load();
+        save_json(&root, &config.config_file_path())?;
+        Ok(())
+    }
+
+    pub fn write_config_value(path: &str, value: &str) -> Result<(), Box<dyn Error>> {
+        let mut root: Value = serde_json::to_value(Self::load()?)?;
+        let (current, last_part) = Self::traverse_path(&mut root, path)?;
+
+        let parsed_value =
+            if value.eq_ignore_ascii_case("true") || value.eq_ignore_ascii_case("false") {
+                Value::Bool(value.parse::<bool>()?)
+            } else if let Ok(int_value) = value.parse::<i64>() {
+                Value::Number(int_value.into())
+            } else {
+                Value::String(value.to_string())
+            };
+
+        match current {
+            Value::Object(map) => {
+                if map.contains_key(&last_part) {
+                    map.insert(last_part, parsed_value);
+                } else {
+                    return Err(format!("Invalid configuration key: {}", path).into());
+                }
+            }
+            _ => return Err("Invalid configuration path".into()),
+        }
+
+        let updated_root: Root = serde_json::from_value(root)?;
+        Self::save(updated_root)?;
+
+        Ok(())
+    }
+
+    pub fn read_config_value(path: &str) -> Result<(), Box<dyn Error>> {
+        let mut root: Value = serde_json::to_value(Self::load()?)?;
+        let (current, last_part) = Self::traverse_path(&mut root, path)?;
+
+        match current.get(&last_part) {
+            Some(value) => {
+                if value.is_object() {
+                    println!("{}", serde_json::to_string_pretty(&value)?);
+                } else {
+                    println!("{}", value);
+                }
+            }
+            None => return Err(format!("Invalid configuration key: {}", path).into()),
+        }
+
+        Ok(())
+    }
+
+    fn traverse_path<'a>(
+        root: &'a mut Value,
+        path: &str,
+    ) -> Result<(&'a mut Value, String), Box<dyn Error>> {
+        let parts: Vec<&str> = path.split('.').collect();
+        if parts.is_empty() {
+            return Err("Invalid configuration path".into());
+        }
+
+        let mut current = root;
+        for part in parts.iter().take(parts.len() - 1) {
+            current = current.get_mut(*part).ok_or("Invalid configuration path")?;
+        }
+
+        let last_part = parts
+            .last()
+            .ok_or("Invalid configuration path")?
+            .to_string();
+        Ok((current, last_part))
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Default)]
@@ -50,6 +126,18 @@ impl Engine {
     }
 }
 
+impl FromStr for Engine {
+    type Err = ();
+
+    fn from_str(input: &str) -> Result<Engine, Self::Err> {
+        match input.to_lowercase().as_str() {
+            "docker" => Ok(Engine::Docker),
+            "podman" => Ok(Engine::Podman),
+            _ => Err(()),
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Logs {
     #[serde(default)]