Bug fixes, age, watcher rework, yaml search (#175)

Signed-off-by: Daniel Guns <danbguns@gmail.com>

Author: dgunzy

Cargo.toml

@@ -121,14 +121,14 @@ openssl = { version = "0.10", optional = true }
 # Logging (tracing is already a transitive dependency via kube-rs, but we need it explicitly for macros)
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "ansi"] }
-insta = "1.46.0"
 
 # Version update notifications
 update-informer = "1.1"
 
 [dev-dependencies]
 # Testing
 mockall = "0.13"
+insta = "1.46.0"
 
 [package.metadata.binstall]
 # cargo-binstall configuration for pre-built binary installation

README.md

@@ -115,7 +115,9 @@ By default, `flux9s` watches the `flux-system` namespace. Use `:ns all` to view
 - `j` / `k` - Navigate up/down
 - `:` - Command mode (e.g., `:kustomization`, `:gitrepository`)
 - `Enter` - View resource details
-- `/` - Filter resources by name
+- `/` - Filter resources by name (list views) or search text (YAML/describe/trace views)
+- `n` / `N` - Next/previous search match (in text views)
+- `Shift+N` / `Shift+A` / `Shift+T` / `Shift+S` - Sort by name/age/type/status (press again to reverse)
 - `s` - Suspend resource
 - `r` - Resume resource
 - `R` - Reconcile resource

docs/content/user-guide/_index.md

@@ -55,7 +55,12 @@ Use these keyboard shortcuts to navigate flux9s:
 | `j` / `k` | Navigate up/down                                        |
 | `:`       | Command mode (e.g., `:kustomization`, `:gitrepository`) |
 | `Enter`   | View resource details                                   |
-| `/`       | Filter resources by name                                |
+| `/`       | Filter resources by name (in list views) or search text (in YAML/describe/trace views) |
+| `n` / `N` | Jump to next/previous search match (in YAML/describe/trace views) |
+| `Shift+N` | Sort list by name (press again to reverse, third press restores default order) |
+| `Shift+A` | Sort list by age                                        |
+| `Shift+T` | Sort list by type                                       |
+| `Shift+S` | Sort list by status (problems first)                    |
 | `s`       | Suspend reconciliation                                  |
 | `r`       | Resume reconciliation                                   |
 | `R`       | Reconcile resource                                      |
@@ -165,6 +170,30 @@ The header displays a health percentage indicator showing the overall health of
 - **Yellow (⚠)** - 70-89% health
 - **Red (✗)** - Below 70% health
 
+## Sorting
+
+Sort the resource list k9s-style with shift-key shortcuts: `Shift+N` (name), `Shift+A` (age), `Shift+T` (type), or `Shift+S` (status, problems first). Press the same key again to reverse the order, and a third time to restore the default namespace/type/name ordering. The active sort column is marked with an arrow (`↑`/`↓`) in the table header, and favorites always stay grouped at the top.
+
+## Searching Text Views
+
+Inside the YAML (`y`), describe (`d`), and trace (`t`) views, press `/` to search:
+
+- Type a query and press `Enter` to jump to the first match (matching is case-insensitive)
+- `n` / `N` - Jump to the next/previous match
+- `Esc` - Clear the search (press again to leave the view)
+
+The view title shows the active query and match position (e.g., `/spec (2/7)`), and matching lines are highlighted.
+
+## Watch Status Banner
+
+flux9s watches the cluster continuously. If the connection to the API server degrades (network outage, VPN reconnect, laptop sleep), a red banner appears in the top-right corner of the resource list:
+
+```
+⚠ Watch degraded (N) — data may be stale, reconnecting...
+```
+
+Watchers retry automatically with exponential backoff; the banner disappears as soon as the watch streams recover. While the banner is visible, the displayed resources may be out of date.
+
 ## Resource Views
 
 ### Graph View (`g`)

src/config/schema.rs

@@ -56,6 +56,43 @@ pub struct Config {
     pub connect_timeout_seconds: u64,
 }
 
