Tauri MCP插件

# 1. Add to your Tauri app's Cargo.toml
tauri-plugin-mcp = { path = "../.tauri-plugin-mcp" }

# 2. Register in src-tauri/src/main.rs (debug builds only!)
#[cfg(debug_assertions)]
{
    use tauri_plugin_mcp::PluginConfig;
    builder = builder.plugin(tauri_plugin_mcp::init_with_config(
        PluginConfig::new("YourApp".to_string())
            .start_socket_server(true)
            .socket_path("/tmp/tauri-mcp.sock")  // macOS/Linux
    ));
}

# 3. Build the MCP server
cd .tauri-plugin-mcp/mcp-server-ts
pnpm install && pnpm build

# 4. Configure your AI agent (Claude Code/Cursor/Cline)
# Add to ~/.config/claude/claude_code_config.json:
{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/.tauri-plugin-mcp/mcp-server-ts/build/index.js"]
    }
  }
}

# 5. Start your Tauri app and test!
pnpm run tauri dev

┌─────────────────────────────────────────────────────────────┐
│                     AI Agent (Claude/Cursor)                 │
│                  (MCP Client via stdio/SSE)                  │
└───────────────────────────┬─────────────────────────────────┘
                            │
                            │ MCP Protocol
                            │ (JSON-RPC)
                            │
┌───────────────────────────▼─────────────────────────────────┐
│              MCP Server (TypeScript - Node.js)               │
│  • Implements MCP protocol                                   │
│  • Exposes tools to AI agents                                │
│  • Manages socket connection lifecycle                       │
└───────────────────────────┬─────────────────────────────────┘
                            │
                            │ IPC Socket or TCP
                            │ (JSON commands)
                            │
┌───────────────────────────▼─────────────────────────────────┐
│         Tauri Plugin (Rust - Socket Server)                  │
│  • Listens on Unix socket/Named pipe/TCP                     │
│  • Processes JSON commands                                   │
│  • Executes Tauri API calls                                  │
└───────────────────────────┬─────────────────────────────────┘
                            │
                            │ Tauri IPC
                            │
┌───────────────────────────▼─────────────────────────────────┐
│              Your Tauri Application                          │
│  • Frontend (React/Vue/Svelte/etc.)                          │
│  • Webview rendering                                         │
│  • Application logic                                         │
└─────────────────────────────────────────────────────────────┘

AI Request → MCP Server → Socket → Tauri Plugin → Tauri API → App
                    ←       ←        ←            ←         ←
           AI Response   JSON    Rust Handler   Result   Effect

{
  quality?: number;        // JPEG quality 1-100 (default: 90)
  width?: number;         // Target width in pixels (optional)
  height?: number;        // Target height in pixels (optional)
  window_label?: string;  // Target window (default: main window)
}

{
  window_label?: string;  // Target window (default: main window)
}

{
  selector: string;       // CSS selector (required)
  window_label?: string;  // Target window (default: main window)
}

{
  script: string;         // JavaScript code to execute (required)
  window_label?: string;  // Target window (default: main window)
}

{
  window_label?: string;  // Target window (default: main window)
}

{
  level?: "log" | "warn" | "error" | "info" | "debug";  // Filter by level
  since?: number;         // Unix timestamp - only logs after this time
  limit?: number;         // Max number of logs to return
  window_label?: string;  // Target window
}

{
  window_label?: string;  // Target window (default: main window)
}

{
  since?: number;         // Unix timestamp - only errors after this time
  limit?: number;         // Max number of errors to return
  window_label?: string;  // Target window
}

{
  key: string;            // Storage key (required)
  window_label?: string;  // Target window
}

{
  key: string;            // Storage key (required)
  value: string;          // Value to store (required)
  window_label?: string;  // Target window
}

{
  key: string;            // Storage key (required)
  window_label?: string;  // Target window
}

{
  window_label?: string;  // Target window
}

{
  window_label?: string;  // Target window
}

{
  action: "resize" | "move" | "focus" | "minimize" | "maximize" | "restore";
  window_label?: string;  // Target window (default: main window)
  x?: number;            // X position for move action
  y?: number;            // Y position for move action
  width?: number;        // Width for resize action
  height?: number;       // Height for resize action
}

{}  // No parameters required

{}  // No parameters required

# Install dependencies
pnpm install

# Build the Rust plugin and TypeScript server
pnpm run build && pnpm run build-plugin

