feat(cli): Add Podman Support (#697)

## Description
Adds Podman container runtime support as an alternative to Docker. Users
can now configure `container_runtime = "podman"` in `helix.toml` to use
Podman for deployments.

**Changes:**
- Added `ContainerRuntime` enum (`Docker`/`Podman`) in `config.rs`
- Updated `DockerManager` to use runtime from project config
- Added auto-start daemon functionality for both runtimes
(macOS/Linux/Windows)
- Renamed `check_docker_available()` to `check_runtime_available()` with
runtime-agnostic logic
- Updated all CLI commands to support both container runtimes

## Related Issues
Closes #653


## Checklist when merging to main


- [x] No compiler warnings (if applicable)
- [x] Code is formatted with `rustfmt`
- [x] No useless or dead code (if applicable)
- [x] Code is easy to understand
- [x] Doc comments are used for all functions, enums, structs, and
fields (where appropriate)
- [x] All tests pass
- [ ] Performance has not regressed (assuming change was not to fix a
bug)
- [ ] Version number has been updated in `helix-cli/Cargo.toml` and
`helixdb/Cargo.toml`

## Additional Notes
<!-- Add any additional information that would be helpful for reviewers
-->

<!-- greptile_comment -->

<h3>Greptile Summary</h3>


- Adds Podman container runtime support as an alternative to Docker by
introducing a `ContainerRuntime` enum and updating `DockerManager` to
use configured runtime from project settings
- Implements comprehensive cross-platform daemon auto-start
functionality for both Docker and Podman across macOS/Linux/Windows with
platform-specific handling
- Refactors all CLI commands to use runtime-agnostic container
availability checks replacing hardcoded Docker dependencies

<details><summary><h3>Important Files Changed</h3></summary>


| Filename | Overview |
|----------|----------|
| `helix-cli/src/config.rs` | Added `ContainerRuntime` enum and
integration into project config with Docker as default for backward
compatibility |
| `helix-cli/src/docker.rs` | Major refactoring to support both Docker
and Podman with platform-specific daemon management and runtime-agnostic
operations |
| `helix-cli/src/commands/status.rs` | Updated to use configurable
runtime but still displays "Docker Status" label regardless of runtime
choice - potential UX inconsistency |
</details>


<!-- greptile_other_comments_section -->

**Context used:**

- Context from `dashboard` - Main documentation for all of HelixDB, the
SDKs, HelixQL, and the Helix CLI
([source](https://app.greptile.com/review/custom-context?memory=861865e1-0cf9-4602-a499-40c0c360142c))
- Context from `dashboard` - readme for helixdb
([source](https://app.greptile.com/review/custom-context?memory=128beba4-b562-4fe4-b7ba-aef1f5b3f204))

<!-- /greptile_comment -->

Author: xav-db

helix-cli/src/commands/add.rs

@@ -67,16 +67,20 @@ async fn run_add_inner(
             let helix_manager = HelixManager::new(&project_context);
 
             // Create cloud instance configuration
-            let cloud_config = helix_manager.create_instance_config(&instance_name, region).await?;
+            let cloud_config = helix_manager
+                .create_instance_config(&instance_name, region)
+                .await?;
 
             // Initialize the cloud cluster
-            helix_manager.init_cluster(&instance_name, &cloud_config).await?;
+            helix_manager
+                .init_cluster(&instance_name, &cloud_config)
+                .await?;
 
             // Insert into project configuration
-            project_context
-                .config
-                .cloud
-                .insert(instance_name.clone(), CloudConfig::Helix(cloud_config.clone()));
+            project_context.config.cloud.insert(
+                instance_name.clone(),
+                CloudConfig::Helix(cloud_config.clone()),
+            );
 
             print_status("CLOUD", "Helix cloud instance configuration added");
         }
@@ -95,7 +99,9 @@ async fn run_add_inner(
                 .await?;
 
             // Initialize the ECR repository
-            ecr_manager.init_repository(&instance_name, &ecr_config).await?;
+            ecr_manager
+                .init_repository(&instance_name, &ecr_config)
+                .await?;
 
             // Save configuration to ecr.toml
             ecr_manager.save_config(&instance_name, &ecr_config).await?;
@@ -135,12 +141,14 @@ async fn run_add_inner(
             );
 
             // Initialize the Fly.io app
-            fly_manager.init_app(&instance_name, &instance_config).await?;
+            fly_manager
+                .init_app(&instance_name, &instance_config)
+                .await?;
 
-            project_context
-                .config
-                .cloud
-                .insert(instance_name.clone(), CloudConfig::FlyIo(instance_config.clone()));
+            project_context.config.cloud.insert(
+                instance_name.clone(),
+                CloudConfig::FlyIo(instance_config.clone()),
+            );
         }
         _ => {
             // Add local instance with default configuration

helix-cli/src/commands/build.rs

@@ -86,8 +86,10 @@ pub async fn run(instance_name: String, metrics_sender: &MetricsSender) -> Resul
 
     // For local instances, build Docker image
     if instance_config.should_build_docker_image() {
+        let runtime = project.config.project.container_runtime;
+        DockerManager::check_runtime_available(runtime)?;
         let docker = DockerManager::new(&project);
-        DockerManager::check_docker_available()?;
+
         docker.build_image(&instance_name, instance_config.docker_build_target())?;
     }
 
@@ -119,13 +121,19 @@ fn needs_cache_recreation(repo_cache: &std::path::Path) -> Result<bool> {
 
     match (DEV_MODE, is_git_repo) {
         (true, true) => {
-            print_status("CACHE", "Cache is git repo but DEV_MODE requires copy - recreating...");
+            print_status(
+                "CACHE",
+                "Cache is git repo but DEV_MODE requires copy - recreating...",
+            );
             Ok(true)
-        },
+        }
         (false, false) => {
-            print_status("CACHE", "Cache is copy but production mode requires git repo - recreating...");
+            print_status(
+                "CACHE",
+                "Cache is copy but production mode requires git repo - recreating...",
+            );
             Ok(true)
-        },
+        }
         _ => Ok(false),
     }
 }
@@ -290,10 +298,9 @@ async fn generate_docker_files(
         return Ok(());
     }
 
-    print_status("DOCKER", "Generating Docker configuration...");
-
     let docker = DockerManager::new(project);
 
+    print_status(docker.runtime.label(), "Generating configuration...");
     // Generate Dockerfile
     let dockerfile_content = docker.generate_dockerfile(instance_name, instance_config.clone())?;
     let dockerfile_path = project.dockerfile_path(instance_name);

helix-cli/src/commands/delete.rs

@@ -37,7 +37,8 @@ pub async fn run(instance_name: String) -> Result<()> {
     print_status("DELETE", &format!("Deleting instance '{instance_name}'"));
 
     // Stop and remove Docker containers and volumes
-    if DockerManager::check_docker_available().is_ok() {
+    let runtime = project.config.project.container_runtime;
+    if DockerManager::check_runtime_available(runtime).is_ok() {
         let docker = DockerManager::new(&project);
 
         // Remove containers and Docker volumes

helix-cli/src/commands/integrations/ecr.rs

@@ -92,7 +92,6 @@ impl<'a> EcrManager<'a> {
         format!("helix-{}-{instance_name}", self.project.config.project.name)
     }
 
-
     fn image_name(&self, repository_name: &str, build_mode: BuildMode) -> String {
         let tag = match build_mode {
             BuildMode::Debug => "debug",
@@ -343,7 +342,7 @@ impl<'a> EcrManager<'a> {
             .to_string();
 
         use tokio::io::AsyncWriteExt;
-        let mut login_cmd = tokio::process::Command::new("docker");
+        let mut login_cmd = tokio::process::Command::new(docker.runtime.binary());
         login_cmd.args([
             "login",
             "--username",

helix-cli/src/commands/migrate.rs

@@ -1,5 +1,6 @@
 use crate::config::{
-    BuildMode, DbConfig, GraphConfig, HelixConfig, LocalInstanceConfig, ProjectConfig, VectorConfig,
+    BuildMode, ContainerRuntime, DbConfig, GraphConfig, HelixConfig, LocalInstanceConfig,
+    ProjectConfig, VectorConfig,
 };
 use crate::errors::{CliError, project_error};
 use crate::utils::{
@@ -231,7 +232,10 @@ fn find_hx_files(project_dir: &Path) -> Result<Vec<PathBuf>> {
         let entry = entry?;
         let path = entry.path();
 
-        if let Some(extension) = path.extension() && extension == "hx" && path.file_name() != Some("schema.hx".as_ref()) {
+        if let Some(extension) = path.extension()
+            && extension == "hx"
+            && path.file_name() != Some("schema.hx".as_ref())
+        {
             hx_files.push(path);
         }
     }
@@ -274,18 +278,28 @@ fn show_migration_plan(ctx: &MigrationContext) -> Result<()> {
 
     print_newline();
     print_header("🏠 Home Directory Migration:");
-    let home_dir = dirs::home_dir().ok_or_else(|| CliError::new("Could not find home directory"))?;
+    let home_dir =
+        dirs::home_dir().ok_or_else(|| CliError::new("Could not find home directory"))?;
     let v1_helix_dir = home_dir.join(".helix");
     if v1_helix_dir.exists() {
         let v2_marker = v1_helix_dir.join(".v2");
         if v2_marker.exists() {
-            print_field("Already migrated", "~/.helix directory already migrated to v2");
+            print_field(
+                "Already migrated",
+                "~/.helix directory already migrated to v2",
+            );
         } else {
             print_field("Create backup", "~/.helix → ~/.helix-v1-backup");
             if v1_helix_dir.join("dockerdev").exists() {
-                print_field("Clean up Docker", "Stop/remove helix-dockerdev containers and images");
+                print_field(
+                    "Clean up Docker",
+                    "Stop/remove helix-dockerdev containers and images",
+                );
             }
-            print_field("Clean directory", "Remove all except ~/.helix/credentials and ~/.helix/repo");
+            print_field(
+                "Clean directory",
+                "Remove all except ~/.helix/credentials and ~/.helix/repo",
+            );
             if v1_helix_dir.join("credentials").exists() {
                 print_field("Preserve file", "~/.helix/credentials");
             }
@@ -428,6 +442,7 @@ fn create_v2_config(ctx: &MigrationContext) -> Result<()> {
     let project_config = ProjectConfig {
         name: ctx.project_name.clone(),
         queries: PathBuf::from(&ctx.queries_dir),
+        container_runtime: ContainerRuntime::Docker,
     };
 
     // Create final helix config
@@ -500,9 +515,8 @@ fn provide_post_migration_guidance(ctx: &MigrationContext) -> Result<()> {
 fn migrate_home_directory(_ctx: &MigrationContext) -> Result<()> {
     print_status("HOME", "Migrating ~/.helix directory");
 
-    let home_dir = dirs::home_dir().ok_or_else(|| {
-        CliError::new("Could not find home directory")
-    })?;
+    let home_dir =
+        dirs::home_dir().ok_or_else(|| CliError::new("Could not find home directory"))?;
 
     let v1_helix_dir = home_dir.join(".helix");
 
@@ -529,8 +543,7 @@ fn migrate_home_directory(_ctx: &MigrationContext) -> Result<()> {
 
     // Use the utility function to copy the directory without exclusions
     crate::utils::copy_dir_recursively(&v1_helix_dir, &backup_dir).map_err(|e| {
-        CliError::new("Failed to backup ~/.helix directory")
-            .with_caused_by(e.to_string())
+        CliError::new("Failed to backup ~/.helix directory").with_caused_by(e.to_string())
     })?;
 
     print_success("Created backup: ~/.helix-v1-backup");
@@ -549,8 +562,7 @@ fn migrate_home_directory(_ctx: &MigrationContext) -> Result<()> {
     let temp_credentials = if credentials_path.exists() {
         let temp_path = home_dir.join(".helix-credentials-temp");
         fs::rename(&credentials_path, &temp_path).map_err(|e| {
-            CliError::new("Failed to backup credentials")
-                .with_caused_by(e.to_string())
+            CliError::new("Failed to backup credentials").with_caused_by(e.to_string())
         })?;
         Some(temp_path)
     } else {
@@ -559,48 +571,40 @@ fn migrate_home_directory(_ctx: &MigrationContext) -> Result<()> {
 
     let temp_repo = if repo_path.exists() {
         let temp_path = home_dir.join(".helix-repo-temp");
-        fs::rename(&repo_path, &temp_path).map_err(|e| {
-            CliError::new("Failed to backup repo")
-                .with_caused_by(e.to_string())
-        })?;
+        fs::rename(&repo_path, &temp_path)
+            .map_err(|e| CliError::new("Failed to backup repo").with_caused_by(e.to_string()))?;
         Some(temp_path)
     } else {
         None
     };
 
     // Remove the entire .helix directory
     fs::remove_dir_all(&v1_helix_dir).map_err(|e| {
-        CliError::new("Failed to remove ~/.helix directory")
-            .with_caused_by(e.to_string())
+        CliError::new("Failed to remove ~/.helix directory").with_caused_by(e.to_string())
     })?;
 
     // Recreate .helix directory
     fs::create_dir_all(&v1_helix_dir).map_err(|e| {
-        CliError::new("Failed to recreate ~/.helix directory")
-            .with_caused_by(e.to_string())
+        CliError::new("Failed to recreate ~/.helix directory").with_caused_by(e.to_string())
     })?;
 
     // Restore credentials and repo
     if let Some(temp_creds) = temp_credentials {
         fs::rename(&temp_creds, &credentials_path).map_err(|e| {
-            CliError::new("Failed to restore credentials")
-                .with_caused_by(e.to_string())
+            CliError::new("Failed to restore credentials").with_caused_by(e.to_string())
         })?;
         print_info("Preserved ~/.helix/credentials");
     }
 
     if let Some(temp_repo) = temp_repo {
-        fs::rename(&temp_repo, &repo_path).map_err(|e| {
-            CliError::new("Failed to restore repo")
-                .with_caused_by(e.to_string())
-        })?;
+        fs::rename(&temp_repo, &repo_path)
+            .map_err(|e| CliError::new("Failed to restore repo").with_caused_by(e.to_string()))?;
         print_info("Preserved ~/.helix/repo");
     }
 
     // Create .v2 marker file to indicate migration is complete
     fs::write(&v2_marker, "").map_err(|e| {
-        CliError::new("Failed to create v2 marker file")
-            .with_caused_by(e.to_string())
+        CliError::new("Failed to create v2 marker file").with_caused_by(e.to_string())
     })?;
 
     print_success("Cleaned up ~/.helix directory, preserving credentials and repo");
@@ -625,7 +629,13 @@ fn cleanup_dockerdev() -> Result<()> {
 
     // Try to remove any helix-related images
     let output = std::process::Command::new("docker")
-        .args(["images", "--format", "{{.Repository}}:{{.Tag}}", "--filter", "reference=helix*"])
+        .args([
+            "images",
+            "--format",
+            "{{.Repository}}:{{.Tag}}",
+            "--filter",
+            "reference=helix*",
+        ])
         .output();
 
     if let Ok(output) = output {
@@ -639,7 +649,14 @@ fn cleanup_dockerdev() -> Result<()> {
 
     // Try to remove helix volumes
     let output = std::process::Command::new("docker")
-        .args(["volume", "ls", "--format", "{{.Name}}", "--filter", "name=helix"])
+        .args([
+            "volume",
+            "ls",
+            "--format",
+            "{{.Name}}",
+            "--filter",
+            "name=helix",
+        ])
         .output();
 
     if let Ok(output) = output {