feat: VM-level container logs, named volume tmpfs, Docker health semantics

Three fixes that get both postgres services in gpu-cli-two passing health checks:

1. **VM-level container logs**: Bind-mount `/run/vz-oci/logs/{cid}/` into
   containers at `/var/log/vz-oci/` so stdout/stderr logs survive container
   death. Added `exec_host()` on Runtime for VM-level command execution
   without nsenter. `logs()` now reads from VM level, working even when
   the container's init process has exited.

2. **Named volumes use tmpfs**: VirtioFS doesn't support chown/chmod from
   the guest, which breaks containers like postgres that change data dir
   ownership. Named volumes now use tmpfs inside the VM (matching Docker
   Desktop behavior) instead of VirtioFS host-backed storage.

3. **Docker health check semantics**: When retries are exhausted, container
   stays Running (unhealthy) instead of being killed and recreated. Health
   checks continue indefinitely; a future pass promotes to healthy.

Also includes exec_with_output on ContainerRuntime trait, OCI service
implementation in guest agent, and shared VM volume mount support.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lightsofapollo

crates/vz-agent-proto/src/lib.rs

@@ -246,10 +246,12 @@ mod tests {
                 NetworkServiceConfig {
                     name: "web".to_string(),
                     addr: "172.20.0.2/24".to_string(),
+                    network_name: "default".to_string(),
                 },
                 NetworkServiceConfig {
                     name: "db".to_string(),
                     addr: "172.20.0.3/24".to_string(),
+                    network_name: "default".to_string(),
                 },
             ],
         };

crates/vz-cli/src/commands/oci.rs

@@ -659,6 +659,7 @@ async fn create_container(runtime: &vz_oci_macos::Runtime, args: CreateArgs) ->
         domainname: None,
         stop_signal: None,
         stop_grace_period_secs: None,
+        mount_tag_offset: 0,
     };
 
     info!(image = %args.image, "creating long-lived container");
@@ -886,6 +887,7 @@ fn build_run_config(args: &RunArgs) -> anyhow::Result<vz_oci_macos::RunConfig> {
         domainname: None,
         stop_signal: None,
         stop_grace_period_secs: None,
+        mount_tag_offset: 0,
     })
 }
 

crates/vz-cli/src/commands/stack.rs

@@ -373,23 +373,6 @@ impl OciContainerRuntime {
         Ok(Self { backend, handle })
     }
 
