fix (cli): implementing env vars (#702)

## Description
<!-- Provide a brief description of the changes in this PR -->
implementing docker build reading env vars 
## Related Issues
<!-- Link to any related issues using #issue_number -->

Closes #

## Checklist when merging to main
<!-- Mark items with "x" when completed -->

- [ ] No compiler warnings (if applicable)
- [ ] Code is formatted with `rustfmt`
- [ ] No useless or dead code (if applicable)
- [ ] Code is easy to understand
- [ ] Doc comments are used for all functions, enums, structs, and
fields (where appropriate)
- [ ] 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
-->

Author: xav-db

helix-cli/src/docker.rs

@@ -1,10 +1,8 @@
 use crate::config::{BuildMode, InstanceInfo};
 use crate::project::ProjectContext;
-use crate::utils::{print_confirm, print_status, print_warning};
+use crate::utils::print_status;
 use eyre::{Result, eyre};
 use std::process::{Command, Output};
-use std::thread;
-use std::time::Duration;
 
 pub struct DockerManager<'a> {
     project: &'a ProjectContext,
@@ -46,8 +44,12 @@ impl<'a> DockerManager<'a> {
     }
 
     /// Get environment variables for an instance
+    /// Loads from .env file and shell environment
     pub(crate) fn environment_variables(&self, instance_name: &str) -> Vec<String> {
-        vec![
+        // Load .env file (silently ignore if it doesn't exist)
+        let _ = dotenvy::dotenv();
+
+        let mut env_vars = vec![
             {
                 let port = self
                     .project
@@ -64,7 +66,17 @@ impl<'a> DockerManager<'a> {
                 let project_name = &self.project.config.project.name;
                 format!("HELIX_PROJECT={project_name}")
             },
-        ]
+        ];
+
+        // Add API keys from environment (which includes .env after dotenv() call)
+        if let Ok(openai_key) = std::env::var("OPENAI_API_KEY") {
+            env_vars.push(format!("OPENAI_API_KEY={openai_key}"));
+        }
+        if let Ok(gemini_key) = std::env::var("GEMINI_API_KEY") {
+            env_vars.push(format!("GEMINI_API_KEY={gemini_key}"));
+        }
+
+        env_vars
     }
 
     /// Get the container name for an instance
@@ -107,112 +119,6 @@ impl<'a> DockerManager<'a> {
         Ok(output)
     }
 
-    /// Detect the current operating system platform
-    fn detect_platform() -> &'static str {
-        #[cfg(target_os = "macos")]
-        return "macos";
-
-        #[cfg(target_os = "linux")]
-        return "linux";
-
-        #[cfg(target_os = "windows")]
-        return "windows";
-
-        #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
-        return "unknown";
-    }
-
-    /// Start the Docker daemon based on the platform
-    fn start_docker_daemon() -> Result<()> {
-        let platform = Self::detect_platform();
-
-        match platform {
-            "macos" => {
-                print_status("DOCKER", "Starting Docker Desktop for macOS...");
-                Command::new("open")
-                    .args(["-a", "Docker"])
-                    .output()
-                    .map_err(|e| eyre!("Failed to start Docker Desktop: {}", e))?;
-            }
-            "linux" => {
-                print_status("DOCKER", "Attempting to start Docker daemon on Linux...");
-                // Try systemctl first, then service command as fallback
-                let systemctl_result = Command::new("systemctl").args(["start", "docker"]).output();
-
-                match systemctl_result {
-                    Ok(output) if output.status.success() => {
-                        // systemctl succeeded
-                    }
-                    _ => {
-                        // Try service command as fallback
-                        let service_result = Command::new("service")
-                            .args(["docker", "start"])
-                            .output()
-                            .map_err(|e| eyre!("Failed to start Docker daemon: {}", e))?;
-
-                        if !service_result.status.success() {
-                            let stderr = String::from_utf8_lossy(&service_result.stderr);
-                            return Err(eyre!("Failed to start Docker daemon: {}", stderr));
-                        }
-                    }
-                }
-            }
-            "windows" => {
-                print_status("DOCKER", "Starting Docker Desktop for Windows...");
-                // Try Docker Desktop CLI (4.37+) first
-                let cli_result = Command::new("docker")
-                    .args(["desktop", "start"])
-                    .output();
-
-                match cli_result {
-                    Ok(output) if output.status.success() => {
-                        // Modern Docker Desktop CLI worked
-                    }
-                    _ => {
-                        // Fallback to direct executable path for older versions
-                        // Note: Empty string "" is required as window title parameter
-                        Command::new("cmd")
-                            .args(["/c", "start", "", "\"C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe\""])
-                            .output()
-                            .map_err(|e| eyre!("Failed to start Docker Desktop: {}", e))?;
-                    }
-                }
-            }
-            _ => {
-                return Err(eyre!("Unsupported platform for auto-starting Docker"));
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Wait for Docker daemon to be ready
-    fn wait_for_docker(timeout_secs: u64) -> Result<()> {
-        print_status("DOCKER", "Waiting for Docker daemon to start...");
-
-        let start = std::time::Instant::now();
-        let timeout = Duration::from_secs(timeout_secs);
-
-        while start.elapsed() < timeout {
-            // Check if Docker daemon is responding
-            let output = Command::new("docker").args(["info"]).output();
-
-            if let Ok(output) = output
-                && output.status.success()
-            {
-                print_status("DOCKER", "Docker daemon is now running");
-                return Ok(());
-            }
-
-            // Wait a bit before retrying
-            thread::sleep(Duration::from_millis(500));
-        }
-
-        Err(eyre!(
-            "Timeout waiting for Docker daemon to start. Please start Docker manually and try again."
-        ))
-    }
-
     /// Check if Docker is installed and running
     pub fn check_docker_available() -> Result<()> {
         let output = Command::new("docker")
@@ -231,33 +137,7 @@ impl<'a> DockerManager<'a> {
             .map_err(|_| eyre!("Failed to check Docker daemon status"))?;
 
         if !output.status.success() {
-            // Docker daemon is not running - prompt user
-            let should_start =
-                print_confirm("Docker daemon is not running. Would you like to start Docker?")
-                    .unwrap_or(false);
-
-            if should_start {
-                // Try to start Docker
-                Self::start_docker_daemon()?;
-
-                // Wait for Docker to be ready
-                Self::wait_for_docker(15)?;
-
-                // Verify Docker is now running
-                let verify_output = Command::new("docker")
-                    .args(["info"])
-                    .output()
-                    .map_err(|_| eyre!("Failed to verify Docker daemon status"))?;
-
-                if !verify_output.status.success() {
-                    return Err(eyre!(
-                        "Docker daemon failed to start. Please start Docker manually and try again."
-                    ));
-                }
-            } else {
-                print_warning("Docker daemon must be running to execute this command.");
-                return Err(eyre!("Docker daemon is not running. Please start Docker."));
-            }
+            return Err(eyre!("Docker daemon is not running. Please start Docker."));
         }
 
         Ok(())
@@ -354,6 +234,14 @@ CMD ["helix-container"]
         let container_name = self.container_name(instance_name);
         let network_name = self.network_name(instance_name);
 
+        // Get all environment variables dynamically
+        let env_vars = self.environment_variables(instance_name);
+        let env_section = env_vars
+            .iter()
+            .map(|var| format!("      - {var}"))
+            .collect::<Vec<_>>()
+            .join("\n");
+
         let compose = format!(
             r#"# Generated docker-compose.yml for Helix instance: {instance_name}
 services:
@@ -369,10 +257,7 @@ services:
     volumes:
       - ../.volumes/{instance_name}:/data
     environment:
-      - HELIX_PORT={port}
-      - HELIX_DATA_DIR={data_dir}
-      - HELIX_INSTANCE={instance_name}
-      - HELIX_PROJECT={project_name}
+{env_section}
     restart: unless-stopped
     networks:
       - {network_name}
@@ -384,8 +269,6 @@ networks:
             platform = instance_config
                 .docker_build_target()
                 .map_or("".to_string(), |p| format!("platforms:\n        - {p}")),
-            project_name = self.project.config.project.name,
-            data_dir = HELIX_DATA_DIR,
         );
 
         Ok(compose)