feat(storage): persist app state across sessions

- What: Added new storage module (src/storage.rs) for saving/loading app state
- What: State is saved to ~/.config/httpulse/state.json (cross-platform via dirs crate)
- What: Added serde_json and dirs dependencies to Cargo.toml
- What: Added Serialize/Deserialize derives to MetricKind, ProfileViewMode, TargetPaneMode, MetricsCategory
- What: Added to_persisted_state() and restore_from_persisted() methods to AppState
- What: Integrated state loading on startup in main.rs (CLI targets override persisted state)
- What: Integrated state saving on quit and after state-changing actions (add/remove target, settings changes)
- Why: Users reported that added URLs were lost after restarting the application

Tests: cargo fmt, cargo clippy, cargo test all pass.

Author: DennySORA

Cargo.lock

@@ -16,6 +16,8 @@ hdrhistogram = "7"
 libc = "0.2"
 ratatui = "0.30"
 serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+dirs = "6"
 thiserror = "2"
 url = { version = "2", features = ["serde"] }
 uuid = { version = "1.19.0", features = ["v4", "serde"] }

Cargo.toml

@@ -4,17 +4,20 @@ use crate::metrics_aggregate::{MetricsStore, ProfileKey};
 use crate::probe::{ProbeErrorKind, ProbeSample};
 use crate::probe_engine::detect_tls13_support;
 use crate::runtime::{ControlMessage, WorkerHandle, spawn_profile_worker};
