Tauri 2.0 Plugins Using and Creating Custom Plugins

// Popular official Tauri plugins
// Cargo.toml
[dependencies]
tauri = { version = "2.0" }
tauri-plugin-fs = "2.0"              # Filesystem operations
tauri-plugin-http = "2.0"            # HTTP requests
tauri-plugin-shell = "2.0"           # Shell commands
tauri-plugin-dialog = "2.0"          # File dialogs
tauri-plugin-clipboard = "2.0"       # Clipboard access
tauri-plugin-notification = "2.0"    # System notifications
tauri-plugin-store = "2.0"           # Key-value store
tauri-plugin-updater = "2.0"         # Auto-updates
tauri-plugin-window-state = "2.0"    # Save window state

// Register plugins in main.rs
use tauri::Manager;

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_fs::init())
        .plugin(tauri_plugin_http::init())
        .plugin(tauri_plugin_shell::init())
        .plugin(tauri_plugin_dialog::init())
        .plugin(tauri_plugin_clipboard::init())
        .plugin(tauri_plugin_notification::init())
        .plugin(tauri_plugin_store::Builder::default().build())
        .setup(|app| {
            // Additional setup
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Frontend usage - Install npm packages
npm install @tauri-apps/plugin-fs
npm install @tauri-apps/plugin-http
npm install @tauri-apps/plugin-shell
npm install @tauri-apps/plugin-dialog
npm install @tauri-apps/plugin-clipboard
npm install @tauri-apps/plugin-notification

// Using plugins in frontend
import { readTextFile, writeTextFile } from '@tauri-apps/plugin-fs';
import { fetch } from '@tauri-apps/plugin-http';
import { open } from '@tauri-apps/plugin-shell';
import { open as openDialog } from '@tauri-apps/plugin-dialog';
import { readText, writeText } from '@tauri-apps/plugin-clipboard';
import { sendNotification } from '@tauri-apps/plugin-notification';

// Filesystem plugin
async function useFilesystem() {
  // Read file
  const content = await readTextFile('config.json');
  console.log(content);

  // Write file
  await writeTextFile('output.txt', 'Hello, Tauri!');
}

// HTTP plugin
async function fetchData() {
  const response = await fetch('https://api.example.com/data');
  const data = await response.json();
  return data;
}

// Shell plugin
async function openUrl() {
  await open('https://tauri.app');
}

// Dialog plugin
async function selectFile() {
  const selected = await openDialog({
    multiple: false,
    directory: false,
    filters: [{
      name: 'Text',
      extensions: ['txt', 'md']
    }]
  });
  return selected;
}

// Clipboard plugin
async function copyToClipboard(text: string) {
  await writeText(text);
}

async function pasteFromClipboard() {
  const text = await readText();
  return text;
}

// Notification plugin
async function showNotification() {
  await sendNotification({
    title: 'Task Complete',
    body: 'Your file has been saved successfully',
    icon: 'success',
  });
}

// Store plugin for persistent data
import { Store } from '@tauri-apps/plugin-store';

const store = new Store('settings.json');

async function saveSettings(settings: any) {
  await store.set('theme', settings.theme);
  await store.set('language', settings.language);
  await store.save();
}

async function loadSettings() {
  const theme = await store.get<string>('theme');
  const language = await store.get<string>('language');
  return { theme, language };
}

// Updater plugin
import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/api/process';

async function checkForUpdates() {
  const update = await check();
  
  if (update?.available) {
    console.log(`Update available: ${update.version}`);
    
    // Download and install
    await update.downloadAndInstall();
    
    // Restart app
    await relaunch();
  }
}

// Window state plugin
import { saveWindowState, restoreWindowState } from '@tauri-apps/plugin-window-state';

// Save window position and size
await saveWindowState();

// Restore on next launch (in setup)
await restoreWindowState();

// Create new plugin project
cargo new --lib tauri-plugin-example
cd tauri-plugin-example

// Cargo.toml
[package]
name = "tauri-plugin-example"
version = "0.1.0"
edition = "2021"

[dependencies]
tauri = "2.0"
serde = { version = "1", features = ["derive"] }
serde_json = "1"

[lib]
crate-type = ["lib", "cdylib", "staticlib"]

// src/lib.rs - Plugin implementation
use tauri::{
    plugin::{Builder, TauriPlugin},
    Runtime, Manager,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize)]
struct EncryptRequest {
    text: String,
    key: String,
}

#[derive(Debug, Serialize)]
struct EncryptResponse {
    encrypted: String,
}

// Plugin commands
#[tauri::command]
fn encrypt(request: EncryptRequest) -> Result<EncryptResponse, String> {
    // Simple XOR encryption (use proper crypto in production)
    let encrypted: String = request.text
        .bytes()
        .zip(request.key.bytes().cycle())
        .map(|(t, k)| (t ^ k))
        .map(|b| format!("{:02x}", b))
        .collect();
    
    Ok(EncryptResponse { encrypted })
}

#[tauri::command]
fn decrypt(encrypted: String, key: String) -> Result<String, String> {
    let bytes: Result<Vec<u8>, _> = (0..encrypted.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&encrypted[i..i + 2], 16))
        .collect();
    
    let bytes = bytes.map_err(|e| e.to_string())?;
    
    let decrypted: String = bytes
        .iter()
        .zip(key.bytes().cycle())
        .map(|(b, k)| (b ^ k) as char)
        .collect();
    
    Ok(decrypted)
}

// Plugin state (optional)
pub struct ExamplePlugin {
    config: PluginConfig,
}

