feat(macos): port the native runtime + sidecar to macOS

The native stack previously compiled only on Linux. This adds macOS
(aarch64/x86_64) support, gated entirely behind cfg(target_os) so the Linux
paths are untouched.

v8-runtime (per-thread CPU accounting):
- timeout.rs: pthread_getcpuclockid has no macOS equivalent; the CpuBudgetGuard
  watchdog now reads the execution thread's CPU time via the Mach thread port
  (pthread_mach_thread_np + thread_info(THREAD_BASIC_INFO)), readable
  cross-thread like the Linux clockid.
- bridge.rs: RUSAGE_THREAD is Linux-only; process.cpuUsage/resourceUsage get
  per-thread CPU time from thread_info, the rest best-effort from RUSAGE_SELF.

sidecar (host-mount filesystem confinement):
- macos_fs.rs: macOS has no openat2(RESOLVE_BENEATH); resolve-beneath path
  resolution now goes through cap-std (audited userspace walk; openat2 on Linux,
  fd-relative O_NOFOLLOW walk elsewhere). F_GETPATH replaces readlink on
  /proc/self/fd; /dev/fd/N replaces /proc/self/fd/N.
- host_dir.rs + filesystem.rs: open_beneath / mapped-runtime helpers resolve via
  cap-std on macOS; O_PATH -> read-only anchor, O_TMPFILE -> empty. All nine
  mapped-runtime child ops (mkdir/rmdir/unlink/symlink/rename/readlink/lstat/
  lutimes) converted from the Linux /proc/self/fd-join idiom to fd-relative *at
  calls, since /dev/fd/N cannot have children appended. lstat goes through a
  platform-neutral HostStat translator; rename uses renameat with a real-path
  EXDEV fallback. Also fixes a latent dangling-fd bug in the mapped utimes path
  (the resolved handle is now held across the operation on both platforms).
- execution.rs: waitid/WNOWAIT is unavailable in nix on macOS; the child-status
  poll uses waitpid(WNOHANG) there.
- Plus latent macOS type-width fixes (mode_t/dev_t/nlink_t).

All sidecar lib tests pass on macOS, including every host-mount escape test.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: abcxff

Cargo.lock

@@ -56,6 +56,11 @@ url = "2"
 vbare = { workspace = true }
 vfs = { workspace = true }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+# macOS has no openat2/RESOLVE_BENEATH; cap-std provides the audited
+# resolve-beneath path resolution used in place of openat2 on this platform.
+cap-std = "3"
+
 [build-dependencies]
 vbare-compiler = { workspace = true }
 

crates/sidecar/Cargo.toml

@@ -62,7 +62,11 @@ use http::{HeaderMap, HeaderName, HeaderValue, Method, Request, Response, Uri};
 use md5::Md5;
 use nix::libc;
 use nix::sys::signal::{kill as send_signal, Signal};
-use nix::sys::wait::{waitid as wait_on_child, Id as WaitId, WaitPidFlag, WaitStatus};
+use nix::sys::wait::WaitStatus;
+#[cfg(not(target_os = "macos"))]
+use nix::sys::wait::{waitid as wait_on_child, Id as WaitId, WaitPidFlag};
+#[cfg(target_os = "macos")]
+use nix::sys::wait::{waitpid, WaitPidFlag};
 use nix::unistd::Pid;
 use openssl::bn::{BigNum, BigNumContext};
 use openssl::derive::Deriver;
@@ -20991,6 +20995,7 @@ pub(crate) fn runtime_child_is_alive(child_pid: u32) -> Result<bool, SidecarErro
     Ok(runtime_child_exit_status(child_pid)?.is_none())
 }
 
+#[cfg(not(target_os = "macos"))]
 fn runtime_child_exit_status(child_pid: u32) -> Result<Option<i32>, SidecarError> {
     if child_pid == 0 {
         return Ok(Some(0));
@@ -21016,6 +21021,30 @@ fn runtime_child_exit_status(child_pid: u32) -> Result<Option<i32>, SidecarError
     }
 }
 
+// macOS nix exposes no `waitid`/`WNOWAIT`, so we poll with `waitpid(WNOHANG)`.
+// NOTE: unlike Linux's `waitid(WNOWAIT)`, `waitpid` REAPS an exited child rather
+// than leaving it waitable. That is correct for this poll (the sidecar is the
+// reaping parent), but a second status query after exit returns ECHILD → treated
+// as "exited(0)" below.
+#[cfg(target_os = "macos")]
+fn runtime_child_exit_status(child_pid: u32) -> Result<Option<i32>, SidecarError> {
+    if child_pid == 0 {
+        return Ok(Some(0));
+    }
+
+    match waitpid(Pid::from_raw(child_pid as i32), Some(WaitPidFlag::WNOHANG)) {
+        Ok(WaitStatus::StillAlive)
+        | Ok(WaitStatus::Stopped(_, _))
+        | Ok(WaitStatus::Continued(_)) => Ok(None),
+        Ok(WaitStatus::Exited(_, status)) => Ok(Some(status)),
+        Ok(WaitStatus::Signaled(_, signal, _)) => Ok(Some(128 + signal as i32)),
+        Err(nix::errno::Errno::ECHILD) => Ok(Some(0)),
+        Err(error) => Err(SidecarError::Execution(format!(
+            "failed to inspect guest runtime process {child_pid}: {error}"
+        ))),
+    }
+}
+
 pub(crate) fn signal_runtime_process(child_pid: u32, signal: i32) -> Result<(), SidecarError> {
     if child_pid == 0 {
         return Ok(());