Tauri MCP Bridge Plugin

A Tauri plugin that bridges the Model Context Protocol (MCP) with Tauri applications, enabling deep inspection and interaction with Tauri's IPC layer, backend state, and window management.

Overview

The MCP Bridge plugin extends MCP servers with direct access to Tauri internals. It provides real-time IPC monitoring, window state inspection, backend state access, and event emission capabilities.

Installation

Add this to your Cargo.toml:

[dependencies]
tauri-plugin-mcp-bridge = "0.1"

Usage

Register the plugin in your Tauri application:

use tauri_plugin_mcp_bridge;

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

Custom Configuration

By default, the plugin binds to 0.0.0.0 (all interfaces) to support remote device development. For localhost-only access:

use tauri_plugin_mcp_bridge::Builder;

fn main() {
    tauri::Builder::default()
        .plugin(Builder::new().bind_address("127.0.0.1").build())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Features

1. IPC Monitoring

Monitor all Tauri IPC calls in real-time with timing and argument capture:

// Start monitoring
await invoke('plugin:mcp-bridge|start_ipc_monitor');

// Execute some commands to generate IPC traffic
await invoke('greet', { name: 'World' });

// Get captured events
const events = await invoke('plugin:mcp-bridge|get_ipc_events');

2. Window Information

Get detailed window state:

const windowInfo = await invoke('plugin:mcp-bridge|get_window_info');
// Returns: { width, height, x, y, title, focused, visible }

3. Backend State

Inspect application backend state:

const state = await invoke('plugin:mcp-bridge|get_backend_state');
// Returns: { app: { name, identifier, version }, tauri: { version },
//            environment: { debug, os, arch, family }, windows: [...], timestamp }

4. Event Emission

Trigger custom events for testing:

await invoke('plugin:mcp-bridge|emit_event', {
  eventName: 'custom-event',
  payload: { data: 'test' }
});

MCP Server Integration

This plugin is part of the larger MCP Server for Tauri, which provides 23 total MCP tools for comprehensive Tauri development and testing. The plugin specifically enables the following tools:

Project Management Tools (4)

1. tauri_run_command - Run any Tauri CLI command with full flexibility
2. tauri_read_config - Read Tauri configuration files (including platform-specific configs)
3. tauri_write_config - Write to Tauri configuration files with validation
4. tauri_get_docs - Get Tauri documentation (LLM Cheat Sheet) for the detected project version

Mobile Development Tools (2)

1. tauri_list_devices - List connected Android devices and iOS simulators
2. tauri_launch_emulator - Launch an Android AVD or iOS Simulator

UI Automation & WebView Tools (11)

Tools for UI automation and webview interaction via the plugin's WebSocket connection:

1. tauri_driver_session - Manage automation session (start or stop)
2. tauri_webview_find_element - Find an element in the webview
3. tauri_driver_get_console_logs - Get console logs from the webview
4. tauri_read_platform_logs - Read platform logs (Android logcat, iOS device logs, system logs)
5. tauri_webview_interact - Perform gestures (click, double-click, long-press, swipe, scroll)
6. tauri_webview_screenshot - Take screenshots of the entire webview
7. tauri_webview_keyboard - Type text or simulate keyboard events with optional modifiers
8. tauri_webview_wait_for - Wait for element selectors, text content, or IPC events
9. tauri_webview_get_styles - Get computed CSS styles for element(s)
10. tauri_webview_execute_js - Execute arbitrary JavaScript code in the webview context
11. tauri_webview_focus_element - Focus on a specific element in the webview

IPC & Plugin Tools (6)

Tools that directly use the MCP Bridge plugin's Rust backend:

1. tauri_plugin_execute_ipc - Execute any Tauri IPC command with the MCP bridge plugin
2. tauri_plugin_get_window_info - Get detailed information about the current window
3. tauri_plugin_ipc_monitor - Manage IPC monitoring (start or stop)
4. tauri_plugin_ipc_get_events - Retrieve all captured IPC events with optional filtering
5. tauri_plugin_emit_event - Emit custom Tauri events for testing event handlers
6. tauri_plugin_get_backend_state - Get backend application state and metadata

Architecture

MCP Server (Node.js)
    │
    ├── Native IPC (via plugin) ────> Tauri App Webview (DOM/UI)
    │                                       │
    └── Plugin Client ──────────────────────┼──> Plugin Commands
         (WebSocket port 9223)              │
                                            │
                                      mcp-bridge Plugin
                                      (Rust Backend)

WebSocket Communication

The plugin runs a WebSocket server on port 9223 (or next available in range 9223-9322) for real-time communication with the MCP server.

Remote Device Development

By default, the WebSocket server binds to 0.0.0.0 (all network interfaces), enabling connections from:

• iOS devices on the same network
• Android devices on the same network or via adb reverse
• Emulators/Simulators via localhost

Connecting from MCP Server

The MCP server supports connecting to remote Tauri apps via the tauri_driver_session tool:

// Connect to a Tauri app on a remote device
tauri_driver_session({ action: 'start', host: '192.168.1.100' })

// Or use environment variables:
// MCP_BRIDGE_HOST=192.168.1.100 npx mcp-server-tauri
// TAURI_DEV_HOST=192.168.1.100 npx mcp-server-tauri (same as Tauri CLI uses)

Connection Strategy

The MCP server uses a fallback strategy:

1. Try localhost:{port} first (most reliable for simulators/emulators/desktop)
2. If localhost fails and a remote host is configured, try {host}:{port}
3. Auto-discover apps on localhost if specific connection fails

Development

Building the Plugin

From the plugin directory:

cd packages/tauri-plugin-mcp-bridge
cargo build

Or from the workspace root:

npm run build:plugin

Documentation

View the comprehensive Rust API documentation:

npm run docs:rust

Or directly:

cd packages/tauri-plugin-mcp-bridge
cargo doc --open --no-deps

Testing

Run the MCP server tests which include plugin integration tests:

npm test

Permissions

The plugin requires the following permissions to be configured in your Tauri capabilities:

• execute_command
• get_window_info
• get_backend_state
• emit_event
• start_ipc_monitor
• stop_ipc_monitor
• get_ipc_events

These are typically auto-configured when using the plugin.

API Documentation

For detailed API documentation, including:

• Complete function signatures and parameters
• Rust examples for backend integration
• TypeScript examples for frontend usage
• Architecture and design details

Visit the docs.rs documentation or build locally with npm run docs:rust.

License

This project is licensed under either of:

• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

at your option.