[dependencies]
tauri-plugin-mcp = { path = "../path/to/tauri-plugin-mcp" }
# Or from a git repository:
# tauri-plugin-mcp = { git = "https://github.com/yourusername/tauri-plugin-mcp" }

{
  "dependencies": {
    "tauri-plugin-mcp": "file:../path/to/tauri-plugin-mcp"
  }
}

use tauri_plugin_mcp;

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    let mut builder = tauri::Builder::default();

    // Only enable MCP in development builds
    #[cfg(debug_assertions)]
    {
        use tauri_plugin_mcp::PluginConfig;

        builder = builder.plugin(tauri_plugin_mcp::init_with_config(
            PluginConfig::new("YourAppName".to_string())  // Must match your app's window name
                .start_socket_server(true)
                // Choose ONE connection mode:

                // Option 1: IPC Socket (Default - Recommended)
                .socket_path("/tmp/tauri-mcp.sock")  // macOS/Linux
                // .socket_path("\\\\.\\pipe\\tauri-mcp")  // Windows

                // Option 2: TCP Socket (Useful for Docker/Remote debugging)
                // .tcp("127.0.0.1".to_string(), 4000)
        ));

        log::info!("MCP plugin enabled for development");
    }

    builder
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

cd mcp-server-ts
pnpm install
pnpm build

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/tauri-plugin-mcp/mcp-server-ts/build/index.js"]
    }
  }
}

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

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["/path/to/mcp-server-ts/build/index.js"],
      "env": {
        "TAURI_MCP_IPC_PATH": "/custom/path/to/socket"
      }
    }
  }
}

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["/path/to/mcp-server-ts/build/index.js"],
      "env": {
        "TAURI_MCP_CONNECTION_TYPE": "tcp",
        "TAURI_MCP_TCP_HOST": "127.0.0.1",
        "TAURI_MCP_TCP_PORT": "4000"
      }
    }
  }
}

#[cfg(debug_assertions)]
{
    builder = builder.plugin(tauri_plugin_mcp::init_with_config(
        PluginConfig::new("YourApp".to_string())
            .start_socket_server(true)
            .tcp("127.0.0.1".to_string(), 4000)  // Must match MCP server config
    ));
}

1. AI Agent sends MCP request
   ↓
2. MCP Server receives tool call (e.g., "take_screenshot")
   ↓
3. MCP Server constructs JSON command
   {
     "action": "take_screenshot",
     "params": { "quality": 80 }
   }
   ↓
4. Socket Client sends command to Socket Server (IPC or TCP)
   ↓
5. Socket Server (Rust) receives JSON command
   ↓
6. Router dispatches to appropriate tool handler
   ↓
7. Tool handler calls Tauri API
   (e.g., window.screenshot())
   ↓
8. Result returned as JSON
   {
     "success": true,
     "data": { "image": "base64..." }
   }
   ↓
9. Socket Client receives response
   ↓
10. MCP Server formats response per MCP protocol
   ↓
11. AI Agent receives result

// Simplified example
match command.action.as_str() {
    "take_screenshot" => {
        let params: ScreenshotParams = serde_json::from_value(command.params)?;
        let result = tools::take_screenshot(&app, params).await?;
        Ok(json!({ "success": true, "data": result }))
    }
    // ... other actions
}

// Simplified example
async function sendCommand(action: string, params: any): Promise<any> {
    const command = { action, params };
    await socket.write(JSON.stringify(command) + '\n');
    const response = await socket.readLine();
    return JSON.parse(response);
}

server.registerTool({
    name: "take_screenshot",
    description: "Capture a screenshot of the Tauri window",
    inputSchema: {
        type: "object",
        properties: {
            quality: { type: "number", minimum: 1, maximum: 100 }
        }
    }
});

# Check if socket server is listening (TCP mode)
lsof -i :4000  # macOS/Linux
netstat -an | findstr :4000  # Windows

# Check Tauri app logs
# Look for: "Socket server started on..."

cd tauri-plugin-mcp
git pull
pnpm run build && pnpm run build-plugin

# List available tools using MCP Inspector
cd mcp-server-ts
npx @modelcontextprotocol/inspector node build/index.js
# Click "List Tools" to see registered tools

// Bad: Returns DOM element (not serializable)
execute_js({ script: "document.getElementById('app')" })

// Good: Returns serializable data
execute_js({ script: "document.getElementById('app').textContent" })

cd mcp-server-ts

