feat(mcp): add VPC Peering, Cloud Accounts, and CRDB Tasks tools (#560)

Add 9 new MCP tools:

Cloud:
- cloud_vpc_peerings_get: Get VPC peerings for a subscription
- cloud_vpc_peering_delete: Delete a VPC peering
- cloud_accounts_list: List all cloud accounts
- cloud_account_get_by_id: Get a specific cloud account
- cloud_account_delete: Delete a cloud account

Enterprise:
- enterprise_crdb_tasks_list: List all CRDB tasks
- enterprise_crdb_task_get: Get a specific CRDB task
- enterprise_crdb_tasks_by_crdb: List CRDB tasks by CRDB GUID
- enterprise_crdb_task_cancel: Cancel a CRDB task

Author: joshrotenberg

crates/redisctl-mcp/src/cloud_tools.rs

@@ -4,8 +4,8 @@
 
 use redis_cloud::fixed::subscriptions::FixedSubscriptionCreateRequest;
 use redis_cloud::{
-    AccountHandler, CloudClient, DatabaseHandler, FixedDatabaseHandler, FixedSubscriptionHandler,
-    SubscriptionHandler, TaskHandler,
+    AccountHandler, CloudAccountHandler, CloudClient, DatabaseHandler, FixedDatabaseHandler,
+    FixedSubscriptionHandler, SubscriptionHandler, TaskHandler, VpcPeeringHandler,
 };
 use redisctl_config::Config;
 use rmcp::{ErrorData as RmcpError, model::*};
@@ -322,4 +322,72 @@ impl CloudTools {
             .map_err(|e| self.to_error(e))?;
         self.to_result(serde_json::to_value(result).map_err(|e| self.to_error(e))?)
     }
+
+    // =========================================================================
+    // VPC Peering Operations
+    // =========================================================================
+
+    /// Get VPC peerings for a subscription
+    pub async fn get_vpc_peerings(
+        &self,
+        subscription_id: i64,
+    ) -> Result<CallToolResult, RmcpError> {
+        let handler = VpcPeeringHandler::new(self.client.clone());
+        let peerings = handler
+            .get(subscription_id as i32)
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(peerings).map_err(|e| self.to_error(e))?)
+    }
+
+    /// Delete a VPC peering
+    pub async fn delete_vpc_peering(
+        &self,
+        subscription_id: i64,
+        peering_id: i64,
+    ) -> Result<CallToolResult, RmcpError> {
+        let handler = VpcPeeringHandler::new(self.client.clone());
+        handler
+            .delete(subscription_id as i32, peering_id as i32)
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::json!({
+            "success": true,
+            "message": format!("VPC peering {} deleted from subscription {}", peering_id, subscription_id)
+        }))
+    }
+
+    // =========================================================================
+    // Cloud Account Operations
+    // =========================================================================
+
+    /// List all cloud accounts
+    pub async fn list_cloud_accounts(&self) -> Result<CallToolResult, RmcpError> {
+        let handler = CloudAccountHandler::new(self.client.clone());
+        let accounts = handler
+            .get_cloud_accounts()
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(accounts).map_err(|e| self.to_error(e))?)
+    }
+
+    /// Get a specific cloud account
+    pub async fn get_cloud_account(&self, account_id: i64) -> Result<CallToolResult, RmcpError> {
+        let handler = CloudAccountHandler::new(self.client.clone());
+        let account = handler
+            .get_cloud_account_by_id(account_id as i32)
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(account).map_err(|e| self.to_error(e))?)
+    }
+
+    /// Delete a cloud account
+    pub async fn delete_cloud_account(&self, account_id: i64) -> Result<CallToolResult, RmcpError> {
+        let handler = CloudAccountHandler::new(self.client.clone());
+        let result = handler
+            .delete_cloud_account(account_id as i32)
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(result).map_err(|e| self.to_error(e))?)
+    }
 }

crates/redisctl-mcp/src/enterprise_tools.rs

