fix: address PR #84 review comments, bump to v0.1.6

- Gate runtime_compose_tests with #[cfg(all(test, feature = "docker"))]
- Replace blocking Path::exists() with tokio::fs::try_exists() in deploy
- Cache detect_kata_runtime() with OnceLock + 5s timeout
- Log errors in unlink_handler try_exists path
- Bump version to 0.1.6
- Update CHANGELOG

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: vsilent

CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.1.6 — 2026-04-08
+### Added — Kata Containers Runtime Support
+
+#### Container Runtime Selection (`commands/stacker.rs`)
+- `ContainerRuntime` enum (`runc`/`kata`) with serde support and Docker runtime name mapping
+- `detect_kata_runtime()` — cached detection via `docker info` with 5s timeout and `OnceLock`
+- `inject_runtime_into_compose()` — parses compose YAML and injects `runtime:` per-service
+- `DeployAppCommand` and `DeployWithConfigsCommand` accept optional `runtime` field
+- Graceful fallback: if Kata is requested but unavailable, deploys with runc and emits `kata_fallback` warning
+- Effective runtime reported in deploy result body
+
+#### Capabilities Discovery (`comms/local_api.rs`)
+- `/capabilities` endpoint reports `"kata"` in features list when Kata runtime is detected on the host
+
+#### Code Quality Fixes (PR #84 review)
+- `runtime_compose_tests` gated with `#[cfg(all(test, feature = "docker"))]` for minimal builds
+- Replaced blocking `std::path::Path::exists()` with `tokio::fs::try_exists()` in async deploy path
+- Added proper error logging in `unlink_handler` for `try_exists` failures
+
+#### Tests
+- 14 new tests: enum behavior, serde deserialization, compose YAML injection (including edge cases), command parsing with runtime field
+
+## 0.1.5 — 2026-03-26
+### Added — Long Polling, Vault Integration, Compose Agent Sidecar
+
 ## 0.1.4 — 2026-03-13
 ### Added — CLI Improvements, Install Script & GitHub Releases
 

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "status-panel"
-version = "0.1.5"
+version = "0.1.6"
 edition = "2021"
 
 [features]

Cargo.toml

@@ -58,23 +58,38 @@ impl ContainerRuntime {
 
 /// Detect whether the Kata Containers runtime is available on this host.
 /// Checks `docker info` output for a registered kata runtime.
+/// Result is cached for the lifetime of the process via `OnceLock`.
 #[cfg(feature = "docker")]
 pub async fn detect_kata_runtime() -> bool {
+    use std::sync::OnceLock;
     use tokio::process::Command;
 
-    let output = Command::new("docker")
-        .args(["info", "--format", "{{json .Runtimes}}"])
-        .output()
-        .await;
+    static KATA_AVAILABLE: OnceLock<bool> = OnceLock::new();
 
-    match output {
-        Ok(out) if out.status.success() => {
-            let stdout = String::from_utf8_lossy(&out.stdout);
-            let lower = stdout.to_lowercase();
-            lower.contains("kata") || lower.contains("io.containerd.kata")
-        }
-        _ => false,
+    if let Some(&cached) = KATA_AVAILABLE.get() {
+        return cached;
     }
+
+    let result = tokio::time::timeout(std::time::Duration::from_secs(5), async {
+        let output = Command::new("docker")
+            .args(["info", "--format", "{{json .Runtimes}}"])
+            .output()
+            .await;
+
+        match output {
+            Ok(out) if out.status.success() => {
+                let stdout = String::from_utf8_lossy(&out.stdout);
+                let lower = stdout.to_lowercase();
+                lower.contains("kata") || lower.contains("io.containerd.kata")
+            }
+            _ => false,
+        }
+    })
+    .await
+    .unwrap_or(false);
+
+    let _ = KATA_AVAILABLE.set(result);
+    result
 }
 
 /// Inject a `runtime` field into every service definition of a docker-compose YAML string.
@@ -2718,33 +2733,51 @@ async fn handle_deploy_app(
         );
     } else if let Some(runtime) = &data.runtime {
         // Compose content not in payload — modify existing file on disk if runtime is requested
-        if *runtime == ContainerRuntime::Kata && std::path::Path::new(&compose_file).exists() {
-            let kata_available = detect_kata_runtime().await;
-            if kata_available {
-                if let Ok(existing) = tokio::fs::read_to_string(&compose_file).await {
-                    let injected = inject_runtime_into_compose(&existing, runtime);
-                    if let Err(e) = tokio::fs::write(&compose_file, &injected).await {
+        if *runtime == ContainerRuntime::Kata {
+            match tokio::fs::try_exists(&compose_file).await {
+                Ok(true) => {
+                    let kata_available = detect_kata_runtime().await;
+                    if kata_available {
+                        if let Ok(existing) = tokio::fs::read_to_string(&compose_file).await {
+                            let injected = inject_runtime_into_compose(&existing, runtime);
+                            if let Err(e) = tokio::fs::write(&compose_file, &injected).await {
+                                errors.push(make_error(
+                                    "runtime_inject_warning",
+                                    format!(
+                                        "Failed to inject Kata runtime into compose file: {}",
+                                        e
+                                    ),
+                                    None,
+                                ));
+                            } else {
+                                tracing::info!(
+                                    compose_file = %compose_file,
+                                    "Injected Kata runtime into existing compose file"
+                                );
+                            }
+                        }
+                    } else {
+                        tracing::warn!(
+                            "Kata runtime requested but not available on this host — falling back to runc"
+                        );
                         errors.push(make_error(
-                            "runtime_inject_warning",
-                            format!("Failed to inject Kata runtime into compose file: {}", e),
+                            "kata_fallback",
+                            "Kata runtime requested but not available on this host; deploying with runc",
                             None,
                         ));
-                    } else {
-                        tracing::info!(
-                            compose_file = %compose_file,
-                            "Injected Kata runtime into existing compose file"
-                        );
                     }
                 }
-            } else {
-                tracing::warn!(
-                    "Kata runtime requested but not available on this host — falling back to runc"
-                );
-                errors.push(make_error(
-                    "kata_fallback",
-                    "Kata runtime requested but not available on this host; deploying with runc",
-                    None,
-                ));
+                Ok(false) => {}
+                Err(e) => {
+                    errors.push(make_error(
+                        "runtime_inject_warning",
+                        format!(
+                            "Failed to check compose file before runtime injection: {}",
+                            e
+                        ),
+                        None,
+                    ));
+                }
             }
         }
     }
@@ -5028,7 +5061,7 @@ mod tests {
     );
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "docker"))]
 mod runtime_compose_tests {
     use super::*;
 

src/commands/stacker.rs

@@ -1234,11 +1234,19 @@ async fn link_select_handler(
 
 async fn unlink_handler(State(state): State<SharedState>) -> impl IntoResponse {
     let reg_path = "/etc/status-panel/registration.json";
-    if tokio::fs::try_exists(reg_path).await.unwrap_or(false) {
-        if let Err(e) = tokio::fs::remove_file(reg_path).await {
-            error!("failed to remove registration: {}", e);
-        } else {
-            info!("dashboard unlinked, registration removed");
+    match tokio::fs::try_exists(reg_path).await {
+        Ok(true) => {
+            if let Err(e) = tokio::fs::remove_file(reg_path).await {
+                error!("failed to remove registration: {}", e);
+            } else {
+                info!("dashboard unlinked, registration removed");
+            }
+        }
+        Ok(false) => {
+            info!("unlink requested but no registration file found");
+        }
+        Err(e) => {
+            error!("failed to check registration file at {}: {}", reg_path, e);
         }
     }
     if state.with_ui {