#[derive(Clone, Serialize, Deserialize)]
pub struct PluginConfig {
    pub enabled: bool,
    pub max_length: usize,
}

impl Default for PluginConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            max_length: 1000,
        }
    }
}

// Plugin initialization
pub fn init<R: Runtime>() -> TauriPlugin<R> {
    Builder::new("example")
        .invoke_handler(tauri::generate_handler![encrypt, decrypt])
        .setup(|app, _api| {
            // Plugin setup logic
            app.manage(ExamplePlugin {
                config: PluginConfig::default(),
            });
            Ok(())
        })
        .build()
}

// With configuration
pub fn init_with_config<R: Runtime>(config: PluginConfig) -> TauriPlugin<R> {
    Builder::new("example")
        .invoke_handler(tauri::generate_handler![encrypt, decrypt])
        .setup(move |app, _api| {
            app.manage(ExamplePlugin {
                config: config.clone(),
            });
            Ok(())
        })
        .build()
}

// Using plugin in main app
// src-tauri/Cargo.toml
[dependencies]
tauri-plugin-example = { path = "../tauri-plugin-example" }

// src-tauri/src/main.rs
use tauri_plugin_example;

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_example::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Or with custom config
use tauri_plugin_example::{init_with_config, PluginConfig};

pub fn run() {
    let config = PluginConfig {
        enabled: true,
        max_length: 2000,
    };
    
    tauri::Builder::default()
        .plugin(init_with_config(config))
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// TypeScript bindings
// Create npm package: tauri-plugin-example-api
// package.json
{
  "name": "tauri-plugin-example-api",
  "version": "0.1.0",
  "type": "module",
  "exports": {
    ".": "./dist/index.js"
  },
  "scripts": {
    "build": "tsc"
  },
  "devDependencies": {
    "@tauri-apps/api": "^2.0.0",
    "typescript": "^5.0.0"
  }
}

// src/index.ts
import { invoke } from '@tauri-apps/api/core';

export interface EncryptOptions {
  text: string;
  key: string;
}

export interface EncryptResult {
  encrypted: string;
}

export async function encrypt(options: EncryptOptions): Promise<EncryptResult> {
  return await invoke<EncryptResult>('plugin:example|encrypt', options);
}

export async function decrypt(
  encrypted: string,
  key: string
): Promise<string> {
  return await invoke<string>('plugin:example|decrypt', { encrypted, key });
}

// Usage in frontend
import { encrypt, decrypt } from 'tauri-plugin-example-api';

async function testPlugin() {
  const result = await encrypt({
    text: 'Hello, World!',
    key: 'secret',
  });
  
  console.log('Encrypted:', result.encrypted);
  
  const original = await decrypt(result.encrypted, 'secret');
  console.log('Decrypted:', original);
}

// Plugin permissions definition
// permissions/default.toml
[[permission]]
identifier = "allow-encrypt"
description = "Allows encryption of text"
commands.allow = ["encrypt"]

[[permission]]
identifier = "allow-decrypt"
description = "Allows decryption of text"
commands.allow = ["decrypt"]

[[permission]]
identifier = "allow-all"
description = "Allows all plugin operations"
commands.allow = ["encrypt", "decrypt"]

// Using permissions in app
// src-tauri/capabilities/default.json
{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "windows": ["main"],
  "permissions": [
    "core:default",
    "example:allow-encrypt",
    "example:allow-decrypt"
  ]
}

// Conditional permissions
{
  "identifier": "limited",
  "windows": ["main"],
  "permissions": [
    "example:allow-encrypt"  // Only allow encryption
  ]
}

// Plugin with permission checks
use tauri::{
    plugin::{Builder, TauriPlugin},
    Runtime, Manager,
};

#[tauri::command]
fn sensitive_operation(
    app: tauri::AppHandle,
) -> Result<String, String> {
    // Check if user has permission
    // This is handled automatically by Tauri's permission system
    
    // Perform operation
    Ok("Success".to_string())
}

// Dynamic permission requests (frontend)
import { checkPermission, requestPermission } from '@tauri-apps/api/permission';

async function checkPluginAccess() {
  const hasPermission = await checkPermission('example:allow-encrypt');
  
  if (!hasPermission) {
    const granted = await requestPermission('example:allow-encrypt');
    if (!granted) {
      console.error('Permission denied');
      return;
    }
  }
  
  // Use plugin
  await encrypt({ text: 'data', key: 'key' });
}

// Unit tests for plugin
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_encrypt_decrypt() {
        let request = EncryptRequest {
            text: "Hello".to_string(),
            key: "secret".to_string(),
        };

        let encrypted = encrypt(request).unwrap();
        assert!(!encrypted.encrypted.is_empty());

        let decrypted = decrypt(encrypted.encrypted, "secret".to_string()).unwrap();
        assert_eq!(decrypted, "Hello");
    }

    #[test]
    fn test_wrong_key() {
        let request = EncryptRequest {
            text: "Hello".to_string(),
            key: "secret".to_string(),
        };

        let encrypted = encrypt(request).unwrap();
        let decrypted = decrypt(encrypted.encrypted, "wrong".to_string()).unwrap();
        
        assert_ne!(decrypted, "Hello");
    }
}

// Integration tests
#[cfg(test)]
mod integration_tests {
    use tauri::test::{mock_builder, MockRuntime};

    #[test]
    fn test_plugin_integration() {
        let app = mock_builder()
            .plugin(super::init())
            .build(tauri::generate_context!())
            .expect("Failed to build app");

        // Test plugin is registered
        assert!(app.state::<super::ExamplePlugin>().is_some());
    }
}