diff --git a/src/engine/engine/command.rs b/src/engine/engine/command.rs
new file mode 100644
index 0000000..67affcf
--- /dev/null
+++ b/src/engine/engine/command.rs
@@ -0,0 +1,163 @@
+use crate::{engine::Engine, store::config::Config};
+
+use pulse_wire::terminal::{ItemState, Mode, Strategy};
+use toml::Value;
+
+impl Engine {
+    pub async fn execute_command(&self, command: &str, args: Vec<&str>) -> tokio::io::Result<()> {
+        match command {
+            "config" | "cfg" => {
+                if args.len() == 0 {
+                    return self.invalid_command_usage("config").await;
+                }
+
+                match args[0] {
+                    "reload" => {
+                        *self.config.lock().await = Config::new().await?;
+                    }
+
+                    "set" => {
+                        macro_rules! set_cfg {
+                            ($n:ident, $v:expr) => {
+                                if let Ok(Ok($n)) = Value::try_from(args[2]).map(|v| v.try_into()) {
+                                    $v;
+                                } else {
+                                    self.terminal_server
+                                        .error("config::set", "Unable to parse value")
+                                        .await?;
+                                }
+                            };
+                        }
+
+                        if args.len() == 3 {
+                            match args[1] {
+                                "watchlist" | "watch" | "wl" => {
+                                    set_cfg!(v, self.config.lock().await.watchlist = v);
+                                }
+
+                                "strategy" | "strat" | "str" | "sg" => {
+                                    set_cfg!(id, {
+                                        let id: String = id;
+                                        self.strategy.reload_strategy(id.as_str()).await?;
+                                        self.config.lock().await.strategy = id;
+                                    });
+                                }
+
+                                "risk" | "rs" => {
+                                    set_cfg!(id, {
+                                        let id: String = id;
+                                        self.strategy.reload_risk(id.as_str()).await?;
+                                        self.config.lock().await.risk = id;
+                                    });
+                                }
+
+                                "cooldown" | "cool" | "cd" => {
+                                    set_cfg!(cooldown, {
+                                        self.config.lock().await.cooldown = cooldown;
+
+                                        self.terminal_server.broadcast(
+                                            pulse_wire::terminal::TerminalServerMessage::StrategyUpdated(Strategy {
+                                                strategy: self.strategy.strategy.manifest.lock().await.clone(),
+                                                risk: self.strategy.risk.manifest.lock().await.clone(),
+                                                mode: Mode::Auto,
+                                                state: ItemState::Running,
+                                                cooldown,
+                                            }),
+                                        )
+                                        .await?;
+                                    });
+                                }
+
+                                _ => {
+                                    self.terminal_server
+                                        .error("config::set", "Invalid usage, available options: watchlist, strategy, risk, cooldown")
+                                        .await?;
+                                }
+                            }
+                        } else {
+                            self.invalid_command_usage("config").await?;
+                        }
+                    }
+
+                    _ => {
+                        self.invalid_command_usage("config").await?;
+                    }
+                }
+            }
+
+            "account" | "acc" => {
+                if args.len() == 0 {
+                    return self.invalid_command_usage("account man").await;
+                }
+
+                match args[0] {
+                    "list" | "ls" => {
+                        self.terminal_server
+                            .info("account man", "ACCOUNT LIST")
+                            .await?;
+
+                        let accounts = self.accounts.lock().await;
+
+                        for (name, acc) in &accounts.accounts {
+                            self.terminal_server
+                                .info(
+                                    "account man",
+                                    &if name == &accounts.active {
+                                        format!(
+                                            "{} (active) -> {}",
+                                            name,
+                                            acc.get_truncated_address()
+                                        )
+                                    } else {
+                                        format!("{} -> {}", name, acc.get_truncated_address())
+                                    },
+                                )
+                                .await?;
+                        }
+                    }
+
+                    "use" | "set" => {
+                        if args.len() < 2 {
+                            return self.invalid_command_usage("account man").await;
+                        }
+
+                        let new_active = args[1];
+
+                        let mut accounts = self.accounts.lock().await;
+
+                        if !accounts.accounts.contains_key(new_active) {
+                            return self
+                                .terminal_server
+                                .error("account man", &format!("Account not found ({new_active})"))
+                                .await;
+                        }
+
+                        accounts.active = new_active.to_string();
+
+                        self.terminal_server
+                            .info(
+                                "account man",
+                                &format!("Account set to {new_active} successfully!"),
+                            )
+                            .await?;
+                    }
+
+                    _ => {
+                        return self.invalid_command_usage("account man").await;
+                    }
+                }
+            }
+
+            _ => {
+                self.terminal_server
+                    .error(
+                        "Command executor",
+                        &format!("Command '{}' not found", command),
+                    )
+                    .await?;
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/engine/engine/mod.rs b/src/engine/engine/mod.rs
index dcd8e65..6afa49f 100644
--- a/src/engine/engine/mod.rs
+++ b/src/engine/engine/mod.rs
@@ -1,4 +1,5 @@
 pub mod plugin;
+pub mod command;
 
 use crate::{
     engine::plugin::StrategyEngine,
@@ -136,104 +137,4 @@ impl Engine {
     pub async fn invalid_command_usage(&self, name: &str) -> tokio::io::Result<()> {
         self.terminal_server.error(name, "Invalid usage").await
     }
-
-    pub async fn execute_command(&self, command: &str, args: Vec<&str>) -> tokio::io::Result<()> {
-        match command {
-            "config" | "cfg" => {
-                if args.len() != 1 {
-                    return self.invalid_command_usage("config").await;
-                }
-
-                match args[0] {
-                    "reload" => {
-                        *self.config.lock().await = Config::new().await?;
-                    }
-
-                    _ => {
-                        self.terminal_server
-                            .error("config", "Invalid usage")
-                            .await?;
-                    }
-                }
-            }
-
-            "account" | "acc" => {
-                if args.len() == 0 {
-                    return self.invalid_command_usage("account man").await;
-                }
-
-                match args[0] {
-                    "reload" => {
-                        *self.accounts.lock().await = AccountList::new().await?;
-                    }
-
-                    "list" | "ls" => {
-                        self.terminal_server
-                            .info("account man", "ACCOUNT LIST")
-                            .await?;
-
-                        let accounts = self.accounts.lock().await;
-
-                        for (name, acc) in &accounts.accounts {
-                            self.terminal_server
-                                .info(
-                                    "account man",
-                                    &if name == &accounts.active {
-                                        format!(
-                                            "{} (active) -> {}",
-                                            name,
-                                            acc.get_truncated_address()
-                                        )
-                                    } else {
-                                        format!("{} -> {}", name, acc.get_truncated_address())
-                                    },
-                                )
-                                .await?;
-                        }
-                    }
-
-                    "use" | "set" => {
-                        if args.len() < 2 {
-                            return self.invalid_command_usage("account man").await;
-                        }
-
-                        let new_active = args[1];
-
-                        let mut accounts = self.accounts.lock().await;
-
-                        if !accounts.accounts.contains_key(new_active) {
-                            return self
-                                .terminal_server
-                                .error("account man", &format!("Account not found ({new_active})"))
-                                .await;
-                        }
-
-                        accounts.active = new_active.to_string();
-
-                        self.terminal_server
-                            .info(
-                                "account man",
-                                &format!("Account set to {new_active} successfully!"),
-                            )
-                            .await?;
-                    }
-
-                    _ => {
-                        return self.invalid_command_usage("account man").await;
-                    }
-                }
-            }
-
-            _ => {
-                self.terminal_server
-                    .error(
-                        "Command executor",
-                        &format!("Command '{}' not found", command),
-                    )
-                    .await?;
-            }
-        }
-
-        Ok(())
-    }
 }