MCP (Model Context Protocol)를 통한 크로스 플랫폼 Tauri 테스트 자동화 플러그인.
Claude와 같은 AI 어시스턴트가 테스트 및 자동화를 위해 Tauri 데스크탑 앱과 상호작용할 수 있도록 합니다.
이 저장소는 Claude Code 플러그인으로도 작동합니다. 완벽하게 작동하는 설정을 위한 세 단계:
1. 마켓플레이스 추가 및 플러그인 설치
/plugin marketplace add DaveDev42/tauri-plugin-mcp
/plugin install tauri-mcp설치 중에 다음 항목을 묻는 메시지가 표시됩니다:
Tauri 앱 디렉토리: 프로젝트 루트 기준 경로 (예: 단일 앱 저장소의 경우 ., 모노레포의 경우 apps/desktop).
2. 설치 프로그램 명령 실행
/tauri-mcp:install이 명령은 Tauri 프로젝트(Cargo.toml, src-tauri/src/lib.rs, capabilities, package.json, 프론트엔드 엔트리(main.tsx/main.ts), .gitignore)를 자동으로 편집합니다. 모든 쓰기 작업은 먼저 diff로 미리보기되며 사용자의 확인이 필요합니다.
3. Claude Code 재시작
tauri-mcp MCP 서버는 재시작 시 등록됩니다. /mcp 명령으로 확인하세요. tauri-mcp가 연결된 것으로 표시되어야 합니다. 이제 start_session, snapshot, click 등을 호출할 수 있습니다.
MCP 서버는 Claude Code 시작 시 등록됩니다. 플러그인을 설치하거나 tauri_app_dir을 변경하면 적용을 위해 재시작이 필요합니다.
MCP 서버는 모든 의존성이 포함된 단일 파일 번들(packages/tauri-mcp/dist/index.js)로 제공됩니다. 대상 머신에 node_modules가 필요하지 않으므로 macOS, Linux, Windows에서 동일하게 설치됩니다.
포함된 내용:
구성 요소 | 설명 |
MCP 서버 | 독립형 |
| 플러그인을 연결하기 위해 Tauri 프로젝트를 편집하는 원샷 설치 프로그램 |
| QA 오케스트레이션 — 테스트 시나리오 준비, QA 에이전트에 위임, 결과 검증 |
| 일반적인 MCP 세션 문제에 대한 진단 의사결정 트리 |
| MCP 도구를 사용하여 테스트 시나리오를 실행하는 테스트 에이전트 (haiku) |
QA 검증 훅 | QA PASS 결과에 실제 도구 호출 증거가 포함되어 있는지 확인 |
Related MCP server: MCP Server Tauri
크로스 플랫폼: Windows (Named Pipes) + macOS/Linux (Unix Sockets)
CDP 의존성 없음: macOS WKWebView를 포함한 모든 WebView 백엔드에서 작동
MCP 통합: Claude Code 및 기타 MCP 클라이언트와 직접 통합
다중 창 지원: 레이블별로 창 타겟팅; 자동 브리지 주입
통합 로깅: 필터링 기능이 포함된 빌드, 런타임, 콘솔 및 네트워크 로그
동적 포트 할당: 충돌 방지를 위한 자동 무작위 포트 할당
Node.js >= 18
Tauri v2.x
pnpm (권장) 또는 npm
Rust (cargo 포함)
[ ] src-tauri/Cargo.toml에 Rust 플러그인 추가
[ ] npm 패키지 설치: pnpm add github:DaveDev42/tauri-plugin-mcp#main
[ ] src-tauri/src/lib.rs에 플러그인 등록
[ ] mcp:default 권한 추가
[ ] main.tsx에서 브리지 초기화
[ ] Claude Code를 위한 .mcp.json 생성
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp" }pnpm add github:DaveDev42/tauri-plugin-mcp#mainMCP 서버 바이너리(tauri-mcp)는 설치 후 자동으로 사용할 수 있습니다. 추가 설정이 필요하지 않습니다.
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_mcp::init())
.run(tauri::generate_context!())
.expect("error while running tauri application");
}옵션 A: tauri.conf.json 또는 config/*.json5 (권장)
{
"security": {
"capabilities": [{
"identifier": "main-capability",
"windows": ["main"],
"permissions": ["core:default", "mcp:default"]
}]
}
}옵션 B: 별도 파일 (src-tauri/capabilities/default.json)
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"windows": ["main"],
"permissions": ["core:default", "mcp:default"]
}// Initialize MCP bridge for E2E testing (dev mode only)
if (import.meta.env.DEV) {
import('tauri-plugin-mcp').then(({ initMcpBridge }) => {
initMcpBridge().catch(err => {
console.warn('[MCP] Bridge initialization failed:', err);
});
});
}위의 기본 설정은 모든 빌드에 MCP를 포함합니다. 프로덕션 앱의 경우, MCP를 개발 중에만 사용하고 릴리스 바이너리에서는 완전히 제거하는 것이 좋습니다.
이 방식은 Cargo의 선택적 의존성 기능을 사용하여 명시적으로 요청할 때만 플러그인이 컴파일되도록 합니다.
[features]
default = []
dev-tools = ["dep:tauri-plugin-mcp"]
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp", optional = true }pub fn run() {
let mut builder = tauri::Builder::default();
#[cfg(feature = "dev-tools")]
{
builder = builder.plugin(tauri_plugin_mcp::init());
}
builder
.run(tauri::generate_context!())
.expect("error while running tauri application");
}mcp:default를 별도의 capability 파일로 분리하여 빌드 시점에 토글할 수 있도록 합니다.
capabilities/default.json — 항상 활성, MCP 권한 없음:
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"windows": ["main"],
"permissions": ["core:default"]
}capabilities/.dev-tools.json.disabled — MCP 권한 템플릿 (git 추적):
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "dev-tools",
"windows": ["main"],
"permissions": ["mcp:default"]
}capabilities/dev-tools.json — .gitignore에 추가 (빌드 시점에 생성됨):
# Dev-tools capability (generated from .disabled at build time)
src-tauri/capabilities/dev-tools.jsonbuild.rs는 기능이 활성화되면 템플릿을 복사하고, 그렇지 않으면 제거합니다:
fn main() {
let dev_tools_cap = std::path::Path::new("capabilities/dev-tools.json");
let source_path = std::path::Path::new("capabilities/.dev-tools.json.disabled");
if std::env::var("CARGO_FEATURE_DEV_TOOLS").is_ok() {
// Copy .disabled → active (skip if already identical to avoid rebuild churn)
let should_copy = if dev_tools_cap.exists() {
std::fs::read(source_path).ok() != std::fs::read(dev_tools_cap).ok()
} else {
true
};
if should_copy {
std::fs::copy(source_path, dev_tools_cap)
.expect("Failed to copy dev-tools capability file");
}
} else if dev_tools_cap.exists() {
std::fs::remove_file(dev_tools_cap).ok();
}
tauri_build::try_build(
tauri_build::Attributes::default()
).expect("Failed to build tauri");
}{
"scripts": {
"dev": "tauri dev --features dev-tools"
}
}이제 pnpm dev는 MCP를 활성화하고, tauri build(기능 없이)는 MCP 코드가 전혀 없는 깔끔한 릴리스를 생성합니다.
참고: 기본 설정의 프론트엔드 브리지 가드(
import.meta.env.DEV)는 여전히 적용됩니다. 이는 런타임에 플러그인이 존재하더라도 브리지가 초기화되는 것을 방지합니다.
참고: Claude Code 플러그인을 설치했다면 MCP 서버는 이미 자동으로 구성되었습니다. 플러그인은 설치 중에 Tauri 앱 디렉토리를 묻습니다. 이 섹션은 플러그인 없이 수동으로 설정하는 경우를 위한 것입니다.
프로젝트 루트의 .mcp.json에 추가하세요:
{
"mcpServers": {
"tauri-mcp": {
"command": "npx",
"args": ["tauri-mcp"],
"env": {
"TAURI_APP_DIR": "."
}
}
}
}참고: pnpm 사용자는
pnpx tauri-mcp또는pnpm exec tauri-mcp를 사용할 수도 있습니다.
Tauri 앱이 하위 디렉토리(예: apps/desktop)에 있는 경우 TAURI_APP_DIR을 설정하세요:
{
"mcpServers": {
"tauri-mcp": {
"command": "npx",
"args": ["tauri-mcp"],
"env": {
"TAURI_APP_DIR": "./apps/desktop"
}
}
}
}여러 Tauri 앱이 있는 모노레포의 경우, 앱당 별도의 MCP 서버 인스턴스를 실행하세요:
{
"mcpServers": {
"tauri-desktop": {
"command": "npx",
"args": ["tauri-mcp"],
"env": { "TAURI_APP_DIR": "./apps/desktop" }
},
"tauri-kiosk": {
"command": "npx",
"args": ["tauri-mcp"],
"env": { "TAURI_APP_DIR": "./apps/kiosk" }
}
}
}도구는 서버 이름별로 네임스페이스가 지정됩니다: mcp__tauri-desktop__snapshot, mcp__tauri-kiosk__snapshot 등.
도구 | 매개변수 | 설명 |
|
| 세션(앱) 상태 확인; |
|
| 세션 시작 ( |
| - | 세션 중지 (앱 프로세스 트리 종료) |
도구 | 매개변수 | 설명 |
| - | 레이블, 제목, 포커스 상태 및 브리지 상태가 포함된 모든 열린 창 나열 |
|
| 레이블별로 특정 창에 포커스 |
모든 상호작용 도구는 특정 창을 타겟팅하기 위한 선택적 window 매개변수를 허용합니다 (기본값은 포커스된 창).
도구 | 매개변수 | 설명 |
|
|
|
|
| 참조 또는 CSS 선택자로 요소 클릭 |
|
| 입력 필드 채우기 |
|
| 키보드 키 누르기 (예: "Enter", "Tab") |
|
| URL로 이동 |
|
| 기본 OS 캡처를 통해 스크린샷 찍기 |
|
| 웹뷰에서 JavaScript 실행 |
도구 | 매개변수 | 설명 |
|
| 소스/레벨 필터링이 포함된 통합 로그 액세스 (빌드, 런타임, 콘솔, 네트워크) |
|
| 트리거 파일을 포함한 최근 앱 재시작/새로고침 이벤트 가져오기 |
features 매개변수 사용Cargo 기능을 사용하여 실행하려면:
start_session({ features: ["my_feature"] })이는 다음을 실행합니다: pnpm tauri dev --features my_feature
일반적인 테스트 워크플로우:
1. start_session({ timeout_secs: 120 })
2. snapshot() # Get element refs
3. click({ ref: 5 }) # Click button by ref
4. fill({ selector: "input[name='email']", value: "test@example.com" })
5. screenshot() # Verify result
6. stop_session()Claude Code <-> MCP Server <-> Socket <-> Tauri Plugin <-> JS Bridge <-> Your AppRust 플러그인이 IPC 서버(Unix 소켓 또는 Windows 명명된 파이프) 생성
MCP 서버가 IPC에 연결하고 Claude에 도구 노출
JS 브리지(initMcpBridge())가 웹뷰에서 DOM 작업 활성화
Unix: {project_root}/.tauri-mcp.sock
Windows: \\.\pipe\tauri-mcp-{hash} (해시는 프로젝트 경로에서 파생됨)
JS 브리지가 실행되지 않고 있습니다. 확인 사항:
프론트엔드 코드에서 initMcpBridge()가 호출되었는지 확인
앱이 개발 모드(import.meta.env.DEV)에서 실행 중인지 확인
브라우저 콘솔에서 초기화 오류 확인
앱이 실행 중인지 확인 (start_session 먼저 실행)
Windows의 경우 로그에서 파이프 경로 확인: [tauri-plugin-mcp] full_path: \\.\pipe\tauri-mcp-XXXXX
Unix의 경우 프로젝트 루트에 .tauri-mcp.sock이 있는지 확인
timeout_secs 증가 (기본값: 60)
pnpm tauri dev가 수동으로 작동하는지 확인
터미널 출력에서 빌드 오류 확인
앱이 완전히 로드될 때까지 대기 (wait_for_ready: true 사용)
브리지가 초기화되었는지 확인 (콘솔에서 [MCP] 로그 확인)
복제 후 pnpm install은 자동으로 git 훅을 구성하고 프로젝트를 빌드합니다.
dist/ 디렉토리는 저장소에 커밋되므로 git 기반 설치(pnpm add github:...)가 빌드 단계 없이 작동합니다. 사전 커밋 훅은 dist/가 TypeScript 소스와 동기화 상태를 유지하는지 확인합니다. 훅이 커밋을 차단하면 다음을 실행하세요:
pnpm build
git add packages/*/dist/그런 다음 커밋을 다시 시도하세요.
MIT OR Apache-2.0
Click element by ref or selector
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Ref from snapshot | |
| selector | No | CSS selector | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fails to disclose behavioral traits such as whether the click waits for element visibility, triggers navigation, or handles errors. It adds no behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the action, but it is overly minimal. It sacrifices completeness for brevity, lacking sufficient detail for a three-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description does not provide enough contextual completeness. It omits behavioral details, expected side effects, and error handling, which are important for correct tool usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all parameters. The description adds no extra semantics beyond the schema's details, achieving baseline adequacy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'click' and the resource 'element', and specifies two methods of identification (ref or selector). It effectively distinguishes from sibling tools like fill or press_key, but could be more explicit about simulating a mouse click.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as press_key or evaluate_script. There is no mention of prerequisites, context, or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run JS in webview
| Name | Required | Description | Default |
|---|---|---|---|
| script | Yes | JS code | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'Run JS' without indicating if the script is sandboxed, whether it returns results, or any potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the key action. It is efficient but could benefit from additional context without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a script execution tool with two parameters and no output schema, the description is incomplete. It does not explain return values, error behavior, or how the script interacts with the webview environment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds no value beyond the schema: 'JS code' and 'Window label' are already in the input schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Run JS in webview' clearly states the action and target resource. It distinguishes from sibling browser tools like click and navigate by specifying script execution, but lacks detail on what 'webview' refers to.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as click or fill. There is no mention of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill input by ref or selector
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Ref from snapshot | |
| selector | No | CSS selector | |
| value | Yes | Value | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as whether it clears the existing value, supports file inputs, or handles non-input elements. The brief description leaves significant ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (5 words) and front-loaded. However, it may be too brief, sacrificing necessary detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and lack of output schema, the description is incomplete: it does not specify the behavior on different input types, whether it simulates typing or sets value programmatically, or error scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all 4 parameters. The description adds 'by ref or selector' to clarify parameter usage, but does not add further semantic meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'fill' and resource 'input', and specifies the method 'by ref or selector'. It is clear but does not differentiate from siblings like 'click' or 'press_key'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., 'press_key' for key presses, 'click' for clicks). No context or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Focus a specific window by label
| Name | Required | Description | Default |
|---|---|---|---|
| window | Yes | Window label to focus |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It fails to disclose what 'focus' entails (e.g., bring to front, activate window) or behavior on missing label.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no fluff, front-loaded. Score would be 5 if it contained more behavioral detail without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, and description lacks detail on return values, error cases, or prerequisites. Minimal for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear parameter description. Tool description adds no extra meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'focus', the resource 'window', and the qualifier 'by label'. It distinguishes the tool from siblings like 'list_windows' and 'click'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no preconditions or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get application logs with filtering. Filters can be combined (e.g., ["build", "error"] for build errors only).
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Filters to apply (empty = all logs) | |
| limit | No | Max entries | |
| clear | No | Clear logs after reading | |
| window | No | Window label for frontend logs (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose all behavioral traits. It mentions filter combination but omits the clear parameter's destructive nature and window parameter's scope. Key behaviors remain undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: one sentence plus a helpful example. No wasted words, but could be better structured (e.g., bullet points). Still effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 4 parameters and no output schema, the description only covers filter semantics. It does not explain the return format, window parameter, clear effect, or limitations. Incomplete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (baseline 3). The tool description adds an example for filter combination, clarifying that filters can be combined, though the case of a string type with array-like example may cause confusion. Minimal value added beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get application logs' as the verb+resource, and adds filtering details. However, it could be more specific about the log source (e.g., browser console logs) to fully distinguish from sibling tools like get_restart_events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives (e.g., evaluate_script, screenshot). The description only explains filtering, not the broader context of log retrieval use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent app restart/reload events with the files that triggered them. Includes Rust rebuilds (backend) and HMR updates (frontend).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max events | |
| clear | No | Clear events after reading | |
| window | No | Window label for frontend HMR events (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It partially discloses what events are included but fails to mention the destructive nature of the 'clear' parameter or side effects. The description is neutral but could be more explicit about read-only vs modifying behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and scope, no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should explain return values. It mentions events include files but not the structure. Also missing context on parameter interactions (e.g., clear, window) beyond schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds context about event types but does not enhance parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves app restart/reload events, specifies it includes Rust rebuilds and HMR updates, and uses a specific verb 'Get' with a resource, distinguishing it from siblings like get_logs or get_session_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool vs alternatives (e.g., get_logs), nor does it mention when not to use it or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check session (app) status. Use probe_bridge to verify bridge health per window.
| Name | Required | Description | Default |
|---|---|---|---|
| probe_bridge | No | Actively probe bridge health per window (adds latency) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It only mentions that probe_bridge adds latency, but does not disclose behavioral traits of this tool itself (e.g., read-only, latency, destructions). The description is too brief to offer adequate transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise—two short sentences—with no unnecessary words. Every sentence serves a purpose: stating the tool's function and directing to an alternative for a specific use case.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and only one parameter, the description is minimally adequate. It states the purpose and references an alternative, but lacks details on return values, scope of 'session status', or how it fits with other tools. For a tool with 12 siblings, more completenss would help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with one parameter described as 'Actively probe bridge health per window (adds latency)'. The description does not add extra meaning beyond the schema, so it meets the baseline 3 without exceeding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Check session (app) status' as a specific verb+resource. It further distinguishes from the sibling 'probe_bridge' by directing to use that tool for verifying bridge health per window, avoiding confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides limited guidance: it tells users to use 'probe_bridge' for bridge health verification, implying this tool is for general session status. However, it does not specify when to choose this over other siblings like get_logs or get_restart_events, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all open windows with their labels, titles, and focus state
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description accurately conveys a read-only operation with no side effects. It is straightforward but could mention if any special permissions or constraints apply.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no extraneous information. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose and output fields (labels, titles, focus state). Missing details like ordering or whether minimized windows are included, but acceptable for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and the description correctly omits parameter details. According to guidelines, zero parameters baseline is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists open windows and specifies the information returned (labels, titles, focus state). It distinguishes from sibling tools like focus_window, which performs a different action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you need to see current windows) but does not explicitly state when to use or not use this tool, nor does it mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Press key
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Key name | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description offers no behavioral information such as whether the press is momentary, if it supports key combinations, or what happens on failure. The agent is left to infer all side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While short, the description is under-specified. It does not earn its place as it adds no information beyond the tool name. It is not appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the two parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain the tool's behavior, return value, or error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides for 'key' and 'window'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description 'Press key' is essentially a tautology of the tool name 'press_key'. It does not specify what kind of key press (e.g., single key, combination) or provide any distinguishing detail from sibling tools like 'click' or 'fill'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description does not mention typical scenarios (e.g., keyboard simulation) or exclude cases where 'click' or 'fill' might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take screenshot
| Name | Required | Description | Default |
|---|---|---|---|
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It only states the action without explaining output, side effects, or required permissions. 'Take screenshot' is too vague for an agent to understand the tool's full impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two words, with no wasted text. However, it may be too brief for optimal clarity, though it earns a high score for lack of verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema or annotations, and the presence of a potentially similar sibling (snapshot), the description is insufficiently complete. It omits return value, side effects, and how it differs from snapshot.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, so the description adds no extra meaning beyond what the schema already provides (window label). Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Take screenshot' clearly states the action and resource, but does not differentiate from the sibling tool 'snapshot', which may have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like snapshot, nor are there any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get accessibility tree (returns ref numbers for click/fill)
| Name | Required | Description | Default |
|---|---|---|---|
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions the return value (ref numbers) and hints at read-only nature, but does not disclose error conditions, effects, or permissions. Without annotations, this is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the core functionality without extraneous words. It is efficient and scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description adequately covers what it does and what it returns. It could mention preconditions or errors, but remains mostly sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'window' is fully described in the input schema. The description adds no additional information about parameter usage or defaults, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Get accessibility tree' and its output 'returns ref numbers for click/fill', which distinguishes it from sibling tools like click and fill. It is specific about the resource and purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use before actions like click or fill, but does not explicitly state when to use it or provide alternatives. No comparison with siblings is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start session (launch Tauri app)
| Name | Required | Description | Default |
|---|---|---|---|
| wait_for_ready | No | Wait for ready | |
| timeout_secs | No | Timeout seconds | |
| features | No | Cargo features to enable | |
| devtools | No | Open devtools on launch |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'launch Tauri app', missing critical details like whether the call blocks until the app is ready, if it returns a session ID, or what happens on failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words. The parenthetical adds clarity. Could be slightly more informative without losing conciseness, but it is not overly terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that launches an application, the description lacks information about return values, error states, expected duration, and side effects. No output schema, so description should cover these aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are documented. However, the tool description adds no meaning beyond the schema; for example, it doesn't explain how 'wait_for_ready' interacts with 'timeout_secs'. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Start') and the resource ('session'), and includes a parenthetical explanation ('launch Tauri app') that distinguishes it from siblings like 'stop_session' and 'get_session_status'. However, 'session' could be more specific about what kind of session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For instance, it doesn't explain whether it should be called before other tools, if there are prerequisites, or when 'stop_session' is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Stop session (kill app)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It only says 'kill app' but does not disclose whether state is saved, if confirmation is required, or any side effects. Minimal behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single efficient phrase with no unnecessary words. However, it could be slightly more descriptive without adding length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is too minimal for a mutation tool. It lacks context on how the session termination affects the application state or subsequent actions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist and schema coverage is 100%, so the baseline is 3. The description adds no parameter info beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the action 'stop session' with the parenthetical '(kill app)' emphasizing termination. It directly contrasts with sibling tools like start_session and get_session_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives such as get_session_status or focus_window. Usage is implied by the name but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.3.6app_statusget_session_statuslaunch_appstart_sessionstop_appstop_sessionv0.1.0app_statusclickevaluate_scriptfillfocus_windowget_logsget_restart_eventslaunch_applist_windowsnavigatepress_keyscreenshotsnapshotstop_appScored across 14 tools
Each tool targets a distinct action or information source: UI interactions (click, fill, press_key), scripting (evaluate_script), navigation (navigate), visual capture (screenshot), accessibility (snapshot), window management (list_windows, focus_window), session lifecycle (start/stop_session), and diagnostics (get_logs, get_restart_events, get_session_status). No two tools have overlapping purposes.
All tool names follow a clear verb_noun pattern using lowercase with underscores (e.g., get_logs, focus_window, start_session). Even single-word names like click, fill, navigate are consistent with the imperative style. No mixed conventions or inconsistent verbs.
14 tools is well-scoped for a Tauri testing/MCP server. It covers all major aspects: session control, window management, UI interaction, scripting, diagnostics, and capture. The count is neither too sparse (missing essential features) nor bloated.
The tool surface covers the full lifecycle of a Tauri app test: start/stop sessions, manage windows, interact via clicks/keys/scripts, navigate, capture screenshots and accessibility trees, and retrieve logs/events. No obvious gaps for typical automation tasks, making it a self-contained toolset.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Run, debug, and triage tests from your IDE using natural language, no dashboard switching, no manual data transfers. The TestMu AI (formerly LambdaTest) MCP Server is a single remote server exposing four tool suites: HyperExecute — analyze your project, generate YAML configs and test runner commands, then monitor jobs and sessions. Automation — pull a TestID's details plus command, network, and console logs into one chat for instant root-cause analysis. Includes mobile app upload. SmartUI — explain pixel, layout, DOM, and perceptual changes in a visual regression run, with context-aware React/HTML/CSS fixes. Accessibility — audit any public URL or a local React app against WCAG and get ready-to-apply remediation steps. Connects over https://mcp.lambdatest.com/mcp using OAuth 2.1 — no API keys in your config. One-click install in Cursor; works with Claude, GitHub Copilot, Cline, and any MCP client. Tests execute on the TestMu AI cloud: 3,000+ browsers and 10,000+ real devices.
A Model Context Protocol server for Wix AI tools
Drive real devices from your AI Coding tool. Embed a client SDK (Unity, Godot, Flutter, iOS/macOS, Android, React Native, Web) in your app, then capture screenshots, traverse the UI tree, inject taps and key events, and run automated test tasks on the physical device over a secure relay.
