tauri-plugin-mcp

Plattformübergreifendes Tauri-Testautomatisierungs-Plugin via MCP (Model Context Protocol).

Ermöglicht KI-Assistenten wie Claude die Interaktion mit Ihrer Tauri-Desktop-App zu Test- und Automatisierungszwecken.

Claude Code Plugin

Dieses Repository fungiert gleichzeitig als Claude Code Plugin. Drei Schritte für ein vollständig funktionierendes Setup:

1. Marketplace hinzufügen und Plugin installieren

/plugin marketplace add DaveDev42/tauri-plugin-mcp
/plugin install tauri-mcp

Während der Installation werden Sie nach Folgendem gefragt:

• Tauri-App-Verzeichnis: Pfad relativ zum Projektstammverzeichnis (z. B. . für Single-App-Repos, apps/desktop für Monorepos).

2. Installer-Befehl ausführen

/tauri-mcp:install

Dies bearbeitet automatisch Ihr Tauri-Projekt: Cargo.toml, src-tauri/src/lib.rs, Capabilities, package.json, den Frontend-Einstiegspunkt (main.tsx/main.ts) und .gitignore. Jeder Schreibvorgang wird zuerst als Diff in der Vorschau angezeigt und erfordert Ihre Bestätigung.

3. Claude Code neu starten

Der tauri-mcp MCP-Server registriert sich beim Neustart. Überprüfen Sie dies mit /mcp — es sollte tauri-mcp als verbunden anzeigen. Sie können nun start_session, snapshot, click usw. aufrufen.

Warum neu starten?

MCP-Server werden beim Start von Claude Code registriert. Die Installation des Plugins oder das Ändern von tauri_app_dir erfordern jeweils einen Neustart, damit die Änderungen wirksam werden.

Was das Plugin liefert

Der MCP-Server wird als in sich geschlossenes Single-File-Bundle (packages/tauri-mcp/dist/index.js) mit allen Abhängigkeiten ausgeliefert — auf dem Zielrechner sind keine node_modules erforderlich, sodass die Installation auf macOS, Linux und Windows identisch funktioniert.

Was ist enthalten:

Funktionen

• Plattformübergreifend: Windows (Named Pipes) + macOS/Linux (Unix Sockets)

• Keine CDP-Abhängigkeit: Funktioniert auf allen WebView-Backends, einschließlich macOS WKWebView

• MCP-Integration: Direkte Integration mit Claude Code und anderen MCP-Clients

• Multi-Window-Unterstützung: Jedes Fenster über Label ansteuern; automatische Bridge-Injektion

• Vereinheitlichtes Logging: Build-, Laufzeit-, Konsolen- und Netzwerk-Logs mit Filterung

• Dynamische Port-Zuweisung: Automatische zufällige Port-Zuweisung zur Vermeidung von Konflikten

Voraussetzungen

• Node.js >= 18

• Tauri v2.x

• pnpm (empfohlen) oder npm

• Rust mit cargo

Schnellstart

1. [ ] Rust-Plugin zu src-tauri/Cargo.toml hinzufügen

2. [ ] npm-Paket installieren: pnpm add github:DaveDev42/tauri-plugin-mcp#main

3. [ ] Plugin in src-tauri/src/lib.rs registrieren

4. [ ] mcp:default Berechtigung hinzufügen

5. [ ] Bridge in main.tsx initialisieren

6. [ ] .mcp.json für Claude Code erstellen

Installation

1. Rust-Plugin (src-tauri/Cargo.toml)

