Merge pull request #391 from joshrotenberg/feat/shard-and-local-commands

feat(enterprise): implement local node commands and expose shard commands

Author: joshrotenberg

crates/redisctl/src/cli.rs

@@ -1133,6 +1133,10 @@ pub enum EnterpriseCommands {
     #[command(subcommand)]
     Workflow(EnterpriseWorkflowCommands),
 
+    /// Local node operations
+    #[command(subcommand)]
+    Local(crate::commands::enterprise::local::LocalCommands),
+
     /// Shard management operations
     #[command(subcommand)]
     Shard(crate::commands::enterprise::shard::ShardCommands),

crates/redisctl/src/commands/enterprise/local.rs

@@ -0,0 +1,96 @@
+use crate::cli::OutputFormat;
+use crate::connection::ConnectionManager;
+use crate::error::{RedisCtlError, Result as CliResult};
+use clap::Subcommand;
+
+#[derive(Debug, Clone, Subcommand)]
+pub enum LocalCommands {
+    /// Get local node master healthcheck
+    #[command(name = "healthcheck")]
+    MasterHealthcheck,
+
+    /// List local services
+    Services,
+
+    /// Update local services configuration
+    #[command(name = "services-update")]
+    ServicesUpdate {
+        /// Service configuration as JSON string or @file.json
+        #[arg(long)]
+        data: String,
+    },
+}
+
+impl LocalCommands {
+    #[allow(dead_code)]
+    pub async fn execute(
+        &self,
+        conn_mgr: &ConnectionManager,
+        profile_name: Option<&str>,
+        output_format: OutputFormat,
+        query: Option<&str>,
+    ) -> CliResult<()> {
+        let client = conn_mgr.create_enterprise_client(profile_name).await?;
+
+        match self {
+            LocalCommands::MasterHealthcheck => {
+                let response: serde_json::Value = client
+                    .get("/v1/local/node/master_healthcheck")
+                    .await
+                    .map_err(RedisCtlError::from)?;
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            LocalCommands::Services => {
+                let response: serde_json::Value = client
+                    .get("/v1/local/services")
+                    .await
+                    .map_err(RedisCtlError::from)?;
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            LocalCommands::ServicesUpdate { data } => {
+                let json_data = super::utils::read_json_data(data)?;
+
+                let response: serde_json::Value = client
+                    .post("/v1/local/services", &json_data)
+                    .await
+                    .map_err(RedisCtlError::from)?;
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[allow(dead_code)]
+pub async fn handle_local_command(
+    conn_mgr: &ConnectionManager,
+    profile_name: Option<&str>,
+    local_cmd: LocalCommands,
+    output_format: OutputFormat,
+    query: Option<&str>,
+) -> CliResult<()> {
+    local_cmd
+        .execute(conn_mgr, profile_name, output_format, query)
+        .await
+}

crates/redisctl/src/commands/enterprise/mod.rs

@@ -20,6 +20,7 @@ pub mod jsonschema;
 pub mod ldap;
 pub mod license;
 pub mod license_workflow;
+pub mod local;
 pub mod logs;
 pub mod logs_impl;
 pub mod migration;

crates/redisctl/src/main.rs

@@ -436,6 +436,16 @@ async fn execute_enterprise_command(
         Workflow(workflow_cmd) => {
             handle_enterprise_workflow_command(conn_mgr, profile, workflow_cmd, output).await
         }
+        Local(local_cmd) => {
+            commands::enterprise::local::handle_local_command(
+                conn_mgr,
+                profile,
+                local_cmd.clone(),
+                output,
+                query,
+            )
+            .await
+        }
         Shard(shard_cmd) => {
             commands::enterprise::shard::handle_shard_command(
                 conn_mgr,