site update, compose volumes fix

Author: robotizeit

README.md

@@ -160,7 +160,10 @@ The end-user tool. No server required for local deploys.
 | `stacker status` | Show running containers and health |
 | `stacker logs` | View container logs (`--follow`, `--service`, `--tail`) |
 | `stacker secrets` | Manage local `.env` secrets or remote Vault-backed `service` / `server` secrets |
-| `stacker list deployments` | List deployments on the Stacker server |
+| `stacker list deployments` / `stacker deployments` | List deployments on the Stacker server |
+| `stacker list servers` / `stacker servers` | List saved servers |
+| `stacker list clouds` / `stacker clouds` | List saved cloud credentials |
+| `stacker list ssh-keys` / `stacker ssh-keys` | List per-server SSH key status |
 | `stacker destroy` | Tear down the deployed stack |
 | `stacker config validate` | Validate `stacker.yml` syntax |
 | `stacker config show` | Show resolved configuration |

src/bin/stacker.rs

@@ -258,6 +258,43 @@ enum StackerCommands {
         #[command(subcommand)]
         command: ListCommands,
     },
+    /// List all projects (alias for `stacker list projects`)
+    Projects {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+    },
+    /// List deployments (alias for `stacker list deployments`)
+    Deployments {
+        /// Filter by project ID
+        #[arg(long)]
+        project: Option<i32>,
+        /// Limit number of results
+        #[arg(long)]
+        limit: Option<i64>,
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+    },
+    /// List all servers (alias for `stacker list servers`)
+    Servers {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+    },
+    /// List SSH keys (alias for `stacker list ssh-keys`)
+    #[command(name = "ssh-keys")]
+    SshKeys {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+    },
+    /// List saved cloud credentials (alias for `stacker list clouds`)
+    Clouds {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+    },
     /// SSH key management (generate, show, upload, repair)
     #[command(long_about = "Manage Stacker server SSH keys.\n\n\
 Cloud deploys automatically create a local backup SSH key under the Stacker config directory and authorize it on the deployed server when possible. The `generate` command manages the server-side Vault key; `inject` repairs a server by using an already-working local private key to add the Vault public key.")]
@@ -1935,6 +1972,27 @@ fn get_command(
                 Box::new(stacker::console::commands::cli::list::ListCloudsCommand::new(json))
             }
         },