# IPC mode (default)
npx @modelcontextprotocol/inspector node build/index.js

# TCP mode
TAURI_MCP_CONNECTION_TYPE=tcp \
TAURI_MCP_TCP_HOST=127.0.0.1 \
TAURI_MCP_TCP_PORT=4000 \
npx @modelcontextprotocol/inspector node build/index.js

# Windows (TCP mode)
set TAURI_MCP_CONNECTION_TYPE=tcp&& set TAURI_MCP_TCP_HOST=127.0.0.1&& set TAURI_MCP_TCP_PORT=4000&& npx @modelcontextprotocol/inspector node build\index.js

# Test TCP socket
echo '{"action":"ping","params":{}}' | nc 127.0.0.1 4000

# Test Unix socket (macOS/Linux)
echo '{"action":"ping","params":{}}' | nc -U /tmp/tauri-mcp.sock

{"success":true,"data":"pong"}

// Step 1: Health check
await health_check({});

// Step 2: Ping test
await ping({});

// Enable console log capture
await inject_console_capture({});

// Enable error tracking
await inject_error_tracker({});

// Capture current visual state
const screenshot = await take_screenshot({ quality: 80 });

// Analyze the screenshot to understand:
// - Is the UI rendered correctly?
// - Are there visual errors?
// - Which elements are visible?

// Get full DOM
const dom = await get_dom({});

// Or find specific elements
const buttonPos = await get_element_position({
    selector: "button.submit"
});

// Check React state (if using React)
const state = await execute_js({
    script: `
        const app = document.getElementById('root');
        const fiber = app._reactRootContainer?._internalRoot?.current;
        // Return serializable state information
        JSON.stringify({ /* state data */ });
    `
});

// Check localStorage for session data
const storage = await local_storage_get_all({});

// Check specific configuration
const config = await execute_js({
    script: "JSON.stringify(window.__APP_CONFIG__ || {})"
});

// Get recent error messages
const errors = await get_exceptions({
    since: Date.now() - 60000,  // Last minute
    limit: 50
});

// Get console logs
const logs = await get_console_logs({
    level: "error",
    since: Date.now() - 60000
});

// Analyze patterns:
// - Are there recurring errors?
// - What was the sequence of events?
// - Are there unhandled promise rejections?

// Example: Testing if a specific function exists
const hasFunction = await execute_js({
    script: "typeof window.myFunction === 'function'"
});

// Example: Testing if data loaded
const dataLoaded = await execute_js({
    script: `
        const data = window.myData;
        JSON.stringify({
            exists: !!data,
            length: data?.length || 0,
            isEmpty: !data || data.length === 0
        });
    `
});

// Example: Testing localStorage state
const authState = await local_storage_get({ key: "auth_token" });

// 1. Verify form is visible
const screenshot = await take_screenshot({});

// 2. Check form state
const formData = await execute_js({
    script: `
        const form = document.querySelector('form');
        const formData = new FormData(form);
        const obj = {};
        formData.forEach((value, key) => obj[key] = value);
        JSON.stringify({
            action: form.action,
            method: form.method,
            data: obj
        });
    `
});

// 3. Check for validation errors
const logs = await get_console_logs({ level: "error" });

// 4. Check network-related errors (if applicable)
const exceptions = await get_exceptions({});

// 1. Inspect current state
const currentState = await execute_js({
    script: "JSON.stringify(window.store?.getState() || {})"
});

// 2. Check localStorage for persisted state
const persistedState = await local_storage_get({ key: "redux_state" });

// 3. Compare expected vs actual
// 4. Check for state update errors in logs
const logs = await get_console_logs({ level: "warn" });

// 1. Take screenshot
const screenshot = await take_screenshot({});

// 2. Get DOM to check element attributes
const dom = await get_dom({});

// 3. Check element positioning
const position = await get_element_position({
    selector: ".problematic-element"
});

// 4. Check computed styles
const styles = await execute_js({
    script: `
        const el = document.querySelector('.problematic-element');
        const styles = window.getComputedStyle(el);
        JSON.stringify({
            display: styles.display,
            visibility: styles.visibility,
            opacity: styles.opacity,
            position: styles.position,
            zIndex: styles.zIndex
        });
    `
});

// 1. Check for network errors in console
const logs = await get_console_logs({ level: "error" });

