Struct SandboxCapabilities 

pub struct SandboxCapabilities {

    pub files: bool,
    pub reconnect: bool,
    pub jobs: bool,
    pub preview: bool,
    pub pause_resume: bool,
    pub snapshot: bool,
    pub domain_egress_rules: bool,
    pub egress_deny: bool,
    pub enforced_limits: bool,
    pub process_limit: bool,
    pub sandbox_lifetime: bool,
    pub supervisor_pid_namespace: bool,
    pub supervisor_isolation: bool,
}

What a platform’s sandbox backend can actually do.

Published so portable code can branch before calling rather than discovering a gap through an error. Every field here corresponds to a capability that at least one platform lacks; create, exec and terminate are the guaranteed floor and are therefore not listed.

Fields

files: bool

Files can be moved in and out of a sandbox

reconnect: bool

A later call can reach a sandbox created by an earlier one

jobs: bool

A command can be started, polled and cancelled across separate calls, so it outlives the one that started it. False where nothing inside the sandbox owns the process in between.

preview: bool

An authenticated, port-scoped capability to reach a service inside the sandbox

pause_resume: bool

Sandbox state can be paused and resumed

snapshot: bool

A sandbox’s full state can be captured and used to create another

domain_egress_rules: bool

Egress can be restricted to a hostname allowlist

egress_deny: bool

Whether a declared deny is actually enforced, rather than accepted and dropped

enforced_limits: bool

The platform enforces the declared cpu, memory and disk ceilings

process_limit: bool

The platform can cap how many processes a sandbox runs

sandbox_lifetime: bool

The platform terminates a sandbox at a declared wall-clock deadline

supervisor_pid_namespace: bool

A command runs in its own PID namespace and cannot see or signal the agent’s processes.

Only where an agent runs as root. Creating the namespace needs CAP_SYS_ADMIN, and the Kubernetes sandbox pod drops every capability — which is also what denies ptrace by construction, so granting it there would remove a lock to add one.

supervisor_isolation: bool

The process supervising a command is a different identity from the command.

False where a command runs as the agent’s own user: it can then read the supervisor’s environment and signal it. Separate from supervisorPidNamespace, which is about visibility rather than identity — a backend can have one without the other.

Implementations

impl SandboxCapabilities

pub fn for_platform(platform: Platform) -> Result<Self>

Returns what the given platform’s sandbox backend supports.

Errors for platforms with no sandbox backend, rather than returning an all-false set — “every capability is missing” and “this platform has no sandboxes” are different conditions and an application should not have to tell them apart by inspection.

pub fn azure() -> Self

What the Azure sandbox backend supports; the body of the Platform::Azure arm.

pub fn gcp_agent_platform() -> Self

What the GCP Agent Platform sandbox backend supports; the body of the Platform::Gcp arm.

pub fn require( &self, capability: SandboxCapability, platform: Platform, ) -> Result<()>

Returns a typed error if the named capability is absent on this platform.

Trait Implementations

impl Clone for SandboxCapabilities

fn clone(&self) -> SandboxCapabilities

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SandboxCapabilities

impl Debug for SandboxCapabilities

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SandboxCapabilities

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SandboxCapabilities

impl PartialEq for SandboxCapabilities

fn eq(&self, other: &SandboxCapabilities) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SandboxCapabilities

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SandboxCapabilities