@@ -3,7 +3,7 @@
 //! Wraps Redis Enterprise API client operations for MCP tool invocation.
 
 use redis_enterprise::{
-    AlertHandler, BdbHandler, ClusterHandler, CrdbHandler, CreateDatabaseRequest,
+    AlertHandler, BdbHandler, ClusterHandler, CrdbHandler, CrdbTasksHandler, CreateDatabaseRequest,
     CreateLdapMappingRequest, CreateRedisAclRequest, CreateRoleRequest, CreateUserRequest,
     DebugInfoHandler, DiagnosticRequest, DiagnosticsHandler, EndpointsHandler, EnterpriseClient,
     JobSchedulerHandler, LdapMappingHandler, LicenseHandler, LogsHandler, ModuleHandler,
@@ -853,4 +853,48 @@ impl EnterpriseTools {
         let report = handler.run(request).await.map_err(|e| self.to_error(e))?;
         self.to_result(serde_json::to_value(report).map_err(|e| self.to_error(e))?)
     }
+
+    // =========================================================================
+    // CRDB Task Operations
+    // =========================================================================
+
+    /// List all CRDB tasks
+    pub async fn list_crdb_tasks(&self) -> Result<CallToolResult, RmcpError> {
+        let handler = CrdbTasksHandler::new(self.client.clone());
+        let tasks = handler.list().await.map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(tasks).map_err(|e| self.to_error(e))?)
+    }
+
+    /// Get a specific CRDB task
+    pub async fn get_crdb_task(&self, task_id: &str) -> Result<CallToolResult, RmcpError> {
+        let handler = CrdbTasksHandler::new(self.client.clone());
+        let task = handler.get(task_id).await.map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(task).map_err(|e| self.to_error(e))?)
+    }
+
+    /// List CRDB tasks for a specific Active-Active database
+    pub async fn list_crdb_tasks_by_crdb(
+        &self,
+        crdb_guid: &str,
+    ) -> Result<CallToolResult, RmcpError> {
+        let handler = CrdbTasksHandler::new(self.client.clone());
+        let tasks = handler
+            .list_by_crdb(crdb_guid)
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::to_value(tasks).map_err(|e| self.to_error(e))?)
+    }
+
+    /// Cancel a CRDB task
+    pub async fn cancel_crdb_task(&self, task_id: &str) -> Result<CallToolResult, RmcpError> {
+        let handler = CrdbTasksHandler::new(self.client.clone());
+        handler
+            .cancel(task_id)
+            .await
+            .map_err(|e| self.to_error(e))?;
+        self.to_result(serde_json::json!({
+            "success": true,
+            "message": format!("CRDB task {} cancelled", task_id)
+        }))
+    }
 }

crates/redisctl-mcp/src/server.rs

@@ -337,6 +337,32 @@ pub struct EssentialsDatabaseIdParam {
     pub database_id: i64,
 }
 