+impl Config {
+    /// Resolve which skin to use for the given context.
+    ///
+    /// Priority order:
+    /// 1. `FLUX9S_SKIN` environment variable (highest)
+    /// 2. Context-specific skin from `contextSkins`
+    /// 3. Readonly-specific skin (`ui.skinReadOnly`) when `readOnly` is true
+    /// 4. Default skin (`ui.skin`)
+    pub fn resolve_skin_name(&self, context_name: Option<&str>) -> String {
+        if let Ok(env_skin) = std::env::var("FLUX9S_SKIN") {
+            tracing::debug!(
+                "Using skin from FLUX9S_SKIN environment variable: {}",
+                env_skin
+            );
+            return env_skin;
+        }
+        if let Some(context) = context_name {
+            if let Some(context_skin) = self.context_skins.get(context) {
+                tracing::debug!(
+                    "Using context-specific skin for '{}': {}",
+                    context,
+                    context_skin
+                );
+                return context_skin.clone();
+            }
+        }
+        if self.read_only {
+            if let Some(ref skin) = self.ui.skin_read_only {
+                tracing::debug!("Using readonly-specific skin: {}", skin);
+                return skin.clone();
+            }
+        }
+        tracing::debug!("Using default skin: {}", self.ui.skin);
+        self.ui.skin.clone()
+    }
+}
+
 /// UI configuration
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]

src/kube/api.rs

@@ -238,6 +238,38 @@ pub fn get_flux_api_resources_with_fallback(
         .collect())
 }
 
+/// Classification of a failed GET used while probing API versions.
+#[derive(Debug, PartialEq, Eq)]
+enum NotFoundKind {
+    /// The API version itself is not served on this cluster (404 for the API path).
+    VersionMissing,
+    /// The version is served but the named resource does not exist.
+    ResourceMissing,
+    /// Any other failure (auth, network, server error, ...).
+    Other,
+}
+
+/// Distinguish "this API version is not served" from "the named resource does
+/// not exist". Both surface as HTTP 404, but the API server uses a generic
+/// "could not find the requested resource" (or "404 page not found") message
+/// for unserved versions, and names the object (`<plural>.<group> "<name>"
+/// not found`) when only the object is missing — in which case the version IS
+/// served and there is no point probing fallback versions.
+fn classify_not_found(error: &kube::Error) -> NotFoundKind {
+    if let kube::Error::Api(api_err) = error {
+        if api_err.code == 404 {
+            let msg = api_err.message.to_lowercase();
+            if msg.contains("could not find the requested resource")
+                || msg.contains("page not found")
+            {
+                return NotFoundKind::VersionMissing;
+            }
+            return NotFoundKind::ResourceMissing;
+        }
+    }
+    NotFoundKind::Other
+}
+
 /// Get ApiResource for a resource type with version fallback
 ///
 /// **Why kubectl works without versions but kube-rs doesn't:**
@@ -286,12 +318,17 @@ pub async fn get_api_resource_with_fallback(
             // Default version works!
             return Ok(api_resource);
         }
-        Err(e) => {
-            if !is_version_missing_error(&format!("{}", e)) {
+        Err(e) => match classify_not_found(&e) {
+            // Version doesn't exist on this cluster, try fallback versions below
+            NotFoundKind::VersionMissing => {}
+            // The API answered for this GVR, so the version is served — the named
+            // resource just doesn't exist. Return immediately instead of probing
+            // fallback versions; the caller's own GET produces the proper error.
+            NotFoundKind::ResourceMissing => return Ok(api_resource),
+            NotFoundKind::Other => {
                 return Err(anyhow::anyhow!("Failed to fetch {}: {}", resource_type, e));
             }
-            // Version doesn't exist on this cluster, try fallback versions
-        }
+        },
     }
 
     // Generate fallback versions dynamically based on the default version
@@ -322,12 +359,14 @@ pub async fn get_api_resource_with_fallback(
                 );
                 return Ok(fallback_api_resource);
             }
-            Err(e) => {
-                if !is_version_missing_error(&format!("{}", e)) {
-                    // Non-"not found" error means this version exists but the resource doesn't
-                    return Ok(fallback_api_resource);
+            Err(e) => match classify_not_found(&e) {
+                NotFoundKind::VersionMissing => {} // Try the next version
+                // Version is served; resource doesn't exist at any version.
+                NotFoundKind::ResourceMissing => return Ok(fallback_api_resource),
+                NotFoundKind::Other => {
+                    return Err(anyhow::anyhow!("Failed to fetch {}: {}", resource_type, e));
                 }
-            }
+            },
         }
     }
 
@@ -443,4 +482,51 @@ mod tests {
         assert!(!is_version_missing_error("timeout waiting for response"));
         assert!(!is_version_missing_error("unauthorized: token expired"));
     }
