feat(workflows): add subscription setup workflow for Redis Cloud (#269)

* feat(workflows): add subscription setup workflow for Redis Cloud

- Implement SubscriptionSetupWorkflow to automate subscription creation
- Support database creation with modules, HA, and persistence options
- Add async operation handling with progress indicators
- Include dry-run mode for preview without execution
- Support JSON/YAML output formats for automation
- Add comprehensive documentation

Closes #262

* fix: resolve clippy warnings

- Allow dead_code for workflow module (will be used by more workflows)
- Fix collapsible if statement in subscription_setup

Author: joshrotenberg

crates/redisctl/src/cli.rs

@@ -951,6 +951,9 @@ pub enum CloudCommands {
     /// Fixed subscription operations
     #[command(subcommand, name = "fixed-subscription")]
     FixedSubscription(CloudFixedSubscriptionCommands),
+    /// Workflow operations for multi-step tasks
+    #[command(subcommand)]
+    Workflow(CloudWorkflowCommands),
 }
 
 /// Enterprise-specific commands (placeholder for now)
@@ -1009,6 +1012,16 @@ pub enum EnterpriseCommands {
     Stats(EnterpriseStatsCommands),
 }
 
+/// Cloud workflow commands
+#[derive(Debug, Subcommand)]
+pub enum CloudWorkflowCommands {
+    /// List available workflows
+    List,
+    /// Complete subscription setup with optional database
+    #[command(name = "subscription-setup")]
+    SubscriptionSetup(crate::workflows::cloud::subscription_setup::SubscriptionSetupArgs),
+}
+
 /// Enterprise workflow commands
 #[derive(Debug, Subcommand)]
 pub enum EnterpriseWorkflowCommands {

crates/redisctl/src/lib.rs

@@ -87,3 +87,4 @@ pub(crate) mod config;
 pub(crate) mod connection;
 pub(crate) mod error;
 pub(crate) mod output;
+pub(crate) mod workflows;

crates/redisctl/src/main.rs

@@ -268,6 +268,119 @@ async fn execute_enterprise_command(
     }
 }
 
+async fn handle_cloud_workflow_command(
+    conn_mgr: &ConnectionManager,
+    cli: &cli::Cli,
+    workflow_cmd: &cli::CloudWorkflowCommands,
+) -> Result<(), RedisCtlError> {
+    use cli::CloudWorkflowCommands::*;
+    use workflows::{WorkflowArgs, WorkflowContext, WorkflowRegistry};
+
+    let output = cli.output;
+    let profile = cli.profile.as_deref();
+
+    match workflow_cmd {
+        List => {
+            let registry = WorkflowRegistry::new();
+            let workflows = registry.list();
+
+            // Filter to show only cloud workflows
+            let cloud_workflows: Vec<_> = workflows
+                .into_iter()
+                .filter(|(name, _)| name.contains("subscription") || name.contains("cloud"))
+                .collect();
+
+            match output {
+                cli::OutputFormat::Json | cli::OutputFormat::Yaml => {
+                    let workflow_list: Vec<serde_json::Value> = cloud_workflows
+                        .into_iter()
+                        .map(|(name, description)| {
+                            serde_json::json!({
+                                "name": name,
+                                "description": description
+                            })
+                        })
+                        .collect();
+                    let output_format = match output {
+                        cli::OutputFormat::Json => output::OutputFormat::Json,
+                        cli::OutputFormat::Yaml => output::OutputFormat::Yaml,
+                        _ => output::OutputFormat::Table,
+                    };
+                    crate::output::print_output(
+                        serde_json::json!(workflow_list),
+                        output_format,
+                        None,
+                    )?;
+                }
+                _ => {
+                    println!("Available Cloud Workflows:");
+                    println!();
+                    for (name, description) in cloud_workflows {
+                        println!("  {} - {}", name, description);
+                    }
+                }
+            }
+            Ok(())
+        }
+        SubscriptionSetup(args) => {
+            let mut workflow_args = WorkflowArgs::new();
+            workflow_args.insert("args", args);
+
+            let output_format = match output {
+                cli::OutputFormat::Json => output::OutputFormat::Json,
+                cli::OutputFormat::Yaml => output::OutputFormat::Yaml,
+                cli::OutputFormat::Table | cli::OutputFormat::Auto => output::OutputFormat::Table,
+            };
+
+            let context = WorkflowContext {
+                conn_mgr: conn_mgr.clone(),
+                profile_name: profile.map(String::from),
+                output_format,
+                wait_timeout: args.wait_timeout as u64,
+            };
+
+            let registry = WorkflowRegistry::new();
+            let workflow =
+                registry
+                    .get("subscription-setup")
+                    .ok_or_else(|| RedisCtlError::ApiError {
+                        message: "Workflow not found".to_string(),
+                    })?;
+
+            let result = workflow
+                .execute(context, workflow_args)
+                .await
+                .map_err(|e| RedisCtlError::ApiError {
+                    message: e.to_string(),
+                })?;
+
+            if !result.success {
+                return Err(RedisCtlError::ApiError {
+                    message: result.message,
+                });
+            }
+
+            // Print result as JSON/YAML if requested
+            match output {
+                cli::OutputFormat::Json | cli::OutputFormat::Yaml => {
+                    let result_json = serde_json::json!({
+                        "success": result.success,
+                        "message": result.message,
+                        "outputs": result.outputs,
+                    });
+                    crate::output::print_output(&result_json, output_format, None)?;
+                }
+                _ => {
+                    // Human output
+                    println!("{}", result.message);
+                }
+            }
+
+            Ok(())
+        }
+    }
+}
+
 async fn handle_enterprise_workflow_command(
     conn_mgr: &ConnectionManager,
     profile: Option<&str>,
@@ -817,5 +930,6 @@ async fn execute_cloud_command(
             )
             .await
         }
+        Workflow(workflow_cmd) => handle_cloud_workflow_command(conn_mgr, cli, workflow_cmd).await,
     }
 }

crates/redisctl/src/output.rs

@@ -19,6 +19,16 @@ impl Default for OutputFormat {
     }
 }
 
+impl OutputFormat {
+    pub fn is_json(&self) -> bool {
+        matches!(self, Self::Json)
+    }
+
+    pub fn is_yaml(&self) -> bool {
+        matches!(self, Self::Yaml)
+    }
+}
+
 pub fn print_output<T: Serialize>(
     data: T,
     format: OutputFormat,

crates/redisctl/src/workflows/cloud/mod.rs

@@ -0,0 +1 @@
+pub mod subscription_setup;