Capabilities

A capability is one thing a plugin may do, written as a stable string such as launch.args, cdp:Network or page.script:example.com. A plugin declares the ones it needs in its metadata; a PluginSet grants them and checks them against what the host supports. Items are in seleniumbase_rs_plugin, defined in capability.rs, host.rs and switch_policy.rs of crates/seleniumbase-rs-plugin/src/.

Capability#

enum non_exhaustive seleniumbase_rs_plugin::Capability

#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]#[non_exhaustive]pub enum Capability {    LaunchArgs,    LaunchPrefs,    LaunchHeadless,    LaunchNetwork,    LaunchProxy,    LaunchExtensions,    LaunchProfile,    PageScript(HostScope),    PageEvaluate,    PageNavigate,    Cdp(Cow<'static, str>),    NetObserve,    NetSensitive,    NetBodies,    NetIntercept,    NetFulfill,    CookiesRead,    CookiesWrite,    StorageClear,    Contexts,    TestHooks,    Task,    ArtifactsWrite,    HostNet(NetScope),    HostFsRead(PathScope),    HostFsWrite(PathScope),    HostProcess,    Clock,    Random,    State { persist: bool },    Raw(RawKind),}

One thing a plugin may do. Every variant has a string form (Display and FromStr), a risk, and an enforcement. A CapabilitySet keeps them sorted in the order of the variants above.

“WASM” is wasm_grantable(); “Native” is enforcement(false).

Capability::risk#

#[must_use]pub fn risk(&self) -> Risk

PluginSet::with and Registry::plugin_set never grant a Critical capability; PluginSet::with_trusted must name each one.

Capability::wasm_grantable#

#[must_use]pub fn wasm_grantable(&self) -> bool

Capability::enforcement#

#[must_use]pub fn enforcement(&self, wasm: bool) -> Enforcement

PluginSet::audit and sbrs plugin info report enforcement(false).

Capability::covers#

#[must_use]pub fn covers(&self, wanted: &Self) -> bool

Equal capabilities cover each other. Beyond that:

raw:cdp does not cover raw:switches, and temp or run-output cover only themselves.

Display and FromStr#

impl impl fmt::Display for Capability, impl FromStr for Capability

impl fmt::Display for Capability { /* the string form */ }impl FromStr for Capability {    type Err = ParseCapabilityError;    fn from_str(text: &str) -> Result<Self, Self::Err>;}

The string forms in the table round-trip: text.parse::<Capability>()?.to_string() == text. The grammar is HEAD or HEAD:ARG, split at the first ::

• page.script:* is every site; page.script:a.com,b.com is a host list (empty entries are dropped); page.script: alone is refused.
• cdp:DOMAIN needs a domain; the domain is kept as written.
• host.fs.read:SCOPE and host.fs.write:SCOPE take temp, run-output, or comma-separated paths.
• host.net: takes loopback or any; state: takes persist; raw: takes cdp or switches.
• Any other text is ParseCapabilityError.

ParseCapabilityError#

struct seleniumbase_rs_plugin::ParseCapabilityError

#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]#[error("unknown capability `{0}`")]pub struct ParseCapabilityError(pub String);

CapabilitySet#

struct seleniumbase_rs_plugin::CapabilitySet

#[derive(Clone, Debug, Default, PartialEq, Eq)]pub struct CapabilitySet(/* private BTreeSet<Capability> */);impl FromIterator<Capability> for CapabilitySet { /* ... */ }

A set of capabilities, sorted and without repeats: the capabilities and optional of Metadata, and the grants of a plugin in a set. Build one with collect(), new and insert, or legacy.

CapabilitySet::new#

#[must_use]pub fn new() -> Self

CapabilitySet::legacy#

#[must_use]pub fn legacy() -> Self

CapabilitySet::insert#

pub fn insert(&mut self, capability: Capability)

CapabilitySet::covers#

#[must_use]pub fn covers(&self, wanted: &Capability) -> bool

CapabilitySet::iter#

pub fn iter(&self) -> impl Iterator<Item = &Capability>

CapabilitySet::is_empty#

#[must_use]pub fn is_empty(&self) -> bool