// 2. Check application state for API responses
const apiState = await execute_js({
    script: `
        JSON.stringify({
            baseURL: window.API_BASE_URL,
            lastResponse: window.__lastAPIResponse__,
            pendingRequests: window.__pendingRequests__?.length || 0
        });
    `
});

// 3. Check localStorage for tokens
const authToken = await local_storage_get({ key: "auth_token" });

// 4. Verify token format and expiration
const tokenInfo = await execute_js({
    script: `
        try {
            const token = localStorage.getItem('auth_token');
            if (!token) throw new Error('No token');
            const parts = token.split('.');
            const payload = JSON.parse(atob(parts[1]));
            JSON.stringify({
                isExpired: payload.exp * 1000 < Date.now(),
                expiresAt: new Date(payload.exp * 1000).toISOString()
            });
        } catch (e) {
            JSON.stringify({ error: e.message });
        }
    `
});

try {
    const result = await some_tool({ params });
} catch (error) {
    // 1. Check if it's a connectivity issue
    try {
        await ping({});
    } catch (pingError) {
        // Plugin is not accessible - inform user
        // Suggest: Check if Tauri app is running
        // Suggest: Verify socket configuration
        return;
    }

    // 2. Check if it's a parameter validation issue
    if (error.message.includes('validation')) {
        // Review parameter types in Tool Parameters Reference
        // Provide corrected parameters
    }

    // 3. Check if it's a window-specific issue
    if (error.message.includes('window')) {
        // Verify window_label is correct
        // Check if window still exists
    }

    // 4. Provide helpful context to user
    // Include: What you were trying to do
    // Include: The specific error message
    // Include: Suggested next steps
}

#[cfg(debug_assertions)]
{
    builder = builder.plugin(tauri_plugin_mcp::init_with_config(...));
}

# Build for production
pnpm run tauri build

# Check the binary doesn't include MCP symbols (Linux/macOS)
nm -a ./target/release/myapp | grep -i mcp
# Should return nothing if properly excluded

# Or check Cargo features
cargo tree --features | grep mcp

use tauri::{AppHandle, Runtime};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
pub struct CustomToolParams {
    pub param1: String,
}

#[derive(Serialize)]
pub struct CustomToolResult {
    pub result: String,
}

pub async fn custom_tool<R: Runtime>(
    app: &AppHandle<R>,
    params: CustomToolParams,
) -> Result<CustomToolResult, String> {
    // Your custom logic here
    Ok(CustomToolResult {
        result: format!("Processed: {}", params.param1),
    })
}

pub mod custom_tool;

// In the command router
match action {
    "custom_tool" => {
        let params = serde_json::from_value(command.params)?;
        let result = custom_tool::custom_tool(&app, params).await?;
        Ok(json!({ "success": true, "data": result }))
    }
    // ... other actions
}

export const customToolDefinition = {
    name: "custom_tool",
    description: "Your custom tool description",
    inputSchema: {
        type: "object",
        properties: {
            param1: {
                type: "string",
                description: "Parameter description"
            }
        },
        required: ["param1"]
    }
};

export async function customTool(params: { param1: string }) {
    return await client.sendCommand("custom_tool", params);
}

import { customToolDefinition, customTool } from './custom_tool';

server.registerTool(customToolDefinition, customTool);

PluginConfig::new("App".to_string())
    .screenshot_quality(60)  // Lower quality = smaller size

// Good: Reuse connection
const client = await createClient();
await client.sendCommand("ping", {});
await client.sendCommand("take_screenshot", {});

// Bad: New connection each time
await (await createClient()).sendCommand("ping", {});
await (await createClient()).sendCommand("take_screenshot", {});

// Good: Single JS execution
execute_js({
    script: `
        const data = {
            title: document.title,
            url: window.location.href,
            userCount: document.querySelectorAll('.user').length
        };
        JSON.stringify(data);
    `
});

// Bad: Multiple roundtrips
execute_js({ script: "document.title" });
execute_js({ script: "window.location.href" });
execute_js({ script: "document.querySelectorAll('.user').length" });

// macOS: Usually exact match
PluginConfig::new("MyApp".to_string())

// Windows: May include additional decorations
PluginConfig::new("MyApp - Window Name".to_string())

// Linux: Depends on window manager
// Test with: wmctrl -l

#[cfg(target_os = "macos")]
const DEFAULT_SOCKET: &str = "/tmp/tauri-mcp.sock";

#[cfg(target_os = "linux")]
const DEFAULT_SOCKET: &str = "/tmp/tauri-mcp.sock";