+        StackerCommands::Projects { json } => {
+            Box::new(stacker::console::commands::cli::list::ListProjectsCommand::new(json))
+        }
+        StackerCommands::Deployments {
+            json,
+            project,
+            limit,
+        } => Box::new(
+            stacker::console::commands::cli::list::ListDeploymentsCommand::new(
+                json, project, limit,
+            ),
+        ),
+        StackerCommands::Servers { json } => {
+            Box::new(stacker::console::commands::cli::list::ListServersCommand::new(json))
+        }
+        StackerCommands::SshKeys { json } => {
+            Box::new(stacker::console::commands::cli::list::ListSshKeysCommand::new(json))
+        }
+        StackerCommands::Clouds { json } => {
+            Box::new(stacker::console::commands::cli::list::ListCloudsCommand::new(json))
+        }
         StackerCommands::SshKey { command: ssh_cmd } => match ssh_cmd {
             SshKeyCommands::Generate { server_id, save_to } => Box::new(
                 stacker::console::commands::cli::ssh_key::SshKeyGenerateCommand::new(
@@ -2929,6 +2987,44 @@ mod tests {
         assert!(sync.is_ok(), "secrets apps sync should parse successfully");
     }
 
+    #[test]
+    fn test_top_level_servers_alias_parses() {
+        let parsed = Cli::try_parse_from(["stacker", "servers", "--json"]);
+
+        assert!(
+            parsed.is_ok(),
+            "top-level servers alias should parse successfully"
+        );
+    }
+
+    #[test]
+    fn test_top_level_deployments_alias_parses() {
+        let parsed = Cli::try_parse_from([
+            "stacker",
+            "deployments",
+            "--project",
+            "42",
+            "--limit",
+            "10",
+            "--json",
+        ]);
+
+        assert!(
+            parsed.is_ok(),
+            "top-level deployments alias should parse successfully"
+        );
+    }
+
+    #[test]
+    fn test_top_level_ssh_keys_alias_parses() {
+        let parsed = Cli::try_parse_from(["stacker", "ssh-keys", "--json"]);
+
+        assert!(
+            parsed.is_ok(),
+            "top-level ssh-keys alias should parse successfully"
+        );
+    }
+
     #[test]
     fn test_secrets_help_mentions_remote_modes() {
         let mut command = Cli::command();

src/cli/compose_service_sync.rs

@@ -69,10 +69,7 @@ fn inject_external_network(
                 }
             }
             None => {
-                svc.insert(
-                    networks_key,
-                    serde_yaml::Value::Sequence(vec![network_val]),
-                );
+                svc.insert(networks_key, serde_yaml::Value::Sequence(vec![network_val]));
                 changed = true;
             }
             _ => {}
@@ -387,7 +384,9 @@ fn push_unique_network(networks: &mut Vec<String>, name: &str) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::cli::config_parser::{AppSource, DeployConfig, DomainConfig, ProjectConfig, SslMode};
+    use crate::cli::config_parser::{
+        AppSource, DeployConfig, DomainConfig, ProjectConfig, SslMode,
+    };
     use std::collections::HashMap;
     use tempfile::TempDir;
 

src/cli/generator/compose.rs

@@ -3,7 +3,9 @@ use std::convert::TryFrom;
 use std::fmt;
 use std::path::Path;
 
-use crate::cli::config_parser::{AppType, DomainConfig, ProxyType, ServiceDefinition, StackerConfig};
+use crate::cli::config_parser::{
+    AppType, DomainConfig, ProxyType, ServiceDefinition, StackerConfig,
+};
 use crate::cli::error::CliError;
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -160,7 +162,9 @@ impl TryFrom<&StackerConfig> for ComposeDefinition {
                 }
             }
             if injected {
-                compose.external_networks.push("default_network".to_string());
+                compose
+                    .external_networks
+                    .push("default_network".to_string());
             }
         }
 
@@ -773,9 +777,18 @@ mod tests {
         );
 
         let yaml = compose.render();
-        assert!(yaml.contains("volumes:"), "top-level volumes: block must exist");
-        assert!(yaml.contains("  rustfs_data:"), "rustfs_data entry must appear");
-        assert!(yaml.contains("  rustfs_logs:"), "rustfs_logs entry must appear");
+        assert!(
+            yaml.contains("volumes:"),
+            "top-level volumes: block must exist"
+        );
+        assert!(
+            yaml.contains("  rustfs_data:"),
+            "rustfs_data entry must appear"
+        );
+        assert!(
+            yaml.contains("  rustfs_logs:"),
+            "rustfs_logs entry must appear"
+        );
     }
 
     #[test]
@@ -910,11 +923,16 @@ mod tests {
             api_svc.networks
         );
         assert!(
-            compose.external_networks.contains(&"default_network".to_string()),
+            compose
+                .external_networks
+                .contains(&"default_network".to_string()),
             "default_network should be declared as external"
         );
         let yaml = compose.render();
-        assert!(yaml.contains("external: true"), "rendered YAML should declare default_network external:\n{yaml}");
+        assert!(
+            yaml.contains("external: true"),
+            "rendered YAML should declare default_network external:\n{yaml}"
+        );
     }
 
     #[test]

src/cli/install_runner.rs

