Refactor network handling and appearance management

- Update `NetObsChamber` to prevent clobbering in-progress typing during periodic refresh.
- Prefer NIC hardware counters when available for network statistics.
- Enhance `SettingsApp` initialization to sync global settings.
- Introduce network mode selection in `setup-dev.sh` with support for bridge and user NAT modes.
- Implement bridge ACL checks and helper availability in `setup-dev.sh`.
- Add `netcheck` application for network diagnostics, including DHCP lease acquisition and DNS resolution.
- Refactor appearance management in `shelld` to use a shared `DesktopAppearance` struct for consistent theming.
- Update various islands in `shelld` to utilize dynamic color settings from `ShellState`.
- Introduce persistence for desktop appearance settings in `libmorpheus`.

Author: T. Andrew Davis

Cargo.lock

@@ -21,6 +21,7 @@ members = [
     "shelld",
     "settings",
     "tests/syscall-e2e",
+    "tests/netcheck",
     "tests/spinning-cube",
     "tests/system-visualizer",
 ]

Cargo.toml

@@ -45,10 +45,13 @@ pub(super) unsafe fn net_cfg_get(buf: *mut u8) -> i64 {
 }
 
 pub(super) unsafe fn net_cfg_dhcp() -> i64 {
-    if state::user_net_stack_mut().is_some() {
-        0
-    } else {
-        -1
+    let Some(stack) = state::user_net_stack_mut() else {
+        return -1;
+    };
+
+    match stack.restart_dhcp() {
+        Ok(()) => 0,
+        Err(_) => -1,
     }
 }
 
@@ -81,6 +84,8 @@ pub(super) unsafe fn net_poll_stats(buf: *mut u8) -> i64 {
         0,
         core::mem::size_of::<morpheus_hwinit::NetStats>(),
     );
+    out.tx_packets = morpheus_network::stack::tx_packet_count() as u64;
+    out.rx_packets = morpheus_network::stack::rx_packet_count() as u64;
     out.tcp_active = state::tcp_active_count();
     0
 }

bootloader/src/baremetal_ops/network/config.rs

@@ -13,12 +13,9 @@ pub const TITLE_H: u32 = 22;
 pub const BORDER: u32 = 1;
 pub const CASCADE_STEP: i32 = 28;
 
-pub const TITLE_FOCUSED_RGB: (u8, u8, u8) = (0, 85, 0);
 pub const TITLE_UNFOCUSED_RGB: (u8, u8, u8) = (40, 40, 40);
 pub const TITLE_TEXT_RGB: (u8, u8, u8) = (255, 255, 255);
-pub const BORDER_FOCUSED_RGB: (u8, u8, u8) = (0, 170, 0);
 pub const BORDER_UNFOCUSED_RGB: (u8, u8, u8) = (85, 85, 85);
-pub const DESKTOP_RGB: (u8, u8, u8) = (26, 26, 46);
 pub const CURSOR_RGB: (u8, u8, u8) = (255, 255, 255);
 
 // shelld's panel height. hardcoded here so compd can re-blit it above windows.
