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.
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-mcpWä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:installDies 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.
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.
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:
Komponente | Beschreibung |
MCP Server | In sich geschlossenes |
| Einmaliger Installer, der Ihr Tauri-Projekt bearbeitet, um das Plugin einzubinden |
| QA-Orchestrierung — bereitet Testszenarien vor, delegiert an QA-Agenten, validiert Ergebnisse |
| Diagnostische Entscheidungsbäume für häufige MCP-Sitzungsprobleme |
| Test-Agent (Haiku), der Testszenarien mithilfe von MCP-Werkzeugen ausführt |
QA-Validierungs-Hook | Überprüft, ob QA-PASS-Ergebnisse tatsächliche Tool-Call-Nachweise enthalten |
Related MCP server: MCP Server Tauri
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
Node.js >= 18
Tauri v2.x
pnpm (empfohlen) oder npm
Rust mit cargo
[ ] Rust-Plugin zu src-tauri/Cargo.toml hinzufügen
[ ] npm-Paket installieren: pnpm add github:DaveDev42/tauri-plugin-mcp#main
[ ] Plugin in src-tauri/src/lib.rs registrieren
[ ] mcp:default Berechtigung hinzufügen
[ ] Bridge in main.tsx initialisieren
[ ] .mcp.json für Claude Code erstellen
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp" }pnpm add github:DaveDev42/tauri-plugin-mcp#mainDie MCP-Server-Binärdatei (tauri-mcp) ist nach der Installation automatisch verfügbar. Keine zusätzliche Einrichtung erforderlich.
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_mcp::init())
.run(tauri::generate_context!())
.expect("error while running tauri application");
}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"]
}// 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);
});
});
}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.
[features]
default = []
dev-tools = ["dep:tauri-plugin-mcp"]
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp", optional = true }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");
}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.jsonbuild.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");
}{
"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.
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-mcpoderpnpm exec tauri-mcpverwenden.
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"
}
}
}
}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.
Werkzeug | Parameter | Beschreibung |
|
| Sitzungsstatus (App) prüfen; mit |
|
| Sitzung starten (Tauri-App via |
| - | Sitzung stoppen (App-Prozessbaum beenden) |
Werkzeug | Parameter | Beschreibung |
| - | Alle offenen Fenster mit Labels, Titeln, Fokus-Status und Bridge-Status auflisten |
|
| Ein bestimmtes Fenster anhand des Labels fokussieren |
Alle Interaktionswerkzeuge akzeptieren einen optionalen window-Parameter, um ein bestimmtes Fenster anzusteuern (Standard ist das fokussierte Fenster).
Werkzeug | Parameter | Beschreibung |
|
| Barrierefreiheitsbaum mit Referenznummern für |
|
| Element per Referenz oder CSS-Selektor anklicken |
|
| Eingabefeld ausfüllen |
|
| Tastaturtaste drücken (z. B. "Enter", "Tab") |
|
| Zu URL navigieren |
|
| Screenshot über native OS-Erfassung machen |
|
| JavaScript in WebView ausführen |
Werkzeug | Parameter | Beschreibung |
|
| Vereinheitlichter Log-Zugriff (Build, Laufzeit, Konsole, Netzwerk) mit Quell-/Level-Filterung |
|
| Letzte App-Neustart-/Neulade-Ereignisse mit auslösenden Dateien abrufen |
features-ParametersZum Starten mit Cargo-Features:
start_session({ features: ["my_feature"] })Dies führt aus: pnpm tauri dev --features my_feature
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()Claude Code <-> MCP Server <-> Socket <-> Tauri Plugin <-> JS Bridge <-> Your AppRust-Plugin erstellt IPC-Server (Unix-Socket oder Windows Named Pipe)
MCP-Server verbindet sich mit IPC und stellt Werkzeuge für Claude bereit
JS-Bridge (initMcpBridge()) ermöglicht DOM-Operationen in WebView
Unix: {project_root}/.tauri-mcp.sock
Windows: \\.\pipe\tauri-mcp-{hash} (Hash wird aus dem Projektpfad abgeleitet)
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
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
timeout_secs erhöhen (Standard: 60)
Prüfen, ob pnpm tauri dev manuell funktioniert
Nach Build-Fehlern in der Terminalausgabe suchen
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)
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.
MIT ODER Apache-2.0
Click element by ref or selector
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Ref from snapshot | |
| selector | No | CSS selector | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fails to disclose behavioral traits such as whether the click waits for element visibility, triggers navigation, or handles errors. It adds no behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the action, but it is overly minimal. It sacrifices completeness for brevity, lacking sufficient detail for a three-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description does not provide enough contextual completeness. It omits behavioral details, expected side effects, and error handling, which are important for correct tool usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all parameters. The description adds no extra semantics beyond the schema's details, achieving baseline adequacy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'click' and the resource 'element', and specifies two methods of identification (ref or selector). It effectively distinguishes from sibling tools like fill or press_key, but could be more explicit about simulating a mouse click.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as press_key or evaluate_script. There is no mention of prerequisites, context, or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run JS in webview
| Name | Required | Description | Default |
|---|---|---|---|
| script | Yes | JS code | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'Run JS' without indicating if the script is sandboxed, whether it returns results, or any potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the key action. It is efficient but could benefit from additional context without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a script execution tool with two parameters and no output schema, the description is incomplete. It does not explain return values, error behavior, or how the script interacts with the webview environment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds no value beyond the schema: 'JS code' and 'Window label' are already in the input schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Run JS in webview' clearly states the action and target resource. It distinguishes from sibling browser tools like click and navigate by specifying script execution, but lacks detail on what 'webview' refers to.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as click or fill. There is no mention of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill input by ref or selector
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Ref from snapshot | |
| selector | No | CSS selector | |
| value | Yes | Value | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as whether it clears the existing value, supports file inputs, or handles non-input elements. The brief description leaves significant ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (5 words) and front-loaded. However, it may be too brief, sacrificing necessary detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and lack of output schema, the description is incomplete: it does not specify the behavior on different input types, whether it simulates typing or sets value programmatically, or error scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all 4 parameters. The description adds 'by ref or selector' to clarify parameter usage, but does not add further semantic meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'fill' and resource 'input', and specifies the method 'by ref or selector'. It is clear but does not differentiate from siblings like 'click' or 'press_key'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., 'press_key' for key presses, 'click' for clicks). No context or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Focus a specific window by label
| Name | Required | Description | Default |
|---|---|---|---|
| window | Yes | Window label to focus |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It fails to disclose what 'focus' entails (e.g., bring to front, activate window) or behavior on missing label.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no fluff, front-loaded. Score would be 5 if it contained more behavioral detail without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, and description lacks detail on return values, error cases, or prerequisites. Minimal for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear parameter description. Tool description adds no extra meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'focus', the resource 'window', and the qualifier 'by label'. It distinguishes the tool from siblings like 'list_windows' and 'click'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no preconditions or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get application logs with filtering. Filters can be combined (e.g., ["build", "error"] for build errors only).
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Filters to apply (empty = all logs) | |
| limit | No | Max entries | |
| clear | No | Clear logs after reading | |
| window | No | Window label for frontend logs (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose all behavioral traits. It mentions filter combination but omits the clear parameter's destructive nature and window parameter's scope. Key behaviors remain undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: one sentence plus a helpful example. No wasted words, but could be better structured (e.g., bullet points). Still effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 4 parameters and no output schema, the description only covers filter semantics. It does not explain the return format, window parameter, clear effect, or limitations. Incomplete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (baseline 3). The tool description adds an example for filter combination, clarifying that filters can be combined, though the case of a string type with array-like example may cause confusion. Minimal value added beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get application logs' as the verb+resource, and adds filtering details. However, it could be more specific about the log source (e.g., browser console logs) to fully distinguish from sibling tools like get_restart_events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives (e.g., evaluate_script, screenshot). The description only explains filtering, not the broader context of log retrieval use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent app restart/reload events with the files that triggered them. Includes Rust rebuilds (backend) and HMR updates (frontend).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max events | |
| clear | No | Clear events after reading | |
| window | No | Window label for frontend HMR events (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It partially discloses what events are included but fails to mention the destructive nature of the 'clear' parameter or side effects. The description is neutral but could be more explicit about read-only vs modifying behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and scope, no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should explain return values. It mentions events include files but not the structure. Also missing context on parameter interactions (e.g., clear, window) beyond schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds context about event types but does not enhance parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves app restart/reload events, specifies it includes Rust rebuilds and HMR updates, and uses a specific verb 'Get' with a resource, distinguishing it from siblings like get_logs or get_session_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool vs alternatives (e.g., get_logs), nor does it mention when not to use it or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check session (app) status. Use probe_bridge to verify bridge health per window.
| Name | Required | Description | Default |
|---|---|---|---|
| probe_bridge | No | Actively probe bridge health per window (adds latency) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It only mentions that probe_bridge adds latency, but does not disclose behavioral traits of this tool itself (e.g., read-only, latency, destructions). The description is too brief to offer adequate transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise—two short sentences—with no unnecessary words. Every sentence serves a purpose: stating the tool's function and directing to an alternative for a specific use case.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and only one parameter, the description is minimally adequate. It states the purpose and references an alternative, but lacks details on return values, scope of 'session status', or how it fits with other tools. For a tool with 12 siblings, more completenss would help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with one parameter described as 'Actively probe bridge health per window (adds latency)'. The description does not add extra meaning beyond the schema, so it meets the baseline 3 without exceeding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Check session (app) status' as a specific verb+resource. It further distinguishes from the sibling 'probe_bridge' by directing to use that tool for verifying bridge health per window, avoiding confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides limited guidance: it tells users to use 'probe_bridge' for bridge health verification, implying this tool is for general session status. However, it does not specify when to choose this over other siblings like get_logs or get_restart_events, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all open windows with their labels, titles, and focus state
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description accurately conveys a read-only operation with no side effects. It is straightforward but could mention if any special permissions or constraints apply.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no extraneous information. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose and output fields (labels, titles, focus state). Missing details like ordering or whether minimized windows are included, but acceptable for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and the description correctly omits parameter details. According to guidelines, zero parameters baseline is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists open windows and specifies the information returned (labels, titles, focus state). It distinguishes from sibling tools like focus_window, which performs a different action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you need to see current windows) but does not explicitly state when to use or not use this tool, nor does it mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Press key
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Key name | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description offers no behavioral information such as whether the press is momentary, if it supports key combinations, or what happens on failure. The agent is left to infer all side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While short, the description is under-specified. It does not earn its place as it adds no information beyond the tool name. It is not appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the two parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain the tool's behavior, return value, or error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides for 'key' and 'window'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description 'Press key' is essentially a tautology of the tool name 'press_key'. It does not specify what kind of key press (e.g., single key, combination) or provide any distinguishing detail from sibling tools like 'click' or 'fill'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description does not mention typical scenarios (e.g., keyboard simulation) or exclude cases where 'click' or 'fill' might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take screenshot
| Name | Required | Description | Default |
|---|---|---|---|
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It only states the action without explaining output, side effects, or required permissions. 'Take screenshot' is too vague for an agent to understand the tool's full impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two words, with no wasted text. However, it may be too brief for optimal clarity, though it earns a high score for lack of verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema or annotations, and the presence of a potentially similar sibling (snapshot), the description is insufficiently complete. It omits return value, side effects, and how it differs from snapshot.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, so the description adds no extra meaning beyond what the schema already provides (window label). Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Take screenshot' clearly states the action and resource, but does not differentiate from the sibling tool 'snapshot', which may have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like snapshot, nor are there any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get accessibility tree (returns ref numbers for click/fill)
| Name | Required | Description | Default |
|---|---|---|---|
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions the return value (ref numbers) and hints at read-only nature, but does not disclose error conditions, effects, or permissions. Without annotations, this is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the core functionality without extraneous words. It is efficient and scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description adequately covers what it does and what it returns. It could mention preconditions or errors, but remains mostly sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'window' is fully described in the input schema. The description adds no additional information about parameter usage or defaults, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Get accessibility tree' and its output 'returns ref numbers for click/fill', which distinguishes it from sibling tools like click and fill. It is specific about the resource and purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use before actions like click or fill, but does not explicitly state when to use it or provide alternatives. No comparison with siblings is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start session (launch Tauri app)
| Name | Required | Description | Default |
|---|---|---|---|
| wait_for_ready | No | Wait for ready | |
| timeout_secs | No | Timeout seconds | |
| features | No | Cargo features to enable | |
| devtools | No | Open devtools on launch |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'launch Tauri app', missing critical details like whether the call blocks until the app is ready, if it returns a session ID, or what happens on failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words. The parenthetical adds clarity. Could be slightly more informative without losing conciseness, but it is not overly terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that launches an application, the description lacks information about return values, error states, expected duration, and side effects. No output schema, so description should cover these aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are documented. However, the tool description adds no meaning beyond the schema; for example, it doesn't explain how 'wait_for_ready' interacts with 'timeout_secs'. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Start') and the resource ('session'), and includes a parenthetical explanation ('launch Tauri app') that distinguishes it from siblings like 'stop_session' and 'get_session_status'. However, 'session' could be more specific about what kind of session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For instance, it doesn't explain whether it should be called before other tools, if there are prerequisites, or when 'stop_session' is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Stop session (kill app)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It only says 'kill app' but does not disclose whether state is saved, if confirmation is required, or any side effects. Minimal behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single efficient phrase with no unnecessary words. However, it could be slightly more descriptive without adding length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is too minimal for a mutation tool. It lacks context on how the session termination affects the application state or subsequent actions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist and schema coverage is 100%, so the baseline is 3. The description adds no parameter info beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the action 'stop session' with the parenthetical '(kill app)' emphasizing termination. It directly contrasts with sibling tools like start_session and get_session_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives such as get_session_status or focus_window. Usage is implied by the name but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.3.6app_statusget_session_statuslaunch_appstart_sessionstop_appstop_sessionv0.1.0app_statusclickevaluate_scriptfillfocus_windowget_logsget_restart_eventslaunch_applist_windowsnavigatepress_keyscreenshotsnapshotstop_appScored across 14 tools
Each tool targets a distinct action or information source: UI interactions (click, fill, press_key), scripting (evaluate_script), navigation (navigate), visual capture (screenshot), accessibility (snapshot), window management (list_windows, focus_window), session lifecycle (start/stop_session), and diagnostics (get_logs, get_restart_events, get_session_status). No two tools have overlapping purposes.
All tool names follow a clear verb_noun pattern using lowercase with underscores (e.g., get_logs, focus_window, start_session). Even single-word names like click, fill, navigate are consistent with the imperative style. No mixed conventions or inconsistent verbs.
14 tools is well-scoped for a Tauri testing/MCP server. It covers all major aspects: session control, window management, UI interaction, scripting, diagnostics, and capture. The count is neither too sparse (missing essential features) nor bloated.
The tool surface covers the full lifecycle of a Tauri app test: start/stop sessions, manage windows, interact via clicks/keys/scripts, navigate, capture screenshots and accessibility trees, and retrieve logs/events. No obvious gaps for typical automation tasks, making it a self-contained toolset.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Run, debug, and triage tests from your IDE using natural language, no dashboard switching, no manual data transfers. The TestMu AI (formerly LambdaTest) MCP Server is a single remote server exposing four tool suites: HyperExecute — analyze your project, generate YAML configs and test runner commands, then monitor jobs and sessions. Automation — pull a TestID's details plus command, network, and console logs into one chat for instant root-cause analysis. Includes mobile app upload. SmartUI — explain pixel, layout, DOM, and perceptual changes in a visual regression run, with context-aware React/HTML/CSS fixes. Accessibility — audit any public URL or a local React app against WCAG and get ready-to-apply remediation steps. Connects over https://mcp.lambdatest.com/mcp using OAuth 2.1 — no API keys in your config. One-click install in Cursor; works with Claude, GitHub Copilot, Cline, and any MCP client. Tests execute on the TestMu AI cloud: 3,000+ browsers and 10,000+ real devices.
A Model Context Protocol server for Wix AI tools
Drive real devices from your AI Coding tool. Embed a client SDK (Unity, Godot, Flutter, iOS/macOS, Android, React Native, Web) in your app, then capture screenshots, traverse the UI tree, inject taps and key events, and run automated test tasks on the physical device over a secure relay.