+// Cloud - VPC Peering parameter structs
+
+#[derive(Debug, Deserialize, schemars::JsonSchema)]
+pub struct VpcPeeringIdParam {
+    /// The subscription ID
+    pub subscription_id: i64,
+    /// The VPC peering ID
+    pub peering_id: i64,
+}
+
+// Cloud - Cloud Account parameter structs
+
+#[derive(Debug, Deserialize, schemars::JsonSchema)]
+pub struct CloudAccountIdParam {
+    /// The cloud account ID
+    pub account_id: i64,
+}
+
+// Enterprise - CRDB Task parameter structs
+
+#[derive(Debug, Deserialize, schemars::JsonSchema)]
+pub struct CrdbTaskIdParam {
+    /// The CRDB task ID
+    pub task_id: String,
+}
+
 impl RedisCtlMcp {
     /// Create a new MCP server instance
     pub fn new(profile: Option<&str>, read_only: bool) -> anyhow::Result<Self> {
@@ -1809,6 +1835,143 @@ impl RedisCtlMcp {
             .delete_essentials_database(params.subscription_id, params.database_id)
             .await
     }
+
+    // =========================================================================
+    // Cloud Tools - VPC Peering Operations
+    // =========================================================================
+
+    #[tool(description = "Get VPC peerings for a subscription")]
+    async fn cloud_vpc_peerings_get(
+        &self,
+        Parameters(params): Parameters<SubscriptionIdParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(
+            subscription_id = params.subscription_id,
+            "Tool called: cloud_vpc_peerings_get"
+        );
+        let tools = self.get_cloud_tools().await?;
+        tools.get_vpc_peerings(params.subscription_id).await
+    }
+
+    #[tool(description = "Delete a VPC peering. This is a destructive operation.")]
+    async fn cloud_vpc_peering_delete(
+        &self,
+        Parameters(params): Parameters<VpcPeeringIdParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(
+            subscription_id = params.subscription_id,
+            peering_id = params.peering_id,
+            "Tool called: cloud_vpc_peering_delete"
+        );
+
+        if self.config.read_only {
+            return Err(RmcpError::invalid_request(
+                "Server is in read-only mode. Use --allow-writes to enable write operations.",
+                None,
+            ));
+        }
+
+        let tools = self.get_cloud_tools().await?;
+        tools
+            .delete_vpc_peering(params.subscription_id, params.peering_id)
+            .await
+    }
+
+    // =========================================================================
+    // Cloud Tools - Cloud Account Operations
+    // =========================================================================
+
+    #[tool(
+        description = "List all cloud provider accounts (AWS, GCP, Azure) configured in your Redis Cloud account"
+    )]
+    async fn cloud_accounts_list(&self) -> Result<CallToolResult, RmcpError> {
+        info!("Tool called: cloud_accounts_list");
+        let tools = self.get_cloud_tools().await?;
+        tools.list_cloud_accounts().await
+    }
+
+    #[tool(description = "Get detailed information about a specific cloud provider account")]
+    async fn cloud_account_get_by_id(
+        &self,
+        Parameters(params): Parameters<CloudAccountIdParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(
+            account_id = params.account_id,
+            "Tool called: cloud_account_get_by_id"
+        );
+        let tools = self.get_cloud_tools().await?;
+        tools.get_cloud_account(params.account_id).await
+    }
+
+    #[tool(description = "Delete a cloud provider account. This is a destructive operation.")]
+    async fn cloud_account_delete(
+        &self,
+        Parameters(params): Parameters<CloudAccountIdParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(
+            account_id = params.account_id,
+            "Tool called: cloud_account_delete"
+        );
+
+        if self.config.read_only {
+            return Err(RmcpError::invalid_request(
+                "Server is in read-only mode. Use --allow-writes to enable write operations.",
+                None,
+            ));
+        }
+
+        let tools = self.get_cloud_tools().await?;
+        tools.delete_cloud_account(params.account_id).await
+    }
+
+    // =========================================================================
+    // Enterprise Tools - CRDB Task Operations
+    // =========================================================================
+
+    #[tool(description = "List all Active-Active (CRDB) tasks in the Redis Enterprise cluster")]
+    async fn enterprise_crdb_tasks_list(&self) -> Result<CallToolResult, RmcpError> {
+        info!("Tool called: enterprise_crdb_tasks_list");
+        let tools = self.get_enterprise_tools().await?;
+        tools.list_crdb_tasks().await
+    }
+
+    #[tool(description = "Get detailed information about a specific CRDB task")]
+    async fn enterprise_crdb_task_get(
+        &self,
+        Parameters(params): Parameters<CrdbTaskIdParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(task_id = %params.task_id, "Tool called: enterprise_crdb_task_get");
+        let tools = self.get_enterprise_tools().await?;
+        tools.get_crdb_task(&params.task_id).await
+    }
+
+    #[tool(description = "List CRDB tasks for a specific Active-Active database")]
+    async fn enterprise_crdb_tasks_by_crdb(
+        &self,
+        Parameters(params): Parameters<CrdbGuidParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(crdb_guid = %params.crdb_guid, "Tool called: enterprise_crdb_tasks_by_crdb");
+        let tools = self.get_enterprise_tools().await?;
+        tools.list_crdb_tasks_by_crdb(&params.crdb_guid).await
+    }
+
+    #[tool(description = "Cancel a CRDB task")]
+    async fn enterprise_crdb_task_cancel(
+        &self,
+        Parameters(params): Parameters<CrdbTaskIdParam>,
+    ) -> Result<CallToolResult, RmcpError> {
+        info!(task_id = %params.task_id, "Tool called: enterprise_crdb_task_cancel");
+
+        if self.config.read_only {
+            return Err(RmcpError::invalid_request(
+                "Server is in read-only mode. Use --allow-writes to enable write operations.",
+                None,
+            ));
+        }
+
+        let tools = self.get_enterprise_tools().await?;
+        tools.cancel_crdb_task(&params.task_id).await
+    }
 }
 
 #[tool_handler]