-    /// Execute a command in a running container and capture output.
-    fn exec_with_output(
-        &self,
-        container_id: &str,
-        cmd: Vec<String>,
-    ) -> Result<vz_runtime_contract::ExecOutput, StackError> {
-        use vz_runtime_contract::RuntimeBackend;
-        tokio::task::block_in_place(|| {
-            let exec_config = vz_runtime_contract::ExecConfig {
-                cmd,
-                ..Default::default()
-            };
-            self.handle
-                .block_on(self.backend.exec_container(container_id, exec_config))
-                .map_err(|e| StackError::Network(format!("exec failed: {e}")))
-        })
-    }
 }
 
 impl ContainerRuntime for OciContainerRuntime {
@@ -443,6 +426,15 @@ impl ContainerRuntime for OciContainerRuntime {
     }
 
     fn exec(&self, container_id: &str, command: &[String]) -> Result<i32, StackError> {
+        let (code, _, _) = ContainerRuntime::exec_with_output(self, container_id, command)?;
+        Ok(code)
+    }
+
+    fn exec_with_output(
+        &self,
+        container_id: &str,
+        command: &[String],
+    ) -> Result<(i32, String, String), StackError> {
         use vz_runtime_contract::RuntimeBackend;
         tokio::task::block_in_place(|| {
             let exec_config = vz_runtime_contract::ExecConfig {
@@ -451,7 +443,7 @@ impl ContainerRuntime for OciContainerRuntime {
             };
             self.handle
                 .block_on(self.backend.exec_container(container_id, exec_config))
-                .map(|output| output.exit_code)
+                .map(|output| (output.exit_code, output.stdout, output.stderr))
                 .map_err(|e| StackError::Network(format!("exec failed: {e}")))
         })
     }
@@ -530,21 +522,12 @@ impl ContainerRuntime for OciContainerRuntime {
     }
 
     fn logs(&self, container_id: &str) -> Result<ContainerLogs, StackError> {
-        let output = self.exec_with_output(
-            container_id,
-            vec![
-                "tail".into(),
-                "-n".into(),
-                "100".into(),
-                CONTAINER_LOG_FILE.into(),
-            ],
-        )?;
+        use vz_runtime_contract::RuntimeBackend;
+        let logs = self.backend.logs(container_id).map_err(|e| {
+            StackError::Network(format!("logs failed: {e}"))
+        })?;
         Ok(ContainerLogs {
-            output: if output.exit_code == 0 {
-                output.stdout
-            } else {
-                String::new()
-            },
+            output: logs.output,
         })
     }
 }
@@ -978,11 +961,11 @@ fn handle_exec(
     );
 
     let runtime = orchestrator.executor().runtime();
-    match runtime.exec_with_output(container_id, request.cmd.clone()) {
-        Ok(output) => ControlResponse {
-            exit_code: output.exit_code,
-            stdout: output.stdout,
-            stderr: output.stderr,
+    match runtime.exec_with_output(container_id, &request.cmd) {
+        Ok((exit_code, stdout, stderr)) => ControlResponse {
+            exit_code,
+            stdout,
+            stderr,
             error: None,
         },
         Err(e) => ControlResponse {

crates/vz-cli/src/tui.rs

@@ -1104,6 +1104,7 @@ mod tests {
                     labels: std::collections::HashMap::new(),
                     stop_signal: None,
                     stop_grace_period_secs: None,
+                    container_name: None,
                 },
                 vz_stack::ServiceSpec {
                     name: "db".into(),
@@ -1137,6 +1138,7 @@ mod tests {
                     labels: std::collections::HashMap::new(),
                     stop_signal: None,
                     stop_grace_period_secs: None,
+                    container_name: None,
                 },
             ],
             networks: vec![],

crates/vz-guest-agent/src/grpc_server.rs

@@ -523,14 +523,19 @@ impl oci_service_server::OciService for OciServiceImpl {
             format!("--root=/proc/{pid}/root"),
             format!("--target={pid}"),
             "--".into(),
+            "env".into(),
         ];
 
-        // Build env prefix if environment variables are specified.
-        if !req.env.is_empty() || !req.working_dir.is_empty() || !req.user.is_empty() {
-            nsenter_args.push("env".into());
-            for (key, value) in &req.env {
-                nsenter_args.push(format!("{key}={value}"));
-            }
+        // Always set a standard PATH so commands like pg_isready are found.
+        let has_path = req.env.keys().any(|k| k == "PATH");
+        if !has_path {
+            nsenter_args.push(
+                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin".into(),
+            );
+        }
+
+        for (key, value) in &req.env {
+            nsenter_args.push(format!("{key}={value}"));
         }
 
         nsenter_args.push(req.command);
@@ -661,10 +666,23 @@ async fn run_youki(args: &[&str]) -> Result<(), Status> {
     if !status.success() {
         let youki_log = tokio::fs::read_to_string(&log_file).await.unwrap_or_default();
         error!(command = %subcmd, log = %youki_log, "youki command failed");
-        return Err(Status::internal(format!(
-            "youki {subcmd} failed (exit {}): see youki log",
-            status.code().unwrap_or(-1)
-        )));
+        // Include the last few lines of the youki log in the error response
+        // so the host can surface them without needing VM access.
+        let log_tail: String = youki_log
+            .lines()
+            .rev()
+            .take(10)
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+            .collect::<Vec<_>>()
+            .join("\n");
+        let exit_code = status.code().unwrap_or(-1);
+        return Err(Status::internal(if log_tail.is_empty() {
+            format!("youki {subcmd} failed (exit {exit_code}): no log output")
+        } else {
+            format!("youki {subcmd} failed (exit {exit_code}): {log_tail}")
+        }));
     }
 
     Ok(())
@@ -745,10 +763,10 @@ async fn patch_oci_config(config_path: &str) -> Result<(), Status> {
         });
     }
 
-    // Strip maskedPaths, readonlyPaths, and namespaces — the minimal VM
-    // kernel doesn't support the namespace types youki tries to unshare,
-    // and masked/readonly paths reference /proc and /sys paths that may
-    // not exist, causing youki to hang.
+    // Strip maskedPaths, readonlyPaths, and unsupported namespaces — the
+    // minimal VM kernel doesn't support all namespace types youki tries to
+    // unshare, and masked/readonly paths reference /proc and /sys paths that
+    // may not exist, causing youki to hang.
     if let Some(linux) = config.pointer_mut("/linux") {
         if let Some(obj) = linux.as_object_mut() {
             if obj.remove("maskedPaths").is_some() {
@@ -757,10 +775,22 @@ async fn patch_oci_config(config_path: &str) -> Result<(), Status> {
             if obj.remove("readonlyPaths").is_some() {
                 tracing::info!("stripped readonlyPaths from OCI config");
             }
-            // Strip all namespaces — the container runs directly in the
-            // guest VM's namespace. The VM itself provides isolation.
-            if obj.remove("namespaces").is_some() {
-                tracing::info!("stripped namespaces from OCI config");
+            // Strip unsupported namespaces but preserve mount and network.
+            // The host-side bundle already strips PID/IPC/UTS/cgroup, but
+            // older bundles or third-party configs may still include them.
+            // Network namespaces MUST be preserved — multi-service stacks
+            // use per-service netns (e.g. /var/run/netns/svc-web) for
+            // container network isolation and service discovery.
+            if let Some(namespaces) = obj.get_mut("namespaces").and_then(|v| v.as_array_mut()) {
+                let before = namespaces.len();
+                namespaces.retain(|ns| {
+                    let typ = ns.get("type").and_then(|t| t.as_str()).unwrap_or("");
+                    matches!(typ, "mount" | "network")
+                });
+                let stripped = before - namespaces.len();
+                if stripped > 0 {
+                    tracing::info!(stripped, "stripped unsupported namespaces from OCI config");
+                }
             }
         }
     }

crates/vz-oci-macos/src/config.rs

@@ -186,6 +186,9 @@ pub struct RunConfig {
     pub stop_signal: Option<String>,
     /// Seconds to wait after stop signal before SIGKILL. Default: 10.
     pub stop_grace_period_secs: Option<u64>,
+    // ── Shared VM mount support ──────────────────────────────────
+    /// Offset added to VirtioFS mount tag indices in shared VM mode.
+    pub mount_tag_offset: usize,
 }
 
 /// Options for executing a command in an already-running container.

crates/vz-oci-macos/src/macos_backend.rs

@@ -187,13 +187,13 @@ impl RuntimeBackend for MacosRuntimeBackend {
     }
 
     fn logs(&self, container_id: &str) -> Result<contract::ContainerLogs, RuntimeError> {
+        use crate::runtime::container_log_dir;
+
+        // Read from the VM-level log directory (not inside the container).
+        // This works even when the container's init process has exited.
+        let log_path = format!("{}/output.log", container_log_dir(container_id));
         let exec_config = oci_config::ExecConfig {
-            cmd: vec![
-                "tail".into(),
-                "-n".into(),
-                "100".into(),
-                "/var/log/vz-oci/output.log".into(),
-            ],
+            cmd: vec!["tail".into(), "-n".into(), "100".into(), log_path],
             working_dir: None,
             env: vec![],
             user: None,
@@ -202,7 +202,7 @@ impl RuntimeBackend for MacosRuntimeBackend {
 
         let output = tokio::task::block_in_place(|| {
             tokio::runtime::Handle::current()
-                .block_on(self.runtime.exec_container(container_id, exec_config))
+                .block_on(self.runtime.exec_host(container_id, exec_config))
         })
         .map_err(oci_err)?;
 
@@ -264,6 +264,7 @@ fn run_config_from_contract(c: contract::RunConfig) -> oci_config::RunConfig {
         domainname: c.domainname,
         stop_signal: c.stop_signal,
         stop_grace_period_secs: c.stop_grace_period_secs,
+        mount_tag_offset: c.mount_tag_offset,
     }
 }