Add Describe, change 'd' to describe, change delete (#150)

Author: dgunzy

Cargo.lock

@@ -21,7 +21,7 @@ flux9s stores its configuration in a YAML file. The location depends on your ope
 
 ### Read-Only Mode
 
-By default, flux9s launches in readonly mode to prevent accidental changes (Delete operations always have a confirmation screen).
+By default, flux9s launches in readonly mode to prevent accidental changes (`Ctrl+d` delete operations always have a confirmation screen).
 You can change this:
 
 **Via command line:**

docs/content/configuration/_index.md

@@ -60,12 +60,13 @@ Use these keyboard shortcuts to navigate flux9s:
 | `r`       | Resume reconciliation                                   |
 | `R`       | Reconcile resource                                      |
 | `y`       | View resource YAML                                      |
+| `d`       | View describe output                                    |
 | `f`       | Toggle favorite                                         |
 | `g`       | View resource graph (Kustomization, HelmRelease, etc.)  |
 | `h`       | View reconciliation history                             |
 | `t`       | Trace ownership chain                                   |
 | `W`       | Reconcile with source                                   |
-| `d`       | Delete resource                                         |
+| `Ctrl+d`  | Delete resource (with confirmation)                     |
 | `?`          | Show/hide help                                          |
 | `q` / `Esc`  | Go back; shows a quit prompt when at the root view      |
 | `Q`          | Quit immediately (no prompt)                            |
@@ -222,7 +223,7 @@ Perform actions on selected resources:
 | `r` | Resume reconciliation  | GitRepository, OCIRepository, HelmRepository, Kustomization, HelmRelease, ImageUpdateAutomation |
 | `R` | Reconcile resource     | All Flux resources (cannot reconcile suspended resources)                                       |
 | `W` | Reconcile with source  | Kustomization, HelmRelease only                                                                 |
-| `d` | Delete resource        | All Flux resources (with confirmation)                                                          |
+| `Ctrl+d` | Delete resource   | All Flux resources (with confirmation)                                                          |
 
 **Note:** Suspend and Resume operations are only available for resources that support the `spec.suspend` field. Reconcile operations will fail if the resource is currently suspended.
 

docs/content/user-guide/_index.md

@@ -22,7 +22,8 @@ test-integration:
 
 # Run cargo-audit to check for CVEs (ignores unmaintained warnings)
 audit:
-    cargo audit --ignore RUSTSEC-2024-0436
+    # RUSTSEC-2026-0002 is currently pulled in transitively via ratatui 0.29's lru dependency.
+    cargo audit --ignore RUSTSEC-2024-0436 --ignore RUSTSEC-2026-0002
 
 # Run all CI checks in order
 ci: fmt clippy audit test test-integration

justfile

@@ -12,6 +12,10 @@ pub const MAX_RECONCILIATION_HISTORY: usize = 50;
 /// Status message timeout in seconds
 pub const STATUS_MESSAGE_TIMEOUT_SECS: u64 = 4;
 
+/// Status message shown when a write action is attempted in readonly mode
+pub const READ_ONLY_WRITE_ACTION_MESSAGE: &str =
+    "Readonly mode is enabled. Use :readonly to toggle write actions.";
+
 /// Minimum terminal width required for the TUI
 pub const MIN_TERMINAL_WIDTH: u16 = 80;
 

src/constants.rs

@@ -1,59 +1,47 @@
 //! Resource fetching utilities
 //!
-//! Provides functions for fetching Flux resource YAML from the Kubernetes API.
+//! Provides functions for fetching full Kubernetes resources from the API.
 
-use crate::models::FluxResourceKind;
-use crate::watcher::{
-    Alert, ArtifactGenerator, Bucket, ExternalArtifact, FluxInstance, FluxReport, GitRepository,
-    HelmChart, HelmRelease, HelmRepository, ImagePolicy, ImageRepository, ImageUpdateAutomation,
-    Kustomization, OCIRepository, Provider, Receiver, ResourceSet, ResourceSetInputProvider,
-};
+use anyhow::Context;
 use kube::Api;
+use kube::core::DynamicObject;
 
-/// Fetch resource YAML from the Kubernetes API
-pub async fn fetch_resource_yaml(
+use crate::kube::get_api_resource_with_fallback;
+
+/// Fetch a full resource object from the Kubernetes API using discovery-backed version fallback.
+pub async fn fetch_resource(
     client: &kube::Client,
     resource_type: &str,
     namespace: &str,
     name: &str,
 ) -> anyhow::Result<serde_json::Value> {
-    // Match resource type and fetch using appropriate API
-    macro_rules! fetch_resource {
-        ($type:ty) => {{
-            let api: Api<$type> = Api::namespaced(client.clone(), namespace);
-            match api.get(name).await {
-                Ok(obj) => {
-                    return Ok(serde_json::to_value(&obj)?);
-                }
-                Err(e) => {
-                    return Err(anyhow::anyhow!("Failed to fetch {}: {}", resource_type, e));
-                }
-            }
-        }};
-    }
+    let api_resource = get_api_resource_with_fallback(client, resource_type, namespace, name)
+        .await
+        .with_context(|| {
+            format!(
+                "Failed to discover API resource for {}/{} in namespace {}",
+                resource_type, name, namespace
+            )
+        })?;
+    let api: Api<DynamicObject> = Api::namespaced_with(client.clone(), namespace, &api_resource);
+    let obj = api.get(name).await.with_context(|| {
+        format!(
+            "Failed to fetch {}/{} in namespace {}",
+            resource_type, name, namespace
+        )
+    })?;
 
-    match FluxResourceKind::parse_optional(resource_type) {
-        Some(FluxResourceKind::GitRepository) => fetch_resource!(GitRepository),
-        Some(FluxResourceKind::OCIRepository) => fetch_resource!(OCIRepository),
-        Some(FluxResourceKind::HelmRepository) => fetch_resource!(HelmRepository),
-        Some(FluxResourceKind::Bucket) => fetch_resource!(Bucket),
-        Some(FluxResourceKind::HelmChart) => fetch_resource!(HelmChart),
-        Some(FluxResourceKind::ExternalArtifact) => fetch_resource!(ExternalArtifact),
-        Some(FluxResourceKind::ArtifactGenerator) => fetch_resource!(ArtifactGenerator),
-        Some(FluxResourceKind::Kustomization) => fetch_resource!(Kustomization),
-        Some(FluxResourceKind::HelmRelease) => fetch_resource!(HelmRelease),
-        Some(FluxResourceKind::ImageRepository) => fetch_resource!(ImageRepository),
-        Some(FluxResourceKind::ImagePolicy) => fetch_resource!(ImagePolicy),
-        Some(FluxResourceKind::ImageUpdateAutomation) => fetch_resource!(ImageUpdateAutomation),
-        Some(FluxResourceKind::Alert) => fetch_resource!(Alert),
-        Some(FluxResourceKind::Provider) => fetch_resource!(Provider),
-        Some(FluxResourceKind::Receiver) => fetch_resource!(Receiver),
-        Some(FluxResourceKind::ResourceSet) => fetch_resource!(ResourceSet),
-        Some(FluxResourceKind::ResourceSetInputProvider) => {
-            fetch_resource!(ResourceSetInputProvider)
-        }
-        Some(FluxResourceKind::FluxReport) => fetch_resource!(FluxReport),
-        Some(FluxResourceKind::FluxInstance) => fetch_resource!(FluxInstance),
-        None => Err(anyhow::anyhow!("Unknown resource type: {}", resource_type)),
-    }
+    serde_json::to_value(&obj).context("Failed to serialize fetched resource")
+}
+
+/// Fetch resource data for the YAML view.
+///
+/// This remains as a compatibility wrapper around the generic resource fetch path.
+pub async fn fetch_resource_yaml(
+    client: &kube::Client,
+    resource_type: &str,
+    namespace: &str,
+    name: &str,
+) -> anyhow::Result<serde_json::Value> {
+    fetch_resource(client, resource_type, namespace, name).await
 }

src/kube/fetch.rs

@@ -18,7 +18,7 @@ pub mod inventory;
 #[allow(unused_imports)] // Public API re-exports used by lib consumers
 pub use api::{get_api_resource_with_fallback, get_gvk_for_resource_type};
 #[allow(unused_imports)] // Public API re-exports used by lib consumers
-pub use fetch::fetch_resource_yaml;
+pub use fetch::{fetch_resource, fetch_resource_yaml};
 
 use anyhow::Result;
 use kube::config::Kubeconfig;

src/kube/mod.rs

@@ -48,7 +48,9 @@ pub use services::ClusterSession;
 pub use operations::{FluxOperation, OperationRegistry};
 
 // Re-export kube utilities
-pub use kube::{fetch_resource_yaml, get_api_resource_with_fallback, get_gvk_for_resource_type};
+pub use kube::{
+    fetch_resource, fetch_resource_yaml, get_api_resource_with_fallback, get_gvk_for_resource_type,
+};
 
 // Re-export trace types
 pub use trace::{

src/lib.rs

@@ -60,6 +60,27 @@ impl App {
         None
     }
 
+    /// Trigger describe fetch if pending
+    pub fn trigger_describe_fetch(
+        &mut self,
+    ) -> Option<(
+        String,
+        kube::Client,
+        tokio::sync::oneshot::Sender<anyhow::Result<serde_json::Value>>,
+    )> {
+        if let Some(ref key) = self.async_state.describe_fetch_pending {
+            if let Some(ref client) = self.kube_client {
+                let (tx, rx) = tokio::sync::oneshot::channel();
+                let key_clone = key.clone();
+                let client_clone = client.clone();
+                self.async_state.describe_fetch_pending = None;
+                self.async_state.describe_fetch_rx = Some(rx);
+                return Some((key_clone, client_clone, tx));
+            }
+        }
+        None
+    }
+
     /// Set YAML fetch result
     pub fn set_yaml_fetched(&mut self, yaml: serde_json::Value) {
         self.async_state.yaml_fetched = Some(yaml);
@@ -71,6 +92,17 @@ impl App {
         self.async_state.yaml_fetch_pending = None;
     }
 
+    /// Set describe fetch result
+    pub fn set_describe_fetched(&mut self, describe: serde_json::Value) {
+        self.async_state.describe_fetched = Some(describe);
+    }
+
+    /// Set describe fetch error
+    pub fn set_describe_fetch_error(&mut self) {
+        self.async_state.describe_fetched = None;
+        self.async_state.describe_fetch_pending = None;
+    }
+
     /// Try to get YAML fetch result
     pub fn try_get_yaml_result(&mut self) -> Option<anyhow::Result<serde_json::Value>> {
         if let Some(ref mut rx) = self.async_state.yaml_fetch_rx {
@@ -91,6 +123,26 @@ impl App {
         None
     }
 
+    /// Try to get describe fetch result
+    pub fn try_get_describe_result(&mut self) -> Option<anyhow::Result<serde_json::Value>> {
+        if let Some(ref mut rx) = self.async_state.describe_fetch_rx {
+            match rx.try_recv() {
+                Ok(result) => {
+                    self.async_state.describe_fetch_rx = None;
+                    return Some(result);
+                }
+                Err(tokio::sync::oneshot::error::TryRecvError::Empty) => {
+                    return None;
+                }
+                Err(_) => {
+                    self.async_state.describe_fetch_rx = None;
+                    return Some(Err(anyhow::anyhow!("Describe fetch failed")));
+                }
+            }
+        }
+        None
+    }
+
     /// Trigger trace if pending
     pub fn trigger_trace(&mut self) -> Option<TraceRequest> {
         if let Some(ref rk) = self.async_state.trace_pending {

src/tui/app/async_ops.rs

@@ -307,6 +307,7 @@ impl App {
     }
 
     #[cfg(test)]
+    #[allow(dead_code)]
     pub fn set_previous_list_view(&mut self, view: View) {
         self.view_state.previous_list_view = view;
     }
@@ -372,7 +373,7 @@ impl App {
                 let resources = self.get_filtered_resources();
                 resources.get(self.view_state.selected_index).cloned()
             }
-            View::ResourceDetail => self
+            View::ResourceDetail | View::ResourceDescribe => self
                 .selection_state
                 .selected_resource_key
                 .as_ref()
@@ -530,6 +531,10 @@ impl std::fmt::Debug for App {
             .field("selected_index", &self.view_state.selected_index)
             .field("scroll_offset", &self.view_state.scroll_offset)
             .field("yaml_scroll_offset", &self.view_state.yaml_scroll_offset)
+            .field(
+                "describe_scroll_offset",
+                &self.view_state.describe_scroll_offset,
+            )
             .field("show_help", &self.ui_state.show_help)
             .field("context", &self.context)
             .field("namespace", &self.namespace)
@@ -545,6 +550,18 @@ impl std::fmt::Debug for App {
             .field("yaml_fetch_pending", &self.async_state.yaml_fetch_pending)
             .field("yaml_fetched", &self.async_state.yaml_fetched.is_some())
             .field("yaml_fetch_rx", &self.async_state.yaml_fetch_rx.is_some())
+            .field(
+                "describe_fetch_pending",
+                &self.async_state.describe_fetch_pending,
+            )
+            .field(
+                "describe_fetched",
+                &self.async_state.describe_fetched.is_some(),
+            )
+            .field(
+                "describe_fetch_rx",
+                &self.async_state.describe_fetch_rx.is_some(),
+            )
             .field("trace_pending", &self.async_state.trace_pending)
             .field("trace_result", &self.async_state.trace_result.is_some())
             .field(