Tauri MCP Server

Un servidor para probar e interactuar con aplicaciones Tauri v2, que proporciona herramientas para la gestión de procesos, manipulación de ventanas y depuración.

GitHub

Prueba este MCPPatrocinado

Documentación

Tauri MCP Server

Un servidor de Model Context Protocol (MCP) para probar e interactuar con aplicaciones Tauri v2. Esta herramienta permite a los asistentes de IA comprender, depurar e interactuar mejor con las aplicaciones Tauri durante el desarrollo.

El protocolo MCP proporciona una forma estandarizada para que los asistentes de IA interactúen con herramientas y sistemas externos. Este servidor implementa la especificación MCP para exponer capacidades de prueba y depuración de aplicaciones Tauri.

Cumplimiento de MCP

Este servidor es totalmente compatible con la especificación del Model Context Protocol. Implementa:

✅ Transporte JSON-RPC 2.0 sobre stdio
✅ Handshake de initialize/shutdown
✅ Capacidad de herramientas con 12 herramientas especializadas de prueba de Tauri
✅ Manejo de errores adecuado con mensajes descriptivos
✅ Esquemas de herramientas utilizando el formato JSON Schema
✅ Compatibilidad de versiones de protocolo: admite tanto "1.0" como versiones basadas en fechas (p. ej., "2024-11-05")

Para más detalles sobre MCP:

Características

Herramientas principales

Gestión de procesos
- launch_app - Iniciar aplicaciones Tauri con argumentos
- stop_app - Detener aplicaciones en ejecución de forma elegante
- get_app_logs - Capturar salida de stdout/stderr
- monitor_resources - Realizar seguimiento del uso de CPU, memoria y disco
Manipulación de ventanas
- take_screenshot - Capturar capturas de pantalla de la ventana de la aplicación
- get_window_info - Obtener dimensiones, posición y estado de la ventana
Simulación de entrada
- send_keyboard_input - Simular entrada de teclado
- send_mouse_click - Simular clics de ratón
- Soporte de movimiento, arrastre y desplazamiento del ratón
Herramientas de depuración
- execute_js - Ejecutar JavaScript en la webview
- get_devtools_info - Obtener información de conexión de DevTools
- Integración con WebDriver para pruebas avanzadas
- Captura de registros de consola
Interacción IPC
- list_ipc_handlers - Listar comandos Tauri registrados
- call_ipc_command - Llamar comandos IPC de Tauri
- Emisión y escucha de eventos

Instalación

Usando DXT (Recomendado para Claude Desktop)

La forma más sencilla de instalar tauri-mcp para usar con Claude Desktop es mediante DXT (Desktop Extension):

Descargue el archivo tauri-mcp-node-*.dxt más reciente desde la página de versiones
Haga doble clic en el archivo .dxt para instalarlo (o arrástrelo sobre Claude Desktop)
El servidor se configurará automáticamente y estará listo para usar

Nota: Debido a un problema conocido con la extracción de DXT de Claude Desktop, proporcionamos una versión contenedora de Node.js (tauri-mcp-node-*.dxt) que evita esta limitación.

Usando Cargo

cargo install tauri-mcp

Nota importante sobre servidores MCP basados en Rust: Claude Desktop actualmente tiene problemas de compatibilidad con servidores MCP basados en Rust, lo que provoca desconexiones inmediatas después de la inicialización. Este es un problema conocido que afecta a todos los servidores MCP que no son de Node.js. La instalación con Cargo es adecuada para:

Uso directo desde la CLI
Integración con otras herramientas
Desarrollo y pruebas

Para usar con Claude Desktop, utilice el paquete DXT que incluye un contenedor de Node.js.

Desde el código fuente

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

# Build and install
cargo install --path .

Uso

Como servidor independiente

# 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

Configuración

Cree un archivo tauri-mcp.toml para la configuración:

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

Variables de entorno

