Major refactor, additional comments, performance improvements, idle performance improvements, access token, port specification

Release highlights

Introduced split client/agent architecture with a ratatui-based TUI and a lightweight WebSocket agent.
Added adaptive (idle-aware) sampler: agent samples fast only when clients are connected; sleeps when idle.
Implemented metrics JSON caching for instant ws replies; cold-start does one-off collection.
Port configuration: --port/-p, positional PORT, or SOCKTOP_PORT env (default 3000).
Optional token auth: SOCKTOP_TOKEN on agent, ws://HOST:PORT/ws?token=VALUE in client.
Logging via tracing with RUST_LOG control.
CI workflow (fmt, clippy, build) for Linux and Windows.
Systemd unit example for always-on agent.
TUI features

CPU: overall sparkline + per-core history with trend arrows and color thresholds.
Memory/Swap gauges with humanized labels.
Disks panel with per-device usage and icons.
Network download/upload sparklines (KB/s) with peak tracking.
Top processes table (PID, name, CPU%, mem, mem%).
Header with hostname and CPU temperature indicator.
Agent changes

sysinfo 0.36.1 targeted refresh: refresh_cpu_all, refresh_memory, refresh_processes_specifics(ProcessesToUpdate::All, ProcessRefreshKind::new().with_cpu().with_memory(), true).
WebSocket handler: client counting with wake notifications, cold-start handling, proper Response returns.
Sampler uses MissedTickBehavior::Skip to avoid catch-up bursts.
Docs

README updates: running instructions, port configuration, optional token auth, platform notes, example JSON.
Added socktop-agent.service systemd unit.
Platform notes

Linux (AMD/Intel) supported; tested on AMD, targeting Intel next.
Raspberry Pi supported (availability of temps varies by model).
Windows builds/run; CPU temperature may be unavailable (shows N/A).
Known/next

Roadmap includes configurable refresh interval, TUI filtering/sorting, TLS/WSS, and export to file.
Add Context...
README.md

socktop_agent/src/ws.rs

@@ -0,0 +1,66 @@
+//! WebSocket upgrade and per-connection handler. Serves cached JSON quickly.
+
+use axum::{
+    extract::{
+        ws::{Message, WebSocket, WebSocketUpgrade},
+        Query, State,
+    },
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
+use futures_util::stream::StreamExt;
+
+use crate::metrics::collect_metrics;
+use crate::state::AppState;
+
+use std::collections::HashMap;
+use std::sync::atomic::Ordering;
+
+pub async fn ws_handler(
+    ws: WebSocketUpgrade,
+    State(state): State<AppState>,
+    Query(q): Query<HashMap<String, String>>,
+) -> Response {
+    if let Some(expected) = state.auth_token.as_ref() {
+        match q.get("token") {
+            Some(t) if t == expected => {}
+            _ => return StatusCode::UNAUTHORIZED.into_response(),
+        }
+    }
+    ws.on_upgrade(move |socket| handle_socket(socket, state))
+}
+
+async fn handle_socket(mut socket: WebSocket, state: AppState) {
+    // Bump client count on connect and wake the sampler.
+    state.client_count.fetch_add(1, Ordering::Relaxed);
+    state.wake_sampler.notify_waiters();
+
+    // Ensure we decrement on disconnect (drop).
+    struct ClientGuard(AppState);
+    impl Drop for ClientGuard {
+        fn drop(&mut self) {
+            self.0.client_count.fetch_sub(1, Ordering::Relaxed);
+            self.0.wake_sampler.notify_waiters();
+        }
+    }
+    let _guard = ClientGuard(state.clone());
+
+    while let Some(Ok(msg)) = socket.next().await {
+        match msg {
+            Message::Text(text) if text == "get_metrics" => {
+                // Serve the cached JSON quickly; if empty (cold start), collect once.
+                let cached = state.last_json.read().await.clone();
+                if !cached.is_empty() {
+                    let _ = socket.send(Message::Text(cached)).await;
+                } else {
+                    let metrics = collect_metrics(&state).await;
+                    if let Ok(js) = serde_json::to_string(&metrics) {
+                        let _ = socket.send(Message::Text(js)).await;
+                    }
+                }
+            }
+            Message::Close(_) => break,
+            _ => {}
+        }
+    }
+}