Tauri MCP Server

Um servidor para testar e interagir com aplicações Tauri v2, fornecendo ferramentas para gerenciamento de processos, manipulação de janelas e depuração.

GitHub

Experimente este MCPPatrocinado

Documentação

Servidor MCP Tauri

Um servidor Model Context Protocol (MCP) para testar e interagir com aplicações Tauri v2. Esta ferramenta permite que assistentes de IA entendam, depurem e interajam melhor com aplicativos Tauri durante o desenvolvimento.

O protocolo MCP fornece uma forma padronizada para assistentes de IA interagirem com ferramentas e sistemas externos. Este servidor implementa a especificação MCP para expor capacidades de teste e depuração de aplicações Tauri.

Conformidade com MCP

Este servidor é totalmente compatível com a especificação do Model Context Protocol. Ele implementa:

✅ Transporte JSON-RPC 2.0 via stdio
✅ Handshake de inicialização/encerramento
✅ Capacidade de ferramentas com 12 ferramentas especializadas de teste Tauri
✅ Tratamento adequado de erros com mensagens descritivas
✅ Esquemas de ferramentas usando formato JSON Schema
✅ Compatibilidade de versão do protocolo - Suporta tanto a versão "1.0" quanto versões baseadas em data (ex.: "2024-11-05")

Para mais detalhes sobre MCP:

Recursos

Ferramentas Principais

Gerenciamento de Processos
- launch_app - Iniciar aplicações Tauri com argumentos
- stop_app - Encerrar aplicativos em execução de forma graciosa
- get_app_logs - Capturar saída stdout/stderr
- monitor_resources - Rastrear uso de CPU, memória e disco
Manipulação de Janelas
- take_screenshot - Capturar capturas de tela da janela do aplicativo
- get_window_info - Obter dimensões, posição e estado da janela
Simulação de Entrada
- send_keyboard_input - Simular entrada de teclado
- send_mouse_click - Simular cliques do mouse
- Suporte a movimento do mouse, arrastar e rolar
Ferramentas de Depuração
- execute_js - Executar JavaScript no webview
- get_devtools_info - Obter informações de conexão do DevTools
- Integração com WebDriver para testes avançados
- Captura de log do console
Interação IPC
- list_ipc_handlers - Listar comandos Tauri registrados
- call_ipc_command - Chamar comandos IPC do Tauri
- Emissão e escuta de eventos

Instalação

Usando DXT (Recomendado para Claude Desktop)

A maneira mais fácil de instalar o tauri-mcp para uso com Claude Desktop é via DXT (Desktop Extension):

Baixe o arquivo tauri-mcp-node-*.dxt mais recente da página de releases
Clique duas vezes no arquivo .dxt para instalar (ou arraste-o para o Claude Desktop)
O servidor será configurado automaticamente e estará pronto para uso

Nota: Devido a um problema conhecido com a extração DXT do Claude Desktop, fornecemos uma versão wrapper Node.js (tauri-mcp-node-*.dxt) que contorna essa limitação.

Usando Cargo

cargo install tauri-mcp

Nota Importante para Servidores MCP Baseados em Rust: O Claude Desktop atualmente tem problemas de compatibilidade com servidores MCP baseados em Rust, causando desconexões imediatas após a inicialização. Este é um problema conhecido que afeta todos os servidores MCP que não são Node.js. A instalação via cargo é adequada para:

Uso direto via CLI
Integração com outras ferramentas
Desenvolvimento e testes

Para uso com Claude Desktop, use o pacote DXT que inclui um wrapper Node.js.

A partir do Código Fonte

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

# Build and install
cargo install --path .

Uso

Como Servidor Autônomo

# 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

Configuração

Crie um arquivo tauri-mcp.toml para configuração:

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

Variáveis de Ambiente

TAURI_MCP_LOG_LEVEL - Definir nível de log (trace, debug, info, warn, error)
TAURI_MCP_CONFIG - Caminho para o arquivo de configuração (padrão: tauri-mcp.toml)

Integração MCP

Configuração do Claude Desktop

Opção 1: Usando Pacote DXT (Recomendado)

Instale o pacote tauri-mcp-node-*.dxt clicando duas vezes nele. O servidor será configurado automaticamente.

Opção 2: Configuração Manual

Se você precisar configurar manualmente ou usar a versão de desenvolvimento, adicione à configuração do seu Claude Desktop:

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

Nota: A configuração direta do binário Rust ("command": "tauri-mcp") não funcionará com Claude Desktop devido a problemas de compatibilidade. Use a abordagem com wrapper Node.js mostrada acima.

Ferramentas MCP Disponíveis

Todas as ferramentas são expostas através do protocolo MCP e podem ser chamadas por assistentes 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"
});

Suporte a Plataformas

macOS - Suporte completo incluindo gerenciamento de janelas
Windows - Suporte completo com APIs nativas de janela
Linux - Suporte X11 (Wayland em andamento)

Desenvolvimento

Compilação

# Debug build
cargo build

# Release build
cargo build --release

# Run tests
cargo test

Compilando Pacotes DXT

O projeto inclui scripts de build para criar pacotes DXT (Desktop Extension) para diferentes plataformas.

Pré-requisitos

Toolchain Rust instalado
Node.js 18+ (para o wrapper Node.js)
Comando zip disponível no PATH

Compilando no macOS/Linux

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

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

Compilando no 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

Estrutura do Pacote DXT

O pacote DXT inclui:

manifest.json - Metadados e configuração da extensão
tauri-mcp - O binário Rust compilado
server/ - Wrapper Node.js e dependências
- index.js - Servidor MCP Node.js que inicia o binário Rust
- package.json - Dependências Node.js
- node_modules/ - SDK MCP e dependências

Notas Importantes

Use a flag --no-dir-entries: Ao criar o arquivo zip, use a flag --no-dir-entries para evitar problemas de extração:
```
zip -r package.dxt . --no-dir-entries
```
Permissões do binário: Garanta que o binário Rust tenha permissões de execução antes de empacotar:
```
chmod +x tauri-mcp
```
Builds multiplataforma: Para distribuir para outras plataformas, você precisará compilar o binário Rust em cada plataforma de destino ou usar compilação cruzada.

Estrutura do Projeto

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

Exemplos

Testando um Aplicativo 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 Teste Automatizado

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

Solução de Problemas

Problemas Comuns

Permissão Negada no macOS
- Conceda permissões de acessibilidade nas Preferências do Sistema
- Necessário para simulação de entrada
Falha na Captura de Tela
- Garanta que as permissões de gravação de tela sejam concedidas
- Verifique se a janela do aplicativo está visível
Falha na Conexão WebDriver
- Garanta que o aplicativo Tauri tenha DevTools habilitado
- Verifique se o ChromeDriver está instalado para suporte WebDriver

Modo de Depuração

Habilite o log de depuração:

TAURI_MCP_LOG_LEVEL=debug tauri-mcp serve

Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para enviar um Pull Request.

Faça um fork do repositório
Crie sua branch de recurso (git checkout -b feature/amazing-feature)
Faça commit das suas alterações (git commit -m 'Add some amazing feature')
Envie para a branch (git push origin feature/amazing-feature)
Abra um Pull Request

Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para detalhes.

Agradecimentos

Implementa a especificação do Model Context Protocol
Projetado para aplicações Tauri v2
Simulação de entrada alimentada por enigo
Funcionalidade de captura de tela via screenshots-rs