ui: deprecate add and unload key features from UI

Signed-off-by: saiaunghlyanhtet <saiaunghlyanhtet2003@gmail.com>

Author: saiaunghlyanhtet

README.md

@@ -127,9 +127,9 @@ BPF maps used:
 
 Built with [ratatui](https://docs.rs/ratatui) and [crossterm](https://docs.rs/crossterm):
 
-- **`app.rs`** — Application state: active rules, log buffer, per-rule stats, input mode.
+- **`app.rs`** — Application state: active rules, log buffer, per-rule stats.
 - **`widgets.rs`** — Renders a rules table (name, IP, protocol, direction, ports, action, stats, description), a scrolling log pane, and help text.
-- **`events.rs`** — Keyboard event handling: `Q` to quit, `A` to add a rule interactively, `U` to unload the firewall (with confirmation).
+- **`events.rs`** — Keyboard event handling: `Q` to quit. Rules are managed via the CLI (`firebee add/delete`).
 
 ## Usage
 

src/bpf_user/handler.rs

@@ -1,10 +1,16 @@
 use crate::bpf_user::{loader::BpfLoader, maps::BpfMaps};
 use crate::models::rule::Rule;
-use crate::ui::app::Command;
 use libbpf_rs::{Link, RingBufferBuilder};
 use std::net::Ipv4Addr;
 use tokio::sync::mpsc;
 
+#[allow(dead_code)]
+pub enum Command {
+    AddRule(Rule),
+    RemoveRule(Ipv4Addr),
+    Unload,
+}
+
 #[allow(dead_code)]
 pub struct BpfHandler {
     bpf_object: Option<Box<libbpf_rs::Object>>,

src/main.rs

@@ -12,7 +12,6 @@ use once_cell::sync::OnceCell;
 use ratatui::prelude::*;
 use std::io;
 use std::path::PathBuf;
-use tokio::sync::mpsc;
 
 mod bpf_user;
 mod models;
@@ -183,8 +182,7 @@ async fn run_firewall(interface: &str, policy: Option<PathBuf>) -> Result<()> {
 }
 
 async fn run_tui() -> Result<()> {
-    let (tx_cmd, _rx_cmd) = mpsc::channel(32);
-    let (tx_log, rx_log) = mpsc::channel(32);
+    let (tx_log, rx_log) = tokio::sync::mpsc::channel(32);
 
     let maps = open_pinned_maps()?;
     let existing_rules = RulesState::list_rules(&maps).unwrap_or_else(|e| {
@@ -242,7 +240,7 @@ async fn run_tui() -> Result<()> {
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
-    let mut app = App::new(tx_cmd, rx_log, existing_rules);
+    let mut app = App::new(rx_log, existing_rules);
 
     let mut stats_interval = tokio::time::interval(tokio::time::Duration::from_secs(1));
 

src/ui/app.rs

@@ -1,43 +1,20 @@
-use crate::models::rule::{Action, Direction, Rule};
 use crate::policy::PolicyRule;
 use std::collections::HashMap;
-use std::net::{IpAddr, Ipv4Addr};
 use tokio::sync::mpsc;
 
-#[allow(dead_code)]
-pub enum Command {
-    AddRule(Rule),
-    RemoveRule(Ipv4Addr),
-    Unload,
-}
-
 pub struct App {
     pub rules: Vec<PolicyRule>,
     pub logs: Vec<String>,
-    pub input: String,
-    pub input_mode: bool,
-    pub confirm_unload: bool,
-    pub unload_requested: bool,
     pub rule_stats: HashMap<String, (u64, u64)>,
-    cmd_tx: mpsc::Sender<Command>,
     log_rx: mpsc::Receiver<String>,
 }
 
 impl App {
-    pub fn new(
-        cmd_tx: mpsc::Sender<Command>,
-        log_rx: mpsc::Receiver<String>,
-        initial_rules: Vec<PolicyRule>,
-    ) -> Self {
+    pub fn new(log_rx: mpsc::Receiver<String>, initial_rules: Vec<PolicyRule>) -> Self {
         Self {
             rules: initial_rules,
             logs: vec![],
-            input: String::new(),
-            input_mode: false,
-            confirm_unload: false,
-            unload_requested: false,
             rule_stats: HashMap::new(),
-            cmd_tx,
             log_rx,
         }
     }
@@ -54,51 +31,4 @@ impl App {
             }
         }
     }
-
-    pub async fn add_rule(&mut self, ip: &str, action: Action) -> bool {
-        if let Ok(ip_addr) = ip.parse::<Ipv4Addr>() {
-            let rule = Rule {
-                ip: IpAddr::V4(ip_addr),
-                subnet_mask: None,
-                action: action.clone(),
-                protocol: crate::models::rule::Protocol::Any,
-                direction: Direction::Ingress,
-                src_port: None,
-                dst_port: None,
-            };
-            let policy_rule = PolicyRule {
-                name: format!("rule_{}", ip),
-                ip: ip.to_string(),
-                action: match action {
-                    Action::Allow => "allow".to_string(),
-                    Action::Drop => "drop".to_string(),
-                },
-                description: None,
-                protocol: "any".to_string(),
-                direction: "ingress".to_string(),
-                src_port: None,
-                dst_port: None,
-            };
-            self.rules.push(policy_rule);
-            self.cmd_tx.send(Command::AddRule(rule)).await.is_ok()
-        } else {
-            false
-        }
-    }
-
-    #[allow(dead_code)]
-    pub async fn remove_rule(&mut self, ip: Ipv4Addr) -> bool {
-        self.rules.retain(|r| r.ip != ip.to_string());
-        self.cmd_tx.send(Command::RemoveRule(ip)).await.is_ok()
-    }
-
-    pub async fn unload(&mut self) -> bool {
-        match self.cmd_tx.send(Command::Unload).await {
-            Ok(_) => {
-                self.unload_requested = true;
-                true
-            }
-            Err(_) => false,
-        }
-    }
 }

src/ui/events.rs

@@ -1,57 +1,12 @@
-use crate::models::rule::Action;
 use crate::ui::app::App;
 use crossterm::event::{Event, KeyCode};
 
 pub async fn handle_events(app: &mut App) -> anyhow::Result<bool> {
     if crossterm::event::poll(std::time::Duration::from_millis(50))? {
         if let Event::Key(key_event) = crossterm::event::read()? {
-            if app.confirm_unload {
-                match key_event.code {
-                    KeyCode::Char('Y') | KeyCode::Char('y') => {
-                        if app.unload().await {
-                            return Ok(true);
-                        } else {
-                            log::error!("Failed to send unload command");
-                            app.confirm_unload = false;
-                        }
-                    }
-                    KeyCode::Char('N') | KeyCode::Char('n') | KeyCode::Esc => {
-                        app.confirm_unload = false;
-                    }
-                    _ => {}
-                }
-            } else if app.input_mode {
-                match key_event.code {
-                    KeyCode::Enter => {
-                        let action = Action::Drop;
-                        let input_copy = app.input.clone();
-                        let _ = app.add_rule(&input_copy, action).await;
-                        app.input.clear();
-                        app.input_mode = false;
-                    }
-                    KeyCode::Char(c) => {
-                        app.input.push(c);
-                    }
-                    KeyCode::Backspace => {
-                        app.input.pop();
-                    }
-                    KeyCode::Esc => {
-                        app.input.clear();
-                        app.input_mode = false;
-                    }
-                    _ => {}
-                }
-            } else {
-                match key_event.code {
-                    KeyCode::Char('Q') => return Ok(true),
-                    KeyCode::Char('A') => {
-                        app.input_mode = true;
-                    }
-                    KeyCode::Char('U') => {
-                        app.confirm_unload = true;
-                    }
-                    _ => {}
-                }
+            match key_event.code {
+                KeyCode::Char('Q') | KeyCode::Char('q') => return Ok(true),
+                _ => {}
             }
         }
     }

src/ui/widgets.rs

@@ -1,5 +1,5 @@
 use crate::ui::app::App;
-use ratatui::{prelude::*, text::ToText, widgets::*};
+use ratatui::{prelude::*, widgets::*};
 
 pub fn render_ui(f: &mut Frame, app: &mut App) {
     let chunks = Layout::default()
@@ -97,47 +97,12 @@ pub fn render_ui(f: &mut Frame, app: &mut App) {
         .block(Block::default().borders(Borders::ALL).title("Logs"));
     f.render_widget(logs, chunks[1]);
 
-    let help_text = "Shortcuts: [Q] Quit | Use 'firebee add' command to add rules";
+    let help_text = "[Q] Quit | Manage rules via CLI: firebee add/delete/get";
     let help = Paragraph::new(help_text)
         .style(Style::default().fg(Color::Gray))
         .alignment(ratatui::layout::Alignment::Center)
         .block(Block::default().borders(Borders::ALL));
     f.render_widget(help, chunks[2]);
-
-    if app.input_mode {
-        let popup = Paragraph::new(app.input.to_text()).block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title("Enter IP (e.g., 192.168.1.1)"),
-        );
-        let area = centered_rect(40, 20, f.area());
-        f.render_widget(Clear, area);
-        f.render_widget(popup, area);
-    }
-
-    if app.confirm_unload {
-        let warning_text = [
-            "WARNING: This will unload the XDP firewall program!",
-            "",
-            "Are you sure you want to continue?",
-            "",
-            "Press Y to confirm, N or ESC to cancel",
-        ];
-
-        let popup = Paragraph::new(warning_text.join("\n"))
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .title("Confirm Unload")
-                    .style(Style::default().fg(Color::Red)),
-            )
-            .alignment(ratatui::layout::Alignment::Center)
-            .wrap(Wrap { trim: true });
-
-        let area = centered_rect(60, 40, f.area());
-        f.render_widget(Clear, area);
-        f.render_widget(popup, area);
-    }
 }
 
 fn format_number(n: u64) -> String {
@@ -164,26 +129,6 @@ fn format_bytes(bytes: u64) -> String {
     }
 }
 
-fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
-    let popup_layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Percentage((100 - percent_y) / 2),
-            Constraint::Percentage(percent_y),
-            Constraint::Percentage((100 - percent_y) / 2),
-        ])
-        .split(r);
-
-    Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([
-            Constraint::Percentage((100 - percent_x) / 2),
-            Constraint::Percentage(percent_x),
-            Constraint::Percentage((100 - percent_x) / 2),
-        ])
-        .split(popup_layout[1])[1]
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;