feat: implement workflow system with enterprise init-cluster workflow (#261)

* feat: implement workflow system with init-cluster workflow

- Add workflow trait and registry system for multi-step operations
- Implement enterprise init-cluster workflow for cluster bootstrapping
- Add CLI commands for listing and running workflows
- Support async operations with progress indicators
- Include optional database creation after cluster init

This provides a foundation for automating complex multi-step operations
that require multiple API calls, waiting, and conditional logic.

Part of #260

* fix: address clippy warnings in workflow implementation

- Add #[allow(dead_code)] for fields/methods that will be used in future workflows
- Collapse nested if statement in wait_for_cluster_ready function
- All clippy checks now pass with --all-targets --all-features

* fix: update init-cluster workflow with correct bootstrap endpoint and simplified flow

- Use correct /v1/bootstrap/create_cluster endpoint with proper payload structure
- Fix JSON payload format with cluster, credentials, and flash_enabled fields
- Simplify cluster ready check to avoid authentication issues
- Change create_database flag to skip_database for better UX
- Add #[allow(dead_code)] for unused wait_for_cluster_ready function

Successfully tested against Redis Enterprise Docker container - workflow completes and creates cluster

* feat(docker): add docker-compose setup with init service placeholder

- Add Redis Enterprise container with proper configuration
- Include redis-enterprise-init service (commented for future Docker image)
- Create docker-init.sh script for host-based initialization
- Document architecture mismatch issue and workaround

* fix(workflows): remove unused function and fix CLI argument documentation

- Remove unused wait_for_cluster_ready function
- Fix command documentation (--name not --cluster-name)
- Workflow now works correctly with proper argument names

* feat(workflows): add structured output support and remove emojis

- Remove all emojis from workflow output for professional appearance
- Add JSON/YAML output support for programmatic use
- Human-readable output only shown for Table format
- Add AsyncOperationArgs to workflow commands for consistent --wait pattern
- Support JSON/YAML output for workflow list command
- Pass wait_timeout through workflow context for future use
- Test with fresh Docker containers shows all formats working correctly

* feat(enterprise): add Redis command execution via REST API

- Add execute_command method to Enterprise client using /v1/bdbs/{uid}/command endpoint
- Integrate PING command in workflow to verify database connectivity
- Handle both boolean and string responses from command endpoint
- Keep feature undocumented as it's an internal capability

* fix(workflows): create authenticated client after bootstrap for database operations

- Create new authenticated client with bootstrap credentials for database operations
- Remove unsupported 'persistence' field from database creation payload
- Increase stabilization wait time from 5 to 10 seconds after bootstrap
- Successfully tested full workflow: bootstrap → database creation → PING verification

* chore: remove docker-init.sh script

Script is no longer needed as the workflow can be run directly from the host

* docs: add comprehensive workflow documentation

- Add enterprise/workflows.md with detailed init-cluster documentation
- Add features/workflows.md explaining workflow architecture and patterns
- Update SUMMARY.md with workflow sections
- Add workflow example to quickstart guide
- Update enterprise overview to mention workflows
- Document all workflow parameters, output formats, and error handling
- Include Docker development examples and CI/CD integration

* feat(docker): use standard Redis Enterprise image with environment configuration

- Replace hardcoded kurtfm/rs-arm:latest with configurable image via environment variables
- Add REDIS_ENTERPRISE_IMAGE and REDIS_ENTERPRISE_PLATFORM environment variables
- Default to standard redislabs/redis:latest image for Intel/AMD systems
- Provide .env.example with configuration for ARM64 (Apple Silicon) systems
- Update documentation to explain environment-based configuration
- Maintain backwards compatibility with ARM Macs through .env configuration

* chore: remove references to non-public Docker image

- Remove kurtfm image references from .env.example
- Update documentation to reference ARM64-compatible images generically
- Users can set their own ARM64 image via environment variables

* fix: resolve CI failures - clippy and dead code warnings

- Add #[allow(dead_code)] for wait_timeout field (will be used by future workflows)
- Fix collapsible else-if warning
- Fix collapsible if statement warning
- Remove needless borrow in print_output call

Author: joshrotenberg

.env.example

@@ -0,0 +1,14 @@
+# Docker Compose environment variables for Redis Enterprise
+
+# Redis Enterprise Docker image
+# Default: redislabs/redis:latest
+REDIS_ENTERPRISE_IMAGE=redislabs/redis:latest
+
+# Docker platform
+# Default: linux/amd64
+# For ARM64 (Apple Silicon): linux/arm64
+REDIS_ENTERPRISE_PLATFORM=linux/amd64
+
+# Note: For ARM64 systems (Apple Silicon Macs), you'll need to:
+# 1. Use an ARM64-compatible Redis Enterprise image
+# 2. Set REDIS_ENTERPRISE_PLATFORM=linux/arm64

crates/redis-enterprise/src/client.rs

@@ -478,4 +478,26 @@ impl EnterpriseClient {
             }
         }
     }
