jason/socktop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial check for process summary screen

Browse Source 
This check in offers alpha support for per process metrics, you can view threads, process CPU usage over time, IO, memory, CPU time, parent process, command, uptime and journal entries. This is unfinished but all major functionality is available and I wanted to make it available to feedback and testing.
This commit is contained in:
jasonwitty
2025-10-02 16:54:27 -07:00
parent a238ce320b
commit e66008f341
21 changed files with 3625 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files
socktop/src/app.rs
+288 -21
View File
@@ -17,7 +17,7 @@ use ratatui::{
backend::CrosstermBackend,
layout::{Constraint, Direction, Rect},
};
use tokio::time::sleep;
use tokio::time::{sleep, timeout};
use crate::history::{PerCoreHistory, push_capped};
use crate::retry::{RetryTiming, compute_retry_timing};
@@ -28,7 +28,9 @@ use crate::ui::cpu::{
per_core_handle_scrollbar_mouse,
};
use crate::ui::modal::{ModalAction, ModalManager, ModalType};
use crate::ui::processes::{ProcSortBy, processes_handle_key, processes_handle_mouse};
use crate::ui::processes::{
ProcSortBy, processes_handle_key_with_selection, processes_handle_mouse_with_selection,
};
use crate::ui::{
disks::draw_disks, gpu::draw_gpu, header::draw_header, mem::draw_mem, net::draw_net_spark,
swap::draw_swap,
@@ -76,12 +78,32 @@ pub struct App {
pub procs_sort_by: ProcSortBy,
last_procs_area: Option<ratatui::layout::Rect>,
// Process selection state
pub selected_process_pid: Option<u32>,
pub selected_process_index: Option<usize>, // Index in the visible/sorted list
prev_selected_process_pid: Option<u32>, // Track previous selection to detect changes
last_procs_poll: Instant,
last_disks_poll: Instant,
procs_interval: Duration,
disks_interval: Duration,
metrics_interval: Duration,
// Process details polling
pub process_details: Option<socktop_connector::ProcessMetricsResponse>,
pub journal_entries: Option<socktop_connector::JournalResponse>,
pub process_cpu_history: VecDeque<f32>, // CPU history for sparkline (last 60 samples)
pub process_mem_history: VecDeque<u64>, // Memory usage history in bytes (last 60 samples)
pub process_io_read_history: VecDeque<u64>, // Disk read DELTA history in bytes (last 60 samples)
pub process_io_write_history: VecDeque<u64>, // Disk write DELTA history in bytes (last 60 samples)
last_io_read_bytes: Option<u64>, // Previous read bytes for delta calculation
last_io_write_bytes: Option<u64>, // Previous write bytes for delta calculation
pub process_details_unsupported: bool, // Track if agent doesn't support process details
last_process_details_poll: Instant,
last_journal_poll: Instant,
process_details_interval: Duration,
journal_interval: Duration,
// For reconnects
ws_url: String,
tls_ca: Option<String>,
@@ -120,6 +142,9 @@ impl App {
procs_drag: None,
procs_sort_by: ProcSortBy::CpuDesc,
last_procs_area: None,
selected_process_pid: None,
selected_process_index: None,
prev_selected_process_pid: None,
last_procs_poll: Instant::now()
.checked_sub(Duration::from_secs(2))
.unwrap_or_else(Instant::now), // trigger immediately on first loop
@@ -129,6 +154,23 @@ impl App {
procs_interval: Duration::from_secs(2),
disks_interval: Duration::from_secs(5),
metrics_interval: Duration::from_millis(500),
process_details: None,
journal_entries: None,
process_cpu_history: VecDeque::with_capacity(600),
process_mem_history: VecDeque::with_capacity(600),
process_io_read_history: VecDeque::with_capacity(600),
process_io_write_history: VecDeque::with_capacity(600),
last_io_read_bytes: None,
last_io_write_bytes: None,
process_details_unsupported: false,
last_process_details_poll: Instant::now()
.checked_sub(Duration::from_secs(10))
.unwrap_or_else(Instant::now),
last_journal_poll: Instant::now()
.checked_sub(Duration::from_secs(10))
.unwrap_or_else(Instant::now),
process_details_interval: Duration::from_millis(500),
journal_interval: Duration::from_secs(5),
ws_url: String::new(),
tls_ca: None,
verify_hostname: false,
@@ -565,14 +607,42 @@ impl App {
continue; // Skip normal key processing
}
ModalAction::Cancel | ModalAction::Dismiss => {
// If ProcessDetails modal was dismissed, clear the data to save resources
if let Some(crate::ui::modal::ModalType::ProcessDetails {
..
}) = self.modal_manager.current_modal()
{
self.clear_process_details();
}
// Modal was dismissed, continue to normal processing
}
ModalAction::Confirm => {
// Handle confirmation action here if needed in the future
}
ModalAction::SwitchToParentProcess(_current_pid) => {
// Get parent PID from current process details
if let Some(details) = &self.process_details {
if let Some(parent_pid) = details.process.parent_pid {
// Clear current process details
self.clear_process_details();
// Update selected process to parent
self.selected_process_pid = Some(parent_pid);
// Open modal for parent process
self.modal_manager.push_modal(
crate::ui::modal::ModalType::ProcessDetails {
pid: parent_pid,
},
);
}
}
continue;
}
ModalAction::Handled => {
// Modal consumed the key, don't pass to main window
continue;
}
ModalAction::None => {
// Modal is still active but didn't consume the key
continue; // Skip normal key processing
// Modal didn't handle the key, pass through to normal handling
}
}
}
@@ -603,7 +673,49 @@ impl App {
.split(rows[1]);
let content = per_core_content_area(top[1]);
per_core_handle_key(&mut self.per_core_scroll, k, content.height as usize);
// First try process selection (only handles arrows if a process is selected)
let process_handled = if let Some(p_area) = self.last_procs_area {
let page = p_area.height.saturating_sub(3).max(1) as usize; // borders (2) + header (1)
let total_rows = self
.last_metrics
.as_ref()
.map(|m| m.top_processes.len())
.unwrap_or(0);
processes_handle_key_with_selection(
&mut self.procs_scroll_offset,
&mut self.selected_process_pid,
&mut self.selected_process_index,
k,
page,
total_rows,
self.last_metrics.as_ref(),
)
} else {
false
};
// If process selection didn't handle it, use CPU scrolling
if !process_handled {
per_core_handle_key(
&mut self.per_core_scroll,
k,
content.height as usize,
);
}
// Check if process selection changed and clear details if so
if self.selected_process_pid != self.prev_selected_process_pid {
self.clear_process_details();
self.prev_selected_process_pid = self.selected_process_pid;
}
// Check if Enter was pressed with a process selected
if process_handled && k.code == KeyCode::Enter {
if let Some(selected_pid) = self.selected_process_pid {
self.modal_manager
.push_modal(ModalType::ProcessDetails { pid: selected_pid });
}
}
let total_rows = self
.last_metrics
@@ -615,14 +727,13 @@ impl App {
total_rows,
content.height as usize,
);
if let Some(p_area) = self.last_procs_area {
// page size = visible rows (inner height minus header = 1)
let page = p_area.height.saturating_sub(3).max(1) as usize; // borders (2) + header (1)
processes_handle_key(&mut self.procs_scroll_offset, k, page);
}
}
Event::Mouse(m) => {
// If modal is active, don't handle mouse events on the main window
if self.modal_manager.is_active() {
continue;
}
// Layout to get areas
let sz = terminal.size()?;
let area = Rect::new(0, 0, sz.width, sz.height);
@@ -671,18 +782,32 @@ impl App {
content.height as usize,
);
// Processes table: sort by column on header click
// Processes table: sort by column on header click and handle row selection
if let (Some(mm), Some(p_area)) =
(self.last_metrics.as_ref(), self.last_procs_area)
&& let Some(new_sort) = processes_handle_mouse(
&mut self.procs_scroll_offset,
&mut self.procs_drag,
m,
p_area,
mm.top_processes.len(),
)
{
self.procs_sort_by = new_sort;
use crate::ui::processes::ProcessMouseParams;
if let Some(new_sort) =
processes_handle_mouse_with_selection(ProcessMouseParams {
scroll_offset: &mut self.procs_scroll_offset,
selected_process_pid: &mut self.selected_process_pid,
selected_process_index: &mut self.selected_process_index,
drag: &mut self.procs_drag,
mouse: m,
area: p_area,
total_rows: mm.top_processes.len(),
metrics: self.last_metrics.as_ref(),
sort_by: self.procs_sort_by,
})
{
self.procs_sort_by = new_sort;
}
}
// Check if process selection changed via mouse and clear details if so
if self.selected_process_pid != self.prev_selected_process_pid {
self.clear_process_details();
self.prev_selected_process_pid = self.selected_process_pid;
}
}
Event::Resize(_, _) => {}
@@ -732,6 +857,99 @@ impl App {
}
self.last_disks_poll = Instant::now();
}
// Poll process details when modal is active and process is selected
if let Some(pid) = self.selected_process_pid {
// Check if ProcessDetails modal is currently active
if let Some(crate::ui::modal::ModalType::ProcessDetails { .. }) =
self.modal_manager.current_modal()
{
// Poll process details every 500ms when modal is active
if self.last_process_details_poll.elapsed()
>= self.process_details_interval
{
// Use timeout to prevent blocking the event loop
match timeout(
Duration::from_millis(2000),
ws.request(AgentRequest::ProcessMetrics { pid }),
)
.await
{
Ok(Ok(AgentResponse::ProcessMetrics(details))) => {
// Update history for sparklines
let cpu_usage = details.process.cpu_usage;
push_capped(&mut self.process_cpu_history, cpu_usage, 600);
let mem_bytes = details.process.mem_bytes;
push_capped(&mut self.process_mem_history, mem_bytes, 600);
// I/O bytes from agent are cumulative, calculate deltas
if let Some(read) = details.process.read_bytes {
let delta = if let Some(last) = self.last_io_read_bytes
{
read.saturating_sub(last)
} else {
0 // First sample, no delta available
};
push_capped(
&mut self.process_io_read_history,
delta,
600,
);
self.last_io_read_bytes = Some(read);
}
if let Some(write) = details.process.write_bytes {
let delta = if let Some(last) = self.last_io_write_bytes
{
write.saturating_sub(last)
} else {
0 // First sample, no delta available
};
push_capped(
&mut self.process_io_write_history,
delta,
600,
);
self.last_io_write_bytes = Some(write);
}
self.process_details = Some(details);
self.process_details_unsupported = false;
}
Ok(Err(_)) | Err(_) => {
// Agent doesn't support this feature or timeout occurred
// Mark as unsupported so we can show appropriate message
self.process_details_unsupported = true;
}
Ok(Ok(_)) => {
// Wrong response type
self.process_details_unsupported = true;
}
}
self.last_process_details_poll = Instant::now();
}
// Poll journal entries every 5s when modal is active
if self.last_journal_poll.elapsed() >= self.journal_interval {
// Use timeout to prevent blocking the event loop
match timeout(
Duration::from_millis(2000),
ws.request(AgentRequest::JournalEntries { pid }),
)
.await
{
Ok(Ok(AgentResponse::JournalEntries(journal))) => {
self.journal_entries = Some(journal);
}
Ok(Err(_)) | Err(_) | Ok(Ok(_)) => {
// Agent doesn't support this feature, error occurred, or wrong response type
// Keep journal_entries as None
}
}
self.last_journal_poll = Instant::now();
}
}
}
}
Err(e) => {
// Connection error - show modal if not already shown
@@ -760,6 +978,19 @@ impl App {
Ok(())
}
/// Clear process details when modal is closed or selection changes
pub fn clear_process_details(&mut self) {
self.process_details = None;
self.journal_entries = None;
self.process_cpu_history.clear();
self.process_mem_history.clear();
self.process_io_read_history.clear();
self.process_io_write_history.clear();
self.last_io_read_bytes = None;
self.last_io_write_bytes = None;
self.process_details_unsupported = false;
}
fn update_with_metrics(&mut self, mut m: Metrics) {
if let Some(prev) = &self.last_metrics {
// Preserve slower fields when the fast payload omits them
@@ -919,11 +1150,27 @@ impl App {
self.last_metrics.as_ref(),
self.procs_scroll_offset,
self.procs_sort_by,
self.selected_process_pid,
self.selected_process_index,
);
// Render modals on top of everything else
if self.modal_manager.is_active() {
self.modal_manager.render(f);
use crate::ui::modal::{ProcessHistoryData, ProcessModalData};
self.modal_manager.render(
f,
ProcessModalData {
details: self.process_details.as_ref(),
journal: self.journal_entries.as_ref(),
history: ProcessHistoryData {
cpu: &self.process_cpu_history,
mem: &self.process_mem_history,
io_read: &self.process_io_read_history,
io_write: &self.process_io_write_history,
},
unsupported: self.process_details_unsupported,
},
);
}
}
}
@@ -946,6 +1193,9 @@ impl Default for App {
procs_drag: None,
procs_sort_by: ProcSortBy::CpuDesc,
last_procs_area: None,
selected_process_pid: None,
selected_process_index: None,
prev_selected_process_pid: None,
last_procs_poll: Instant::now()
.checked_sub(Duration::from_secs(2))
.unwrap_or_else(Instant::now), // trigger immediately on first loop
@@ -955,6 +1205,23 @@ impl Default for App {
procs_interval: Duration::from_secs(2),
disks_interval: Duration::from_secs(5),
metrics_interval: Duration::from_millis(500),
process_details: None,
journal_entries: None,
process_cpu_history: VecDeque::with_capacity(600),
process_mem_history: VecDeque::with_capacity(600),
process_io_read_history: VecDeque::with_capacity(600),
process_io_write_history: VecDeque::with_capacity(600),
last_io_read_bytes: None,
last_io_write_bytes: None,
process_details_unsupported: false,
last_process_details_poll: Instant::now()
.checked_sub(Duration::from_secs(10))
.unwrap_or_else(Instant::now),
last_journal_poll: Instant::now()
.checked_sub(Duration::from_secs(10))
.unwrap_or_else(Instant::now),
process_details_interval: Duration::from_millis(500),
journal_interval: Duration::from_secs(5),
ws_url: String::new(),
tls_ca: None,
verify_hostname: false,
socktop/src/ui/modal.rs
+1264 -8
View File
File diff suppressed because it is too large Load Diff
socktop/src/ui/processes.rs
+227 -2
View File
@@ -12,7 +12,10 @@ use std::cmp::Ordering;
use crate::types::Metrics;
use crate::ui::cpu::{per_core_clamp, per_core_handle_scrollbar_mouse};
use crate::ui::theme::{SB_ARROW, SB_THUMB, SB_TRACK};
use crate::ui::theme::{
PROCESS_SELECTION_BG, PROCESS_SELECTION_FG, PROCESS_TOOLTIP_BG, PROCESS_TOOLTIP_FG, SB_ARROW,
SB_THUMB, SB_TRACK,
};
use crate::ui::util::human;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -37,6 +40,8 @@ pub fn draw_top_processes(
m: Option<&Metrics>,
scroll_offset: usize,
sort_by: ProcSortBy,
selected_process_pid: Option<u32>,
selected_process_index: Option<usize>,
) {
// Draw outer block and title
let Some(mm) = m else { return };
@@ -110,12 +115,29 @@ pub fn draw_top_processes(
_ => Color::Red,
};
let emphasis = if (cpu_val - peak_cpu).abs() < f32::EPSILON {
let mut emphasis = if (cpu_val - peak_cpu).abs() < f32::EPSILON {
Style::default().add_modifier(Modifier::BOLD)
} else {
Style::default()
};
// Check if this process is selected - prioritize PID matching
let is_selected = if let Some(selected_pid) = selected_process_pid {
selected_pid == p.pid
} else if let Some(selected_idx) = selected_process_index {
selected_idx == ix // ix is the absolute index in the sorted list
} else {
false
};
// Apply selection highlighting
if is_selected {
emphasis = emphasis
.bg(PROCESS_SELECTION_BG)
.fg(PROCESS_SELECTION_FG)
.add_modifier(Modifier::BOLD);
}
let cpu_str = fmt_cpu_pct(cpu_val);
ratatui::widgets::Row::new(vec![
@@ -151,6 +173,47 @@ pub fn draw_top_processes(
.column_spacing(1);
f.render_widget(table, content);
// Draw tooltip if a process is selected
if let Some(selected_pid) = selected_process_pid {
// Find the selected process to get its name
let process_info = if let Some(metrics) = m {
metrics
.top_processes
.iter()
.find(|p| p.pid == selected_pid)
.map(|p| format!("PID {} • {}", p.pid, p.name))
.unwrap_or_else(|| format!("PID {selected_pid}"))
} else {
format!("PID {selected_pid}")
};
let tooltip_text = format!("{process_info} | Enter for details • X to unselect");
let tooltip_width = tooltip_text.len() as u16 + 2; // Add padding
let tooltip_height = 3;
// Position tooltip at bottom-right of the processes area
if area.width > tooltip_width + 2 && area.height > tooltip_height + 1 {
let tooltip_area = Rect {
x: area.x + area.width.saturating_sub(tooltip_width + 1),
y: area.y + area.height.saturating_sub(tooltip_height + 1),
width: tooltip_width,
height: tooltip_height,
};
let tooltip_block = Block::default().borders(Borders::ALL).style(
Style::default()
.bg(PROCESS_TOOLTIP_BG)
.fg(PROCESS_TOOLTIP_FG),
);
let tooltip_paragraph = Paragraph::new(tooltip_text)
.block(tooltip_block)
.wrap(ratatui::widgets::Wrap { trim: true });
f.render_widget(tooltip_paragraph, tooltip_area);
}
}
// Draw scrollbar like CPU pane
let scroll_area = Rect {
x: inner.x + inner.width.saturating_sub(1),
@@ -191,6 +254,8 @@ fn fmt_cpu_pct(v: f32) -> String {
}
/// Handle keyboard scrolling (Up/Down/PageUp/PageDown/Home/End)
/// LEGACY: Use processes_handle_key_with_selection for enhanced functionality
#[allow(dead_code)]
pub fn processes_handle_key(
scroll_offset: &mut usize,
key: crossterm::event::KeyEvent,
@@ -199,8 +264,44 @@ pub fn processes_handle_key(
crate::ui::cpu::per_core_handle_key(scroll_offset, key, page_size);
}
/// Enhanced keyboard handler that also manages process selection
pub fn processes_handle_key_with_selection(
_scroll_offset: &mut usize,
selected_process_pid: &mut Option<u32>,
selected_process_index: &mut Option<usize>,
key: crossterm::event::KeyEvent,
_page_size: usize,
_total_rows: usize,
_metrics: Option<&Metrics>,
) -> bool {
use crossterm::event::KeyCode;
match key.code {
KeyCode::Char('x') | KeyCode::Char('X') => {
// Unselect any selected process
if selected_process_pid.is_some() || selected_process_index.is_some() {
*selected_process_pid = None;
*selected_process_index = None;
true // Handled
} else {
false // No selection to clear
}
}
KeyCode::Enter => {
// Signal that Enter was pressed with a selection
selected_process_pid.is_some() // Return true if we have a selection to handle
}
_ => {
// No other keys handled - let scrollbar handle all navigation
false
}
}
}
/// Handle mouse for content scrolling and scrollbar dragging.
/// Returns Some(new_sort) if the header "CPU %" or "Mem" was clicked.
/// LEGACY: Use processes_handle_mouse_with_selection for enhanced functionality
#[allow(dead_code)]
pub fn processes_handle_mouse(
scroll_offset: &mut usize,
drag: &mut Option<crate::ui::cpu::PerCoreScrollDrag>,
@@ -264,3 +365,127 @@ pub fn processes_handle_mouse(
);
None
}
/// Parameters for process mouse event handling
pub struct ProcessMouseParams<'a> {
pub scroll_offset: &'a mut usize,
pub selected_process_pid: &'a mut Option<u32>,
pub selected_process_index: &'a mut Option<usize>,
pub drag: &'a mut Option<crate::ui::cpu::PerCoreScrollDrag>,
pub mouse: MouseEvent,
pub area: Rect,
pub total_rows: usize,
pub metrics: Option<&'a Metrics>,
pub sort_by: ProcSortBy,
}
/// Enhanced mouse handler that also manages process selection
/// Returns Some(new_sort) if the header was clicked, or handles row selection
pub fn processes_handle_mouse_with_selection(params: ProcessMouseParams) -> Option<ProcSortBy> {
// Inner and content areas (match draw_top_processes)
let inner = Rect {
x: params.area.x + 1,
y: params.area.y + 1,
width: params.area.width.saturating_sub(2),
height: params.area.height.saturating_sub(2),
};
if inner.height == 0 || inner.width <= 2 {
return None;
}
let content = Rect {
x: inner.x,
y: inner.y,
width: inner.width.saturating_sub(2),
height: inner.height,
};
// Scrollbar interactions (click arrows/page/drag)
per_core_handle_scrollbar_mouse(
params.scroll_offset,
params.drag,
params.mouse,
params.area,
params.total_rows,
);
// Wheel scrolling when inside the content
crate::ui::cpu::per_core_handle_mouse(
params.scroll_offset,
params.mouse,
content,
content.height as usize,
);
// Header click to change sort
let header_area = Rect {
x: content.x,
y: content.y,
width: content.width,
height: 1,
};
let inside_header = params.mouse.row == header_area.y
&& params.mouse.column >= header_area.x
&& params.mouse.column < header_area.x + header_area.width;
if inside_header && matches!(params.mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
// Split header into the same columns
let cols = Layout::default()
.direction(Direction::Horizontal)
.constraints(COLS.to_vec())
.split(header_area);
if params.mouse.column >= cols[2].x && params.mouse.column < cols[2].x + cols[2].width {
return Some(ProcSortBy::CpuDesc);
}
if params.mouse.column >= cols[3].x && params.mouse.column < cols[3].x + cols[3].width {
return Some(ProcSortBy::MemDesc);
}
}
// Row click for process selection
let data_start_row = content.y + 1; // Skip header
let data_area_height = content.height.saturating_sub(1); // Exclude header
if matches!(params.mouse.kind, MouseEventKind::Down(MouseButton::Left))
&& params.mouse.row >= data_start_row
&& params.mouse.row < data_start_row + data_area_height
&& params.mouse.column >= content.x
&& params.mouse.column < content.x + content.width
{
let clicked_row = (params.mouse.row - data_start_row) as usize;
// Find the actual process using the same sorting logic as the drawing code
if let Some(m) = params.metrics {
// Create the same sorted index array as in draw_top_processes
let mut idxs: Vec<usize> = (0..m.top_processes.len()).collect();
match params.sort_by {
ProcSortBy::CpuDesc => idxs.sort_by(|&a, &b| {
let aa = m.top_processes[a].cpu_usage;
let bb = m.top_processes[b].cpu_usage;
bb.partial_cmp(&aa).unwrap_or(std::cmp::Ordering::Equal)
}),
ProcSortBy::MemDesc => idxs.sort_by(|&a, &b| {
let aa = m.top_processes[a].mem_bytes;
let bb = m.top_processes[b].mem_bytes;
bb.cmp(&aa)
}),
}
// Calculate which process was actually clicked based on sorted order
let visible_process_position = *params.scroll_offset + clicked_row;
if visible_process_position < idxs.len() {
let actual_process_index = idxs[visible_process_position];
let clicked_process = &m.top_processes[actual_process_index];
*params.selected_process_pid = Some(clicked_process.pid);
*params.selected_process_index = Some(actual_process_index);
}
}
}
// Clamp to valid range
per_core_clamp(
params.scroll_offset,
params.total_rows,
(content.height.saturating_sub(1)) as usize,
);
None
}
socktop/src/ui/theme.rs
+9
View File
@@ -30,6 +30,15 @@ pub const BTN_EXIT_BG_ACTIVE: Color = Color::Rgb(255, 255, 255); // modern red
pub const BTN_EXIT_FG_ACTIVE: Color = Color::Rgb(26, 26, 46);
pub const BTN_EXIT_FG_INACTIVE: Color = Color::Rgb(255, 255, 255);
// Process selection colors
pub const PROCESS_SELECTION_BG: Color = Color::Rgb(147, 112, 219); // Medium slate blue (purple)
pub const PROCESS_SELECTION_FG: Color = Color::Rgb(255, 255, 255); // White text for contrast
pub const PROCESS_TOOLTIP_BG: Color = Color::Rgb(147, 112, 219); // Same purple as selection
pub const PROCESS_TOOLTIP_FG: Color = Color::Rgb(255, 255, 255); // White text for contrast
// Process details modal colors (matches main UI aesthetic - no custom colors, terminal defaults)
pub const PROCESS_DETAILS_ACCENT: Color = Color::Rgb(147, 112, 219); // Purple accent for highlights
// Emoji / icon strings (centralized so they can be themed/swapped later)
pub const ICON_WARNING_TITLE: &str = " 🔌 CONNECTION ERROR ";
pub const ICON_CLUSTER: &str = "⚠️";