#[cfg(target_os = "windows")]
const DEFAULT_SOCKET: &str = "\\\\.\\pipe\\tauri-mcp";

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

# Install dependencies
pnpm install

# Build plugin and server
pnpm run build && pnpm run build-plugin

# Run tests
cargo test
cd mcp-server-ts && pnpm test

# 1. Make changes in src/
vim src/tools/my_tool.rs

# 2. Run format and lint
cargo fmt
cargo clippy

# 3. Build
cargo build

# 4. Test
cargo test

# 5. Test in real app
cd ../your-tauri-app
pnpm run tauri dev

cd mcp-server-ts

# 1. Make changes in src/
vim src/tools/my_tool.ts

# 2. Run format and lint
pnpm run lint
pnpm run format

# 3. Build
pnpm build

# 4. Test
pnpm test

# 5. Test with MCP Inspector
npx @modelcontextprotocol/inspector node build/index.js

# Rust unit tests
cargo test

# TypeScript unit tests
cd mcp-server-ts && pnpm test

# Test ping command
echo '{"action":"ping","params":{}}' | nc -U /tmp/tauri-mcp.sock

# Test health check
echo '{"action":"health_check","params":{}}' | nc -U /tmp/tauri-mcp.sock

#[cfg(debug_assertions)]
{
    env_logger::init();  // Add this
    builder = builder.plugin(tauri_plugin_mcp::init_with_config(...));
}

RUST_LOG=debug pnpm run tauri dev

console.error('[MCP] Sending command:', command);
console.error('[MCP] Received response:', response);

node --inspect build/index.js

Tool: get_network_requests
Purpose: Retrieve all network requests made by the app
Parameters: { since?: timestamp, filter?: regex }
Returns: Array of { url, method, status, headers, body, timing }
Use Case: Debugging API integration issues, analyzing performance

use tauri::{AppHandle, Runtime};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
pub struct MyToolParams {
    pub param1: String,
    pub optional_param: Option<i32>,
}

#[derive(Serialize)]
pub struct MyToolResult {
    pub data: String,
}

pub async fn my_tool<R: Runtime>(
    app: &AppHandle<R>,
    params: MyToolParams,
) -> Result<MyToolResult, String> {
    // Implementation here
    Ok(MyToolResult {
        data: format!("Processed: {}", params.param1),
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_my_tool() {
        // Add unit tests
    }
}

pub mod my_tool;

// In the command router match statement
"my_tool" => {
    let params = serde_json::from_value(command.params)?;
    let result = my_tool::my_tool(&app, params).await?;
    Ok(json!({ "success": true, "data": result }))
}

import { client } from './client';

export const myToolDefinition = {
    name: "my_tool",
    description: "Clear description of what the tool does",
    inputSchema: {
        type: "object",
        properties: {
            param1: {
                type: "string",
                description: "Parameter description"
            },
            optional_param: {
                type: "number",
                description: "Optional parameter"
            }
        },
        required: ["param1"]
    }
};

export async function myTool(params: {
    param1: string;
    optional_param?: number;
}) {
    return await client.sendCommand("my_tool", params);
}

import { myToolDefinition, myTool } from './my_tool';

// In the setup function
server.registerTool(myToolDefinition, myTool);

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_my_tool_success() {
        // Test implementation
    }

    #[tokio::test]
    async fn test_my_tool_validation() {
        // Test error cases
    }
}

// mcp-server-ts/tests/my_tool.test.ts
import { myTool } from '../src/tools/my_tool';

describe('myTool', () => {
    it('should process valid input', async () => {
        // Test implementation
    });
});

# Rust tests
cargo test

# TypeScript tests
cd mcp-server-ts
pnpm test

# Integration tests with MCP Inspector
cd mcp-server-ts
npx @modelcontextprotocol/inspector node build/index.js

# Integration tests with real app
cd examples/test-app
pnpm run tauri dev
# Then test with your AI agent

# Full rebuild
pnpm run build && pnpm run build-plugin

# Rust only
cargo build

# TypeScript only
cd mcp-server-ts && pnpm build

# Tauri app with debug logs
RUST_LOG=debug pnpm run tauri dev

# MCP server with debug logs
DEBUG=* node build/index.js

# Check if socket exists
ls -l /tmp/tauri-mcp.sock

# Test with netcat
echo '{"action":"ping","params":{}}' | nc -U /tmp/tauri-mcp.sock