+
+    /// Execute a Redis command on a specific database (internal use only)
+    /// This uses the /v1/bdbs/{uid}/command endpoint which may not be publicly documented
+    pub async fn execute_command(&self, db_uid: u32, command: &str) -> Result<serde_json::Value> {
+        let url = format!("{}/v1/bdbs/{}/command", self.base_url, db_uid);
+        let body = serde_json::json!({
+            "command": command
+        });
+
+        debug!("Executing command on database {}: {}", db_uid, command);
+
+        let response = self
+            .client
+            .post(&url)
+            .basic_auth(&self.username, Some(&self.password))
+            .json(&body)
+            .send()
+            .await
+            .map_err(|e| self.map_reqwest_error(e, &url))?;
+
+        self.handle_response(response).await
+    }
 }

crates/redisctl/src/cli.rs

@@ -1000,11 +1000,54 @@ pub enum EnterpriseCommands {
     #[command(subcommand)]
     Module(crate::commands::enterprise::module::ModuleCommands),
 
+    /// Workflow operations for multi-step tasks
+    #[command(subcommand)]
+    Workflow(EnterpriseWorkflowCommands),
+
     /// Statistics and metrics operations
     #[command(subcommand)]
     Stats(EnterpriseStatsCommands),
 }
 
+/// Enterprise workflow commands
+#[derive(Debug, Subcommand)]
+pub enum EnterpriseWorkflowCommands {
+    /// List available workflows
+    List,
+
+    /// Initialize a Redis Enterprise cluster
+    #[command(name = "init-cluster")]
+    InitCluster {
+        /// Cluster name
+        #[arg(long, default_value = "redis-cluster")]
+        name: String,
+
+        /// Admin username
+        #[arg(long, default_value = "admin@redis.local")]
+        username: String,
+
+        /// Admin password (required)
+        #[arg(long, env = "REDIS_ENTERPRISE_INIT_PASSWORD")]
+        password: String,
+
+        /// Skip creating a default database after initialization
+        #[arg(long)]
+        skip_database: bool,
+
+        /// Name for the default database
+        #[arg(long, default_value = "default-db")]
+        database_name: String,
+
+        /// Memory size for the default database in GB
+        #[arg(long, default_value = "1")]
+        database_memory_gb: i64,
+
+        /// Async operation options
+        #[command(flatten)]
+        async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
+    },
+}
+
 // Placeholder command structures - will be expanded in later PRs
 
 #[derive(Subcommand, Debug)]

crates/redisctl/src/connection.rs

@@ -7,6 +7,7 @@ use tracing::{debug, info, trace};
 
 /// Connection manager for creating authenticated clients
 #[allow(dead_code)] // Used by binary target
+#[derive(Clone)]
 pub struct ConnectionManager {
     pub config: Config,
 }

crates/redisctl/src/main.rs

@@ -10,6 +10,7 @@ mod config;
 mod connection;
 mod error;
 mod output;
+mod workflows;
 
 use cli::{Cli, Commands};
 use config::Config;
@@ -255,6 +256,9 @@ async fn execute_enterprise_command(
             )
             .await
         }
+        Workflow(workflow_cmd) => {
+            handle_enterprise_workflow_command(conn_mgr, profile, workflow_cmd, output).await
+        }
         Stats(stats_cmd) => {
             commands::enterprise::stats::handle_stats_command(
                 conn_mgr, profile, stats_cmd, output, query,
@@ -264,6 +268,127 @@ async fn execute_enterprise_command(
     }
 }
 
+async fn handle_enterprise_workflow_command(
+    conn_mgr: &ConnectionManager,
+    profile: Option<&str>,
+    workflow_cmd: &cli::EnterpriseWorkflowCommands,
+    output: cli::OutputFormat,
+) -> Result<(), RedisCtlError> {
+    use cli::EnterpriseWorkflowCommands::*;
+    use workflows::{WorkflowArgs, WorkflowContext, WorkflowRegistry};
+
+    match workflow_cmd {
+        List => {
+            let registry = WorkflowRegistry::new();
+            let workflows = registry.list();
+
+            match output {
+                cli::OutputFormat::Json | cli::OutputFormat::Yaml => {
+                    let workflow_list: Vec<serde_json::Value> = 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 Enterprise Workflows:");
+                    println!();
+                    for (name, description) in workflows {
+                        println!("  {} - {}", name, description);
+                    }
+                }
+            }
+            Ok(())
+        }
+        InitCluster {
+            name,
+            username,
+            password,
+            skip_database,
+            database_name,
+            database_memory_gb,
+            async_ops,
+        } => {
+            let mut args = WorkflowArgs::new();
+            args.insert("name", name);
+            args.insert("username", username);
+            args.insert("password", password);
+            args.insert("create_database", !skip_database);
+            args.insert("database_name", database_name);
+            args.insert("database_memory_gb", database_memory_gb);
+
+            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: if async_ops.wait {
+                    async_ops.wait_timeout
+                } else {
+                    0
+                },
+            };
+
+            let registry = WorkflowRegistry::new();
+            let workflow = registry
+                .get("init-cluster")
+                .ok_or_else(|| RedisCtlError::ApiError {
+                    message: "Workflow not found".to_string(),
+                })?;
+
+            let result =
+                workflow
+                    .execute(context, 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 was already printed by the workflow
+                }
+            }
+
+            Ok(())
+        }
+    }
+}
+
 async fn execute_profile_command(
     profile_cmd: &cli::ProfileCommands,
     conn_mgr: &ConnectionManager,