Claude Tauri skill: 10 desktop-app recipes that compile

The prompt

In `apps/desktop/src/lib/storage.ts`, write a `workspaceFile(id, name)` helper that returns the absolute path to `<appLocalDataDir>/workspaces/<id>/<name>`. Use `@tauri-apps/api/path` — never string concatenation. Await every call (they're IPC, so they're Promises). Add a sibling `parentOf(path)` that returns the directory via `dirname`, not manual slicing.

What slides.md looks like

import { appLocalDataDir, join, dirname } from '@tauri-apps/api/path';

// All path fns are async — they round-trip to Rust over IPC.
export async function workspaceFile(id: string, name: string) {
  const base = await appLocalDataDir();
  // join() inserts the platform separator: \ on Windows, / elsewhere.
  return join(base, 'workspaces', id, name);
}

export async function parentOf(path: string) {
  return dirname(path); // not path.slice(0, path.lastIndexOf('/'))
}

Pairs with

The prompt

Write `saveData(segments, bytes)` that resolves `<appLocalDataDir>/<...segments>`, ensures the parent directory exists with `mkdir({ recursive: true })`, then writes with `writeFile`. Use `@tauri-apps/plugin-fs`. Then show the matching capability entry — I'm getting a 'forbidden path' error and I think the scope is missing.

What slides.md looks like

import { appLocalDataDir, join, dirname } from '@tauri-apps/api/path';
import { mkdir, writeFile } from '@tauri-apps/plugin-fs';

export async function saveData(segments: string[], bytes: Uint8Array) {
  const path = await join(await appLocalDataDir(), ...segments);
  await mkdir(await dirname(path), { recursive: true });
  await writeFile(path, bytes);
}
// capabilities/default.json — scope fs to $APPLOCALDATA, not the whole disk:
// { "identifier": "fs:allow-write-file",
//   "allow": [{ "path": "$APPLOCALDATA/**" }] }

Pairs with

The prompt

Add a `read_config` command in `src-tauri/src/lib.rs` that takes an app handle, reads a JSON config from the app config dir, and returns `Result<Config, String>`. Validate the parsed shape in Rust — assume the TypeScript caller is hostile. Register it in `generate_handler!`. Then give me the typed `invoke<Config>('read_config')` call for the frontend.

What slides.md looks like

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Config { theme: String, retries: u8 }

#[tauri::command]
fn read_config(app: tauri::AppHandle) -> Result<Config, String> {
    let dir = app.path().app_config_dir().map_err(|e| e.to_string())?;
    let raw = std::fs::read_to_string(dir.join("config.json"))
        .map_err(|e| e.to_string())?;
    serde_json::from_str(&raw).map_err(|e| e.to_string()) // validate here
}

// lib.rs builder:
// .invoke_handler(tauri::generate_handler![read_config])
// frontend: const cfg = await invoke<Config>('read_config');

Pairs with

The prompt

I added a `delete_recording` command but the frontend can't see it. Register it in the `tauri_specta::collect_commands!` builder, confirm the event payload types are in `collect_events!`, then give me the two commands that regenerate the bindings and cargo-check the Rust side. Remind me not to commit unrelated binding churn.

What slides.md looks like

// src-tauri/src/lib.rs
let builder = tauri_specta::Builder::<tauri::Wry>::new()
    .commands(tauri_specta::collect_commands![read_config, delete_recording])
    .events(tauri_specta::collect_events![RecordingDeleted]);

// Regenerate the derived bindings + type-check Rust:
//   cargo check --manifest-path src-tauri/Cargo.toml
//   bun run bindings:tauri
// bindings.gen.ts is generated output — commit it only when the
// public IPC contract actually changed, and inspect the diff first.

Pairs with

The prompt

Audit `src-tauri/capabilities/default.json`. I currently have `fs:allow-read-file` and `fs:allow-write-file` with no scope and `shell:allow-execute`. Tighten the FS permissions to only `$APPLOCALDATA` and `$APPCONFIG`, drop the unscoped shell permission, and bind the capability to the `main` window only. Explain why each change reduces blast radius.

What slides.md looks like

