tauri

What this skill does

# Tauri Skill

Comprehensive assistance with Tauri development, generated from official documentation.

## When to Use This Skill

This skill should be triggered when:
- Building cross-platform desktop applications with Rust + WebView
- Implementing native system integrations (file system, notifications, system tray)
- Setting up Tauri project structure and configuration
- Debugging Tauri applications in VS Code or Neovim
- Configuring Windows/macOS/Linux code signing for distribution
- Developing mobile apps with Tauri (Android/iOS)
- Creating Tauri plugins for custom native functionality
- Implementing IPC (Inter-Process Communication) between frontend and backend
- Optimizing Tauri app security and permissions
- Setting up CI/CD pipelines for Tauri app releases

## Key Concepts

### Multi-Process Architecture
Tauri uses a **Core Process** (Rust) and **WebView Process** (HTML/CSS/JS) architecture:
- **Core Process**: Manages windows, system tray, IPC routing, and has full OS access
- **WebView Process**: Renders UI using system WebViews (no bundled browser!)
- **Principle of Least Privilege**: Each process has minimal required permissions

### Inter-Process Communication (IPC)
Two IPC primitives:
- **Events**: Fire-and-forget, one-way messages (both Core → WebView and WebView → Core)
- **Commands**: Request-response pattern using `invoke()` API (WebView → Core only)

### Why Tauri?
- **Small binaries**: Uses OS WebViews (Microsoft Edge WebView2/WKWebView/webkitgtk)
- **Security-first**: Message passing architecture prevents direct function access
- **Multi-platform**: Desktop (Windows/macOS/Linux) + Mobile (Android/iOS)

## Quick Reference

### 1. Project Setup - Cargo.toml

```toml
[build-dependencies]
tauri-build = "2.0.0"

[dependencies]
tauri = { version = "2.0.0" }
```

### 2. Windows Code Signing Configuration

```json
{
  "tauri": {
    "bundle": {
      "windows": {
        "certificateThumbprint": "A1B1A2B2A3B3A4B4A5B5A6B6A7B7A8B8A9B9A0B0",
        "digestAlgorithm": "sha256",
        "timestampUrl": "http://timestamp.comodoca.com"
      }
    }
  }
}
```

### 3. VS Code Debugging - launch.json

```json
{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Tauri Development Debug",
      "cargo": {
        "args": [
          "build",
          "--manifest-path=./src-tauri/Cargo.toml",
          "--no-default-features"
        ]
      },
      "preLaunchTask": "ui:dev"
    }
  ]
}
```

### 4. Rust State Management

```rust
let data = app.state::<AppData>();
```

### 5. GitHub Actions - Publish Workflow

```yaml
name: 'publish'

on:
  push:
    tags:
      - 'app-v*'
```

### 6. Trunk Configuration (Rust Frontend)

```toml
# Trunk.toml
[watch]
ignore = ["./src-tauri"]

[serve]
ws_protocol = "ws"
```

### 7. Azure Key Vault Signing (relic.conf)

```toml
[server.azurekv]
url = "https://<KEY_VAULT_NAME>.vault.azure.net/certificates/<CERTIFICATE_NAME>"
```

### 8. Custom Sign Command (tauri.conf.json)

```json
{
  "tauri": {
    "bundle": {
      "windows": {
        "signCommand": "relic sign -c relic.conf -f -o \"%1\""
      }
    }
  }
}
```

### 9. Opening DevTools Programmatically

```rust
use tauri::Manager;

#[tauri::command]
fn open_devtools(window: tauri::Window) {
    window.open_devtools();
}
```

### 10. Mobile Plugin - Android Command

```kotlin
@Command
fun download(invoke: Invoke) {
    val args = invoke.parseArgs(DownloadArgs::class.java)
    // Command implementation
    invoke.resolve()
}
```

## Reference Files

This skill includes comprehensive documentation organized into 9 categories:

### core_concepts.md
**Contains:** 7 pages covering foundational architecture
- **Process Model**: Multi-process architecture, Core vs WebView processes, security principles
- **Inter-Process Communication**: Events and Commands patterns, message passing
- **Debug in VS Code**: Setting up `vscode-lldb`, launch.json configuration, Windows debugger
- **Tauri Architecture**: Ecosystem overview (tauri-runtime, tauri-macros, tauri-utils, WRY, TAO)

**When to use**: Understanding Tauri's design philosophy, debugging setup, architecture decisions

### development.md
**Contains:** 13 pages on development workflows
- **Debug in Neovim**: nvim-dap setup, codelldb configuration, overseer plugin for dev servers
- **CrabNebula DevTools**: Real-time log inspection, performance tracking, event monitoring
- **Debug**: Development-only code patterns, console logging, WebView inspector, production debugging
- **Mobile Plugin Development**: Android (Kotlin) and iOS (Swift) plugin creation, lifecycle events

**When to use**: Setting up development environment, debugging strategies, mobile development

### distribution.md
**Contains:** 8 pages on app distribution
- **Windows Code Signing**: OV certificates, Azure Key Vault, custom sign commands, GitHub Actions
- **Azure Code Signing**: trusted-signing-cli setup, environment variables, signing workflows
- **Code Signing Best Practices**: EV vs OV certificates, SmartScreen reputation, Microsoft Store

**When to use**: Preparing apps for release, code signing, CI/CD pipelines, production builds

### getting_started.md
**Contains:** Quick start guides and initial setup instructions
- Project initialization
- First Tauri app tutorials
- Configuration basics

**When to use**: Starting new Tauri projects, onboarding new developers

### plugins.md
**Contains:** Plugin development and integration guides
- Creating custom plugins
- Mobile plugin patterns (Android/iOS)
- Plugin configuration
- Lifecycle events (load, onNewIntent)
- Command arguments and parsing

**When to use**: Extending Tauri with native functionality, integrating third-party libraries

### reference.md
**Contains:** API references and configuration schemas
- tauri.conf.json structure
- Command-line interface options
- Configuration options reference

**When to use**: Looking up specific API methods, configuration properties, CLI flags

### security.md
**Contains:** Security best practices and patterns
- Content Security Policy (CSP)
- Secure IPC patterns
- Permission management
- WebView security

**When to use**: Hardening applications, security audits, implementing secure features

### tutorials.md
**Contains:** Step-by-step implementation guides
- Building specific features
- Integration examples
- Real-world use cases

**When to use**: Learning by example, implementing common patterns

### other.md
**Contains:** Miscellaneous documentation not categorized above
- Advanced topics
- Edge cases
- Platform-specific notes

**When to use**: Troubleshooting unusual issues, platform-specific implementations

## Working with This Skill

### For Beginners
1. **Start with**: `getting_started.md` for project setup and basic concepts
2. **Then read**: `core_concepts.md` → Process Model and IPC sections
3. **Practice**: Set up debugging with `development.md` → Debug in VS Code
4. **Build**: Follow tutorials in `tutorials.md`

**Common beginner questions:**
- "How do I create a Tauri app?" → `getting_started.md`
- "What is the Core Process?" → `core_concepts.md` → Process Model
- "How do I call Rust from JavaScript?" → `core_concepts.md` → IPC → Commands

### For Intermediate Developers
1. **Focus on**: `plugins.md` for custom native functionality
2. **Master**: `development.md` for debugging and DevTools
3. **Explore**: `reference.md` for API details
4. **Implement**: Custom IPC patterns from `core_concepts.md`

**Common intermediate questions:**
- "How do I create a custom plugin?" → `plugins.md` → Plugin Development
- "How do I debug performance issues?" → `development.md` → CrabNebula DevTools
- "What configuration options are available?" → `reference.md`

### For Advanced Users
1. **Deep dive**: `security.md` for production-ready security
2. **Optimize**: Mobile development patterns in `plugins.md`
3. **Automate**: Distribution workflows in `distribution.md`
4. **Customize**: Advanced patterns i