[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp" }

2. Frontend-API (package.json)

pnpm add github:DaveDev42/tauri-plugin-mcp#main

3. MCP-Server

Die MCP-Server-Binärdatei (tauri-mcp) ist nach der Installation automatisch verfügbar. Keine zusätzliche Einrichtung erforderlich.

Einrichtung

1. Plugin registrieren (src-tauri/src/lib.rs)

pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_mcp::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

2. Berechtigungen hinzufügen

Option A: In tauri.conf.json oder config/*.json5 (empfohlen)

{
  "security": {
    "capabilities": [{
      "identifier": "main-capability",
      "windows": ["main"],
      "permissions": ["core:default", "mcp:default"]
    }]
  }
}

Option B: Separate Datei (src-tauri/capabilities/default.json)

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "windows": ["main"],
  "permissions": ["core:default", "mcp:default"]
}

3. Bridge initialisieren (main.tsx)

// Initialize MCP bridge for E2E testing (dev mode only)
if (import.meta.env.DEV) {
  import('tauri-plugin-mcp').then(({ initMcpBridge }) => {
    initMcpBridge().catch(err => {
      console.warn('[MCP] Bridge initialization failed:', err);
    });
  });
}

Produktionssicheres Setup (Optionale Abhängigkeit)

Das grundlegende Setup oben enthält MCP in allen Builds. Für Produktions-Apps möchten Sie MCP wahrscheinlich nur in der Entwicklung haben und vollständig aus Release-Binärdateien entfernen.

Dieser Ansatz verwendet das Feature für optionale Abhängigkeiten von Cargo, sodass das Plugin nur dann kompiliert wird, wenn es explizit angefordert wird.

1. Optionale Cargo-Abhängigkeit (src-tauri/Cargo.toml)

[features]
default = []
dev-tools = ["dep:tauri-plugin-mcp"]

[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp", optional = true }

2. Bedingte Plugin-Registrierung (src-tauri/src/lib.rs)

pub fn run() {
    let mut builder = tauri::Builder::default();

    #[cfg(feature = "dev-tools")]
    {
        builder = builder.plugin(tauri_plugin_mcp::init());
    }

    builder
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

3. Aufteilung der Capabilities-Datei

Teilen Sie mcp:default in eine eigene Capability-Datei auf, damit sie zur Build-Zeit umgeschaltet werden kann.

capabilities/default.json — immer aktiv, keine MCP-Berechtigung:

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "windows": ["main"],
  "permissions": ["core:default"]
}

capabilities/.dev-tools.json.disabled — MCP-Berechtigungsvorlage (git-tracked):

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "dev-tools",
  "windows": ["main"],
  "permissions": ["mcp:default"]
}

capabilities/dev-tools.json — zu .gitignore hinzufügen (wird zur Build-Zeit generiert):

# Dev-tools capability (generated from .disabled at build time)
src-tauri/capabilities/dev-tools.json

4. build.rs — Verwaltung bedingter Capabilities

build.rs kopiert die Vorlage an den richtigen Ort, wenn das Feature aktiviert ist, und entfernt sie andernfalls:

fn main() {
    let dev_tools_cap = std::path::Path::new("capabilities/dev-tools.json");
    let source_path = std::path::Path::new("capabilities/.dev-tools.json.disabled");

    if std::env::var("CARGO_FEATURE_DEV_TOOLS").is_ok() {
        // Copy .disabled → active (skip if already identical to avoid rebuild churn)
        let should_copy = if dev_tools_cap.exists() {
            std::fs::read(source_path).ok() != std::fs::read(dev_tools_cap).ok()
        } else {
            true
        };
        if should_copy {
            std::fs::copy(source_path, dev_tools_cap)
                .expect("Failed to copy dev-tools capability file");
        }
    } else if dev_tools_cap.exists() {
        std::fs::remove_file(dev_tools_cap).ok();
    }

    tauri_build::try_build(
        tauri_build::Attributes::default()
    ).expect("Failed to build tauri");
}

5. Dev-Skript (package.json)

{
  "scripts": {
    "dev": "tauri dev --features dev-tools"
  }
}

Jetzt aktiviert pnpm dev MCP, während tauri build (ohne das Feature) ein sauberes Release ohne MCP-Code erstellt.

Hinweis: Der Frontend-Bridge-Schutz (import.meta.env.DEV) aus dem grundlegenden Setup gilt weiterhin — er verhindert, dass die Bridge initialisiert wird, selbst wenn das Plugin zur Laufzeit irgendwie vorhanden wäre.

MCP-Server-Konfiguration

Hinweis: Wenn Sie das Claude Code Plugin installiert haben, ist der MCP-Server bereits automatisch konfiguriert. Das Plugin fragt während der Installation nach dem Tauri-App-Verzeichnis. Dieser Abschnitt ist für die manuelle Einrichtung ohne das Plugin gedacht.

Fügen Sie dies zu .mcp.json in Ihrem Projektstammverzeichnis hinzu:

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "npx",
      "args": ["tauri-mcp"],
      "env": {
        "TAURI_APP_DIR": "."
      }
    }
  }
}

Hinweis: pnpm-Benutzer können auch pnpx tauri-mcp oder pnpm exec tauri-mcp verwenden.

Monorepo-Konfiguration

Wenn sich die Tauri-App in einem Unterverzeichnis befindet (z. B. apps/desktop), setzen Sie TAURI_APP_DIR:

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "npx",
      "args": ["tauri-mcp"],
      "env": {
        "TAURI_APP_DIR": "./apps/desktop"
      }
    }
  }
}

Mehrere Tauri-Apps

Für Monorepos mit mehreren Tauri-Apps führen Sie eine separate MCP-Server-Instanz pro App aus:

{
  "mcpServers": {
    "tauri-desktop": {
      "command": "npx",
      "args": ["tauri-mcp"],
      "env": { "TAURI_APP_DIR": "./apps/desktop" }
    },
    "tauri-kiosk": {
      "command": "npx",
      "args": ["tauri-mcp"],
      "env": { "TAURI_APP_DIR": "./apps/kiosk" }
    }
  }
}

Die Werkzeuge sind nach Servernamen benannt: mcp__tauri-desktop__snapshot, mcp__tauri-kiosk__snapshot usw.

Verfügbare Werkzeuge

Sitzungs-Lebenszyklus

Fensterverwaltung

Interaktion

Alle Interaktionswerkzeuge akzeptieren einen optionalen window-Parameter, um ein bestimmtes Fenster anzusteuern (Standard ist das fokussierte Fenster).

Beobachtbarkeit

Verwendung des features-Parameters

Zum Starten mit Cargo-Features:

start_session({ features: ["my_feature"] })

Dies führt aus: pnpm tauri dev --features my_feature

Anwendungsbeispiel

Typischer Test-Workflow:

1. start_session({ timeout_secs: 120 })
2. snapshot()           # Get element refs
3. click({ ref: 5 })    # Click button by ref
4. fill({ selector: "input[name='email']", value: "test@example.com" })
5. screenshot()         # Verify result
6. stop_session()

Funktionsweise

Claude Code <-> MCP Server <-> Socket <-> Tauri Plugin <-> JS Bridge <-> Your App

1. Rust-Plugin erstellt IPC-Server (Unix-Socket oder Windows Named Pipe)

2. MCP-Server verbindet sich mit IPC und stellt Werkzeuge für Claude bereit

3. JS-Bridge (initMcpBridge()) ermöglicht DOM-Operationen in WebView

Socket-Pfade

• Unix: {project_root}/.tauri-mcp.sock

• Windows: \\.\pipe\tauri-mcp-{hash} (Hash wird aus dem Projektpfad abgeleitet)

Fehlerbehebung

"MCP bridge not initialized"

Die JS-Bridge läuft nicht. Prüfen Sie:

• initMcpBridge() wird in Ihrem Frontend-Code aufgerufen

• App läuft im Dev-Modus (import.meta.env.DEV)

• Browser-Konsole auf Initialisierungsfehler prüfen

Socket-Verbindung fehlgeschlagen

• Sicherstellen, dass die App läuft (zuerst start_session)

• Unter Windows den Pipe-Pfad in den Logs prüfen: [tauri-plugin-mcp] full_path: \\.\pipe\tauri-mcp-XXXXX

• Unter Unix prüfen, ob .tauri-mcp.sock im Projektstammverzeichnis existiert

App-Start-Timeout

• timeout_secs erhöhen (Standard: 60)

• Prüfen, ob pnpm tauri dev manuell funktioniert

• Nach Build-Fehlern in der Terminalausgabe suchen

Snapshot gibt nichts zurück

• Warten, bis die App vollständig geladen ist (verwenden Sie wait_for_ready: true)

• Prüfen, ob die Bridge initialisiert wurde (nach [MCP]-Logs in der Konsole suchen)

Entwicklung

Nach dem Klonen konfiguriert pnpm install automatisch Git-Hooks und baut das Projekt.

Die dist/-Verzeichnisse werden in das Repo eingecheckt, damit Git-basierte Installationen (pnpm add github:...) ohne Build-Schritt funktionieren. Ein Pre-Commit-Hook überprüft, ob dist/ mit den TypeScript-Quellen synchron bleibt — falls der Hook Ihren Commit blockiert, führen Sie Folgendes aus:

pnpm build
git add packages/*/dist/

Versuchen Sie dann erneut zu committen.

Lizenz

MIT ODER Apache-2.0