// src-tauri/capabilities/default.json — least privilege:
{
  "identifier": "default",
  "windows": ["main"],            // scoped to one window, not "*"
  "permissions": [
    "core:default",
    { "identifier": "fs:allow-write-file",
      "allow": [{ "path": "$APPLOCALDATA/**" }, { "path": "$APPCONFIG/**" }] },
    { "identifier": "fs:allow-read-file",
      "allow": [{ "path": "$APPLOCALDATA/**" }] }
    // shell:allow-execute removed — nothing here needs a raw shell.
  ]
}

Pairs with

The prompt

Set `app.security.csp` in `tauri.conf.json` for production and a matching `devCsp` for `tauri dev`. Lock `connect-src` to my API origin plus Tauri's IPC. My frontend is a SvelteKit SPA, so production script-src can be `'self'` (codegen hashes inline scripts) but dev needs `'unsafe-inline'`/`'unsafe-eval'` for Vite HMR. Always include the IPC origin or invoke breaks.

What slides.md looks like

// tauri.conf.json -> "app": { "security": { ... } }
"csp": "default-src 'self'; connect-src 'self' ipc: http://ipc.localhost https://api.example.com; img-src 'self' data: blob: https:; style-src 'self' 'unsafe-inline'; script-src 'self'; object-src 'none'; base-uri 'self'; frame-ancestors 'none'",
// dev loads from the unhashed Vite server, so it keeps 'unsafe-inline':
"devCsp": "default-src 'self'; connect-src 'self' ipc: http://ipc.localhost http://localhost:5173 ws://localhost:5173 https://api.example.com; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; object-src 'none'"

Pairs with

The prompt

I need to bundle `bin/transcribe` (a platform-suffixed sidecar) and call it from the frontend. Add the `externalBin` entry to `tauri.conf.json`, add a scoped `shell:allow-execute` permission that only allows that one sidecar, and show the `Command.sidecar('bin/transcribe', [file])` call. Do not give it a broad shell permission.

What slides.md looks like

// tauri.conf.json -> "bundle": { "externalBin": ["bin/transcribe"] }
// capabilities: scope the shell to ONE sidecar, not the whole shell:
// { "identifier": "shell:allow-execute",
//   "allow": [{ "name": "bin/transcribe", "sidecar": true,
//               "args": [{ "validator": "\\S+" }] }] }

import { Command } from '@tauri-apps/plugin-shell';
const out = await Command.sidecar('bin/transcribe', [filePath]).execute();
if (out.code !== 0) throw new Error(out.stderr);

Pairs with

The prompt

Add `tauri-plugin-window-state` so the main window restores its size and position on relaunch. Show the `Cargo.toml` dependency, the `.plugin(...)` line in the Rust builder, and the capability permission it needs. Then tell me the manual save/restore calls in case I want to trigger them myself.

What slides.md looks like

// Cargo.toml: tauri-plugin-window-state = "2"
// src-tauri/src/lib.rs builder:
tauri::Builder::default()
    .plugin(tauri_plugin_window_state::Builder::default().build())
    // ...
// capabilities: add "window-state:default"

// Manual control from the frontend, if you want it:
import { saveWindowState, StateFlags } from '@tauri-apps/plugin-window-state';
await saveWindowState(StateFlags.ALL);

Pairs with

The prompt

Wire an Export button: open a native save dialog with `@tauri-apps/plugin-dialog` defaulting to a `.md` filename, and if the user picks a path, write the markdown there with `writeTextFile`. Handle the cancel case (the dialog returns null). Remind me which dialog and fs permissions the capability needs.

What slides.md looks like

import { save } from '@tauri-apps/plugin-dialog';
import { writeTextFile } from '@tauri-apps/plugin-fs';

export async function exportMarkdown(body: string) {
  const path = await save({
    defaultPath: 'export.md',
    filters: [{ name: 'Markdown', extensions: ['md'] }],
  });
  if (!path) return; // user cancelled
  await writeTextFile(path, body);
}
// capabilities: "dialog:allow-save" + a scoped "fs:allow-write-file".

Pairs with

The prompt

Write a GitHub Actions workflow that builds my Tauri app on macOS and Windows runners and uploads the installers as release assets using `tauri-apps/tauri-action`. Reference signing secrets from repository secrets — don't hardcode anything. Use a matrix so both platforms build from one job definition.

What slides.md looks like

jobs:
  release:
    strategy:
      matrix:
        platform: [macos-latest, windows-latest]
    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - uses: tauri-apps/tauri-action@v0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          # macOS signing pulled from secrets, never inlined:
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}

Pairs with