arcboxlabs/arcbox
58.6
Adequate · 14 November 2026
329.7k
lines of production code
Rust
primary language
4
measurements over time
What this system is
Features
Add util-linux backend for block device operations
The snapshot CoW manager now supports a \util-linux\ backend for loop device and block size operations, in addition to the existing \busybox\ backend. This new \UtilLinuxBlockTools\ implementation uses \losetup -f --show\ for atomic allocation and attachment, eliminating the race-condition retry loop required by busybox's limited applets. The module exposes a \BlockTools\ trait with \BusyboxBlockTools\ and \UtilLinuxBlockTools\ implementations, allowing the system to automatically detect and use the appropriate userland tools based on the environment.
_engine/arcbox-snapshot/src/snapshot\_cow/block\tools · high confidence
Add virtio-balloon device with free page reporting support
The virtio-balloon device is now available, implementing the traditional memory balloon subset of VirtIO 1.2. It supports inflating and deflating guest memory via dedicated queues and advertises the \VIRTIO\_BALLOON\_F\_DEFLATE\_ON\_OOM\ feature, allowing the guest to reclaim balloon pages during out-of-memory conditions. Additionally, it implements free page reporting (\VIRTIO\_BALLOON\_F\_REPORTING\), enabling the guest kernel to periodically hand batches of free pages to the host for release, facilitating continuous idle memory drain. The device uses a pluggable \PageReleaser\ interface, defaulting to \madvise(MADV\_DONTNEED)\ on Linux and allowing custom implementations (such as for HV backends) to handle host-specific memory reclamation.
virt/arcbox-virtio-balloon · high confidence
Added Python SDK code-generation scripts for protobuf and sync wrappers
Two new scripts were added to the Python SDK to automate code generation. \gen\_proto.py\ regenerates the internal \arcbox/\_gen\ module by running \protoc\ on sandbox protocol buffers and rewriting imports for location independence. \gen\_sync.py\ uses \unasync\ to mechanically generate synchronous API wrappers (e.g., \ArcBox\, \Sandbox\) from the existing asynchronous \\_async\ source trees, ensuring parity between sync and async surfaces.
sdk/python/scripts · high confidence
Added macOS host-tunnel proof harness for ArcBox data plane
A new \tun\_proxy\ example has been added to the \virt/arcbox-net\ crate, providing a macOS-only proof harness that drives real host egress traffic through the ArcBox data plane stack (including \FrameClassifier\, \TcpBridge\, and \HostEgress\). This tool opens a \utun\ interface and forwards TCP traffic to an upstream SOCKS5 proxy, demonstrating that the same stack used by the VM datapath can power a host-level proxy. It is intended for experimental verification rather than production use, requiring root privileges and offering best-effort writes without backpressure.
virt/arcbox-net/examples · high confidence
Define the wire protocol between the sandbox host and the vm-agent
This change introduces the \arcbox-vm-proto\ crate, which establishes the shared contract for communication between the host-side sandbox orchestrator and the guest-side \vm-agent\. It defines three distinct channels: boot parameters (including network configuration via \KernelIpParam\ and post-restore reconfiguration via \NetReconfigCommand\), an exec channel for running sessions with PTY support and clock synchronization, and a file channel for read/write/stat/list/watch operations. The protocol uses a binary frame format with JSON payloads, ensuring that both the host and the agent (which may be from different versions) can decode messages correctly through additive evolution and default field handling.
virt/arcbox-vm-proto · high confidence
Docker API compatibility layer with smart proxy and host networking reconciliation
ArcBox now provides a Docker Engine API compatibility layer that routes requests to a guest dockerd via a smart proxy. The server strips Docker API version prefixes (e.g., /v1.51/) to support any version, handles container lifecycle operations locally, and proxies the rest. On macOS, bind-mount paths are automatically rewritten to resolve symlinks (e.g., /tmp → /private/tmp) so they land on the VirtioFS share. A background reconciler periodically checks the guest's running container set and tears down host port-forwarding and DNS entries for containers that have stopped without an explicit API call, preventing resource leaks. Workload routing is centralized: arm64 workloads run natively, while amd64 workloads are routed to the HV utility VM via FEX translation, with VZ/Rosetta removed from the runtime path.
app/arcbox-docker/src · high confidence
E2B-compatible sandbox API surface for Python and TypeScript
The \arcbox.e2b\ (Python) and \@arcbox/sandbox/e2b\ (TypeScript) modules now provide an API surface compatible with the E2B SDK, allowing users to swap imports from \e2b\ to \arcbox.e2b\ while keeping their code. This surface exposes synchronous and asynchronous versions of \Sandbox\, \Commands\, \Filesystem\, \Git\, and \Pty\, backed by the local ArcBox daemon. Features include sandbox lifecycle management (create, connect, list, pause, kill), file operations, command execution with output streaming, and git operations. Unsupported E2B features like fork, volumes, signed URLs, metrics, MCP, and template build DSL raise \UnsupportedException\. Cloud-specific arguments (e.g., \api\_key\) are accepted but ignored, as authentication is handled by the local daemon via socket permissions.
sdk/python/src/arcbox/e2b, sdk/typescript/src/e2b · high confidence
Embedded Claude Code sandbox template and improved CLI error handling
The CLI now includes a built-in sandbox image template for Claude Code, allowing users to launch the agent without manually providing a Dockerfile. This template is built on Node.js 22 and includes necessary tools like git and ripgrep. Additionally, the CLI now provides actionable error messages for machine, sandbox, and snapshot operations, guiding users on how to resolve common issues like missing resources or unavailable services.
app/arcbox-cli/src · high confidence
Enhanced machine exec with flow control, debug shells, and TCP relay
The machine exec subsystem now supports flow-controlled sessions, ensuring output and stdin are managed within host-defined windows to prevent connection stalls. It introduces a debug shell capability that enters a container's namespaces (network, IPC, UTS, PID) and mounts fresh procfs/sysfs views using the agent's local busybox, allowing debugging of shell-less images without external dependencies. Additionally, exec requests can now be run as sshd-style login sessions, and the agent can relay TCP connections initiated from inside the machine, carrying both directions of data and half-closes through the same flow-controlled session loop.
_guest/arcbox-agent/src/agent/linux/machine\exec · high confidence
Explicit guest egress proxy policy and host environment detection
The \arcbox-fakeip\ crate now provides the core logic for explicit guest egress proxy configuration, replacing the previous behavior where the guest unconditionally inherited the host's system proxy. It introduces a \ProxyPolicy\ enum allowing operators to choose between \system\ (follow host settings), \none\ (direct connection), or a \custom\ proxy URL (HTTP CONNECT or SOCKS5). The crate includes \proxy\_detect\ to identify the host's current proxy/VPN environment (including Fake-IP ranges on macOS) and \dns\_log\ to map resolved IP addresses back to domain names, enabling the TCP bridge to tunnel by hostname rather than virtual IP.
common/arcbox-fakeip · high confidence
Extracted lock-free datapath primitives into a shared crate
The \arcbox-datapath\ crate has been introduced to provide reusable, high-performance networking primitives extracted from \arcbox-net\. This new library exposes a lock-free SPSC ring buffer (\LockFreeRing\) for zero-lock packet passing, a pre-allocated \PacketPool\ with O(1) allocation to avoid system malloc overhead, and a \FrameBuf\ type that manages buffer ownership via the pool or heap fallback. It also includes cache-line-aligned \DatapathStats\ for tracking TX/RX/NAT metrics without false sharing, along with utility functions for cache padding and software prefetching. This change centralizes these low-level components for reuse across host-side proxies and VM datapaths.
common/arcbox-datapath · high confidence
Extracted standalone NAT engine into arcbox-conntrack crate
The NAT engine has been extracted from \arcbox-net\ into a new, reusable \arcbox-conntrack\ crate, enabling non-VM consumers to utilize the same high-performance NAT datapath. This crate provides stateful connection tracking using Swiss Tables for O(1) lookups, zero-copy in-place packet translation for SNAT and DNAT with incremental checksums, and a \HostNetIO\ trait to abstract host-side network I/O mechanisms such as utun or TAP devices.
common/arcbox-conntrack · high confidence
Generated Python protobuf types for sandbox v1 API
The SDK now includes generated Python protocol buffer code for the \arcbox/sandbox/v1\ API, enabling type-safe interaction with sandbox services. This adds wire types for core sandbox operations (create, inspect, list, pause, resume, stop, remove), process management (start, attach, signal, wait, list executions), and filesystem access (read, write, stat, list, watch). It also introduces specific capabilities such as exposing and listing sandbox ports, watching sandbox lifecycle events (including a new monotonic sequence number on events), and handling nested virtualization support.
_sdk/python/src/arcbox/\gen · high confidence
Generated Rust bindings for the new Sandbox API and core protocol types
The generated protocol buffer code now includes the full Rust types for the new Sandbox API (arcbox.sandbox.v1), exposing capabilities for sandbox lifecycle management (create, stop, remove), resource limits, network configuration, and execution control. Additionally, the core arcbox.v1 module has been regenerated to include updated common types such as Mount, PortBinding, and ResourceLimits, along with network management services (create, list, inspect) and Kubernetes support, ensuring the client and server implementations have the latest contract definitions for these areas.
rpc/arcbox-protocol/src/generated · high confidence
Generated TypeScript SDK types for the sandbox v1 API
The TypeScript SDK now includes generated protocol-buffer types for the sandbox v1 API, covering the control plane (sandbox lifecycle, port exposure, events), data plane (filesystem and process operations), and supporting services (templates, snapshots). These generated files provide the message schemas, enums, and service definitions that the SDK uses to communicate with the sandbox daemon.
sdk/typescript/src/gen · high confidence
Guest agent boot readiness, container filesystem browsing, and sandbox lifecycle testing
The guest agent now reliably signals when the guest OS has finished booting by installing a distro-agnostic sentinel hook (systemd, OpenRC, or sysvinit) that writes a boot-ID-matched file to /run, allowing the host to gate machine readiness until the guest is truly ready. Additionally, the agent can now resolve container filesystem layer paths via the containerd snapshots service and export running container rootfses over NFSv4, enabling users to browse live container contents at \~/ArcBox. To support these capabilities, the agent's VMM configuration has been split into runtime and adapter halves, and new end-to-end smoke tests have been added to verify sandbox creation, network isolation, and execution flows.
guest/arcbox-agent/src · high confidence
Hypervisor defaults, nested virtualization support, and snapshotting capabilities
The hypervisor now automatically sizes VMs based on the host: vCPU count defaults to the host's logical core count and memory defaults to half of host RAM (clamped to 512 MB–16 GB and aligned to 1 MiB), with Linux builds respecting cgroup memory limits. A new capability probe detects nested virtualization support, and the VM configuration now includes a \nested\_virt\ flag to enable it when required. Additionally, the hypervisor interface now supports VM and vCPU snapshots, dirty page tracking for memory, and device state serialization. Also in this area: Updated vCPU and virtio integration tests for Clippy 1.99 compatibility; Darwin VM console pipe handling and lifecycle cleanup; macOS hypervisor backend refactored to use arcbox-vz and software dirty page tracking; Improved KVM stability and ARM64 boot support in the Linux hypervisor; Added integration tests for macOS hypervisor features; and 2 more.
virt/arcbox-hypervisor · high confidence
Initial release of the @arcbox/sandbox TypeScript SDK
The TypeScript SDK for ArcBox sandboxes is now available as the \@arcbox/sandbox\ npm package, enabling developers to programmatically manage isolated microVMs via the local daemon's Unix socket. The SDK provides a comprehensive API for sandbox lifecycle management (create, connect, kill, pause, info), command execution with foreground results and background streaming handles, file system operations, and event listening. It includes an E2B-compatible surface (\@arcbox/sandbox/e2b\) to allow existing E2B code to run against the local ArcBox daemon with minimal changes, handling behavioral differences such as port exposure requirements and timeout semantics. The package is built with Bunchee, uses Biome for formatting, and requires Node.js 22 or later.
sdk/typescript · high confidence
Initial release of the ArcBox Python SDK
The \arcbox\ Python package is now available, providing both synchronous and asynchronous clients to interact with the local ArcBox daemon. The SDK exposes a public API including \Sandbox\, \ArcBox\, \Commands\, \Files\, \Ports\, and \Templates\ classes, along with typed error handling (e.g., \ConnectionFailedError\, \CommandTimeoutError\) and version information. This release establishes the core transport layer using the Connect protocol over HTTPX, enabling users to manage sandboxes, execute commands, stream output, and handle file operations programmatically.
sdk/python/src/arcbox · high confidence
Initial release of the ArcBox gRPC protocol definitions
This change introduces the complete set of Protocol Buffer definitions for the ArcBox daemon and agent communication. It establishes the public API surface via \api.proto\ (covering Network, System, and Setup status services) and the internal guest agent contract via \agent.proto\ (providing health checks, runtime management, and resource monitoring streams). The schema also defines core domain services for managing container lifecycles (\container.proto\), image operations (\image.proto\), Kubernetes clusters (\kubernetes.proto\), and Linux virtual machines (\machine.proto\). Additionally, it adds a dedicated \macos.proto\ service for managing macOS guest VMs on Apple Silicon, a \stats.proto\ service for streaming machine resource samples, and \common.proto\ for shared types. The \buf.yaml\ configuration splits these into a public sandbox module and an internal daemon module, enforcing a breaking-change gate for the public contract.
rpc/arcbox-protocol/proto · high confidence
Initial repository scaffolding and developer guidelines
The repository now includes foundational configuration and documentation files to support development workflows. A \.envrc\ file configures the \devenv\ tool for reproducible development environments, and a \.pre-commit-config.yaml\ file enforces code quality by running \cargo fmt\ and \cargo clippy\ with strict warning checks before commits. Additionally, \AGENTS.md\ provides comprehensive guidelines for coding agents and contributors, covering project structure, code standards, architecture principles, and release procedures, while \CONTRIBUTING.md\ offers a guide for building from source, including prerequisites and code signing instructions for macOS. A \.release-please-manifest.json\ file establishes the versioning structure for the main project and its SDK components.
(repo-wide) · high confidence
Introduce ArcBox DHCP server with IP pool management and lease handling
Adds a new lightweight DHCP server implementation for ArcBox, including an IP address pool allocator, packet parsing for DHCP messages (RFC 2131), and a server that manages the DISCOVER/OFFER/REQUEST/ACK flow. The server supports IP reservations by MAC address, tracks active leases with configurable durations (default 24 hours), and quarantines declined IPs for 5 minutes to prevent immediate re-allocation of conflicting addresses while preserving reservations on release.
virt/arcbox-dhcp · high confidence
Introduce ArcBox Docker context management
Users can now manage Docker CLI contexts for ArcBox integration. The new \DockerContextManager\ in the context module allows creating, enabling, and disabling an 'arcbox' Docker context that points to the ArcBox socket, while preserving other Docker configuration fields. It also supports setting ArcBox as the default context and restoring the previous default when disabling or removing the context, with comprehensive tests verifying idempotency, status reporting, and config preservation.
app/arcbox-docker/src/context · high confidence
Introduce ArcBox host tool management library
Added a new Rust library (\app/arcbox-docker-tools\) that handles the download, installation, and management of host-side binaries for ArcBox on macOS. The library parses pinned versions and SHA-256 checksums from \assets.lock\ for tools such as Docker CLI, \kubectl\, and \pstramp\, and installs them to \\~/.arcbox/runtime/bin/\. It supports installation from local app bundles or CDN downloads, verifies checksums, and handles architecture-specific artifacts for \arm64\ and \x86\_64\.
app/arcbox-docker-tools · high confidence
Introduce ArcBoxVZShim Swift package for Virtualization framework access
Added the ArcBoxVZShim Swift package, which provides a C ABI boundary for the Rust backend to interact with macOS Virtualization framework objects. This shim exposes functions to configure VM settings (CPU, memory, boot loaders, platforms), construct device configurations (storage, network, serial, socket, entropy, graphics, directory shares, VirtioFS), manage VM lifecycle (start, stop, pause, resume), handle macOS restore images and IPSW installation, and perform vsock connections.
virt/arcbox-vz/shim · high confidence
Introduce Firecracker VM driver adapter
Added the \arcbox-fc-driver\ crate, implementing the \VmDriver\ port for Firecracker. This adapter manages the Firecracker and jailer processes, handles VM lifecycle operations (boot, restore, checkpoint, shutdown), and supports staging files into the jailer's chroot. It includes robust orphan recovery via \Adopt\, which discovers and reconnects to existing Firecracker processes by PID and command-line identity, providing a killable handle even when the API socket is unreachable. The driver enforces path safety within the jail, supports vsock communication, and restricts checkpoint capabilities to jailed VMs to ensure correct disk path handling during restore.
virt/arcbox-fc-driver · high confidence
Introduce Python SDK for ArcBox sandboxes
The \sdk/python\ directory now contains the initial release of the ArcBox Python SDK (v0.1.2), providing both synchronous (\Sandbox\) and asynchronous (\AsyncSandbox\) interfaces to manage isolated microVMs via the local daemon's Unix socket. The SDK supports core operations including creating and connecting to sandboxes, running commands with output streaming, and managing files. It also includes an E2B-compatible surface (\arcbox.e2b\) to allow existing E2B code to run against the local ArcBox daemon with minimal changes. The package is built with \uv\, uses \httpx\ for transport, and enforces strict typing with \pyright\ and linting with \ruff\.
sdk/python · high confidence
Introduce TypeScript SDK for ArcBox sandbox management
The \@arcbox/sandbox\ TypeScript SDK is now available, providing a programmatic interface to manage isolated microVM sandboxes via the local ArcBox daemon. Users can create, connect to, and list sandboxes, run commands with support for PTY, stdin, and output re-attachment, and manage the sandbox filesystem (read, write, watch). The SDK also exposes port management (expose, unexpose, wait for port), template catalog operations (build, list, get), and snapshot/restore capabilities. Connection resolution supports both local Unix sockets and remote API URLs, with configurable timeouts and API key authentication.
sdk/typescript/src · high confidence
Introduce arcbox-hv crate for Apple Hypervisor.framework bindings
The new \arcbox-hv\ crate provides safe Rust bindings for Apple's Hypervisor.framework on ARM64 macOS, enabling the construction of custom virtual machines. It exposes core VMM capabilities including VM lifecycle management (\HvVm\), vCPU execution and register access (\HvVcpu\), guest physical memory mapping, and ARM64 VM exit parsing. It also includes optional GICv3 interrupt controller support (gated behind the \gic\ feature for macOS 15+), typed error handling for framework return codes, and strict thread-safety constraints to comply with the framework's requirements.
virt/arcbox-hv · high confidence
Introduce arcbox-transport crate for host/guest communication
The new \arcbox-transport\ crate provides the foundational transport abstractions for ArcBox host/guest communication, introducing \UnixTransport\ for Unix domain sockets and \VsockTransport\ for virtio-vsock endpoints. It includes platform-specific implementations for Linux (using \AF\_VSOCK\ sockets) and macOS (integrating with \Virtualization.framework\), along with a \BlockingVsockTransport\ for the hypervisor agent control plane. The crate also implements in-band half-close and flow-control mechanisms via \HalfCloseStream\ to ensure reliable Docker attach sessions and prevent connection stalls on macOS. Also in this area: Improved connection lifecycle management and cancellation in transport layer; Fix vsock address structure usage on Linux.
rpc/arcbox-transport · high confidence
Introduce arcbox-vmnet crate for macOS virtual networking
The new \arcbox-vmnet\ crate provides safe Rust bindings to Apple's \vmnet.framework\, enabling VMs on macOS to connect via shared (NAT), host-only, or bridged modes. It includes a high-level \Vmnet\ interface for configuration and lifecycle management, low-level FFI bindings, and an event-driven \VmnetRelay\ that bridges \vmnet\ to a socketpair consumed by \VZFileHandleNetworkDeviceAttachment\. The relay uses an event callback to drain packets to the guest without a polling thread, improving efficiency. The crate also exposes a structured \VmnetError\ type for configuration and I/O failures, and includes integration tests for the public API.
virt/arcbox-vmnet · high confidence
Introduce async Python SDK with generated sync surface
The Python SDK now provides a native async interface (arcbox.\_async) built on an httpx-based Connect-over-httpx transport, exposing sandbox lifecycle management (create, connect, list), command execution with PTY and stdin re-attach, file operations with directory watching, port exposure and readiness waiting, and a template catalog client. A synchronous surface (arcbox.\_sync) is automatically generated from this async core to maintain parity, ensuring both programming models share the same underlying behavior and error handling.
_sdk/python/src/arcbox/\async · high confidence
Introduce guest-agent port and environment composition for sandbox orchestration
The runtime now exposes a dedicated guest-agent port (\GuestAgentFactory\) and an environment composition layer (\NodeEnvironment\) that decouples the sandbox manager from specific VMM and network implementations. Users can now inject custom agent clients and readiness gates (supporting dial-out, polling, or probe patterns) via the composer, allowing the runtime to reach the guest agent over vsock or other transports without hardcoding the connection logic. This change also introduces a hierarchical state machine for the computer lifecycle, separating pure transition logic from I/O-bound actor flows, and provides a \testkit\ with fake drivers and agents to enable testing without a real VMM.
computer/arcbox-computer-runtime/src · high confidence
Introduce local Docker runtime migration from Docker Desktop and OrbStack to ArcBox
The \app/arcbox-migration\ crate now provides a complete local migration flow that discovers and imports Docker objects (images, volumes, networks, and containers) from supported source runtimes—Docker Desktop and OrbStack—into the ArcBox target environment. The implementation includes a \MigrationPlanner\ to inspect source and target daemons and build a normalized \MigrationPlan\, and a \MigrationExecutor\ to carry out the import and recreation steps (including handling image ID reassignment, volume blockers, and container replacement). Users can now migrate their existing local Docker workloads into ArcBox via the CLI. Also in this area: Refactor test assertions for empty collections.
app/arcbox-migration · high confidence
Introduce macOS guest support with copy-on-write image cloning and NAT networking
Added a new macOS guest subsystem for Apple Silicon hosts, enabling the creation of disposable macOS VMs via copy-on-write cloning of base system images. The system supports pulling pre-built macOS images from a remote CDN (darwin.arcboxcdn.com) using a chunked, integrity-verified streaming restore, as well as installing from local or latest Apple IPSW files (behind the macos-ipsw-install feature flag). Guests are configured with NAT networking, and their IP addresses are discovered via the host's DHCP lease table using pinned MAC addresses. The lifecycle enforces a maximum of two concurrently running macOS guests per host, with serialization of start/stop/remove operations to prevent race conditions.
app/arcbox-core/src/macos · high confidence
Introduce native Rust SDK for ArcBox sandboxes
The \sdk/rust\ directory now contains the initial release of the native Rust SDK (\arcbox\), providing a complete interface for managing isolated microVM sandboxes via the local daemon's Unix socket. This SDK introduces a new client entry point (\ArcBox\) and sandbox handle (\Sandbox\) that support full lifecycle management (create, connect, list, info, kill, pause, and set\_lifecycle), command execution (foreground \run\ and background \spawn\ with offset-idempotent stdin and output re-attachment), file operations (streamed read/write, stat, list, mkdir, remove, rename, and watch), port management (wait\_for\_port, expose, unexpose, list), and snapshot capabilities (checkpoint, restore, list, delete). It also exposes a typed event stream for sandbox lifecycle changes. The SDK uses the Connect protocol over HTTP/2, maps daemon errors to a structured \Error\ type with actionable suggestions, and resolves connection settings via environment variables (\ARCBOX\_SOCKET\, \ARCBOX\_DATA\_DIR\, \ARCBOX\_PROFILE\) or explicit configuration.
sdk/rust · high confidence
Introduce safe Rust bindings for Apple Virtualization.framework
The \virt/arcbox-vz/src\ module now provides a new, async-first Rust API for managing macOS virtual machines via Apple's Virtualization.framework. This change introduces a Swift-based C ABI shim (\ArcBoxVZShim\) to handle framework interaction, exposing safe Rust types for VM lifecycle management (start, stop, pause, resume), configuration (CPU, memory, boot loaders, platforms), and device setup (network, storage, graphics, VirtioFS, vsock). It also adds support for macOS-specific features, including restore image handling, the macOS installer, and vsock communication with guests. Also in this area: New device configuration types for macOS Virtualization; VZ backend now uses a SwiftPM-compiled Swift shim instead of hand-written ObjC interop.
virt/arcbox-vz · high confidence
Introduce sandbox runtime configuration and jailer isolation settings
The runtime now exposes a structured configuration model for the sandbox environment, defined in \RuntimeConfig\. This includes \JailerConfig\ for VM isolation parameters (UID/GID, chroot, network namespaces, cgroups) and \ComputerConfig\ for Firecracker-specific settings such as data directories, snapshot restore pooling (\pool\_size\), and the new \warm\_create\ feature which allows subsequent VM creations to restore from pre-warmed template snapshots instead of cold-booting. Network and gRPC transport settings are also explicitly configurable, alongside default VM resource values (vCPUs, memory, kernel, rootfs) and boot arguments that select the VM agent as PID 1.
computer/arcbox-computer-runtime/src/config · high confidence
Introduce shared asset download and verification library
The \common/arcbox-asset\ crate now provides a unified library for downloading, verifying, and caching binary assets. It ensures data integrity by streaming downloads with incremental SHA-256 verification and writes files atomically using unique temporary paths to prevent corruption during concurrent operations. The library exposes architecture detection (mapping \aarch64\ to \arm64\) and progress reporting, serving as the foundation for asset preparation in \arcbox-boot\ and \arcbox-docker-tools\. Also in this area: Standardize empty-collection assertions in tests.
common/arcbox-asset · high confidence
Introduce shared constants crate for ArcBox configuration
A new \common/arcbox-constants\ library centralizes configuration values previously scattered across the codebase. It defines kernel command-line keys for boot parameters (such as Docker vsock ports, network CIDRs, and debug console paths), validates container network address pools, and specifies guest device paths (e.g., \/dev/vda\, \/dev/vdb\). The crate also standardizes runtime paths for Docker and containerd, SSH relay ports, and the privileged helper binary location. Additionally, it introduces the \ArcboxProfile\ enum to distinguish between production and development environments, sets the agent RPC protocol version to 6, and enforces a minimum helper version of 1.1.0 to ensure wire compatibility.
common/arcbox-constants · high confidence
Introduce shared error handling types for ArcBox
The \common/arcbox-error\ crate now provides a unified \CommonError\ enum and associated result type, allowing other ArcBox components to handle standard scenarios like I/O failures, configuration issues, resource not found, and timeouts consistently. This centralization reduces code duplication and ensures that error messages and handling patterns remain uniform across the system.
common/arcbox-error · high confidence
Introduce standalone vm-agent crate and shared wire protocol
The \arcbox-vm-agent\ crate is extracted from \arcbox-vm\ to provide a standalone guest-side daemon (PID 1 in the sandbox microVM) that handles exec sessions, file I/O, and filesystem watching over vsock. This change introduces the \arcbox-vm-proto\ crate, which defines the shared wire vocabulary (frame formats, opcodes, and data types) for the exec, file, and boot channels, ensuring both the host manager and guest agent use the same contract. The agent now includes pure, host-testable helpers for parsing inotify events (with rename pairing), resolving Docker-style user specifications, and checking TCP listen tables, while the binary itself handles Linux-specific syscalls like vsock, pty, and clock synchronization via \ptp\_kvm\.
virt/arcbox-vm-agent · high confidence
Introduce the VM driver port crate for VMM abstraction
The \virt/arcbox-vm-driver/src\ directory now contains the new \arcbox-vm-driver\ crate, which defines the standard interface (port) between the ArcBox orchestrator and underlying Virtual Machine Monitors (VMMs). This crate introduces \VmDriver\ and \VmHandle\ traits to manage VM lifecycle (boot, restore, shutdown) and exposes optional capabilities—such as vsock communication, checkpointing, file staging, and network attachment—through capability accessors. It also defines the serializable \VmSpec\ for VM configuration and the \GuestNetwork\ trait for managing host-side network resources like TAP interfaces and IP leases, effectively decoupling the orchestrator from specific VMM implementations like Firecracker or Virtualization.framework. Also in this area: Test assertions updated for Clippy 1.99 compatibility; Added contract tests for the VM driver port; Contract test suite for VM driver lifecycle and capabilities; New testkit for VM driver adapters.
virt/arcbox-vm-driver · high confidence
Introduce unified logging infrastructure with size-based rotation and structured output
The \common/arcbox-logging\ crate now provides a centralized logging system that writes machine-parseable JSON logs to rotating files (defaulting to 10 MB per file, keeping 5 backups) and optional human-readable logs to stderr when running in the foreground. It initializes the \tracing\ subscriber with configurable filters, supports Sentry integration via a feature flag, and ensures log data is flushed on shutdown via a returned \LogGuard\.
common/arcbox-logging · high confidence
Introduces durable storage manifest and single-use volume provisioning
The \common/arcbox-storage\ crate now enforces strict identity verification and single-use formatting authority for paired runtime volumes. It introduces a \StorageManifest\ that records the host identity (device and inode) and filesystem UUID for both data and metadata images, ensuring they are not replaced or duplicated. Provisioning is now atomic and durable: new volumes receive a one-time provisioning header that grants formatting authority exactly once, and interrupted operations are safely resumable without recreating missing members or reformatting existing ones. The system also supports legacy migration paths where an existing data volume is paired with a new metadata volume, requiring explicit verification before the metadata image is formatted.
common/arcbox-storage · high confidence
Introduction of ArcBox Protocol definition crate
The \rpc/arcbox-protocol\ crate has been added to provide the canonical Protocol Buffer message and service definitions for ArcBox. This new component generates Rust types from a comprehensive set of \.proto\ files covering common types, machine and container lifecycles, image management, agent health, API operations, Kubernetes support, and sandbox-specific resources (processes, filesystems, snapshots, templates, and errors). The crate enforces a strict separation between the protocol layer and data serialization by excluding serde derives from the generated code, ensuring that persisted JSON formats remain decoupled from the protobuf schema evolution. Also in this area: Agent protocol v7 introduces storage health monitoring and recovery; New machine management RPCs and migration safety checks.
rpc/arcbox-protocol · high confidence
Linux guest agent implementation with Btrfs storage, Kubernetes, and exec support
The Linux guest agent now handles vsock RPCs to manage the guest environment, including starting and stopping a single-node Kubernetes cluster, executing commands in the guest or inside containers, and reclaiming disk space via FITRIM. It formats the data disk as Btrfs with dedicated subvolumes for Docker, containerd, and sandboxes, and mounts a separate ext4 volume for fsync-heavy metadata to improve performance.
guest/arcbox-agent/src/agent/linux · high confidence
Machine export and import via sparse tar.zst archives
The engine now supports exporting and importing virtual machines as zstd-compressed tar archives. Exporting writes a manifest (containing machine settings and the required rootfs image) followed by the data disk as a GNU sparse 1.0 entry, which stores only the written extents to keep archive sizes small. Importing reads the manifest to validate the archive format and restores the data disk, preserving sparse holes even if the archive was created by tools that store the disk as a dense file. The rootfs is not included in the archive; import requires the specified image to already exist in the local registry.
engine/arcbox-engine/src/machine/archive · high confidence
Migration manager now supports idempotent re-attachment and safe storage recovery
The migration subsystem in \app/arcbox-core/src/migration\ has been updated to allow clients to safely re-attach to an ongoing migration run without losing progress, by buffering the latest event and streaming subsequent updates. Additionally, a new storage recovery mechanism is introduced that mutually excludes migration execution, ensuring that storage recovery cannot run while a migration is active and vice versa. The migration plan is now projected to wire DTOs for external consumption, and the manager exposes prepared replacement targets for inspection.
app/arcbox-core/src/migration · high confidence
NFSv3 export of the guest machine's root filesystem to the host
The ArcBox agent now serves the guest machine's root filesystem to the host via an NFSv3 server running inside the guest. This allows the host to mount the machine's files at \~/ArcBox/machines/\<name\> for read-write access. The implementation includes an ownership mapping (IdMap) to translate between host and guest user IDs, a stable ID table to handle filesystem objects across renames and copies, and a security relay that only accepts connections from the host's bridge network address.
_guest/arcbox-agent/src/machine\export · high confidence
New CLI commands for boot asset management, Docker plugin registration, and sandbox-based coding agents
The CLI now includes \abctl boot\ commands (prefetch, status, clear, list) to manage and verify boot assets and runtime binaries, \abctl docker plugins\ to register or unregister Docker CLI plugins like compose and buildx, and \abctl claude\ to run coding agent sessions inside isolated sandboxes. Additionally, new commands \abctl debug\ for container debugging, \abctl disk\ for usage and recovery, and \abctl daemon\ for lifecycle management are available, along with improved bundle detection for locating the daemon binary.
app/arcbox-cli/src/commands · high confidence
New PTY primitives crate for interactive sessions
A new \arcbox-pty\ crate has been added to provide shared primitives for interactive machine sessions. It implements Linux-specific PTY allocation, window resizing, and a secure privilege-dropping sequence (setsid, TIOCSCTTY, fd duplication, and credential drop) to establish a controlling terminal for child processes. This enables consistent, secure interactive exec capabilities across the sandbox microVM agent and the machine-level agent.
common/arcbox-pty · high confidence
New SSH server for direct machine access
The daemon now includes an SSH server that allows you to connect directly to your machines using standard SSH clients. It generates and manages its own host and client keys, and writes an OpenSSH client configuration file to simplify authentication and host key pinning. The server supports shell and command execution sessions, SFTP file transfers, and TCP port forwarding (local tunnels), while correctly handling terminal sizes, environment variables, and process signals.
app/arcbox-ssh/src · high confidence
New VMM boot examples for HV and default backends
Added two new example programs in the \virt/arcbox-vmm/examples\ directory: \hv\_boot\_test.rs\ and \vmm\_boot.rs\. The \hv\_boot\_test\ example demonstrates an end-to-end boot sequence using the custom Hypervisor.framework backend (\VmBackend::Hv\), including loading a kernel and rootfs block device, monitoring serial output, and performing a clean shutdown. The \vmm\_boot\ example provides a simpler demonstration of the VMM layer using the default backend, loading a kernel and optional initrd, and monitoring VM state. These examples serve as reference implementations for configuring and running the VMM with different backends and boot configurations.
virt/arcbox-vmm/examples · high confidence
New VMM module with dual macOS backend support (HV and VZ)
The \virt/arcbox-vmm\ module introduces a new Virtual Machine Monitor implementation that supports both Apple's Virtualization.framework (VZ) and Hypervisor.framework (HV) backends on macOS, alongside a KVM-based path for Linux. Users can now select the backend via the \VmBackend\ configuration enum, enabling features like Rosetta 2 translation (VZ), nested virtualization (VZ), and a custom HV path with manual vCPU execution. The module also adds support for VirtioFS shared directories, memory balloon devices, vsock communication, and a debug console socket for the HV backend. Also in this area: macOS HV VM shutdown now waits for guest poweroff; Updated virtualization documentation to reflect vCPU wake mechanism changes; New dedicated I/O workers and DAX mapper for the HV backend; Refactored device manager with new modular submodules and debug capabilities; New HV backend for macOS with manual vCPU execution and full VirtIO emulation; and 2 more.
virt/arcbox-vmm · high confidence
New \`check-layers\` cargo command enforces workspace dependency rules
Developers can now run \cargo xtask check-layers\ to validate that the workspace's direct dependency edges comply with architectural layer rules (e.g., ensuring the engine and computer layers remain daemon-free and do not depend on app-layer crates). The command reads the \cargo metadata\ graph, checks it against a defined set of rules and grandfathered exceptions, and fails the build if any violations or stale exceptions are detected, helping to maintain strict separation between architectural layers.
xtask · high confidence
New arcbox-grpc crate for gRPC service bindings
The \rpc/arcbox-grpc\ crate has been introduced to provide tonic-generated gRPC client and server implementations for ArcBox services. It exposes clients and servers for Machine, Macos, Agent, Migration, Volume, Icon, and System services, alongside a split control-plane/data-plane set for Sandbox operations (Sandbox, Template, Process, Filesystem, and Snapshot services). The crate re-exports these services and the underlying \arcbox\_protocol\ and \tonic\ dependencies for convenient consumption by other parts of the system.
rpc/arcbox-grpc · high confidence
New batch datagram I/O API for reduced syscall overhead
The \arcbox-xnu-net\ crate now exposes \BatchDgram\ and \AsyncBatchDgram\ to send and receive multiple datagrams in a single system call, reducing overhead for high-throughput workloads like L2 Ethernet frames over \AF\_UNIX SOCK\_DGRAM\. On macOS, this uses \recvmsg\_x\/\sendmsg\_x\, and on Linux, \recvmmsg\/\sendmmsg\. The API automatically clamps batch sizes to the live kernel limits (e.g., \kern.ipc.maxrecvmsgx\ on macOS) and handles non-blocking readiness via \WouldBlock\ retries. An async variant is available behind the \tokio\ feature, integrating with \tokio::io::AsyncFd\ for readiness-based polling.
common/arcbox-xnu-net · high confidence
New local development and installation tooling for the ArcBox daemon
Developers and users now have dedicated scripts to streamline daemon management and installation. A new \dev-daemon.sh\ harness allows developers to build, run, and verify the daemon directly against the current code checkout, including a cold-boot reliability loop and automatic crash symbolication, ensuring the correct binary is tested. A \dev.arcbox.daemon.plist\ provides a launchd configuration for running the daemon as a user agent with a 45-second shutdown timeout to preserve the full VM stop budget. Additionally, a new \install.sh\ script enables one-line installation of the \abctl\ CLI and \arcbox-daemon\ binaries with automatic version resolution, architecture detection, and codesigning for macOS 12+, while a \docker-cli-e2e.sh\ script facilitates end-to-end testing of Docker CLI compatibility against the daemon.
scripts · high confidence
New macOS and Linux virtualization examples for arcbox-vz
Added a suite of diagnostic and demonstration examples for the arcbox-vz crate. For macOS, the new examples cover the full lifecycle: \macos\_validate\ (Gate A) verifies VM configuration validity, \macos\_probe\ tests fast boot from metadata, \macos\_install\ (Gate B) performs a full OS installation from an IPSW, \macos\_clone\_boot\ verifies copy-on-write disk cloning, and \macos\_latest\_url\ retrieves the latest restore image URL. For Linux, \simple\_vm\ demonstrates basic kernel booting, \virtiofs\ shows directory sharing between host and guest, and \vsock\_echo\ tests socket communication with a guest service.
virt/arcbox-vz/examples · high confidence
New modular VirtIO console device with multiple I/O backends
The \virt/arcbox-virtio-console\ crate now provides a fully implemented VirtIO console device (\VirtioConsole\) that supports multiple I/O backends via a unified \ConsoleIo\ trait. Users can connect the guest console to standard I/O (\StdioConsole\), a testable buffer (\BufferConsole\), a real terminal via pseudo-terminals on Unix (\PtyConsole\), or a Unix socket for remote access (\SocketConsole\). The device handles multiport configuration, manages TX/RX queues, and ensures thread-safe PTY allocation to prevent race conditions on macOS.
virt/arcbox-virtio-console · high confidence
New modular network stack with cross-platform backends and DNS/mDNS features
The \arcbox-net\ crate has been restructured into a modular network stack that provides NAT, bridge, and host-only networking modes. It introduces platform-specific network backends: a TAP device implementation for Linux and a vmnet wrapper for macOS, both conforming to a unified \NetworkBackend\ trait. The stack now includes a built-in DNS forwarder that supports local hostname resolution, configurable upstream servers, and a shared hosts table, along with an mDNS responder for multicast-based discovery. Networking capabilities are further extended with a DHCP server, a NAT engine for address translation, a TCP/UDP port forwarding service, and a unified timer wheel for efficient flow timeout management. Also in this area: Clarified crate documentation and refined DNS test assertion; Improved local DNS negative responses and added change streaming; Refactored Darwin network datapath loop for lossless delivery and performance; Improved DNS reliability with raw response caching and dynamic upstream following; New Linux network stack implementation for virtualization; and 1 more.
virt/arcbox-net · high confidence
New proxy crate with SOCKS5/HTTP CONNECT egress and L2 inbound relay
The \arcbox-proxy\ crate introduces dedicated modules for host-level proxying and inbound traffic handling. It adds SOCKS5 and HTTP CONNECT clients to tunnel TCP and UDP traffic through upstream proxies, ensuring hostnames are resolved by the proxy to support fake-IP environments. Additionally, it implements an inbound relay that forwards host-to-guest connections by injecting crafted L2 Ethernet frames directly into the guest's network interface, bypassing kernel routing. Also in this area: Expose listener count and empty status in InboundListenerManager.
common/arcbox-proxy/src · high confidence
New sandbox API protocol definitions
The sandbox control and data planes are now defined in the \arcbox/sandbox/v1\ proto package, introducing a structured API for managing sandbox lifecycles, executing processes, and handling filesystem operations. The \sandbox.proto\ file establishes the control plane, defining the sandbox state machine (STARTING, READY, RUNNING, PAUSED, etc.) and lifecycle RPCs such as Create, Pause, Resume, and SetLifecycle. The \process.proto\ file introduces the data plane for addressable, resumable executions, allowing clients to start, attach to, and manage process I/O (stdin/stdout) with offset-based reconnection support. The \filesystem.proto\ file adds a data-plane service for file transfers and path operations (ReadFile, WriteFile, Stat, ListDir, etc.) within the sandbox. Additionally, \errors.proto\ provides a centralized error registry with machine-readable codes and actionable suggestions, while \template.proto\ defines a first-class template catalog for versioned, reproducible sandbox bases. The \snapshot.proto\ file supports checkpoint and restore functionality for cold-start optimization.
rpc/arcbox-protocol/proto/arcbox · high confidence
New shell integration setup and uninstall commands
The CLI now includes \setup install\, \setup uninstall\, \setup status\, and \setup completions\ commands to manage shell integration. Installing creates symlinks for \abctl\ and Docker tools, generates shell completion scripts for Zsh, Bash, and Fish, and injects initialization lines into the user's shell profile. Uninstalling reverses these changes, removing the symlinks, completion files, and profile entries. The status command checks the health of the integration, verifying the binary symlink, profile injection, and login shell PATH/completion availability.
app/arcbox-cli/src/commands/setup · high confidence
New snapshot engine crate for checkpoint and template management
The \engine/arcbox-snapshot\ crate introduces the core engine-layer logic for managing VM snapshots and sandbox templates. It provides a snapshot catalog for storing and retrieving checkpoint metadata (including full and diff types, geometry, and labels), a copy-on-write (CoW) rootfs manager that uses device-mapper snapshots to share read-only template images across sandboxes efficiently, and a versioned template catalog for building, publishing, and resolving sandbox base images with optional pre-warmed snapshots. The implementation includes robust error handling, durable file operations, and support for both busybox and util-linux block-device tooling.
engine/arcbox-snapshot/src · high confidence
New splicetcp crate for userspace TCP termination and frame classification
The \common/splicetcp\ crate introduces a modular, userspace TCP termination shim and frame plane for the ArcBox datapath. It provides a \FrameClassifier\ to demultiplex inbound Ethernet frames (ARP, TCP, UDP, ICMP, DHCP, DNS) and a \TcpBridge\ for fast-path data plane handling without a full userspace TCP stack. The crate includes a \FragmentReassembler\ to handle guest-originated IPv4 fragments, an \EgressResolver\ trait with a \DefaultEgress\ implementation for system-proxy-aware outbound connections, and a \FlowObserver\ seam for per-flow byte accounting. Ingest is handled via pluggable \FrameSource\ implementations (including batched reads via \recvmsg\_x\ on macOS) and egress via \FrameSink\ traits, with an L3-to-L2 shim to support \utun\ interfaces. Also in this area: Improved upload reliability and performance in splicetcp fast path; Standardize empty-collection assertions in tests; Replaces smoltcp-based TCP stack with a custom TCP bridge shim.
common/splicetcp · high confidence
Python SDK connection resolution and type definitions
The Python SDK now includes explicit connection configuration and resolution logic, allowing users to connect to the local daemon via a Unix socket or a remote proxy using environment variables (ARCBOX\_API\_URL, ARCBOX\_SOCKET) or explicit options. It also introduces hand-written public data types (DTOs) for sandbox states, command results, file metadata, and lifecycle events, ensuring consistent, generated-free shapes for the SDK's public API.
arcbox · high confidence
Rootfs builder now enforces capacity and injects the VM agent
The rootfs build process now allows callers to specify a precise ext4 image capacity (in 128 MiB granularities) and builds the image at a caller-owned path. During the build, the VM agent is automatically injected into the image at /sbin/vm-agent, and /etc/resolv.conf is symlinked to /run/resolv.conf to ensure DNS rewrites do not hit the copy-on-write block device. The build validates that the resulting image geometry matches the requested capacity and ensures all loop devices and mounts are cleaned up even if errors occur.
computer/arcbox-computer-runtime/src/rootfs · high confidence
Serve the machine root as an NFSv3 filesystem
The agent now exports the virtual machine's root directory over NFSv3, allowing the host to access and modify guest files using standard network file system operations. This implementation includes a VFS layer that handles file creation, modification, and deletion while specifically managing Mac-specific AppleDouble sidecar files (.\_ files) by either hiding them or translating them into real extended attributes, ensuring compatibility with macOS clients.
_guest/arcbox-agent/src/machine\export/vfs · high confidence
VirtIO block device now supports DISCARD and WRITE\_ZEROES operations
The VirtIO block device implementation in this crate now handles DISCARD and WRITE\_ZEROES requests from the guest. This is enabled by new wire types in \request.rs\ (including \BlockRequestType::Discard\ and \WRITE\_ZEROES\_FLAG\_UNMAP\), a shared \punch.rs\ module that implements sparse-file zeroing and hole-punching for Linux and macOS, and a new \AsyncBlockBackend\ trait in \backend.rs\ that allows backends like \DirectIoBackend\ and \MmapBackend\ to support these operations. Users can now benefit from space reclamation and efficient zeroing in their virtual disks.
virt/arcbox-virtio-blk · high confidence
VirtioFS server refactored with DAX support and adaptive caching
The \virt/arcbox-fs/src\ module has been restructured into a new modular architecture (cache, dispatcher, error, fuse, passthrough, server) to support end-to-end VirtioFS DAX (Direct Access) and improved performance. The server now exposes a \DaxMapper\ trait and integrates a \FuseDispatcher\ that handles FUSE protocol version 7.38, including \SetupMapping\ and \RemoveMapping\ opcodes for zero-copy guest memory mapping. Caching behavior has been enhanced with configurable \CacheProfile\ presets (Static, Dynamic, Custom) for entry/attribute timeouts and a new \NegativeCache\ with adaptive TTL rules for stable paths like \node\_modules\ and \.git\. Additionally, the FUSE dispatcher now uses \read\_unaligned\ for safe parsing of unaligned VirtIO queue memory, and the \PassthroughFs\ backend includes TOCTOU-safe inode open checks to harden against hostile guests. Also in this area: Clarified documentation for arcbox-fs error handling and architecture; Refactored FUSE dispatcher into modular operation handlers; Test assertions updated for Clippy 1.99 compatibility; Refactored passthrough FUSE filesystem into modular components.
virt/arcbox-fs · high confidence
macOS AppleDouble sidecar images are translated into target extended attributes
The agent now intercepts macOS NFSv3 writes to \.\\ sidecar files and converts their AppleDouble content into the target file's extended attributes. Large values that exceed filesystem limits are stored in a hidden side-entry directory, while smaller attributes are applied directly to the inode. This ensures that macOS-specific metadata, such as Finder Info and resource forks, is preserved and accessible within the exported machine without littering the filesystem with \.\\ files.
_guest/arcbox-agent/src/machine\export/vfs/sidecar · high confidence
macOS bundle entitlements split and helper daemon configuration
The macOS application bundle now uses separate entitlement files for development and release builds to support the hardened runtime and local development environments. The release entitlements include \com.apple.vm.networking\ for direct VMnet bridge access, while the new development entitlements disable library validation to accommodate non-Apple-signed dependencies (like nix-store libiconv) and omit the restricted networking entitlement to allow ad-hoc signing for CI tests. Additionally, the bundle includes a new launchd plist for the desktop helper service, configuring it with an idle-exit flag, a specific socket path, and a 45-second exit timeout to ensure graceful shutdown.
bundle · high confidence
Removals
Removal of VirtIO device implementations
The \arcbox-virtio\ crate has been removed, eliminating the block, network, console, filesystem, and vsock device emulation layers from the virtual machine environment. Users will no longer have access to these specific VirtIO-based hardware interfaces for guest I/O operations.
crates/arcbox-virtio · high confidence
Removed Darwin and Linux hypervisor platform implementations
The \arcbox-hypervisor\ crate has removed its platform-specific virtual machine implementations for macOS (Darwin) and Linux. The deleted files include the Darwin FFI bindings for the Virtualization.framework, the Darwin memory, vCPU, and VM modules, as well as the Linux KVM VM implementation. Additionally, the crate's common types file, which defined CPU architectures, platform capabilities, register states, and VirtIO device configurations, has been removed. This change eliminates the existing code responsible for managing virtual machines and their hardware abstractions on these two operating systems.
crates/arcbox-hypervisor · high confidence
Security
Hardened peer authentication and strict input validation for the helper server
The ArcBox helper server now enforces strict security boundaries for privileged operations. In release builds, it requires peer authentication via macOS code-signing verification (checking Team ID and allowed bundle identifiers) before accepting connections on the Unix socket, while debug builds skip this check for local development. Additionally, all RPC mutations now perform strict dynamic validation at the server boundary, ensuring that mutation functions only receive strongly typed, validated inputs rather than raw strings, and the server supports launchd socket activation for improved lifecycle management.
app/arcbox-helper/src/server · high confidence
Architecture
Extracted boot asset and machine image management into a new engine crate
The boot asset and machine image management logic has been extracted from \arcbox-core\ into a new, standalone \arcbox-image\ crate. This new module provides the daemon with the ability to manage the compile-time-pinned boot asset chain (kernel, EROFS rootfs, and runtime binaries like dockerd and k3s) and the published Linux machine image registry. Users benefit from a cleaner separation of concerns where the engine layer remains platform-neutral and daemon-free, while the specific logic for downloading, caching, and verifying these critical VM startup components is now isolated in its own package.
_engine/arcbox-image/src/boot\assets · high confidence
Removal of legacy VMM, device, and IRQ modules
The \arcbox-vmm\ crate has removed its previous implementation files (\vmm.rs\, \device.rs\, and \irq.rs\), which previously contained the main Virtual Machine Monitor logic, VirtIO MMIO device management, and a basic IRQ chip abstraction. This deletion indicates a structural refactoring where these components are being replaced or moved to other locations within the codebase.
crates/arcbox-vmm · high confidence
Unified VirtIO queue infrastructure and memory accessors
The \arcbox-virtio-core\ crate now provides the foundational types for all VirtIO devices, replacing fragmented per-device implementations. It introduces \GuestMemWriter\ for safe, GPA-based access to guest RAM, and a unified \SplitQueue\ abstraction that handles descriptor chain iteration, used-ring publishing, and notification suppression (including EVENT\_IDX support) in a single, cycle-safe location. The \VirtQueue\ implementation has been enhanced with batched used-ring updates and explicit EVENT\_IDX feature negotiation, while error handling now integrates with the central \arcbox-error\ crate.
virt/arcbox-virtio-core · high confidence
Behavioural changes
1 commit (0 fixes) modifying computer/arcbox-sandbox-service, guest/arcbox-agent/src/sandbox
A change to existing behaviour in computer/arcbox-sandbox-service, guest/arcbox-agent/src/sandbox — 1 commit, 18 files: “refactor(computer): move the Sandbox API service out of the guest agent”.
computer/arcbox-sandbox-service, guest/arcbox-agent/src/sandbox · low confidence · unverified
1 commit (0 fixes) modifying runner, runner/arcbox-runner-control-proto, runner/arcbox-runner-proto
A change to existing behaviour in runner, runner/arcbox-runner-control-proto, runner/arcbox-runner-proto — 1 commit, 10 files: “refactor(runner)!: rename Fleet to ArcBox Runners”.
runner, runner/arcbox-runner-control-proto, runner/arcbox-runner-proto · medium confidence · unverified
1 commit (0 fixes) modifying virt/arcbox-vmm/examples/checkpoint\_blk\_spike
A change to existing behaviour in virt/arcbox-vmm/examples/checkpoint\_blk\_spike — 1 commit, 7 files: “test(vmm): multi-vCPU virtio-blk checkpoint probe”.
_virt/arcbox-vmm/examples/checkpoint\_blk\spike · medium confidence · unverified
1 commit (0 fixes) modifying virt/arcbox-vmm/examples/checkpoint\_common, virt/arcbox-vmm/examples/checkpoint\_spike
A change to existing behaviour in virt/arcbox-vmm/examples/checkpoint\_common, virt/arcbox-vmm/examples/checkpoint\_spike — 1 commit, 7 files: “test(hv): bare-metal checkpoint probe”.
_virt/arcbox-vmm/examples/checkpoint\_common, virt/arcbox-vmm/examples/checkpoint\spike · medium confidence · unverified
1 commit (0 fixes) modifying virt/arcbox-vmm/examples/qemu\_probe
A change to existing behaviour in virt/arcbox-vmm/examples/qemu\_probe — 1 commit, 7 files: “test(vmm): add a QEMU backend probe”.
_virt/arcbox-vmm/examples/qemu\probe · medium confidence · unverified
10 commits (3 fixes) modifying app/arcbox-core/src/runtime/web\_services
A change to existing behaviour in app/arcbox-core/src/runtime/web\_services — 10 commits (3 fixs), 4 files: “refactor(tls): authorize signing through captured guests”; “feat(core): capture guest web signing authority”; “feat(protocol): distinguish machine web endpoints”; and 7 more.
_app/arcbox-core/src/runtime/web\services · medium confidence · unverified
10 commits (3 fixes) modifying app/arcbox-helper/src/server/mutations/dns
A change to existing behaviour in app/arcbox-helper/src/server/mutations/dns — 10 commits (3 fixs), 4 files: “feat(helper): lease resolver roots to verified daemon connections”; “test(helper): cover resolver authority watches and EOF cleanup”; “fix(helper): migrate selected inactive legacy resolvers”; and 7 more.
app/arcbox-helper/src/server/mutations/dns · medium confidence · unverified
11 commits (0 fixes) modifying virt/arcbox-hv-driver
A change to existing behaviour in virt/arcbox-hv-driver — 11 commits, 13 files: “test(hv-driver): check side-by-side VMs and resume in a new process”; “feat(hv-driver): boot, prepare and adopt VMs in arcbox-hv-vmm processes”; “feat(hv-driver): checkpoint, balloon, port forward and debug over the socket”; and 8 more.
virt/arcbox-hv-driver · medium confidence · unverified
11 commits (4 fixes) modifying app/arcbox-docker/src/handlers/container/ca\_injection
A change to existing behaviour in app/arcbox-docker/src/handlers/container/ca\_injection — 11 commits (4 fixs), 4 files: “fix(docker): recheck readiness after failed container inspection”; “refactor(docker): register host names from validated inspect metadata”; “fix(net): admit container mutations against a physical VM”; and 8 more.
_app/arcbox-docker/src/handlers/container/ca\injection · medium confidence · unverified
12 commits (3 fixes) modifying common/arcbox-packet/src/ethernet
A change to existing behaviour in common/arcbox-packet/src/ethernet — 12 commits (3 fixs), 5 files: “refactor(packet): share IPv4 TCP control and data encoding”; “feat(packet): encode IPv4 and IPv6 SYN frames”; “fix(packet): clamp negotiated TCP window scale to 14”; and 9 more (refs \#412).
common/arcbox-packet/src/ethernet · medium confidence · unverified
13 commits (3 fixes) modifying app/arcbox-cli/src/commands/uninstall
A change to existing behaviour in app/arcbox-cli/src/commands/uninstall — 13 commits (3 fixs), 6 files: “feat(cli): uninstall the host mount root and the layout before it”; “feat(cli): add the uninstall steps, each reporting what it did (\#716)”; “fix(tls): serialize trust and identity mutations per profile”; and 10 more (refs \#716, \#710).
app/arcbox-cli/src/commands/uninstall · medium confidence · unverified
13 commits (6 fixes) modifying guest/arcbox-agent/src/docker\_events
A change to existing behaviour in guest/arcbox-agent/src/docker\_events — 13 commits (6 fixs), 1 file: “fix(agent): retain cleanup ownership until rule removal succeeds”; “refactor(guest): share sandbox DNS ownership”; “fix(dns): share builtin reservations with the guest”; and 10 more.
_guest/arcbox-agent/src/docker\events · medium confidence · unverified
15 commits (7 fixes) modifying app/arcbox-api/src/connect/machine
A change to existing behaviour in app/arcbox-api/src/connect/machine — 15 commits (7 fixs), 5 files: “feat(api): expose machine directory before System VM initialization”; “fix(engine): let a force stop wait for the host to release a machine's root”; “feat(protocol,api): add machine clone, export, import, resize and default RPCs”; and 12 more.
app/arcbox-api/src/connect/machine · medium confidence · unverified
18 commits (4 fixes) modifying common/arcbox-dns
A change to existing behaviour in common/arcbox-dns — 18 commits (4 fixs), 12 files: “feat(dns): store ownership and revisions in shared registry”; “fix(dns): preserve unknown query types during local lookup”; “test: add integration tests for DNS, shared table, and aliases”; and 15 more.
common/arcbox-dns · medium confidence · unverified
18 commits (5 fixes) modifying virt/arcbox-vhost-user
A change to existing behaviour in virt/arcbox-vhost-user — 18 commits (5 fixs), 10 files: “feat(vhost-user): message header and request codes”; “feat(vhost-user): ring cursors, call notifiers and the device queue API”; “feat(vhost-user): serve virtio-fs shares through FsServer”; and 15 more.
virt/arcbox-vhost-user · medium confidence · unverified
2 commits (0 fixes) modifying computer/arcbox-oci
A change to existing behaviour in computer/arcbox-oci — 2 commits, 16 files: “refactor(oci): move arcbox-oci next to the workload contract”; “docs(adr): renumber the host sandbox ADR to 0011”.
computer/arcbox-oci · medium confidence · unverified
2 commits (0 fixes) modifying engine/arcbox-engine/src/machine/web\_ports
A change to existing behaviour in engine/arcbox-engine/src/machine/web\_ports — 2 commits, 2 files: “feat(api): expose saved machine web policies”; “feat(engine): persist machine web port policies”.
_engine/arcbox-engine/src/machine/web\ports · medium confidence · unverified
2 commits (0 fixes) modifying guest/arcbox-agent/src/agent/linux/storage\_check
A change to existing behaviour in guest/arcbox-agent/src/agent/linux/storage\_check — 2 commits, 3 files: “feat(agent): repair a stale Btrfs free space tree in the recovery guest”; “test(agent): verify storage recovery against real Linux faults”.
_guest/arcbox-agent/src/agent/linux/storage\check · medium confidence · unverified
2 commits (0 fixes) modifying runtime/arcbox-container
A change to existing behaviour in runtime/arcbox-container — 2 commits, 5 files: “refactor: reorganize workspace directory layout”; “refactor: reorganize workspace directory layout (\#53)” (refs \#53).
runtime/arcbox-container · medium confidence · unverified
2 commits (1 fix) modifying common/arcbox-atomic-file
A change to existing behaviour in common/arcbox-atomic-file — 2 commits (1 fix), 1 file: “refactor(engine): extract arcbox-snapshot, and give the durable-write primitive a crate (restructure phase 4a) (\#630)”; “fix(helper): validate resolver ownership before mutation” (refs \#630).
common/arcbox-atomic-file · medium confidence · unverified
2 commits (1 fix) modifying runner/arcbox-runner-agent
A change to existing behaviour in runner/arcbox-runner-agent — 2 commits (1 fix), 28 files: “refactor(runner)!: rename Fleet to ArcBox Runners”; “fix(runner-agent): reach ArcBox's Docker socket through HostLayout”.
runner/arcbox-runner-agent · medium confidence · unverified
235 commits (86 fixes) modifying app/arcbox-daemon
A change to existing behaviour in app/arcbox-daemon — 235 commits (86 fixs), 77 files: “feat(api): expose machine directory before System VM initialization”; “feat(hypervisor): add arcbox-vm Firecracker sandbox library (\#11)”; “refactor(api)!: retire tonic from the daemon (CORE-68)”; and 232 more (refs \#11, \#512, \#107, \#631, \#621, …).
app/arcbox-daemon · medium confidence · unverified
25 commits (11 fixes) modifying app/arcbox-docker/src/handlers/container
A change to existing behaviour in app/arcbox-docker/src/handlers/container — 25 commits (11 fixs), 6 files: “fix(docker): republish container ports after a System VM restart”; “fix(docker): pin container identity across start operations”; “refactor(docker): register host names from validated inspect metadata”; and 22 more.
app/arcbox-docker/src/handlers/container · medium confidence · unverified
26 commits (6 fixes) modifying common/arcbox-local-ca/src
A change to existing behaviour in common/arcbox-local-ca/src — 26 commits (6 fixs), 14 files: “feat(local-ca): mint a certificate per server name from the CA”; “feat(local-ca): authorize admin trust in the login session”; “feat(local-ca): expose validity and bound leaf lifetime”; and 23 more.
common/arcbox-local-ca/src · medium confidence · unverified
28 commits (6 fixes) modifying app/arcbox-helper/src/server/mutations
A change to existing behaviour in app/arcbox-helper/src/server/mutations — 28 commits (6 fixs), 7 files: “refactor(helper): push validation to RPC boundary, mutations accept strong types”; “test(helper): exercise resolver safety through leases”; “style: cargo fmt arcbox-helper”; and 25 more (refs \#613, \#715, \#81, \#145, \#148, …).
app/arcbox-helper/src/server/mutations · medium confidence · unverified
3 commits (1 fix) modifying app/arcbox-core/src/runtime/web\_services/list
A change to existing behaviour in app/arcbox-core/src/runtime/web\_services/list — 3 commits (1 fix), 2 files: “feat(api): expose web snapshots before System VM startup”; “fix(core): retain web queries through cancellation cleanup”; “feat(core): aggregate captured machine web services”.
_app/arcbox-core/src/runtime/web\services/list · medium confidence · unverified
30 commits (10 fixes) modifying engine/arcbox-engine/src/agent\_client
A change to existing behaviour in engine/arcbox-engine/src/agent\_client — 30 commits (10 fixs), 15 files: “fix(engine): require v7 admission for agent RPCs”; “refactor(engine): extract arcbox-engine from arcbox-core (restructure phase 2) (\#621)”; “feat(sandbox): window the guest-\>host sandbox streams (\#268)”; and 27 more (refs \#621, \#268, \#625).
_engine/arcbox-engine/src/agent\client · medium confidence · unverified
31 commits (14 fixes) modifying engine/arcbox-engine/src/vm\_lifecycle
A change to existing behaviour in engine/arcbox-engine/src/vm\_lifecycle — 31 commits (14 fixs), 9 files: “refactor(engine): extract arcbox-engine from arcbox-core (restructure phase 2) (\#621)”; “fix(engine): rebuild the recovery record for a moved image pair”; “test(engine): compare emptiness assertions against an empty value”; and 28 more (refs \#621, \#613).
_engine/arcbox-engine/src/vm\lifecycle · medium confidence · unverified
34 commits (9 fixes) modifying guest/arcbox-agent/src/agent
A change to existing behaviour in guest/arcbox-agent/src/agent — 34 commits (9 fixs), 9 files: “refactor(guest): share sandbox DNS ownership”; “test(agent): cover missing working directory”; “refactor(core,agent): split vm\_lifecycle and agent into module directories (T3) (\#138)”; and 31 more (refs \#138, \#133, \#267, \#613, \#162).
guest/arcbox-agent/src/agent · medium confidence · unverified
4 commits (0 fixes) modifying virt/arcbox-vhost-user/examples
A change to existing behaviour in virt/arcbox-vhost-user/examples — 4 commits, 2 files: “feat(vhost-user): serve virtio-fs shares through FsServer”; “test(vhost-user): time the share and realize vhost-user-vsock in the probe”; “test(vhost-user): share the QEMU probes' socketpair and vsock stub”; and 1 more.
virt/arcbox-vhost-user/examples · medium confidence · unverified
4 commits (0 fixes) modifying virt/arcbox-vmm/examples/checkpoint\_linux\_spike
A change to existing behaviour in virt/arcbox-vmm/examples/checkpoint\_linux\_spike — 4 commits, 4 files: “test(vmm): probe holds a vsock connection across the checkpoint”; “test(vmm): probe covers balloon, console, saved MAC, second generation”; “test(vmm): probe covers DHCP renewal and pending connects”; and 1 more.
_virt/arcbox-vmm/examples/checkpoint\_linux\spike · medium confidence · unverified
4 commits (1 fix) modifying engine/arcbox-image/src
A change to existing behaviour in engine/arcbox-image/src — 4 commits (1 fix), 4 files: “fix(image): drain file writes before cancelling machine pulls”; “feat(image): install the QEMU build from its archive”; “feat(image): pin the QEMU build in assets.lock”; and 1 more (refs \#620).
engine/arcbox-image/src · medium confidence · unverified
40 commits (14 fixes) modifying app/arcbox-helper/src
A change to existing behaviour in app/arcbox-helper/src — 40 commits (14 fixs), 8 files: “fix(helper): wait for installed processes before replacement”; “feat(helper): give arcbox-helper an independent crate version”; “feat(net): L3 direct routing via vmnet bridge (replaces utun approach)”; and 37 more (refs \#117, \#613, \#81, \#84, \#111, …).
app/arcbox-helper/src · medium confidence · unverified
47 commits (8 fixes) modifying rpc/arcbox-connect/descriptor
A change to existing behaviour in rpc/arcbox-connect/descriptor — 47 commits (8 fixs), 4 files: “docs(daemon): document independent host readiness”; “feat(protocol): add flow-control windows to machine exec sessions”; “feat(sandbox): window the guest-\>host sandbox streams (\#268)”; and 44 more (refs \#268, \#575, \#692, \#645, \#618, …).
rpc/arcbox-connect/descriptor · medium confidence · unverified
5 commits (0 fixes) modifying app/arcbox-cli/src/commands/machine
A change to existing behaviour in app/arcbox-cli/src/commands/machine — 5 commits, 4 files: “feat(cli): configure machine web backend ports”; “feat(cli): let machine exec and ssh pick the default machine and a user”; “feat(cli): add machine clone, export, import, resize and default”; and 2 more.
app/arcbox-cli/src/commands/machine · medium confidence · unverified
5 commits (0 fixes) modifying common/arcbox-packet/src
A change to existing behaviour in common/arcbox-packet/src — 5 commits, 4 files: “perf(packet): wire SIMD Internet checksum for long payloads (\#492)”; “feat(splicetcp): validate established IPv6 TCP input”; “feat(packet): add validated TCP packet views”; and 2 more (refs \#492).
common/arcbox-packet/src · medium confidence · unverified
5 commits (0 fixes) modifying common/arcbox-packet/src/ip
A change to existing behaviour in common/arcbox-packet/src/ip — 5 commits, 2 files: “feat(packet): encode IPv4 and IPv6 SYN frames”; “feat(packet): add validated TCP packet views”; “feat(packet): add pure TCP reset frames”; and 2 more.
common/arcbox-packet/src/ip · medium confidence · unverified
5 commits (0 fixes) modifying engine/arcbox-engine/src/agent\_client/instance\_authority
A change to existing behaviour in engine/arcbox-engine/src/agent\_client/instance\_authority — 5 commits, 1 file: “test(engine): cover authority transport failure lifecycle”; “refactor(engine): share retained session transport ownership”; “feat(engine): retain machine web configuration sessions”; and 2 more.
_engine/arcbox-engine/src/agent\_client/instance\authority · medium confidence · unverified
5 commits (2 fixes) modifying app/arcbox-host-sandbox
A change to existing behaviour in app/arcbox-host-sandbox — 5 commits (2 fixs), 2 files: “docs(adr): renumber the host sandbox ADR to 0011”; “fix(host-sandbox): stop publishing host sandbox names nothing routes to”; “feat(host-sandbox): export docker:\<ref\> images from the System VM (D5)”; and 2 more.
app/arcbox-host-sandbox · medium confidence · unverified
6 commits (0 fixes) modifying engine/arcbox-image/src/qemu
A change to existing behaviour in engine/arcbox-image/src/qemu — 6 commits, 6 files: “feat(image): require ArcBox's code signature on the QEMU build”; “feat(image): install the QEMU build from its archive”; “feat(daemon): download QEMU when the System VM falls back to emulation”; and 3 more.
engine/arcbox-image/src/qemu · medium confidence · unverified
6 commits (0 fixes) modifying virt/arcbox-vhost-user/examples/qemu\_system\_vm\_probe
A change to existing behaviour in virt/arcbox-vhost-user/examples/qemu\_system\_vm\_probe — 6 commits, 6 files: “test(vhost-user): count the small files the System VM probe reads”; “test(vhost-user): keep the System VM probe's logs when a back-end fails”; “test(vhost-user): run the System VM probe's agent straight from the share”; and 3 more.
_virt/arcbox-vhost-user/examples/qemu\_system\_vm\probe · medium confidence · unverified
6 commits (0 fixes) modifying virt/arcbox-vz-driver
A change to existing behaviour in virt/arcbox-vz-driver — 6 commits, 13 files: “docs(adr): renumber the host sandbox ADR to 0011”; “test(vz-driver): add the VZ checkpoint probe”; “feat(vz-driver): checkpoint VZ VMs into vz/v1 images”; and 3 more.
virt/arcbox-vz-driver · medium confidence · unverified
6 commits (1 fix) modifying common/arcbox-local-ca/src/keychain
A change to existing behaviour in common/arcbox-local-ca/src/keychain — 6 commits (1 fix), 4 files: “test(tls): verify native Keychain signing identities”; “test(tls): cover interrupted keychain identity cleanup”; “test(tls): cover CA rotation retries and preserve canceled fixtures”; and 3 more.
common/arcbox-local-ca/src/keychain · medium confidence · unverified
61 commits (15 fixes) modifying guest/arcbox-agent/src/domains
A change to existing behaviour in guest/arcbox-agent/src/domains — 61 commits (15 fixs), 37 files: “feat(agent): terminate TLS for container domains with the local CA”; “fix(agent): retain cleanup ownership until rule removal succeeds”; “refactor(guest): bind web frontend to an available port”; and 58 more.
guest/arcbox-agent/src/domains · medium confidence · unverified
7 commits (1 fix) modifying guest/arcbox-agent/src/agent/machine\_web
A change to existing behaviour in guest/arcbox-agent/src/agent/machine\_web — 7 commits (1 fix), 3 files: “test(https): prove machine readiness and cleanup ordering”; “feat(https): deliver machine proxy roots with session policies”; “feat(https): activate machine routes with session-owned authority”; and 4 more.
_guest/arcbox-agent/src/agent/machine\web · medium confidence · unverified
7 commits (2 fixes) modifying app/arcbox-helper/src/server/mutations/dns/lease
A change to existing behaviour in app/arcbox-helper/src/server/mutations/dns/lease — 7 commits (2 fixs), 2 files: “test(helper): exercise resolver safety through leases”; “feat(helper): lease resolver roots to verified daemon connections”; “test(helper): cover resolver authority watches and EOF cleanup”; and 4 more.
app/arcbox-helper/src/server/mutations/dns/lease · medium confidence · unverified
74 commits (18 fixes) modifying app/arcbox-api/src/connect
A change to existing behaviour in app/arcbox-api/src/connect — 74 commits (18 fixs), 19 files: “feat(api): expose machine directory before System VM initialization”; “refactor(api)!: retire tonic from the daemon (CORE-68)”; “fix(https): reject observations from an earlier trust cycle”; and 71 more (refs \#621, \#268, \#575, \#567, \#538, …).
app/arcbox-api/src/connect · medium confidence · unverified
75 commits (36 fixes) modifying engine/arcbox-engine/src
A change to existing behaviour in engine/arcbox-engine/src — 75 commits (36 fixs), 9 files: “fix(engine): retain ownership across competing machine stops”; “feat(daemon): stop QEMU processes a crashed daemon left running”; “feat(engine): pin service connections to the expected VM”; and 72 more (refs \#621, \#268, \#645, \#626, \#623, …).
engine/arcbox-engine/src · medium confidence · unverified
8 commits (1 fix) modifying virt/arcbox-host-net
A change to existing behaviour in virt/arcbox-host-net — 8 commits (1 fix), 11 files: “test(host-net): prove two VMs' datapaths cannot reach each other”; “feat(host-net): add the host sandbox address pool and DNS seam”; “test(host-net): cover placement, replay gating and DNS publication”; and 5 more.
virt/arcbox-host-net · medium confidence · unverified
8 commits (3 fixes) modifying app/arcbox-core/src/runtime/kubernetes\_lb
A change to existing behaviour in app/arcbox-core/src/runtime/kubernetes\_lb — 8 commits (3 fixs), 1 file: “fix(net): retain listener managers through canceled retirement”; “refactor(net): separate inbound forwarding from VM lookup”; “test(app): compare emptiness assertions against an empty value”; and 5 more.
_app/arcbox-core/src/runtime/kubernetes\lb · medium confidence · unverified
8 commits (3 fixes) modifying computer/arcbox-computer
A change to existing behaviour in computer/arcbox-computer — 8 commits (3 fixs), 7 files: “fix(core): admit shared host network writers”; “feat(daemon): boot the System VM on QEMU without hardware virtualization”; “fix(runtime): enforce storage protection in computer and SSH sessions”; and 5 more (refs \#674, \#626, \#623).
computer/arcbox-computer · medium confidence · unverified
80 commits (30 fixes) modifying app/arcbox-core/src/runtime
A change to existing behaviour in app/arcbox-core/src/runtime — 80 commits (30 fixs), 23 files: “fix(docker): republish container ports after a System VM restart”; “fix(dns): publish only granted local mDNS records”; “refactor(core): use canonical registry for domain ownership”; and 77 more (refs \#577, \#538, \#529, \#613, \#398, …).
app/arcbox-core/src/runtime · medium confidence · unverified
9 commits (0 fixes) modifying guest/arcbox-agent/src/agent/linux/rpc
A change to existing behaviour in guest/arcbox-agent/src/agent/linux/rpc — 9 commits, 6 files: “refactor(guest): share sandbox DNS ownership”; “feat(guest): serve the built-in index over managed TLS”; “test(guest): verify durable trust through ordered RPC frames”; and 6 more.
guest/arcbox-agent/src/agent/linux/rpc · medium confidence · unverified
API error classification and Connect transport integration
The API layer now routes all errors through a unified \ApiError\ type that maps internal failures (common, core, and agent-reported errors) to specific Connect error codes. This ensures that clients using Connect, gRPC, or gRPC-Web receive consistent, structured error responses, including detailed registry codes for agent errors like execution not found, sandbox state issues, or file limits.
app/arcbox-api/src · high confidence
Adaptive RX interrupt coalescing for VirtIO-net injection
The RX injection engine now uses an adaptive gather-window policy to dynamically adjust interrupt coalescing based on traffic patterns. Instead of a fixed delay, the system expands the coalescing window (up to 800 µs) under high frame-rate multi-flow loads to reduce guest IRQ overhead, and shrinks it (down to 100 µs) during idle or single-stream periods to lower latency. This change is implemented in the \arcbox-net-inject\ crate, which introduces a dedicated \CoalescePolicy\ module, an \RxInjectThread\ that drives both channel-based and inline fast-path connections, and an \InlineConn\ subsystem for zero-copy TCP data delivery directly into guest memory.
virt/arcbox-net-inject · high confidence
Computer lifecycle restructured as a hierarchical state machine
The computer runtime's lifecycle management has been refactored from a manual implementation into a hierarchical state machine using the \statig\ library. This change introduces explicit state definitions (such as \provisioning\, \staging\, \booting\, \gating\, and \detached\) and a formal transition table that dictates how the system moves between states like \Ready\, \Paused\, and \Failed\. The refactoring separates the state logic from the execution flows, defining specific effects (e.g., \SpawnBoot\, \Detach\, \PersistPhase\) that the actor must execute, and clarifies the durability guarantees for record writes during transitions. This provides a more robust and testable foundation for managing computer lifecycles, including complex operations like handovers and crash recovery.
computer/arcbox-computer-runtime/src/lifecycle · high confidence
Flow-controlled machine exec sessions with guaranteed drain
The engine now manages machine execution sessions as flow-controlled TCP connections, ensuring that input and output are properly back-pressured and that sessions are always fully drained before closing. This change introduces a dedicated module for handling these sessions, replacing the previous ad-hoc implementation. Users benefit from more reliable execution of commands within machines, as the system now correctly handles stdin/stdout streams and signals, preventing data loss or connection hangs during long-running or high-throughput operations.
_engine/arcbox-engine/src/agent\_client/machine\exec · high confidence
Idle balloon shrinking logic extracted and gated by backend reclaim capability
The idle balloon shrinking policy and its message-driven controller have been extracted into the \arcbox-engine\ module. This change introduces a staged descent mechanism that probes guest memory usage and shrinks the balloon in steps, but it is strictly gated by a \reclaim\_capable\ check. Currently, this gate prevents shrinking on macOS backends (VZ and HV) because they do not return memory to the host in a way that reduces the host's physical footprint, ensuring the daemon does not attempt ineffective or harmful memory reclamation.
_engine/arcbox-engine/src/vm\lifecycle/balloon · high confidence
Improved Docker build reliability and network DNS consistency
The Docker API handlers now enforce stricter runtime checks and maintain accurate host DNS records. For \POST /build\ requests, the system verifies that the FEX translator is available in the HV guest before proceeding; if FEX is missing, the build fails immediately with a clear error rather than silently falling back to incompatible runtimes or failing later with cryptic errors. Additionally, when containers are connected to or disconnected from networks, the host's DNS entries are automatically refreshed to reflect the container's current IP and aliases, preventing stale resolution issues.
app/arcbox-docker/src/handlers · high confidence
Improved network reliability and configuration management on macOS
The core layer now uses direct kernel ioctls via the \ifbridge\ crate to discover VM bridge interfaces, replacing fragile text parsing of \ifconfig\ output. This change, along with the introduction of a route reconciler that retries transient failures and falls back to split container routes, makes container networking more robust. Additionally, the daemon now persists VM resource changes (CPU and memory) directly to the user's \\~/.config/arcbox/config.toml\ while preserving existing comments and formatting. Also in this area: Daemon-owned storage recovery with write protection and mutual exclusion; Default machine selection and per-machine resource resizing; Improved networking stability on VM restart and hostname resolution.
app/arcbox-core/src · high confidence
Introduce ArcBox Connect RPC surface with precompiled descriptor generation
The \rpc/arcbox-connect\ crate now provides the public Connect RPC surface for the ArcBox sandbox API, serving \arcbox.sandbox.v1\ and \arcbox.v1\ via Connect (supporting HTTP/JSON, binary protobuf, gRPC, and gRPC-Web) while ensuring musl compatibility for the guest agent. Code generation is handled by a new build script that uses a committed precompiled descriptor set (\arcbox\_connect.protoset\) and source hashing to guarantee that generated buffa message types remain synchronized with \.proto\ definitions without requiring \protoc\ at build time. This crate's generated types are now the single runtime representation for the daemon, \abctl\, and the host-guest vsock wire, while the previous prost-based types in \arcbox-protocol\ are restricted to test support only.
rpc/arcbox-connect · high confidence
Introduce PF\_ROUTE-based routing socket API for macOS
The \arcbox-route\ crate now implements direct kernel syscalls via the BSD \PF\_ROUTE\ socket to manage the macOS routing table, replacing the previous approach of shelling out to \/sbin/route\. This change provides a safe Rust interface for adding, removing, and querying IPv4 subnet routes, utilizing a validated \Ipv4Net\ type to ensure correct prefix and host-bit handling. By communicating directly with the kernel, the system avoids the overhead and potential alignment issues of external process execution, offering a more robust and consistent method for low-level network configuration on Darwin.
common/arcbox-route · high confidence
Introduce guest Docker backend with vsock readiness validation
The container backend layer now includes a dedicated GuestDockerBackend that ensures the guest's Docker daemon is ready before container operations. This implementation validates the guest's vsock endpoint port against the configured expected port, rejecting mismatches or invalid formats, and supports a test mode that skips VM checks for mock-based testing.
_app/arcbox-core/src/container\backend · high confidence
Lifecycle tasks are extracted into dedicated modules
The boot, checkpoint, pause, release, restore, and resume logic has been moved from the \sandbox\ module into new, dedicated files under \lifecycle/tasks\. This refactoring organizes the computer's lifecycle operations into distinct, named sub-tasks (e.g., \boot.rs\, \checkpoint.rs\) while preserving the existing behavior and caller interfaces until the manager is updated to drive these actors directly.
computer/arcbox-computer-runtime/src/lifecycle/tasks · high confidence
Live sandbox CoW state survives startup sweep
The snapshot subsystem now correctly re-registers and preserves the copy-on-write resources (dm-snapshot devices, loop devices, and COW files) for sandboxes that are still running when the host restarts. Previously, a startup sweep might have incorrectly treated these active resources as stale orphans, potentially detaching shared loop devices or removing overlay files, which could lead to data loss or VM crashes. This change ensures that live sandboxes are adopted and their disk state is maintained across agent restarts.
_engine/arcbox-snapshot/src/snapshot\cow · high confidence
New vsock-based GuestAgent implementation for VM communication
The runtime now uses a new \VmProtoAgent\ to communicate with the in-VM guest agent via vsock, replacing the previous mechanism. This change introduces a structured protocol with dedicated modules for command execution (\exec\), file I/O (\files\), clock synchronization (\clock\), network reconfiguration (\net\), and port waiting (\wait\_port\). The implementation handles connection readiness through configurable strategies (dial-out, poll, or probe) and manages the vsock lifecycle, including retry backoffs for transient connection errors and timeouts for individual operations.
computer/arcbox-computer-runtime/src/agent · high confidence
Passive observation streams no longer prevent System VM idle reclaim
The proxy now classifies Docker API requests to distinguish between active operations (like pulls or builds) and passive observation streams (such as GET /events, log follow, and stats streaming). Previously, any open stream kept the System VM out of idle memory reclaim indefinitely; now, passive streams are transparent to the idle clock, allowing the VM to idle and reclaim memory even while clients are watching it.
app/arcbox-docker/src/proxy · high confidence
Per-computer lifecycle actor with preemption and handover logic
The runtime now manages each computer through a dedicated lifecycle actor that serializes commands and executes effects via sub-tasks. This change introduces a central command handler that refuses operations on handed-over (detached) computers and implements a Detach command to transfer ownership, specifically dropping the guest agent before the handover port call to prevent access by the successor. The actor supports preemption, allowing force-removes to cancel in-flight boots or checkpoints, and manages timeouts for handovers and resource handoffs to ensure teardowns can retry or stall safely.
computer/arcbox-computer-runtime/src/lifecycle/actor · high confidence
Refactored computer lifecycle flows into dedicated boot, restore, and teardown modules
The computer runtime's lifecycle management has been reorganized into three distinct flow modules: boot, restore, and teardown. The new boot module handles cold-start sequences, including VM initialization, agent connection, and the readiness gate that withholds the READY state until warm snapshots and initial commands are processed. The restore module manages bringing checkpointed or paused computers back online, handling snapshot loading, network re-addressing, and pool slot management. The teardown module encapsulates checkpoint capture, graceful workload draining, VM shutdown, and resource release logic. This structural change isolates specific lifecycle stages for clearer state management and error handling.
computer/arcbox-computer-runtime/src/lifecycle/flows · high confidence
Reworked VirtIO crate structure with back-compat re-exports
The \arcbox-virtio\ crate has been reorganized to serve as a unified facade for per-device sub-crates (blk, net, console, fs, vsock, rng, balloon). The library now re-exports types and modules from these underlying crates and \arcbox-virtio-core\ to maintain backward compatibility for existing imports, while the integration tests have been restructured into modular blocks to align with the new layout.
virt/arcbox-virtio · high confidence
Sandbox guest networking now uses eBPF TCX for identity-invariant NAT with an nftables backend option
The sandbox's guest network implementation has been refactored into a dedicated crate that supports two host-side NAT datapaths for the identity-invariant link (where every guest uses the fixed 169.254.100.2 address). The default datapath is now eBPF TCX programs that perform stateless, O(1) source/destination rewriting, replacing the previous iptables/fwmark policy-routing chain; if the eBPF object cannot be loaded, the system automatically falls back to the legacy netfilter rule set. Additionally, a new nftables PacketFilter backend has been added alongside the existing iptables-legacy backend, allowing the netfilter rules to be rendered using nftables on stock distributions while remaining mutually invisible to the iptables path.
virt/arcbox-tap-net · high confidence
Sandbox runtime restructured into modular lifecycle components
The sandbox runtime code has been reorganized into distinct modules to improve clarity and maintainability. The boot flow is now handled in \boot.rs\, which implements readiness probes and rootfs staging with copy-on-write support. Checkpoint and restore logic has been moved to \checkpoint.rs\, including safeguards for reserved pause snapshots and warm-create caches. Cleanup and teardown logic is now in \cleanup.rs\, ensuring proper resource release during forced removals. Event handling is centralized in \events.rs\, providing a monotonic sequence number for gap detection in event streams. Execution management is now in \execution.rs\, supporting resumable workload executions with offset-addressed I/O streams. File operations are handled in \files.rs\, providing a thin facade over the guest agent's file channel. Lifecycle management is now in \lifecycle.rs\, handling computer creation, warm restores, and network cleanup. Pause and resume functionality is in \pause.rs\, managing checkpoint-based suspension with disk overlay retention. Policy decisions are separated into \policy.rs\ with submodules for deadlines, recovery, and warm policies.
computer/arcbox-computer-runtime/src/sandbox · high confidence
Skills directory now uses a symbolic link
The .claude/skills location is now a symbolic link pointing to ../.agents/skills, centralizing skill definitions in the .agents directory while maintaining the previous access path for the Claude tooling.
.claude · high confidence
Standardized ArcBox RPC protocol module structure
The \arcbox-protocol\ crate now provides a unified, re-exported module structure for all RPC message types and services. Users and internal consumers can access types via canonical paths (e.g., \arcbox\_protocol::v1::TypeName\) or convenient top-level re-exports, while maintaining backward compatibility through specific submodules like \common\, \machine\, \container\, \image\, \agent\, \kubernetes\, and \api\. This change consolidates definitions for container lifecycle, image management, VM operations, guest agent interactions, and system/migration services into a single, consistent interface. Also in this area: Agent protocol v7 introduces storage health monitoring and recovery; New machine management RPCs and migration safety checks.
rpc/arcbox-protocol/src · high confidence
Strict input validation for privileged operations
The validation module in app/arcbox-helper/src/validate has been refactored to enforce strict, type-safe validation of all external inputs before they reach privileged code. New typed validators ensure that bridge interfaces match the bridge\<N\> pattern, CLI tool names are restricted to an allow list, CLI symlink targets are confined to specific application bundle paths, DNS ports are unprivileged (\>=1024), domain names comply with RFC standards, socket targets are restricted to the .arcbox directory, and subnets are limited to private IPv4 ranges with no host bits. This change hardens the application against injection and path traversal attacks by rejecting invalid inputs at the type level.
app/arcbox-helper/src/validate · high confidence
VirtIO RNG device now fails securely on entropy source errors
The virtio-rng implementation in the new arcbox-virtio-rng crate has been refactored to use the unified SplitQueue for processing guest requests. Crucially, the device no longer falls back to zero-filling buffers when the underlying getrandom call fails; instead, it stops filling the current chain and returns a short read, preventing the guest from receiving invalid entropy that was previously masked by zero-padding.
virt/arcbox-virtio-rng · high confidence
VirtIO-FS device refactored into modular components with FUSE 7.38 support
The \arcbox-virtio-fs\ crate has been restructured from a monolithic library into distinct modules (\device\, \handler\, \protocol\, \request\, \session\) to improve code organization and maintainability. This change introduces a \FuseRequestHandler\ trait that allows downstream implementations (like \arcbox-fs\) to process FUSE requests, decoupling the virtio device logic from filesystem semantics. The protocol support has been updated to FUSE kernel version 7.38, and the session initialization logic now dynamically negotiates the DAX map alignment based on the host's page size (16 KiB on Apple Silicon, 4 KiB on x86) to ensure correct memory mapping. Also in this area: Introduce VirtIO-FS device with parallel request processing and Linux errno mapping.
virt/arcbox-virtio-fs · high confidence
Virtio-net device refactored into modular components with TAP offload support
The virtio-net implementation has been restructured from a monolithic source file into distinct modules (config, header, backend, device, tap) to improve maintainability. This change introduces a \NetBackend\ trait that abstracts network I/O, enabling both a Linux-specific \TapBackend\ and a cross-platform \LoopbackBackend\ for testing. A key behavioral update is the addition of host-side TAP offload configuration (checksum, TSO, UFO) that is applied after feature negotiation, ensuring the host kernel matches the guest's negotiated capabilities. The module also includes updated network configuration structures and wire-format header definitions. Also in this area: VirtioNet device refactored into modular components with hot-path optimizations.
virt/arcbox-virtio-net · high confidence
Virtio-vsock refactored into modular components with improved write reliability
The virtio-vsock implementation has been split from a monolithic structure into distinct modules (addr, backend, connection, device, protocol, etc.) to improve maintainability. This change introduces a robust partial-write handling mechanism in the TX path that retries writes with backoff, preventing silent data truncation when the host socket buffer is full. Additionally, the device now properly handles OP\_SHUTDOWN half-close flags per the vsock specification, allowing connections to be preserved when only one direction is closed, and proactively sends CREDIT\_REQUEST messages when the window is half-full to prevent flow-control stalls. Also in this area: Refactored vsock device internals and added comprehensive tests; Refactored vsock connection manager with improved credit flow control.
virt/arcbox-virtio-vsock · high confidence
Fixes
1 commit (1 fix) fixing app/arcbox-helper/src/install
A fix in app/arcbox-helper/src/install — 1 commit (1 fix), 1 file: “fix(helper): wait for installed processes before replacement”.
app/arcbox-helper/src/install · medium confidence · unverified
10 commits (6 fixes) fixing app/arcbox-core/src/runtime/host\_network
A fix in app/arcbox-core/src/runtime/host\_network — 10 commits (6 fixs), 3 files: “fix(core): admit shared host network writers”; “test(core): preserve forwarding across rejected snapshots”; “fix(net): admit container mutations against a physical VM”; and 7 more.
_app/arcbox-core/src/runtime/host\network · medium confidence · unverified
11 commits (6 fixes) fixing common/arcbox-proxy/src/egress
A fix in common/arcbox-proxy/src/egress — 11 commits (6 fixs), 3 files: “test(proxy): cover the inbound accept path and the ICMP round trip”; “fix(net): deliver inbound forwards on the rule's guest port”; “fix(io): migrate Tokio descriptor registration”; and 8 more (refs \#412).
common/arcbox-proxy/src/egress · medium confidence · unverified
15 commits (8 fixes) fixing engine/arcbox-engine/src/vm
A fix in engine/arcbox-engine/src/vm — 15 commits (8 fixs), 3 files: “feat(engine): pin service connections to the expected VM”; “refactor(engine): extract arcbox-engine from arcbox-core (restructure phase 2) (\#621)”; “feat(net): make guest egress proxying an explicit policy”; and 12 more (refs \#621).
engine/arcbox-engine/src/vm · medium confidence · unverified
38 commits (23 fixes) fixing engine/arcbox-engine/src/machine
A fix in engine/arcbox-engine/src/machine — 38 commits (23 fixs), 8 files: “fix(engine): retain ownership across competing machine stops”; “refactor(engine): extract arcbox-engine from arcbox-core (restructure phase 2) (\#621)”; “fix(engine): rebuild the recovery record for a moved image pair”; and 35 more (refs \#621, \#645).
engine/arcbox-engine/src/machine · medium confidence · unverified
6 commits (4 fixes) fixing app/arcbox-cli/src/commands/install
A fix in app/arcbox-cli/src/commands/install — 6 commits (4 fixs), 4 files: “fix(cli): verify installed helper matches bundled bytes”; “fix(cli): reap helper probes without async exit notifications”; “fix(cli): select the login user for helper installation”; and 3 more.
app/arcbox-cli/src/commands/install · medium confidence · unverified
7 commits (5 fixes) fixing app/arcbox-core/src/runtime/inbound\_listeners
A fix in app/arcbox-core/src/runtime/inbound\_listeners — 7 commits (5 fixs), 1 file: “fix(net): retain listener managers through canceled retirement”; “fix(net): reject stale listener cleanup after replacement”; “fix(net): bind listener managers to physical VM runs”; and 4 more.
_app/arcbox-core/src/runtime/inbound\listeners · medium confidence · unverified
Improved reliability of VM storage maintenance and force-stop operations
The engine now handles storage maintenance and force-stop commands with greater robustness. Storage checks and stops are validated against the VM's lifecycle state to prevent operations during transient phases like creation or stopping. Force-stop failures are now correctly reported to all waiting commands (such as shutdown and readiness checks) without leaving the VM in an inconsistent state. Additionally, storage stop tasks are serialized and properly join with any in-flight recovery boots, ensuring that reserved storage is cleaned up even if the VM was previously stopped or failed.
_engine/arcbox-engine/src/vm\lifecycle/actor · high confidence
Test coverage
1 commit adding/updating tests in engine/arcbox-engine/src/machine/tests; 1 commit adding/updating tests in tests/bench/machine-trust; 1 commit adding/updating tests in tests/bench/no-virtualization-host; 1 commit adding/updating tests in tests/bench/nofile-limit; 1 commit adding/updating tests in tests/bench/qemu-download; 10 commits adding/updating tests in app/arcbox-docker/tests/support; 14 commits adding/updating tests in app/arcbox-helper/tests/common; 2 commits adding/updating tests in app/arcbox-cli/tests; 2 commits adding/updating tests in common/arcbox-proxy/src/inbound\_relay; 2 commits adding/updating tests in tests/bench/signoz/moby-overlay-exit; 28 commits adding/updating tests in app/arcbox-docker/tests; 28 commits adding/updating tests in tests/bench/signoz; 3 commits adding/updating tests in tests/e2e/src/qemu; 4 commits adding/updating tests in tests/bench/local-https; 4 commits adding/updating tests in virt/arcbox-fc-driver/tests; 5 commits adding/updating tests in virt/arcbox-vhost-user/tests; 6 commits adding/updating tests in tests/bench/hv-checkpoint; 6 commits adding/updating tests in tests/e2e/src/bin/qemu\_vsock\_e2e; 8 commits adding/updating tests in app/arcbox-docker/src/handlers/container/ca\_injection/tests; 9 commits adding/updating tests in tests/bench/qemu-tcg; Add shared test helpers for loop device isolation and root detection; Added FEX64 validation harness for AMD64 container support; Added HV backend end-to-end test suite; Added HV cold-boot repro harness example; Added HV wake-path benchmark probes; Added VirtioFS benchmark suite for performance tracking; Added benchmark probes for \.local\ negative DNS answer behavior; Added build script for cross-compiling Linux kernel for ARM64; Added end-to-end test for chained VM checkpoints; Added integration and end-to-end tests for the guest agent; Added integration and manager tests for the computer runtime; Added integration tests for SSH server functionality; Added integration tests for TAP network lifecycle and nftables rendering; Added integration tests for arcbox-helper RPC and E2E scenarios; Added integration tests for container image icon resolution; Added integration tests for network datapath, DNS, and NAT components; Added integration tests for rootfs builder and agent injection; Added lifecycle state machine tests; Added loop-device integration probe test; Added performance benchmarks for checksum and TCP frame construction; Added regression tests for sidecar identity handling; Added reproducible UDP benchmark runner; Added test helpers for network datapath validation; Added test support fixtures for computer runtime flows; Added tests for async storage health stream lifecycle; Added unit and integration tests for the TypeScript SDK; Expanded e2e test coverage for daemon lifecycle, Docker builds, and network performance; Initial test suite for the Python SDK; New e2e test harness and scenario modules.
Dependencies
Rust dependency and workspace manifest updates
Updated Cargo.toml manifests across the ArcBox Rust workspace, including the addition of new crates (arcbox-api, arcbox-cli, arcbox-ssh, arcbox-migration, arcbox-connect, arcbox-grpc, arcbox-protocol, arcbox-container, arcbox-oci, arcbox-dhcp, arcbox-fc-driver, arcbox-hv, arcbox-xnu-net, arcbox-route, arcbox-pty, arcbox-conntrack, arcbox-datapath, arcbox-packet, arcbox-proxy, arcbox-fakeip, arcbox-local-ca, arcbox-logging, arcbox-constants, arcbox-error, arcbox-atomic-file, arcbox-asset, arcbox-dns, arcbox-computer, arcbox-computer-runtime, arcbox-engine, arcbox-image, arcbox-snapshot, arcbox-docker, arcbox-docker-tools, arcbox-helper, arcbox-fleet-agent, arcbox-fleet-proto, arcbox-fleet-control-proto) and updates to existing ones. Key dependency changes include upgrading connectrpc (arcbox-connectrpc) to 0.9.0-arcbox.1, buffa to 0.9.1, russh to 0.62.1, reqwest to 0.12.28 (and 0.13.4 in fleet-agent), and adding new dependencies like statig, oci2rootfs, arcbox-ext4, and security-framework. The Python SDK (pyproject.toml) and TypeScript SDK (package.json) manifests were also updated, with the Python SDK requiring httpx\>=0.28.1, msgspec\>=0.21.1, protobuf\>=7.35.1, and the TypeScript SDK using @connectrpc/connect ^2.1.2 and requiring Node \>=22.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Baseline
- First survey — no prior run to compare against. CAI 59.
Lenses
- Code Health 62
- Architecture 88
- Maturity 93
- Readiness 61
- Security 46
- Domain Modelling 92
- Event Sourcing 100
- Performance 89
Changes since last survey
- 300 commits — 235 feature/other, 65 fixes
By area
- virt/arcbox-vmm — 42 commits
- virt/arcbox-vhost-user — 28 commits
- common/splicetcp — 26 commits
- computer/arcbox-computer-runtime — 23 commits
- (root) — 12 commits
- tests/e2e — 12 commits
- docs/README.md — 11 commits
- tests/bench — 11 commits
- app/arcbox-daemon — 10 commits
- virt/arcbox-hv-driver — 9 commits
- app/arcbox-core — 8 commits
- app/arcbox-api — 7 commits
- engine/arcbox-engine — 7 commits
- virt/arcbox-host-net — 7 commits
- common/arcbox-packet — 6 commits
- virt/arcbox-virtio-vsock — 6 commits
- engine/arcbox-image — 5 commits
- virt/arcbox-vz-driver — 5 commits
- common/arcbox-proxy — 4 commits
- docs/architecture — 4 commits
Notable commits
- fix: fix(agent): link arcbox-transport on every target
- fix: fix(agent): require hyper 1.11 for declared HTTP/1 trailers
- fix: fix(agent): run nfsdcld so nfsd skips the NFSv4 grace period
- fix: fix(api): refuse VM starts up front without hardware virtualization
- fix: fix(api): refuse sandbox control RPCs where sandboxes cannot run
- fix: fix(api): refuse sandbox data-plane RPCs where sandboxes cannot run
- fix: fix(api): refuse sandbox event subscriptions where sandboxes cannot run
- fix: fix(build): align Clippy configuration with Rust 1.96
- fix: fix(cli): show the backend the System VM actually runs on
- fix: fix(computer): ask for dirty tracking only where Firecracker runs
- fix: fix(computer): name the missing oci2rootfs API when a host build injects vm-agent
- fix: fix(computer): reach HV guests from the host location
- fix: fix(computer): restore a template's snapshot on the host location
- fix: fix(daemon): keep System startup retryable without hardware virtualization
- fix: fix(daemon): name why the System VM cannot start on this host
- fix: fix(daemon): raise the open-file soft limit at startup
- fix: fix(daemon): stop the Kubernetes API proxy on shutdown
- fix: fix(docker): forward publishes to the guest on the host port
- fix: fix(docker): point host-gateway at the Mac (#754)
- fix: fix(docker): retry container archive and start requests on a busy overlay
- …and 280 more
Architecture
- 0 containers · 1 bounded contexts · 0 dependency edges (baseline)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
arcboxlabs/arcbox was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 31419ccf96e624f9e40724c936c86147e1ca92bc — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.