@@ -93,6 +90,10 @@ pub struct CompState {
     pub last_buttons: u8,
     pub capture: Option<MouseCapture>,
 
+    pub desktop_rgb: (u8, u8, u8),
+    pub title_focused_rgb: (u8, u8, u8),
+    pub border_focused_rgb: (u8, u8, u8),
+
     // --- channels (SPSC) ---
     pub ch_input_to_focus: Channel<InputMsg, 16>,
     pub ch_mouse_spatial: Channel<MouseSpatialMsg, 32>,
@@ -117,6 +118,9 @@ impl CompState {
             mouse_y: (fb_h / 2) as i32,
             last_buttons: 0,
             capture: None,
+            desktop_rgb: (26, 26, 46),
+            title_focused_rgb: (0, 85, 0),
+            border_focused_rgb: (0, 170, 0),
             ch_input_to_focus: Channel::new(),
             ch_mouse_spatial: Channel::new(),
             ch_mouse_route: Channel::new(),
@@ -132,6 +136,12 @@ impl CompState {
             (r as u32) | ((g as u32) << 8) | ((b as u32) << 16)
         }
     }
+
+    pub fn apply_desktop_appearance(&mut self, a: &libmorpheus::desktop::DesktopAppearance) {
+        self.desktop_rgb = a.desktop_rgb;
+        self.title_focused_rgb = a.title_focus_rgb;
+        self.border_focused_rgb = a.border_focus_rgb;
+    }
 }
 
 pub const fn zeroed_surface_entry() -> compsys::SurfaceEntry {

compd/src/islands/mod.rs

@@ -43,7 +43,7 @@ pub fn compose(state: &mut CompState) {
         }
     }
     if !drew_desktop {
-        let (dr, dg, db) = DESKTOP_RGB;
+        let (dr, dg, db) = state.desktop_rgb;
         raw_fill(
             fb_ptr,
             state.fb_stride,
@@ -148,16 +148,8 @@ fn draw_window(state: &mut CompState, idx: usize, focused: bool) {
         )
     };
 
-    let (tb_r, tb_g, tb_b) = if focused {
-        TITLE_FOCUSED_RGB
-    } else {
-        TITLE_UNFOCUSED_RGB
-    };
-    let (br, bg, bb) = if focused {
-        BORDER_FOCUSED_RGB
-    } else {
-        BORDER_UNFOCUSED_RGB
-    };
+    let (tb_r, tb_g, tb_b) = if focused { state.title_focused_rgb } else { TITLE_UNFOCUSED_RGB };
+    let (br, bg, bb) = if focused { state.border_focused_rgb } else { BORDER_UNFOCUSED_RGB };
 
     let outer_x = win_x - BORDER as i32;
     let outer_y = win_y - TITLE_H as i32 - BORDER as i32;

compd/src/islands/renderer.rs

@@ -30,8 +30,22 @@ fn main() -> i32 {
     let mut state =
         islands::CompState::new(fb_ptr, fb_info.width, fb_info.height, fb_stride_px, is_bgrx);
 
+    if let Some(a) = libmorpheus::desktop::DesktopAppearance::load() {
+        state.apply_desktop_appearance(&a);
+    }
+
+    let mut last_appearance_poll_ms = 0u64;
+
     // 5. enter main vsync loop
     loop {
+        let now_ms = libmorpheus::time::uptime_ms();
+        if now_ms.saturating_sub(last_appearance_poll_ms) >= 400 {
+            if let Some(a) = libmorpheus::desktop::DesktopAppearance::load() {
+                state.apply_desktop_appearance(&a);
+            }
+            last_appearance_poll_ms = now_ms;
+        }
+
         islands::vsync::tick(&mut state);
         islands::input::poll(&mut state);
         islands::surface_mgr::update(&mut state);

compd/src/main.rs

@@ -0,0 +1,154 @@
+//! Desktop environment appearance profile shared across settings, shelld, and compd.
+
+use crate::persist;
+
+pub const APPEARANCE_KEY: &str = "de_appearance_v1";
+pub const APPEARANCE_KEY_LEGACY: &str = "de.appearance.v1";
+const MAGIC: [u8; 4] = *b"MDE1";
+const VERSION: u8 = 1;
+const ENCODED_LEN: usize = 26;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct DesktopAppearance {
+    pub dark_mode: bool,
+    pub accent_rgb: (u8, u8, u8),
+    pub desktop_rgb: (u8, u8, u8),
+    pub panel_rgb: (u8, u8, u8),
+    pub start_rgb: (u8, u8, u8),
+    pub title_focus_rgb: (u8, u8, u8),
+    pub border_focus_rgb: (u8, u8, u8),
+}
+
+impl DesktopAppearance {
+    pub const fn default_dark() -> Self {
+        Self {
+            dark_mode: true,
+            accent_rgb: (0, 230, 118),
+            desktop_rgb: (26, 26, 46),
+            panel_rgb: (18, 20, 30),
+            start_rgb: (0, 85, 0),
+            title_focus_rgb: (0, 85, 0),
+            border_focus_rgb: (0, 170, 0),
+        }
+    }
+
+    pub const fn default_light() -> Self {
+        Self {
+            dark_mode: false,
+            accent_rgb: (0, 132, 96),
+            desktop_rgb: (236, 238, 245),
+            panel_rgb: (220, 223, 230),
+            start_rgb: (0, 132, 96),
+            title_focus_rgb: (0, 132, 96),
+            border_focus_rgb: (0, 165, 120),
+        }
+    }
+
+    pub fn from_theme_choice(dark_mode: bool, accent_rgb: (u8, u8, u8)) -> Self {
+        let (ar, ag, ab) = accent_rgb;
+        let title = scale_rgb(accent_rgb, if dark_mode { 38 } else { 68 });
+        let border = scale_rgb(accent_rgb, if dark_mode { 76 } else { 92 });
+        let start = scale_rgb(accent_rgb, if dark_mode { 34 } else { 74 });
+        let desktop = if dark_mode {
+            (26, 26, 46)
+        } else {
+            (236, 238, 245)
+        };
+        let panel = if dark_mode {
+            (18, 20, 30)
+        } else {
+            (220, 223, 230)
+        };
+
+        Self {
+            dark_mode,
+            accent_rgb: (ar, ag, ab),
+            desktop_rgb: desktop,
+            panel_rgb: panel,
+            start_rgb: start,
+            title_focus_rgb: title,
+            border_focus_rgb: border,
+        }
+    }
+
+    pub fn load() -> Option<Self> {
+        let mut buf = [0u8; ENCODED_LEN];
+        if let Ok(n) = persist::get(APPEARANCE_KEY, &mut buf) {
+            if n == ENCODED_LEN {
+                if let Some(v) = decode(&buf) {
+                    return Some(v);
+                }
+            }
+        }
+
+        if let Ok(n) = persist::get(APPEARANCE_KEY_LEGACY, &mut buf) {
+            if n == ENCODED_LEN {
+                return decode(&buf);
+            }
+        }
+
+        None
+    }
+
+    pub fn store(&self) -> Result<(), u64> {
+        let buf = encode(self);
+        match persist::put(APPEARANCE_KEY, &buf) {
+            Ok(()) => Ok(()),
+            Err(_) => persist::put(APPEARANCE_KEY_LEGACY, &buf),
+        }
+    }
+}
+
+#[inline(always)]
+fn scale8(v: u8, pct: u16) -> u8 {
+    let x = (v as u16).saturating_mul(pct) / 100;
+    x.min(255) as u8
+}
+
+#[inline(always)]
+fn scale_rgb(rgb: (u8, u8, u8), pct: u16) -> (u8, u8, u8) {
+    (scale8(rgb.0, pct), scale8(rgb.1, pct), scale8(rgb.2, pct))
+}
+
+fn encode(a: &DesktopAppearance) -> [u8; ENCODED_LEN] {
+    let mut out = [0u8; ENCODED_LEN];
+    out[0..4].copy_from_slice(&MAGIC);
+    out[4] = VERSION;
+    out[5] = if a.dark_mode { 1 } else { 0 };
+
+    write_rgb(&mut out, 8, a.accent_rgb);
+    write_rgb(&mut out, 11, a.desktop_rgb);
+    write_rgb(&mut out, 14, a.panel_rgb);
+    write_rgb(&mut out, 17, a.start_rgb);
+    write_rgb(&mut out, 20, a.title_focus_rgb);
+    write_rgb(&mut out, 23, a.border_focus_rgb);
+    out
+}
+
+fn decode(buf: &[u8; ENCODED_LEN]) -> Option<DesktopAppearance> {
+    if buf[0..4] != MAGIC || buf[4] != VERSION {
+        return None;
+    }
+
+    Some(DesktopAppearance {
+        dark_mode: buf[5] != 0,
+        accent_rgb: read_rgb(buf, 8),
+        desktop_rgb: read_rgb(buf, 11),
+        panel_rgb: read_rgb(buf, 14),
+        start_rgb: read_rgb(buf, 17),
+        title_focus_rgb: read_rgb(buf, 20),
+        border_focus_rgb: read_rgb(buf, 23),
+    })
+}
+
+#[inline(always)]
+fn write_rgb(buf: &mut [u8; ENCODED_LEN], i: usize, rgb: (u8, u8, u8)) {
+    buf[i] = rgb.0;
+    buf[i + 1] = rgb.1;
+    buf[i + 2] = rgb.2;
+}
+
+#[inline(always)]
+fn read_rgb(buf: &[u8; ENCODED_LEN], i: usize) -> (u8, u8, u8) {
+    (buf[i], buf[i + 1], buf[i + 2])
+}

libmorpheus/src/desktop.rs

@@ -16,6 +16,7 @@ extern crate alloc; // buddy.rs registers #[global_allocator] → Vec/Box/String
 
 pub mod buddy;
 pub mod compositor;
+pub mod desktop;
 pub mod entry;
 pub mod env;
 pub mod error;

libmorpheus/src/lib.rs

@@ -315,6 +315,25 @@ impl<D: NetworkDevice> NetInterface<D> {
         })
     }
 
+    /// Restart DHCP discovery on an existing DHCP-enabled interface.
+    pub fn restart_dhcp(&mut self) -> Result<()> {
+        let Some(dhcp_handle) = self.dhcp_handle else {
+            return Err(NetworkError::ProtocolNotAvailable);
+        };
+
+        let dhcp = self.sockets.get_mut::<DhcpSocket>(dhcp_handle);
+        dhcp.reset();
+
+        // Drop current lease immediately so userspace sees discovery state.
+        self.iface.update_ip_addrs(|addrs| addrs.clear());
+        self.iface.routes_mut().remove_default_ipv4_route();
+        self.gateway = None;
+        self.dns = None;
+        self.state = NetState::DhcpDiscovering;
+
+        Ok(())
+    }
+
     /// Start a DNS query for a hostname. Returns a query handle.
     pub fn start_dns_query(&mut self, hostname: &str) -> Result<smoltcp::socket::dns::QueryHandle> {
         super::debug_log(80, "start_dns_query");