git:20260612.dbca0d8 to git:20260614.78a2809

77 added, 26 removed. Audit A to A.

---

name: tauri-expert

- description: "Expert skill for Tauri (v2) development, covering Rust backend, IPC, security (capabilities/plugins), and frontend integration."

+ description: "Panduan ahli untuk pengembangan Tauri v2, Rust backend, IPC, dan keamanan / Expert skill for Tauri (v2) development, Rust backend, IPC, and security."

author: "Roedy Rustam"

---

# Tauri Expert

- ## Deskripsi

+ [Bahasa Indonesia](#bahasa-indonesia) | [English](#english)

+ ---

+ <a name="bahasa-indonesia"></a>

+ ## Bahasa Indonesia

+ ### Deskripsi

Skill ini memberikan panduan praktik terbaik (best practices) untuk membangun aplikasi desktop dan mobile lintas platform menggunakan Tauri (terutama Tauri v2). Skill ini mencakup integrasi frontend dengan backend Rust, Inter-Process Communication (IPC), manajemen state, serta keamanan.

- ## Instruksi & Best Practices Tauri

+ ### Instruksi & Praktik Terbaik

- 1. **Arsitektur & IPC (Inter-Process Communication)**

- - Gunakan `tauri::command` untuk mendefinisikan fungsi Rust yang bisa dipanggil dari frontend.

- - Panggil fungsi Rust dari frontend menggunakan `@tauri-apps/api/core` (`invoke`).

- - Jangan gunakan polling jika tidak perlu; manfaatkan sistem *event* Tauri (`emit` dari Rust, `listen` di frontend) untuk pembaruan *real-time* atau asinkron dari backend.

- - Usahakan operasi berat dan pemrosesan file dilakukan di sisi Rust (backend), sedangkan frontend hanya fokus pada UI.

+ #### 1. Arsitektur & IPC (Inter-Process Communication)

+ - Gunakan `tauri::command` untuk mendefinisikan fungsi Rust yang bisa dipanggil dari frontend.

+ - Panggil fungsi Rust dari frontend menggunakan `@tauri-apps/api/core` (`invoke`).

+ - Manfaatkan sistem *event* Tauri (`emit` dari Rust, `listen` di frontend) untuk pembaruan *real-time* atau asinkron dari backend.

+ - Lakukan operasi berat di sisi Rust (backend), sedangkan frontend hanya fokus pada UI.

- 2. **Manajemen State (Rust Backend)**

- - Gunakan `tauri::State` untuk menyimpan dan mengelola state global di backend Rust.

- - Gunakan `std::sync::Mutex` atau `tokio::sync::Mutex` (jika asinkron) untuk state yang bisa berubah (mutable state).

- - Selalu *manage* state tersebut pada saat setup aplikasi: `tauri::Builder::default().manage(MyState::default())`.

+ #### 2. Manajemen State (Rust Backend)

+ - Gunakan `tauri::State` untuk menyimpan dan mengelola state global di backend Rust.

+ - Gunakan `std::sync::Mutex` atau `tokio::sync::Mutex` (jika asinkron) untuk state yang bisa berubah (mutable state).

+ - Lakukan inisialisasi state saat setup aplikasi: `tauri::Builder::default().manage(MyState::default())`.

- 3. **Keamanan (Security & Capabilities)**

- - Terapkan isolasi konteks secara ketat.

- - Di Tauri v2, gunakan sistem **Capabilities** untuk membatasi akses API per jendela/plugin.

- - Jangan pernah mengekspos API filesystem, shell, atau jaringan yang berbahaya secara global. Hanya beri akses (`allowlist`) ke path atau perintah (commands) yang spesifik dan dibutuhkan.

+ #### 3. Keamanan (Security & Capabilities)

+ - Terapkan isolasi konteks secara ketat.

+ - Di Tauri v2, gunakan sistem **Capabilities** untuk membatasi akses API per jendela/plugin.

+ - Jangan mengekspos API filesystem, shell, atau jaringan yang berbahaya secara global. Hanya beri akses (`allowlist`) ke path atau perintah (commands) yang spesifik dan dibutuhkan.

- 4. **Kinerja & Asinkronisitas**

- - Gunakan `async fn` pada `tauri::command` untuk I/O yang berat agar tidak memblokir *main thread*. Jika menggunakan `std::fs`, pertimbangkan untuk menggunakan `tokio::fs`.

- - Gunakan `serde` (`Serialize`, `Deserialize`) secara efisien untuk mengirim struktur data kompleks antara Rust dan frontend.

+ #### 4. Kinerja & Asinkronisitas

+ - Gunakan `async fn` pada `tauri::command` untuk I/O yang berat agar tidak memblokir *main thread*.

+ - Gunakan `serde` (`Serialize`, `Deserialize`) secara efisien untuk mengirim struktur data kompleks antara Rust dan frontend.

- 5. **Pengelolaan Plugin (Tauri v2)**

- - Gunakan ekosistem plugin Tauri (seperti `tauri-plugin-fs`, `tauri-plugin-store`, `tauri-plugin-dialog`) alih-alih membuat modul I/O sendiri jika sudah tersedia.

- - Selalu inisialisasi plugin di file `main.rs` atau `lib.rs`: `app.plugin(tauri_plugin_dialog::init())`.

+ #### 5. Pengelolaan Plugin (Tauri v2)

+ - Gunakan ekosistem plugin Tauri (seperti `tauri-plugin-fs`, `tauri-plugin-store`, `tauri-plugin-dialog`) alih-alih membuat modul I/O sendiri jika sudah tersedia.

+ - Inisialisasi plugin di file `main.rs` atau `lib.rs`: `app.plugin(tauri_plugin_dialog::init())`.

- 6. **Cross-Platform & Build**

- - Hindari *hardcode* path sistem operasi (seperti `C:\` atau `/home/`). Gunakan `app_handle.path()` resolver untuk direktori AppData, Cache, dll.

- - Pastikan dependencies di `Cargo.toml` mendukung *cross-compilation* (Windows, macOS, Linux, iOS, Android).

+ #### 6. Lintas Platform (Cross-Platform) & Build

+ - Hindari *hardcode* path sistem operasi. Gunakan `app_handle.path()` resolver untuk direktori AppData, Cache, dsb.

+ - Pastikan dependencies di `Cargo.toml` mendukung *cross-compilation* (Windows, macOS, Linux, iOS, Android).

- ## Kondisi Pemicu

+ ### Kondisi Pemicu

Aktif saat:

- Membangun, men-debug, atau melakukan *refactoring* pada aplikasi Tauri.

- Menulis sistem IPC antara frontend (React/Svelte/Vue) dan backend Rust.

- Mengonfigurasi keamanan (`tauri.conf.json`, capabilities, permission).

+ ---

+ <a name="english"></a>

+ ## English

+ ### Description

+ This skill provides best practice guidance for building cross-platform desktop and mobile applications using Tauri (specifically Tauri v2). It covers frontend integration with the Rust backend, Inter-Process Communication (IPC), state management, and security.

+ ### Instructions & Best Practices

+ #### 1. Architecture & IPC (Inter-Process Communication)

+ - Use `tauri::command` to define Rust functions callable from the frontend.

+ - Invoke Rust functions from the frontend using `@tauri-apps/api/core` (`invoke`).

+ - Utilize Tauri's event system (`emit` from Rust, `listen` on frontend) for real-time or async updates.

+ - Keep heavy processing and filesystem access in Rust (backend), while the frontend focuses purely on UI.

+ #### 2. State Management (Rust Backend)

+ - Use `tauri::State` to store and manage global state in the Rust backend.

+ - Use `std::sync::Mutex` or `tokio::sync::Mutex` (if async) for mutable state.

+ - Initialize managed state during application setup: `tauri::Builder::default().manage(MyState::default())`.

+ #### 3. Security & Capabilities

+ - Enforce strict context isolation.

+ - In Tauri v2, use the **Capabilities** system to restrict API access per window or plugin.

+ - Never expose dangerous filesystem, shell, or network APIs globally. Only grant allowlist access to specific, required paths or commands.

+ #### 4. Performance & Concurrency

+ - Use `async fn` for `tauri::command` when handling heavy I/O to avoid blocking the main thread.

+ - Use `serde` (`Serialize`, `Deserialize`) efficiently for data structures sent between Rust and the frontend.

+ #### 5. Plugin Management (Tauri v2)

+ - Use official Tauri plugins (e.g., `tauri-plugin-fs`, `tauri-plugin-store`, `tauri-plugin-dialog`) instead of writing custom I/O modules when available.

+ - Initialize plugins in `main.rs` or `lib.rs`: `app.plugin(tauri_plugin_dialog::init())`.

+ #### 6. Cross-Platform & Build

+ - Avoid hardcoded paths. Use the `app_handle.path()` resolver for AppData, Cache, and other system directories.

+ - Ensure dependencies in `Cargo.toml` support cross-compilation (Windows, macOS, Linux, iOS, Android).

+ ### Trigger Conditions

+ Active when:

+ - Building, debugging, or refactoring Tauri applications.

+ - Writing IPC systems between the frontend (React/Svelte/Vue) and the Rust backend.

+ - Configuring security (`tauri.conf.json`, capabilities, permissions).