+use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashSet};
 use std::net::IpAddr;
 use url::Url;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum ProfileViewMode {
     Single,
     Compare,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum TargetPaneMode {
     Split,
     Chart,
@@ -23,7 +26,8 @@ pub enum TargetPaneMode {
 }
 
 /// Metrics category for tab-based navigation
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Default)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum MetricsCategory {
     #[default]
     Latency,
@@ -339,4 +343,71 @@ impl AppState {
             .sum();
         summary
     }
+
+    pub fn to_persisted_state(&self) -> crate::storage::PersistedState {
+        crate::storage::PersistedState {
+            version: "1".to_string(),
+            global_config: self.global.clone(),
+            targets: self
+                .targets
+                .iter()
+                .map(|t| crate::storage::PersistedTarget {
+                    config: t.config.clone(),
+                    view_mode: t.view_mode,
+                    selected_profile: t.selected_profile,
+                    pane_mode: t.pane_mode,
+                    metrics_category: t.metrics_category,
+                })
+                .collect(),
+            ui_state: crate::storage::PersistedUiState {
+                selected_target: self.selected_target,
+                selected_metric: self.selected_metric,
+                selected_metrics: self.selected_metrics.clone(),
+                window: self.window,
+            },
+        }
+    }
+
+    pub fn restore_from_persisted(
+        &mut self,
+        state: &crate::storage::PersistedState,
+        sample_tx: crossbeam_channel::Sender<crate::probe::ProbeSample>,
+    ) {
+        for persisted_target in &state.targets {
+            let profiles = persisted_target.config.profiles.clone();
+            let mut profile_runtimes = Vec::new();
+            for profile in &profiles {
+                let worker = spawn_profile_worker(
+                    persisted_target.config.clone(),
+                    profile.clone(),
+                    sample_tx.clone(),
+                );
+                profile_runtimes.push(ProfileRuntime {
+                    config: profile.clone(),
+                    worker,
+                    last_sample: None,
+                    last_error: None,
+                });
+            }
+
+            self.targets.push(TargetRuntime {
+                config: persisted_target.config.clone(),
+                paused: false,
+                last_ip: None,
+                profiles: profile_runtimes,
+                view_mode: persisted_target.view_mode,
+                selected_profile: persisted_target.selected_profile,
+                pane_mode: persisted_target.pane_mode,
+                metrics_category: persisted_target.metrics_category,
+            });
+        }
+
+        self.selected_target = state
+            .ui_state
+            .selected_target
+            .min(self.targets.len().saturating_sub(1));
+        self.selected_metric = state.ui_state.selected_metric;
+        self.selected_metrics = state.ui_state.selected_metrics.clone();
+        self.window = state.ui_state.window;
+    }
 }

src/features/app/state.rs

@@ -2,10 +2,12 @@ pub mod aggregate;
 
 use crate::config::{ProfileId, TargetId, WindowSpec};
 use crate::probe::ProbeErrorKind;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::net::IpAddr;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum MetricKind {
     Dns,
     Connect,

src/features/metrics/mod.rs

@@ -1,5 +1,6 @@
 use crate::app::{AppState, parse_profile_specs, parse_target_url};
 use crate::probe::ProbeSample;
+use crate::storage;
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 use url::Url;
 
@@ -22,6 +23,7 @@ pub(in crate::features::ui) fn handle_input_key(
                 InputMode::AddTarget => {
                     if let Some((url, profiles)) = parse_add_command(input_buffer) {
                         app.add_target(url, profiles, sample_tx.clone());
+                        let _ = storage::save(&app.to_persisted_state());
                     }
                 }
                 InputMode::Normal

src/features/ui/input/add.rs

@@ -1,4 +1,5 @@
 use crate::app::AppState;
+use crate::storage;
 use crossterm::event::{KeyCode, KeyEvent};
 
 use super::super::state::InputMode;
@@ -11,6 +12,7 @@ pub(in crate::features::ui) fn handle_confirm_delete_key(
     match key.code {
         KeyCode::Char('y') | KeyCode::Char('Y') => {
             app.remove_target(app.selected_target);
+            let _ = storage::save(&app.to_persisted_state());
             *input_mode = InputMode::Normal;
         }
         KeyCode::Esc | KeyCode::Char('n') | KeyCode::Char('N') => {

src/features/ui/input/confirm.rs

@@ -1,4 +1,5 @@
 use crate::app::{AppState, apply_edit_command};
+use crate::storage;
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 
 use super::super::render::{seed_settings_input, settings_rows};
@@ -36,6 +37,7 @@ pub(in crate::features::ui) fn handle_settings_key(
                             let mut updated = target.config.clone();
                             updated.dns_enabled = !updated.dns_enabled;
                             app.update_target_config(app.selected_target, updated);
+                            let _ = storage::save(&app.to_persisted_state());
                         }
                     }
                     SettingsField::TargetPane => {
@@ -127,6 +129,7 @@ pub(in crate::features::ui) fn handle_settings_edit_key(
             }
 
             if applied {
+                let _ = storage::save(&app.to_persisted_state());
                 *input_mode = InputMode::Settings;
                 input_buffer.clear();
             }

src/features/ui/input/settings.rs

@@ -4,6 +4,7 @@ mod state;
 
 use crate::app::AppState;
 use crate::probe::ProbeSample;
+use crate::storage;
 use crossterm::event::{self, Event};
 use crossterm::terminal::{
     EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
@@ -184,6 +185,7 @@ pub fn run_ui(
         }
     }
 
+    let _ = storage::save(&app.to_persisted_state());
     cleanup_terminal(&mut terminal)?;
     Ok(())
 }

src/features/ui/mod.rs

@@ -10,4 +10,5 @@ pub mod probe;
 pub mod probe_engine;
 pub mod runtime;
 pub mod settings;
+pub mod storage;
 pub mod ui;

src/lib.rs

@@ -1,20 +1,37 @@
 use httpulse::app::{AppState, parse_target_url};
-use httpulse::config::GlobalConfig;
 use httpulse::settings::{apply_global, load_from_cli};
+use httpulse::storage;
 use httpulse::ui::run_ui;
 
 fn main() -> std::io::Result<()> {
     let settings = load_from_cli()
         .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err.to_string()))?;
-    let mut global = GlobalConfig::default();
+
+    let persisted = storage::load();
+
+    let mut global = persisted.global_config.clone();
     apply_global(&settings, &mut global);
 
     let (sample_tx, sample_rx) = crossbeam_channel::unbounded();
     let mut app = AppState::new(global);
 
-    for target in settings.targets {
-        if let Some(url) = parse_target_url(&target) {
-            app.add_target(url, None, sample_tx.clone());
+    let is_default_target =
+        settings.targets.len() == 1 && settings.targets[0] == "https://google.com";
+    let has_cli_targets = !settings.targets.is_empty() && !is_default_target;
+
+    if has_cli_targets {
+        for target in settings.targets {
+            if let Some(url) = parse_target_url(&target) {
+                app.add_target(url, None, sample_tx.clone());
+            }
+        }
+    } else if !persisted.targets.is_empty() {
+        app.restore_from_persisted(&persisted, sample_tx.clone());
+    } else {
+        for target in settings.targets {
+            if let Some(url) = parse_target_url(&target) {
+                app.add_target(url, None, sample_tx.clone());
+            }
         }
     }