feat: Update zinit-client dependency to 0.4.0

- Upgrade `zinit-client` dependency to version 0.4.0 across all
  relevant crates. This resolves potential compatibility issues
  and incorporates bug fixes and improvements from the latest
  release.

- Improve error handling and logging in `zinit-client` and
  `service_manager` to provide more informative feedback and
  prevent potential hangs during log retrieval.  Add timeout to
  prevent indefinite blocking on log retrieval.

- Update `publish-all.sh` script to correctly handle the
  `service_manager` crate during publishing.  Improves handling of
  special cases in the publishing script.

- Add `zinit-client.workspace = true` to `Cargo.toml` to ensure
  consistent dependency management across the workspace.  This
  ensures the correct version of `zinit-client` is used everywhere.

service_manager/Cargo.toml

@@ -17,7 +17,7 @@ serde_json = { workspace = true }
 futures = { workspace = true }
 once_cell = { workspace = true }
 # Use base zinit-client instead of SAL wrapper
-zinit-client = { version = "0.3.0" }
+zinit-client = { version = "0.4.0" }
 # Optional Rhai integration
 rhai = { workspace = true, optional = true }
 

service_manager/src/zinit.rs

@@ -306,6 +306,8 @@ impl ServiceManager for ZinitServiceManager {
         let logs = self
             .execute_async(async move {
                 use futures::StreamExt;
+                use tokio::time::{timeout, Duration};
+
                 let mut log_stream = client
                     .logs(false, Some(service_name_owned.as_str()))
                     .await?;
@@ -314,18 +316,32 @@ impl ServiceManager for ZinitServiceManager {
                 // Collect logs from the stream with a reasonable limit
                 let mut count = 0;
                 const MAX_LOGS: usize = 100;
+                const LOG_TIMEOUT: Duration = Duration::from_secs(5);
 
-                while let Some(log_result) = log_stream.next().await {
-                    match log_result {
-                        Ok(log_entry) => {
-                            logs.push(format!("{:?}", log_entry));
-                            count += 1;
-                            if count >= MAX_LOGS {
-                                break;
+                // Use timeout to prevent hanging
+                let result = timeout(LOG_TIMEOUT, async {
+                    while let Some(log_result) = log_stream.next().await {
+                        match log_result {
+                            Ok(log_entry) => {
+                                logs.push(format!("{:?}", log_entry));
+                                count += 1;
+                                if count >= MAX_LOGS {
+                                    break;
+                                }
                             }
+                            Err(_) => break,
                         }
-                        Err(_) => break,
                     }
+                })
+                .await;
+
+                // Handle timeout - this is not an error, just means no more logs available
+                if result.is_err() {
+                    log::debug!(
+                        "Log reading timed out after {} seconds, returning {} logs",
+                        LOG_TIMEOUT.as_secs(),
+                        logs.len()
+                    );
                 }
 
                 Ok::<Vec<String>, ZinitError>(logs)