+
+    fn api_error(code: u16, message: &str) -> kube::Error {
+        kube::Error::Api(Box::new(
+            kube::core::Status::failure(message, "NotFound").with_code(code),
+        ))
+    }
+
+    #[test]
+    fn test_classify_not_found_version_missing() {
+        // The message the API server returns when an apiVersion is not served
+        assert_eq!(
+            classify_not_found(&api_error(
+                404,
+                "the server could not find the requested resource"
+            )),
+            NotFoundKind::VersionMissing
+        );
+        // Raw 404 from a missing API group path
+        assert_eq!(
+            classify_not_found(&api_error(404, "404 page not found")),
+            NotFoundKind::VersionMissing
+        );
+    }
+
+    #[test]
+    fn test_classify_not_found_resource_missing() {
+        // The message when the GVR is served but the named object doesn't exist
+        assert_eq!(
+            classify_not_found(&api_error(
+                404,
+                "helmreleases.helm.toolkit.fluxcd.io \"my-release\" not found"
+            )),
+            NotFoundKind::ResourceMissing
+        );
+    }
+
+    #[test]
+    fn test_classify_not_found_other_errors() {
+        assert_eq!(
+            classify_not_found(&api_error(403, "forbidden")),
+            NotFoundKind::Other
+        );
+        assert_eq!(
+            classify_not_found(&api_error(500, "internal error")),
+            NotFoundKind::Other
+        );
+    }
 }

src/main.rs

@@ -104,49 +104,8 @@ async fn main() -> Result<()> {
 
     let read_only = config.read_only;
 
-    // Determine which skin to use (priority order):
-    // 1. FLUX9S_SKIN environment variable (highest priority)
-    // 2. Context-specific skin from config.context_skins
-    // 3. Readonly-specific skin (config.ui.skin_read_only) if readonly mode
-    // 4. Default skin (config.ui.skin)
-    let skin_name = if let Ok(env_skin) = std::env::var("FLUX9S_SKIN") {
-        tracing::debug!(
-            "Using skin from FLUX9S_SKIN environment variable: {}",
-            env_skin
-        );
-        env_skin
-    } else if let Some(context) = context_name {
-        if let Some(context_skin) = config.context_skins.get(context) {
-            tracing::debug!(
-                "Using context-specific skin for '{}': {}",
-                context,
-                context_skin
-            );
-            context_skin.clone()
-        } else if read_only {
-            if let Some(ref skin) = config.ui.skin_read_only {
-                tracing::debug!("Using readonly-specific skin: {}", skin);
-                skin.clone()
-            } else {
-                tracing::debug!("Using default skin: {}", config.ui.skin);
-                config.ui.skin.clone()
-            }
-        } else {
-            tracing::debug!("Using default skin: {}", config.ui.skin);
-            config.ui.skin.clone()
-        }
-    } else if read_only {
-        if let Some(ref skin) = config.ui.skin_read_only {
-            tracing::debug!("Using readonly-specific skin: {}", skin);
-            skin.clone()
-        } else {
-            tracing::debug!("Using default skin: {}", config.ui.skin);
-            config.ui.skin.clone()
-        }
-    } else {
-        tracing::debug!("Using default skin: {}", config.ui.skin);
-        config.ui.skin.clone()
-    };
+    // Determine which skin to use (env var > context skin > readonly skin > default)
+    let skin_name = config.resolve_skin_name(context_name);
 
     // Load theme based on determined skin name
     let theme = config::ThemeLoader::load_theme(&skin_name).unwrap_or_else(|e| {

src/services/cluster_session.rs

@@ -299,7 +299,7 @@ impl ClusterSession {
                         name,
                         namespace: ns,
                         resource_type,
-                        age: Some(chrono::Utc::now()),
+                        age: crate::watcher::extract_creation_timestamp(&obj_json),
                         suspended,
                         ready,
                         message,
@@ -319,6 +319,12 @@ impl ClusterSession {
             WatchEvent::Error(msg) => {
                 tracing::warn!("Watch event error: {}", msg);
             }
+            WatchEvent::WatcherDegraded(name) => {
+                tracing::warn!("Watcher degraded (retrying with backoff): {}", name);
+            }
+            WatchEvent::WatcherRecovered(name) => {
+                tracing::info!("Watcher recovered: {}", name);
+            }
             WatchEvent::PodApplied(_, _)
             | WatchEvent::PodDeleted(_)
             | WatchEvent::DeploymentApplied(_) => {}