redis-developer
diff --git a/‎crates/redis-enterprise/src/shards.rs‎
Lines changed: 1 addition & 1 deletion b/‎crates/redis-enterprise/src/shards.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/redis-enterprise/tests/shard_tests.rs‎
Lines changed: 11 additions & 11 deletions b/‎crates/redis-enterprise/tests/shard_tests.rs‎
Lines changed: 11 additions & 11 deletions
diff --git a/‎crates/redisctl/src/cli.rs‎
Lines changed: 19 additions & 0 deletions b/‎crates/redisctl/src/cli.rs‎
Lines changed: 19 additions & 0 deletions
diff --git a/‎crates/redisctl/src/commands/enterprise/mod.rs‎
Lines changed: 1 addition & 0 deletions b/‎crates/redisctl/src/commands/enterprise/mod.rs‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎crates/redisctl/src/commands/enterprise/status.rs‎
Lines changed: 220 additions & 0 deletions b/‎crates/redisctl/src/commands/enterprise/status.rs‎
Lines changed: 220 additions & 0 deletions
diff --git a/‎crates/redisctl/src/main.rs‎
Lines changed: 15 additions & 0 deletions b/‎crates/redisctl/src/main.rs‎
Lines changed: 15 additions & 0 deletions
@@ -25,7 +25,7 @@ pub struct MetricResponse {
 pub struct Shard {
     pub uid: String,
     pub bdb_uid: u32,
-    pub node_uid: u32,
+    pub node_uid: String,
     pub role: String,
     pub status: String,
     #[serde(skip_serializing_if = "Option::is_none")]
 
@@ -14,7 +14,7 @@ fn master_shard() -> serde_json::Value {
     json!({
         "uid": "shard:1:1",
         "bdb_uid": 1,
-        "node_uid": 1,
+        "node_uid": "1",
         "role": "master",
         "status": "active",
         "slots": "0-8191",
@@ -28,7 +28,7 @@ fn replica_shard() -> serde_json::Value {
     json!({
         "uid": "shard:1:2",
         "bdb_uid": 1,
-        "node_uid": 2,
+        "node_uid": "2",
         "role": "slave",
         "status": "active",
         "slots": "0-8191",
@@ -40,7 +40,7 @@ fn backup_shard() -> serde_json::Value {
     json!({
         "uid": "shard:2:1",
         "bdb_uid": 2,
-        "node_uid": 1,
+        "node_uid": "1",
         "role": "master",
         "status": "backing-up",
         "slots": "8192-16383",
@@ -53,7 +53,7 @@ fn importing_shard() -> serde_json::Value {
     json!({
         "uid": "shard:3:1",
         "bdb_uid": 3,
-        "node_uid": 3,
+        "node_uid": "3",
         "role": "master",
         "status": "importing",
         "slots": "0-16383",
@@ -66,7 +66,7 @@ fn minimal_shard() -> serde_json::Value {
     json!({
         "uid": "shard:4:1",
         "bdb_uid": 4,
-        "node_uid": 1,
+        "node_uid": "1",
         "role": "master",
         "status": "active"
     })
@@ -132,7 +132,7 @@ async fn test_shard_list() {
     let master = &shards[0];
     assert_eq!(master.uid, "shard:1:1");
     assert_eq!(master.bdb_uid, 1);
-    assert_eq!(master.node_uid, 1);
+    assert_eq!(master.node_uid, "1");
     assert_eq!(master.role, "master");
     assert_eq!(master.status, "active");
     assert_eq!(master.slots, Some("0-8191".to_string()));
@@ -219,7 +219,7 @@ async fn test_shard_get() {
     let shard = result.unwrap();
     assert_eq!(shard.uid, "shard:1:1");
     assert_eq!(shard.bdb_uid, 1);
-    assert_eq!(shard.node_uid, 1);
+    assert_eq!(shard.node_uid, "1");
     assert_eq!(shard.role, "master");
     assert_eq!(shard.status, "active");
     assert_eq!(shard.slots, Some("0-8191".to_string()));
@@ -252,7 +252,7 @@ async fn test_shard_get_minimal() {
     let shard = result.unwrap();
     assert_eq!(shard.uid, "shard:4:1");
     assert_eq!(shard.bdb_uid, 4);
-    assert_eq!(shard.node_uid, 1);
+    assert_eq!(shard.node_uid, "1");
     assert_eq!(shard.role, "master");
     assert_eq!(shard.status, "active");
     assert!(shard.slots.is_none());
@@ -453,9 +453,9 @@ async fn test_shard_list_by_node() {
     assert_eq!(shards.len(), 3);
 
     // All shards should be on node 1
-    assert_eq!(shards[0].node_uid, 1);
-    assert_eq!(shards[1].node_uid, 1);
-    assert_eq!(shards[2].node_uid, 1);
+    assert_eq!(shards[0].node_uid, "1");
+    assert_eq!(shards[1].node_uid, "1");
+    assert_eq!(shards[2].node_uid, "1");
 
     // Verify different databases
     assert_eq!(shards[0].bdb_uid, 1);
 
@@ -1323,6 +1323,25 @@ pub enum EnterpriseCommands {
     #[command(subcommand)]
     Stats(EnterpriseStatsCommands),
 
+    /// Comprehensive cluster status (cluster, nodes, databases, shards)
+    Status {
+        /// Show only cluster information
+        #[arg(long)]
+        cluster: bool,
+
+        /// Show only nodes information
+        #[arg(long)]
+        nodes: bool,
+
+        /// Show only databases information
+        #[arg(long)]
+        databases: bool,
+
+        /// Show only shards information
+        #[arg(long)]
+        shards: bool,
+    },
+
     /// Support package generation for troubleshooting
     #[command(subcommand, name = "support-package")]
     SupportPackage(crate::commands::enterprise::support_package::SupportPackageCommands),
 
@@ -35,6 +35,7 @@ pub mod rbac_impl;
 pub mod services;
 pub mod shard;
 pub mod stats;
+pub mod status;
 pub mod suffix;
 pub mod support_package;
 pub mod usage_report;
 
@@ -0,0 +1,220 @@
+//! Comprehensive status command implementation for Redis Enterprise
+//!
+//! Provides a single command to view cluster, nodes, databases, and shards status,
+//! similar to `rladmin status extra all`.
+
+use crate::cli::OutputFormat;
+use crate::connection::ConnectionManager;
+use crate::error::Result as CliResult;
+use anyhow::Context;
+use redis_enterprise::bdb::BdbHandler;
+use redis_enterprise::cluster::ClusterHandler;
+use redis_enterprise::nodes::NodeHandler;
+use redis_enterprise::shards::ShardHandler;
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use super::utils::*;
+
+/// Comprehensive cluster status information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(dead_code)]
+pub struct ClusterStatus {
+    /// Cluster information
+    pub cluster: Value,
+    /// List of nodes
+    pub nodes: Value,
+    /// List of databases
+    pub databases: Value,
+    /// List of shards
+    pub shards: Value,
+    /// Summary statistics
+    pub summary: StatusSummary,
+}
+
+/// Summary statistics for cluster health
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(dead_code)]
+pub struct StatusSummary {
+    /// Total number of nodes
+    pub total_nodes: usize,
+    /// Number of healthy nodes
+    pub healthy_nodes: usize,
+    /// Total number of databases
+    pub total_databases: usize,
+    /// Number of active databases
+    pub active_databases: usize,
+    /// Total number of shards
+    pub total_shards: usize,
+    /// Cluster health status
+    pub cluster_health: String,
+}
+
+/// Sections to display in status output
+#[derive(Debug, Clone, Default)]
+#[allow(dead_code)]
+pub struct StatusSections {
+    /// Show cluster information
+    pub cluster: bool,
+    /// Show nodes information
+    pub nodes: bool,
+    /// Show databases information
+    pub databases: bool,
+    /// Show shards information
+    pub shards: bool,
+}
+
+impl StatusSections {
+    /// Create sections showing all information
+    #[allow(dead_code)]
+    pub fn all() -> Self {
+        Self {
+            cluster: true,
+            nodes: true,
+            databases: true,
+            shards: true,
+        }
+    }
+
+    /// Check if any section is enabled
+    #[allow(dead_code)]
+    pub fn any_enabled(&self) -> bool {
+        self.cluster || self.nodes || self.databases || self.shards
+    }
+}
+
+/// Get comprehensive cluster status
+#[allow(dead_code)]
+pub async fn get_status(
+    conn_mgr: &ConnectionManager,
+    profile_name: Option<&str>,
+    sections: StatusSections,
+    output_format: OutputFormat,
+    query: Option<&str>,
+) -> CliResult<()> {
+    let client = conn_mgr.create_enterprise_client(profile_name).await?;
+
+    // Use provided sections, or default to all if none specified
+    let sections = if sections.any_enabled() {
+        sections
+    } else {
+        StatusSections::all()
+    };
+
+    // Collect cluster info
+    let cluster_result = if sections.cluster {
+        ClusterHandler::new(client.clone())
+            .info()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!({})))
+            .context("Failed to get cluster info")?
+    } else {
+        json!({})
+    };
+
+    // Collect nodes
+    let nodes_result = if sections.nodes {
+        NodeHandler::new(client.clone())
+            .list()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!([])))
+            .context("Failed to list nodes")?
+    } else {
+        json!([])
+    };
+
+    // Collect databases
+    let databases_result = if sections.databases {
+        BdbHandler::new(client.clone())
+            .list()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!([])))
+            .context("Failed to list databases")?
+    } else {
+        json!([])
+    };
+
+    // Collect shards
+    let shards_result = if sections.shards {
+        ShardHandler::new(client.clone())
+            .list()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!([])))
+            .context("Failed to list shards")?
+    } else {
+        json!([])
+    };
+
+    // Calculate summary statistics
+    let summary = calculate_summary(&nodes_result, &databases_result, &shards_result);
+
+    // Build comprehensive status
+    let status = ClusterStatus {
+        cluster: cluster_result,
+        nodes: nodes_result,
+        databases: databases_result,
+        shards: shards_result,
+        summary,
+    };
+
+    let status_json = serde_json::to_value(status).context("Failed to serialize cluster status")?;
+
+    // Apply query if provided
+    let data = handle_output(status_json, output_format, query)?;
+
+    // Format and display
+    print_formatted_output(data, output_format)?;
+
+    Ok(())
+}
+
+/// Calculate summary statistics from collected data
+#[allow(dead_code)]
+fn calculate_summary(nodes: &Value, databases: &Value, shards: &Value) -> StatusSummary {
+    let empty_vec = vec![];
+    let nodes_array = nodes.as_array().unwrap_or(&empty_vec);
+    let databases_array = databases.as_array().unwrap_or(&empty_vec);
+    let shards_array = shards.as_array().unwrap_or(&empty_vec);
+
+    let total_nodes = nodes_array.len();
+    let healthy_nodes = nodes_array
+        .iter()
+        .filter(|n| {
+            n.get("status")
+                .and_then(|s| s.as_str())
+                .map(|s| s == "active" || s == "ok")
+                .unwrap_or(false)
+        })
+        .count();
+
+    let total_databases = databases_array.len();
+    let active_databases = databases_array
+        .iter()
+        .filter(|db| {
+            db.get("status")
+                .and_then(|s| s.as_str())
+                .map(|s| s == "active")
+                .unwrap_or(false)
+        })
+        .count();
+
+    let total_shards = shards_array.len();
+
+    // Determine cluster health
+    let cluster_health = if healthy_nodes == total_nodes && active_databases == total_databases {
+        "healthy".to_string()
+    } else if healthy_nodes == 0 || active_databases == 0 {
+        "critical".to_string()
+    } else {
+        "degraded".to_string()
+    };
+
+    StatusSummary {
+        total_nodes,
+        healthy_nodes,
+        total_databases,
+        active_databases,
+        total_shards,
+        cluster_health,
+    }
+}
@@ -485,6 +485,21 @@ async fn execute_enterprise_command(
             )
             .await
         }
+        Status {
+            cluster,
+            nodes,
+            databases,
+            shards,
+        } => {
+            let sections = commands::enterprise::status::StatusSections {
+                cluster: *cluster,
+                nodes: *nodes,
+                databases: *databases,
+                shards: *shards,
+            };
+            commands::enterprise::status::get_status(conn_mgr, profile, sections, output, query)
+                .await
+        }
         SupportPackage(support_cmd) => {
             commands::enterprise::support_package::handle_support_package_command(
                 conn_mgr,