TAURI_MCP_LOG_LEVEL - Establecer el nivel de registro (trace, debug, info, warn, error)
TAURI_MCP_CONFIG - Ruta al archivo de configuración (predeterminado: tauri-mcp.toml)

Integración con MCP

Configuración de Claude Desktop

Opción 1: Usando el paquete DXT (Recomendado)

Instale el paquete tauri-mcp-node-*.dxt haciendo doble clic en él. El servidor se configurará automáticamente.

Opción 2: Configuración manual

Si necesita configurarlo manualmente o usar la versión de desarrollo, añada a la configuración de Claude Desktop:

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

Nota: La configuración directa del binario Rust ("command": "tauri-mcp") no funcionará con Claude Desktop debido a problemas de compatibilidad. Utilice el enfoque del contenedor de Node.js mostrado arriba.

Herramientas MCP disponibles

Todas las herramientas se exponen a través del protocolo MCP y pueden ser invocadas por asistentes de IA:

// 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"
});

Soporte de plataformas

macOS - Soporte completo, incluida la gestión de ventanas
Windows - Soporte completo con API nativas de ventanas
Linux - Soporte de X11 (Wayland en proceso)

Desarrollo

Compilación

# Debug build
cargo build

# Release build
cargo build --release

# Run tests
cargo test

Compilación de paquetes DXT

El proyecto incluye scripts de compilación para crear paquetes DXT (Desktop Extension) para diferentes plataformas.

Requisitos previos

Kit de herramientas de Rust instalado
Node.js 18+ (para el contenedor de Node.js)
Comando zip disponible en PATH

Compilación en macOS/Linux

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

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

Compilación en Windows

# 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

Estructura del paquete DXT

El paquete DXT incluye:

manifest.json - Metadatos y configuración de la extensión
tauri-mcp - El binario Rust compilado
server/ - Contenedor de Node.js y dependencias
- index.js - Servidor MCP de Node.js que inicia el binario Rust
- package.json - Dependencias de Node.js
- node_modules/ - SDK de MCP y dependencias

Notas importantes

Usar la bandera --no-dir-entries: Al crear el archivo zip, use la bandera --no-dir-entries para evitar problemas de extracción:
```
zip -r package.dxt . --no-dir-entries
```
Permisos del binario: Asegúrese de que el binario Rust tenga permisos de ejecución antes de empaquetar:
```
chmod +x tauri-mcp
```
Compilaciones multiplataforma: Para distribuir a otras plataformas, necesitará compilar el binario Rust en cada plataforma de destino o usar compilación cruzada.

Estructura del proyecto

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

Ejemplos

Prueba de una aplicación Tauri

# 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

Script de pruebas automatizadas

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())

Solución de problemas

Problemas comunes

Permiso denegado en macOS
- Conceda permisos de accesibilidad en Preferencias del Sistema
- Requerido para la simulación de entrada
La captura de pantalla falla
- Asegúrese de que se hayan concedido los permisos de grabación de pantalla
- Verifique que la ventana de la aplicación sea visible
Error de conexión de WebDriver
- Asegúrese de que la aplicación Tauri tenga DevTools habilitado
- Verifique si ChromeDriver está instalado para soporte de WebDriver

Modo de depuración

Habilite el registro de depuración:

TAURI_MCP_LOG_LEVEL=debug tauri-mcp serve

Contribuciones

¡Las contribuciones son bienvenidas! No dude en enviar una Pull Request.

Haga un fork del repositorio
Cree su rama de características (git checkout -b feature/amazing-feature)
Realice sus confirmaciones de cambios (git commit -m 'Add some amazing feature')
Envíe la rama (git push origin feature/amazing-feature)
Abra una Pull Request

Licencia

Este proyecto está licenciado bajo la Licencia MIT; consulte el archivo LICENSE para más detalles.

Agradecimientos

Implementa la especificación del Model Context Protocol
Diseñado para aplicaciones de Tauri v2
Simulación de entrada impulsada por enigo
Funcionalidad de capturas de pantalla mediante screenshots-rs