CapabilitySet::union#

#[must_use]pub fn union(&self, other: &Self) -> Self

CapabilitySet::without_critical#

#[must_use]pub fn without_critical(&self) -> Self

HostScope#

enum seleniumbase_rs_plugin::HostScope

#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]pub enum HostScope {    Hosts(Vec<String>),    Everywhere,}

Which sites a page script may run on: the scope of Capability::PageScript.

NetScope#

enum seleniumbase_rs_plugin::NetScope

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]pub enum NetScope {    Loopback,    Any,}

Which network peers a plugin may talk to from the host: the scope of Capability::HostNet.

PathScope#

enum seleniumbase_rs_plugin::PathScope

#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]pub enum PathScope {    Temp,    RunOutput,    Declared(Vec<PathBuf>),}

Which files a plugin may use: the scope of Capability::HostFsRead and HostFsWrite.

RawKind#

enum seleniumbase_rs_plugin::RawKind

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]pub enum RawKind {    Cdp,    Switches,}

The kind of raw access a plugin has: the scope of Capability::Raw. Both are Critical.

Risk#

enum seleniumbase_rs_plugin::Risk

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]pub enum Risk {    Low,    Medium,    High,    Critical,}

How dangerous a capability is. Ordered from Low to Critical.

Enforcement#

enum seleniumbase_rs_plugin::Enforcement

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]pub enum Enforcement {    Enforced,    DeclaredOnly,}

Whether the host stops a plugin that goes beyond a capability, as Capability::enforcement classifies it.

HostInfo#

struct seleniumbase_rs_plugin::HostInfo

#[derive(Clone, Copy, Debug, PartialEq, Eq)]pub struct HostInfo { /* private: kind */ }

What the host that runs a set supports, passed to PluginSet::check_with so the set can refuse a plugin whose required capabilities the host cannot provide (PluginError::Unsupported).

HostInfo::cdp#

#[must_use]pub const fn cdp() -> Self

HostInfo::webdriver#

#[must_use]pub fn webdriver(family: BrowserFamily) -> Self

HostInfo::embedded#

#[must_use]pub const fn embedded() -> Self

HostInfo::kind#

#[must_use]pub const fn kind(&self) -> HostKind

HostInfo::name#

#[must_use]pub const fn name(&self) -> &'static str

HostInfo::supports#

#[must_use]pub fn supports(&self, capability: &Capability) -> bool

HostKind#

enum non_exhaustive seleniumbase_rs_plugin::HostKind

#[derive(Clone, Copy, Debug, PartialEq, Eq)]#[non_exhaustive]pub enum HostKind {    Cdp,    WebDriverChromium,    WebDriverOther,    Embedded,}

switch_policy#

mod seleniumbase_rs_plugin::switch_policy

The one list of browser switches that no plugin may add, and of the features no plugin may turn on or off. PluginSet::before_launch applies it to every plugin, legacy ones included, unless the plugin holds raw:switches. seleniumbase-rs has a test (tests/plugin_switch_policy.rs) that fails when a switch its own stealth layer forbids is missing from REFUSED_SWITCHES.

REFUSED_SWITCHES#

const seleniumbase_rs_plugin::switch_policy::REFUSED_SWITCHES

pub const REFUSED_SWITCHES: &[&str];

Switch names (no dashes, lower case) refused for every plugin:

REFUSED_FEATURES#

const seleniumbase_rs_plugin::switch_policy::REFUSED_FEATURES

pub const REFUSED_FEATURES: &[&str] = &["isolateorigins", "site-per-process"];

Feature names (lower case) that may not be disabled or enabled, through --disable-features=, --enable-features=, or the disable_features and enable_features fields of LaunchSettings.

switch_name#

fn seleniumbase_rs_plugin::switch_policy::switch_name

#[must_use]pub fn switch_name(arg: &str) -> Option<String>

refusal#

fn seleniumbase_rs_plugin::switch_policy::refusal

#[must_use]pub fn refusal(arg: &str) -> Option<String>

feature_refused#

fn seleniumbase_rs_plugin::switch_policy::feature_refused

#[must_use]pub fn feature_refused(feature: &str) -> bool