Some idle CPU and disk/io fixes, new CommandChanged plugin Event (#5063)

* initial implementation

* fix mouse cpu spam

* prevent excess metadata write and prune sessions on startup

* consolidate CommandChanged and PaneCommandChanged

* tests

* rustfmt

* add pr

2 files changed, 68 insertions, 5 deletions

diff --git a/default-plugins/session-manager/src/main.rs b/default-plugins/session-manager/src/main.rs
index afade742..b6031011 100644
--- a/default-plugins/session-manager/src/main.rs
+++ b/default-plugins/session-manager/src/main.rs
@@ -54,6 +54,8 @@ struct State {
     request_ids: Vec<String>,
     is_web_client: bool,
     current_session_last_saved_time: Option<u64>,
+    is_visible: bool,
+    refresh_timer_armed: bool,
 }
 
 register_plugin!(State);
@@ -76,17 +78,20 @@ impl ZellijPlugin for State {
             self.active_screen = ActiveScreen::SingleScreen;
         }
         self.single_screen_state.is_welcome_screen = self.is_welcome_screen;
-        if !self.is_welcome_screen {
-            set_timeout(0.1); // for the current_session_last_saved_time polling
-        }
+        self.is_visible = true;
         subscribe(&[
             EventType::ModeUpdate,
             EventType::SessionUpdate,
             EventType::Key,
             EventType::RunCommandResult,
             EventType::Timer,
+            EventType::Visible,
         ]);
         rename_plugin_pane(get_plugin_ids().plugin_id, "Session Manager");
+        self.refresh_session_list();
+        if !self.is_welcome_screen {
+            self.arm_refresh_timer();
+        }
     }
 
     fn pipe(&mut self, pipe_message: PipeMessage) -> bool {
@@ -119,12 +124,29 @@ impl ZellijPlugin for State {
         let mut should_render = false;
         match event {
             Event::Timer(_) => {
+                self.refresh_timer_armed = false;
+                if !self.is_visible {
+                    return false;
+                }
                 let new_saved_time = current_session_last_saved_time();
                 if new_saved_time != self.current_session_last_saved_time {
                     self.current_session_last_saved_time = new_saved_time;
                     should_render = true;
                 }
-                set_timeout(1.0);
+                if self.refresh_session_list() {
+                    should_render = true;
+                }
+                self.arm_refresh_timer();
+            },
+            Event::Visible(is_visible) => {
+                let was_visible = self.is_visible;
+                self.is_visible = is_visible;
+                if is_visible && !was_visible {
+                    if self.refresh_session_list() {
+                        should_render = true;
+                    }
+                    self.arm_refresh_timer();
+                }
             },
             Event::ModeUpdate(mode_info) => {
                 self.colors = Colors::new(mode_info.style.colors);
@@ -1171,6 +1193,47 @@ impl State {
         }
         self.session_name = Some(new_name.to_owned());
     }
+    fn arm_refresh_timer(&mut self) {
+        if !self.refresh_timer_armed {
+            set_timeout(1.0);
+            self.refresh_timer_armed = true;
+        }
+    }
+
+    fn refresh_session_list(&mut self) -> bool {
+        let snapshot = match get_session_list() {
+            Ok(snapshot) => snapshot,
+            Err(_) => return false,
+        };
+        for session_info in &snapshot.live_sessions {
+            if session_info.is_current_session {
+                self.new_session_info
+                    .update_layout_list(session_info.available_layouts.clone());
+            }
+        }
+        self.resurrectable_sessions
+            .update(snapshot.resurrectable_sessions);
+        self.update_session_infos(snapshot.live_sessions);
+        if !self.is_multi_screen {
+            self.single_screen_state.update_search_term(
+                &self.sessions.session_ui_infos,
+                &self.resurrectable_sessions.all_resurrectable_sessions,
+            );
+            let previous_selection = self.single_screen_state.layout_list.selected_layout_index;
+            let previous_search_term = self
+                .single_screen_state
+                .layout_list
+                .layout_search_term
+                .clone();
+            self.single_screen_state.layout_list = self.new_session_info.get_layout_list_clone();
+            self.single_screen_state.layout_list.layout_search_term = previous_search_term;
+            self.single_screen_state.layout_list.update_search_term();
+            self.single_screen_state.layout_list.selected_layout_index =
+                previous_selection.min(self.single_screen_state.layout_list.max_index());
+        }
+        true
+    }
+
     fn update_session_infos(&mut self, session_infos: Vec<SessionInfo>) {
         let session_ui_infos: Vec<SessionUiInfo> = session_infos
             .iter()
diff --git a/default-plugins/session-manager/src/resurrectable_sessions.rs b/default-plugins/session-manager/src/resurrectable_sessions.rs
index 3b03d507..a25d8b36 100644
--- a/default-plugins/session-manager/src/resurrectable_sessions.rs
+++ b/default-plugins/session-manager/src/resurrectable_sessions.rs
@@ -19,7 +19,7 @@ pub struct ResurrectableSessions {
 
 impl ResurrectableSessions {
     pub fn update(&mut self, mut list: Vec<(String, Duration)>) {
-        list.sort_by(|a, b| a.1.cmp(&b.1));
+        list.sort_by(|a, b| a.1.cmp(&b.1).then_with(|| a.0.cmp(&b.0)));
         self.all_resurrectable_sessions = list;
         if self.is_searching {
             self.update_search_term();