Struct Capability

pub struct Capability {
    pub identifier: String,
    pub description: String,
    pub remote: Option<CapabilityRemote>,
    pub local: bool,
    pub windows: Vec<String>,
    pub webviews: Vec<String>,
    pub permissions: Vec<PermissionEntry>,
    pub platforms: Option<Vec<Target>>,
}

A grouping and boundary mechanism developers can use to isolate access to the IPC layer.

It controls application windows’ and webviews’ fine grained access to the Tauri core, application, or plugin commands. If a webview or its window is not matching any capability then it has no access to the IPC layer at all.

This can be done to create groups of windows, based on their required system access, which can reduce impact of frontend vulnerabilities in less privileged windows. Windows can be added to a capability by exact name (e.g. main-window) or glob patterns like * or admin-*. A Window can have none, one, or multiple associated capabilities.

Example

{
  "identifier": "main-user-files-write",
  "description": "This capability allows the `main` window on macOS and Windows access to `filesystem` write related commands and `dialog` commands to enable programatic access to files selected by the user.",
  "windows": [
    "main"
  ],
  "permissions": [
    "core:default",
    "dialog:open",
    {
      "identifier": "fs:allow-write-text-file",
      "allow": [{ "path": "$HOME/test.txt" }]
    },
  ],
  "platforms": ["macOS","windows"]
}

Fields

identifier: String

Identifier of the capability.

Example

main-user-files-write

description: String

Description of what the capability is intended to allow on associated windows.

It should contain a description of what the grouped permissions should allow.

Example

This capability allows the main window access to filesystem write related commands and dialog commands to enable programatic access to files selected by the user.

remote: Option<CapabilityRemote>

Configure remote URLs that can use the capability permissions.

This setting is optional and defaults to not being set, as our default use case is that the content is served from our local application.

:::caution Make sure you understand the security implications of providing remote sources with local system access. :::

Example

{
  "urls": ["https://*.mydomain.dev"]
}

local: bool

Whether this capability is enabled for local app URLs or not. Defaults to true.

windows: Vec<String>

List of windows that are affected by this capability. Can be a glob pattern.

If a window label matches any of the patterns in this list, the capability will be enabled on all the webviews of that window, regardless of the value of Self::webviews.

On multiwebview windows, prefer specifying Self::webviews and omitting Self::windows for a fine grained access control.

Example

["main"]

webviews: Vec<String>

List of webviews that are affected by this capability. Can be a glob pattern.

The capability will be enabled on all the webviews whose label matches any of the patterns in this list, regardless of whether the webview’s window label matches a pattern in Self::windows.

Example

["sub-webview-one", "sub-webview-two"]

permissions: Vec<PermissionEntry>

List of permissions attached to this capability.

Must include the plugin name as prefix in the form of ${plugin-name}:${permission-name}. For commands directly implemented in the application itself only ${permission-name} is required.

Example

[
  "core:default",
  "shell:allow-open",
  "dialog:open",
  {
    "identifier": "fs:allow-write-text-file",
    "allow": [{ "path": "$HOME/test.txt" }]
  }
]

platforms: Option<Vec<Target>>

Limit which target platforms this capability applies to.

By default all platforms are targeted.

Example

["macOS","windows"]

Implementations

impl Capability

pub fn is_active(&self, target: &Target) -> bool

Whether this capability should be active based on the platform target or not.

Trait Implementations

impl Clone for Capability

fn clone(&self) -> Capability

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Capability

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Capability

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Capability

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Capability

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 Capability