@@ -278,7 +278,14 @@ fn get_own_compose_running_ports(
     let compose_str = compose_path.to_string_lossy();
     let out = match executor.execute(
         "docker",
-        &["compose", "-f", &compose_str, "ps", "--format", "{{.Ports}}"],
+        &[
+            "compose",
+            "-f",
+            &compose_str,
+            "ps",
+            "--format",
+            "{{.Ports}}",
+        ],
     ) {
         Ok(o) if o.success() => o,
         _ => return Default::default(),

src/connectors/hetzner.rs

@@ -168,7 +168,10 @@ impl HetznerCloudConnector for HetznerCloudClient {
 
         let status = response.status();
         if !status.is_success() {
-            return Err(status_to_error(status, "Hetzner server types lookup failed"));
+            return Err(status_to_error(
+                status,
+                "Hetzner server types lookup failed",
+            ));
         }
 
         let body: HetznerServerTypesResponse = response
@@ -374,10 +377,7 @@ mod tests {
             .await;
 
         let client = HetznerCloudClient::new(api.uri()).unwrap();
-        let types = client
-            .list_server_types("test-token", None)
-            .await
-            .unwrap();
+        let types = client.list_server_types("test-token", None).await.unwrap();
 
         assert_eq!(types, vec!["cx22", "cx32", "cx42"]);
     }

src/console/commands/cli/agent.rs

@@ -452,8 +452,14 @@ fn print_health_result(info: &AgentCommandInfo) {
             if let Some(containers) = result.get("containers").and_then(|v| v.as_array()) {
                 println!("{:<28} {:<10} {}", "CONTAINER", "STATE", "STATUS");
                 for c in containers {
-                    let name = c.get("container_name").and_then(|v| v.as_str()).unwrap_or("-");
-                    let state = c.get("container_state").and_then(|v| v.as_str()).unwrap_or("-");
+                    let name = c
+                        .get("container_name")
+                        .and_then(|v| v.as_str())
+                        .unwrap_or("-");
+                    let state = c
+                        .get("container_state")
+                        .and_then(|v| v.as_str())
+                        .unwrap_or("-");
                     let status = c.get("status").and_then(|v| v.as_str()).unwrap_or("-");
                     println!(
                         "{:<28} {} {:<8} {}",
@@ -469,9 +475,15 @@ fn print_health_result(info: &AgentCommandInfo) {
 
         // Single-container health
         if result_type == "health" {
-            let state = result.get("container_state").and_then(|v| v.as_str()).unwrap_or("-");
+            let state = result
+                .get("container_state")
+                .and_then(|v| v.as_str())
+                .unwrap_or("-");
             let status = result.get("status").and_then(|v| v.as_str()).unwrap_or("-");
-            let app = result.get("app_code").and_then(|v| v.as_str()).unwrap_or("-");
+            let app = result
+                .get("app_code")
+                .and_then(|v| v.as_str())
+                .unwrap_or("-");
             println!(
                 "{}: {} {} ({})",
                 app,
@@ -508,7 +520,10 @@ fn print_all_container_health(containers: &[serde_json::Value]) {
     println!("Overall: {} {}", progress::status_icon(overall), overall);
     println!();
 
-    println!("{:<28} {:<12} {:<8} {:<8} {}", "CONTAINER", "STATE", "CPU%", "MEM%", "IMAGE");
+    println!(
+        "{:<28} {:<12} {:<8} {:<8} {}",
+        "CONTAINER", "STATE", "CPU%", "MEM%", "IMAGE"
+    );
     for c in containers {
         let name = c.get("name").and_then(|v| v.as_str()).unwrap_or("-");
         let state = c.get("status").and_then(|v| v.as_str()).unwrap_or("-");
@@ -656,8 +671,7 @@ impl CallableTrait for AgentHealthCommand {
         // No specific app requested → list all containers with health metrics.
         // This avoids sending app_code="all" to older agents that don't handle it.
         if self.app_code.is_none() && !self.include_system {
-            let containers = fetch_live_containers(&ctx, &hash)?
-                .unwrap_or_default();
+            let containers = fetch_live_containers(&ctx, &hash)?.unwrap_or_default();
             if self.json {
                 println!("{}", serde_json::to_string_pretty(&containers)?);
             } else {
@@ -1764,7 +1778,10 @@ fn print_containers_summary(containers: &[serde_json::Value]) {
         return;
     }
 
-    println!("{:<24} {:<12} {:<22} {:<30}", "CONTAINER", "STATE", "PORTS", "IMAGE");
+    println!(
+        "{:<24} {:<12} {:<22} {:<30}",
+        "CONTAINER", "STATE", "PORTS", "IMAGE"
+    );
     for c in containers {
         let name = c.get("name").and_then(|v| v.as_str()).unwrap_or("-");
         let state = c