npm package: @iflow-mcp/dirvine-tauri-mcp
Description: Node.js MCP server wrapper for tauri-mcp
Latest version: 0.1.8

# Tauri MCP Server

A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) server for testing and interacting with Tauri v2 applications. This tool enables AI assistants to better understand, debug, and interact with Tauri apps during development.

The MCP protocol provides a standardized way for AI assistants to interact with external tools and systems. This server implements the MCP specification to expose Tauri application testing and debugging capabilities.

## MCP Compliance

This server is fully compliant with the [Model Context Protocol specification](https://modelcontextprotocol.io/introduction). It implements:

- ✅ **JSON-RPC 2.0** transport over stdio
- ✅ **Initialize/shutdown** handshake
- ✅ **Tools** capability with 12 specialized Tauri testing tools
- ✅ **Proper error handling** with descriptive messages
- ✅ **Tool schemas** using JSON Schema format
- ✅ **Protocol version compatibility** - Supports both "1.0" and date-based versions (e.g., "2024-11-05")

For more details about MCP:
- [MCP Introduction](https://modelcontextprotocol.io/introduction)
- [Building MCP Servers](https://modelcontextprotocol.io/docs/concepts/servers)
- [Tool Definitions](https://modelcontextprotocol.io/docs/concepts/tools)

## Features

### Core Tools

- **Process Management**
  - `launch_app` - Launch Tauri applications with arguments
  - `stop_app` - Gracefully stop running apps
  - `get_app_logs` - Capture stdout/stderr output
  - `monitor_resources` - Track CPU, memory, and disk usage

- **Window Manipulation**
  - `take_screenshot` - Capture app window screenshots
  - `get_window_info` - Get window dimensions, position, and state

- **Input Simulation**
  - `send_keyboard_input` - Simulate keyboard input
  - `send_mouse_click` - Simulate mouse clicks
  - Mouse movement, dragging, and scrolling support

- **Debugging Tools**
  - `execute_js` - Execute JavaScript in the webview
  - `get_devtools_info` - Get DevTools connection info
  - WebDriver integration for advanced testing
  - Console log capture

- **IPC Interaction**
  - `list_ipc_handlers` - List registered Tauri commands
  - `call_ipc_command` - Call Tauri IPC commands
  - Event emission and listening

## Installation

### Using DXT (Recommended for Claude Desktop)

The easiest way to install tauri-mcp for use with Claude Desktop is via DXT (Desktop Extension):

1. Download the latest `tauri-mcp-node-*.dxt` file from the [releases page](https://github.com/dirvine/tauri-mcp/releases)
2. Double-click the `.dxt` file to install (or drag it onto Claude Desktop)
3. The server will be automatically configured and ready to use

**Note**: Due to a [known issue](https://github.com/anthropics/dxt/issues/18) with Claude Desktop's DXT extraction, we provide a Node.js wrapper version (`tauri-mcp-node-*.dxt`) that works around this limitation.

### Using Cargo

```bash
cargo install tauri-mcp
```

**Important Note for Rust-based MCP Servers**: Claude Desktop currently has [compatibility issues](https://github.com/dirvine/tauri-mcp/issues/1) with Rust-based MCP servers, causing immediate disconnections after initialization. This is a known issue affecting all non-Node.js MCP servers. The cargo installation is suitable for:
- Direct CLI usage
- Integration with other tools
- Development and testing

For use with Claude Desktop, please use the DXT package which includes a Node.js wrapper.

### From Source

```bash
# Clone the repository
git clone https://github.com/dirvine/tauri-mcp.git
cd tauri-mcp

# Build and install
cargo install --path .
```

## Usage

### As a Standalone Server

```bash
# Start the MCP server
tauri-mcp serve

# With custom host and port
tauri-mcp serve --host 127.0.0.1 --port 3000

# With a specific Tauri app
tauri-mcp --app-path ./my-tauri-app
```

### Configuration

Create a `tauri-mcp.toml` file for configuration:

```toml
auto_discover = true
session_management = true
event_streaming = false
performance_profiling = false
network_interception = false
```

### Environment Variables

- `TAURI_MCP_LOG_LEVEL` - Set log level (trace, debug, info, warn, error)
- `TAURI_MCP_CONFIG` - Path to config file (default: tauri-mcp.toml)

## MCP Integration

### Claude Desktop Configuration

#### Option 1: Using DXT Package (Recommended)

Install the `tauri-mcp-node-*.dxt` package by double-clicking it. The server will be automatically configured.

#### Option 2: Manual Configuration

If you need to configure manually or use the development version, add to your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["/path/to/tauri-mcp/server/index.js"],
      "env": {
        "TAURI_MCP_LOG_LEVEL": "info"
      }
    }
  }
}
```

**Note**: Direct Rust binary configuration (`"command": "tauri-mcp"`) will not work with Claude Desktop due to compatibility issues. Use the Node.js wrapper approach shown above.

### Available MCP Tools

All tools are exposed through the MCP protocol and can be called by AI assistants:

```javascript
// Launch a Tauri app
await use_mcp_tool("tauri-mcp", "launch_app", {
  app_path: "/path/to/tauri-app",
  args: ["--debug"]
});

// Take a screenshot
await use_mcp_tool("tauri-mcp", "take_screenshot", {
  process_id: "uuid-here",
  output_path: "./screenshot.png"
});

// Execute JavaScript
await use_mcp_tool("tauri-mcp", "execute_js", {
  process_id: "uuid-here",
  javascript_code: "window.location.href"
});

// Send keyboard input
await use_mcp_tool("tauri-mcp", "send_keyboard_input", {
  process_id: "uuid-here",
  keys: "cmd+a"
});
```

## Platform Support

- **macOS** - Full support including window management
- **Windows** - Full support with native window APIs
- **Linux** - X11 support (Wayland in progress)

## Development

### Building

```bash
# Debug build
cargo build

# Release build
cargo build --release

# Run tests
cargo test
```

### Building DXT Packages

The project includes build scripts for creating DXT (Desktop Extension) packages for different platforms.

#### Prerequisites

- Rust toolchain installed
- Node.js 18+ (for the Node.js wrapper)
- `zip` command available in PATH

#### Building on macOS/Linux

```bash
# Build the Node.js wrapper version (recommended)
./build-dxt-node.sh

# The DXT package will be created as tauri-mcp-node-*.dxt
```

#### Building on Windows

```powershell
# Create a Windows build script or use WSL
# Ensure you have zip.exe available or use PowerShell's Compress-Archive

# Build release binary
cargo build --release

# Create package directory structure
mkdir dxt-package-node
mkdir dxt-package-node\server

# Copy files
copy target\release\tauri-mcp.exe dxt-package-node\
copy server\*.* dxt-package-node\server\
copy manifest-node.json dxt-package-node\manifest.json

# Install Node dependencies
cd dxt-package-node\server
npm install --production
cd ..\..

# Create DXT archive (using PowerShell)
Compress-Archive -Path dxt-package-node\* -DestinationPath tauri-mcp-node.zip
Rename-Item tauri-mcp-node.zip tauri-mcp-node-0.1.8.dxt
```

#### DXT Package Structure

The DXT package includes:
- `manifest.json` - Extension metadata and configuration
- `tauri-mcp` - The compiled Rust binary
- `server/` - Node.js wrapper and dependencies
  - `index.js` - Node.js MCP server that spawns the Rust binary
  - `package.json` - Node.js dependencies
  - `node_modules/` - MCP SDK and dependencies

#### Important Notes

1. **Use `--no-dir-entries` flag**: When creating the zip file, use the `--no-dir-entries` flag to avoid [extraction issues](https://github.com/anthropics/dxt/issues/18):
   ```bash
   zip -r package.dxt . --no-dir-entries
   ```

2. **Binary permissions**: Ensure the Rust binary has executable permissions before packaging:
   ```bash
   chmod +x tauri-mcp
   ```

3. **Cross-platform builds**: For distributing to other platforms, you'll need to build the Rust binary on each target platform or use cross-compilation.

### Project Structure

```
tauri-mcp/
├── src/
│   ├── main.rs          # Entry point
│   ├── server.rs        # MCP server implementation
│   ├── tools/           # Tool implementations
│   │   ├── process.rs   # Process management
│   │   ├── window.rs    # Window manipulation
│   │   ├── input.rs     # Input simulation
│   │   ├── debug.rs     # Debugging tools
│   │   └── ipc.rs       # IPC interaction
│   └── utils/           # Utility modules
├── examples/            # Example Tauri apps
└── tests/              # Integration tests
```

## Examples

### Testing a Tauri App

```bash
# Launch the server
tauri-mcp serve

# In your AI assistant:
# 1. Launch the app
# 2. Take a screenshot
# 3. Send some input
# 4. Check the logs
# 5. Stop the app
```

### Automated Testing Script

```python
import asyncio
from mcp import Client

async def test_tauri_app():
    client = Client("tauri-mcp")
    
    # Launch app
    result = await client.call_tool("launch_app", {
        "app_path": "./my-app",
        "args": ["--test-mode"]
    })
    process_id = result["process_id"]
    
    # Wait for app to start
    await asyncio.sleep(2)
    
    # Take screenshot
    await client.call_tool("take_screenshot", {
        "process_id": process_id,
        "output_path": "./test-screenshot.png"
    })
    
    # Send input
    await client.call_tool("send_keyboard_input", {
        "process_id": process_id,
        "keys": "Hello, Tauri!"
    })
    
    # Get logs
    logs = await client.call_tool("get_app_logs", {
        "process_id": process_id,
        "lines": 50
    })
    print("App logs:", logs)
    
    # Stop app
    await client.call_tool("stop_app", {
        "process_id": process_id
    })

asyncio.run(test_tauri_app())
```

## Troubleshooting

### Common Issues

1. **Permission Denied on macOS**
   - Grant accessibility permissions in System Preferences
   - Required for input simulation

2. **Screenshot Fails**
   - Ensure screen recording permissions are granted
   - Check if the app window is visible

3. **WebDriver Connection Failed**
   - Ensure the Tauri app has DevTools enabled
   - Check if ChromeDriver is installed for WebDriver support

### Debug Mode

Enable debug logging:

```bash
TAURI_MCP_LOG_LEVEL=debug tauri-mcp serve
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgments

- Implements the [Model Context Protocol](https://modelcontextprotocol.io/) specification
- Designed for [Tauri v2](https://tauri.app/) applications
- Input simulation powered by [enigo](https://github.com/enigo-rs/enigo)
- Screenshot functionality via [screenshots-rs](https://github.com/nashaofu/screenshots-rs)