{
  "markdown": "# WpfVisualTreeMcp\n\n<!-- mcp-name: io.github.faze79/wpf-visual-tree -->\n\n[![Build](https://github.com/faze79/WpfVisualTreeMcp/actions/workflows/build.yml/badge.svg)](https://github.com/faze79/WpfVisualTreeMcp/actions/workflows/build.yml)\n[![Release](https://img.shields.io/github/v/release/faze79/WpfVisualTreeMcp)](https://github.com/faze79/WpfVisualTreeMcp/releases)\n[![.NET](https://img.shields.io/badge/.NET-8.0-512BD4)](https://dotnet.microsoft.com/)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green)](https://modelcontextprotocol.io/)\n\n> **Let AI agents see, debug and drive running WPF apps.** Snoop + Playwright for AI, exposed over the Model Context Protocol — visual tree, data bindings, screenshots, clicks, text input and keyboard, against any running WPF process, no source changes needed.\n\n![Demo: an AI agent drives a WPF app and finds a binding bug](docs/assets/demo.gif)\n\n*An AI agent queries controls by visible text, fills the form, selects a list item, clicks Submit — then explains why the Status box stayed empty by pulling the app's binding errors. Every step is one MCP tool call (or CLI command).*\n\n## Quickstart (60 seconds)\n\n1. Download and extract the [latest release](https://github.com/faze79/WPFVisualTreeMcp/releases) zip (requires the [.NET 8 Desktop Runtime](https://dotnet.microsoft.com/download/dotnet/8.0)).\n2. Register it in your MCP client — for Claude Code, add to `.mcp.json`:\n   ```json\n   {\n     \"mcpServers\": {\n       \"wpf-visual-tree\": {\n         \"command\": \"C:/path/to/WpfVisualTreeMcp.Server.exe\",\n         \"args\": []\n       }\n     }\n   }\n   ```\n3. Ask your agent: *\"Look at my running WPF app and tell me why the Save button is disabled.\"*\n\nPrefer the terminal? The same exe is a full CLI: `WpfVisualTreeMcp.Server.exe help`.\n\n## Overview\n\n**WpfVisualTreeMcp** is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that allows AI coding agents (Claude Code, Cursor, GitHub Copilot) to inspect and interact with running WPF applications. Think of it as giving your AI assistant the same capabilities as tools like [Snoop WPF](https://github.com/snoopwpf/snoopwpf) or Visual Studio's Live Visual Tree.\n\n### Why This Matters\n\nDebugging WPF UI issues traditionally requires manual inspection with specialized tools. This project bridges that gap by exposing WPF inspection capabilities through MCP, enabling AI agents to:\n\n- **Understand UI structure** during code reviews\n- **Diagnose binding errors** automatically\n- **Suggest fixes** for layout issues\n- **Assist with UI refactoring** tasks\n- **Analyze visual tree hierarchies** in real-time\n\n## Features\n\n### Core Inspection\n- **Process Discovery** - List all running WPF applications available for inspection\n- **Visual Tree Navigation** - Traverse the complete visual tree hierarchy\n- **Logical Tree Access** - Navigate the logical tree structure\n- **Property Inspection** - Read all dependency properties of any UI element\n\n### Binding & Resources\n- **Binding Analysis** - Inspect bindings with converter, StringFormat, FallbackValue, MultiBinding support\n- **DataContext Inspection** - View DataContext type, properties, INPC status, and inheritance chain\n- **Binding Error Detection** - Automatically capture and report binding errors with classification\n- **Resource Enumeration** - Browse resource dictionaries at any scope\n- **Style Inspection** - View applied styles and templates\n\n### Search & Monitoring\n- **Element Search** - Find elements by type, name, or property values\n- **Deep Search** - Search entire tree including AdornerLayer and Popup elements\n- **Property Watching** - Monitor property changes in real-time\n\n### Interaction & Export\n- **Screenshot Capture** - Capture window/element screenshots visible to AI agents\n- **Element Highlighting** - Visually highlight elements in the running app\n- **Control Click** *(v0.4.0)* - Click elements via UI Automation (`Invoke`/`Toggle`/`Select`/`ExpandCollapse`) or a real OS mouse click\n- **Set Text** *(new in v0.5.0)* - Fill a TextBox/ComboBox/PasswordBox via UI Automation `IValueProvider.SetValue`, with a `TextBox.Text` / `PasswordBox.Password` / reflected-`Text` fallback, or `physical=true` to type via OS keyboard input (full Unicode BMP)\n- **Send Keys** *(new in v0.5.0)* - Send keyboard shortcuts (`Ctrl+S`, `Alt+F4`, `F5`, `Enter`, `Ctrl+Shift+F`, ...) to an element or the focused window via OS keyboard input\n- **Layout Information** - Get detailed layout metrics\n- **Tree Export** - Export visual tree to XAML or JSON format\n- **Auto-Injection** - Inject Inspector into running WPF processes (no source changes needed); **multi-architecture** since v0.6.0 — a 64-bit server can inject into 32-bit WPF apps via a bundled `WpfInjectorHelper.exe`\n\n### Dual-Mode CLI *(new in v0.4.0)*\nThe same `WpfVisualTreeMcp.Server.exe` runs as either an MCP stdio server\n(no arguments, default) or as a **one-shot CLI** (any recognised subcommand).\nUseful when the MCP server isn't connected, for scripting, and for verifying\nthe pipeline manually. Run `WpfVisualTreeMcp.Server.exe help` for the full\ncommand list. Output is JSON on stdout; diagnostics go to stderr.\n\n## How it compares\n\n**vs. the general tool categories:**\n\n| | **WpfVisualTreeMcp** | [Snoop](https://github.com/snoopwpf/snoopwpf) | [FlaUI](https://github.com/FlaUI/FlaUI) / WinAppDriver | Generic computer-use (screenshot + mouse) |\n|---|---|---|---|---|\n| Consumer | **AI agents (MCP) + humans (CLI)** | Humans (GUI) | Test code (C#) | AI agents |\n| Visual tree, dependency properties | ✅ | ✅ | ❌ (UIA view only) | ❌ |\n| Data bindings, binding errors, DataContext | ✅ | ✅ | ❌ | ❌ |\n| Find controls by visible text / properties | ✅ | manual | partial (UIA) | pixel guessing |\n| Click / type / select / shortcuts | ✅ | ❌ | ✅ | ✅ (blind) |\n| Wait for UI conditions (no sleep loops) | ✅ | ❌ | ✅ | ❌ |\n| Element screenshots + popup-aware screen capture | ✅ | ❌ | partial | full screen only |\n| Works without target source changes | ✅ (auto-injection) | ✅ | ✅ | ✅ |\n\n**vs. other WPF MCP servers.** Most WPF MCP servers are built on **UI Automation** (FlaUI): they read the *accessibility* tree, and can only reach WPF internals — bindings, DataContext, ViewModel state — if you **install their in-process probe into the app you want to inspect**. This server takes the Snoop route instead: it **injects at runtime**, so it reads the *real* visual tree and diagnoses binding errors and DataContext **with zero changes to the target app** — nothing to add to your build, nothing to ship into production.\n\n| | **WpfVisualTreeMcp** | UIA-based servers (FlaUI) | Other injection-based servers |\n|---|---|---|---|\n| Sees the real visual tree (not just the UIA view) | ✅ injection | ❌ accessibility tree | ✅ |\n| Binding errors + DataContext **without a probe in the target** | ✅ | ❌ (needs in-process probe) | partial |\n| Interaction surface | click (UIA + physical, double/right), set-text w/ read-back, send-keys, **select-item (virtualized)** | click / type / select | usually invoke-only |\n| Wait for element conditions | ✅ `wpf_wait_for` | ✅ | ❌ |\n| Popup / dropdown / context-menu screenshots | ✅ screen mode | partial | screenshot only |\n| Cross-architecture injection (x64 ⇄ x86) | ✅ | n/a | ❌ |\n| Dual-mode: MCP server **and** one-shot CLI | ✅ | ❌ | ❌ |\n| Distribution | NuGet (`dnx`/tool) + official MCP registry | varies | varies |\n\nIn short: UIA-based tools see what accessibility exposes, and computer-use agents see pixels. This project gives the agent **the same insider view a WPF developer has in Snoop — with no probe to install in the target app** — plus the widest set of hands to act on it, over a protocol every AI coding tool speaks.\n\n## Installation\n\n### Prerequisites\n\n- Windows 10/11\n- [.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) or later\n- A WPF application to inspect\n\n### Installation\n\n#### Option 1: .NET tool / NuGet (Recommended)\n\n```bash\ndotnet tool install -g WpfVisualTreeMcp     # installs the `wpfinspect` command\n```\n\nThe package is also published as an **MCP server package** (`PackageType: McpServer`),\nso MCP clients that support NuGet-hosted servers can launch it directly:\n\n```bash\ndnx WpfVisualTreeMcp                        # runs the MCP stdio server\n```\n\n#### Option 2: Download Release\n\nDownload the latest release from [GitHub Releases](https://github.com/faze79/WpfVisualTreeMcp/releases):\n\n1. Download `WpfVisualTreeMcp-vX.X.X-win-x64.zip`\n2. Extract to a folder (e.g., `C:\\Tools\\WpfVisualTreeMcp`)\n3. The MCP server executable is `WpfVisualTreeMcp.Server.exe`\n\n#### Option 3: Build from Source\n\n```bash\ngit clone https://github.com/faze79/WpfVisualTreeMcp.git\ncd WpfVisualTreeMcp\ndotnet build -c Release\n```\n\n### Configuration\n\nThe server uses the **official Microsoft/Anthropic MCP SDK for .NET**, providing guaranteed compatibility with Claude Code and other MCP clients.\n\n#### Claude Code\n\n**Option 1: Command Line (Recommended)**\n\nUse the `claude mcp add` command to add the server directly:\n\n```bash\n# Add to current project only\nclaude mcp add wpf-visual-tree -- C:/path/to/WpfVisualTreeMcp/publish/WpfVisualTreeMcp.Server.exe\n\n# Add globally (available in all projects)\nclaude mcp add --scope user wpf-visual-tree -- C:/path/to/WpfVisualTreeMcp/publish/WpfVisualTreeMcp.Server.exe\n```\n\nYou can verify the server was added:\n```bash\nclaude mcp list\n```\n\n**Option 2: Project-level JSON Configuration**\n\nCreate or edit `.mcp.json` in your project root:\n\n```json\n{\n  \"mcpServers\": {\n    \"wpf-visual-tree\": {\n      \"command\": \"C:/path/to/WpfVisualTreeMcp/publish/WpfVisualTreeMcp.Server.exe\",\n      \"args\": []\n    }\n  }\n}\n```\n\n**Option 3: Global JSON Configuration**\n\nAdd to `~/.claude/settings.json`:\n\n```json\n{\n  \"mcpServers\": {\n    \"wpf-visual-tree\": {\n      \"command\": \"C:/path/to/WpfVisualTreeMcp/publish/WpfVisualTreeMcp.Server.exe\",\n      \"args\": []\n    }\n  }\n}\n```\n\n**Important Notes:**\n- Use absolute paths to the built `.exe` file\n- Use forward slashes (`/`) in paths on Windows\n- Build in Release mode for production: `dotnet build -c Release`\n- Restart Claude Code after configuration changes\n\n#### Cursor\n\nAdd to your Cursor settings (`.cursor/mcp.json`):\n\n```json\n{\n  \"mcpServers\": {\n    \"wpf-visual-tree\": {\n      \"command\": \"C:/path/to/WpfVisualTreeMcp/publish/WpfVisualTreeMcp.Server.exe\",\n      \"args\": []\n    }\n  }\n}\n```\n\n### Self-Hosted Mode (Recommended)\n\nFor your WPF application to be inspectable, add a reference to the Inspector DLL and initialize it on startup:\n\n1. Add a project reference to `WpfVisualTreeMcp.Inspector`\n\n2. In your `App.xaml.cs`:\n\n```csharp\nusing System.Diagnostics;\nusing System.Windows;\nusing WpfVisualTreeMcp.Inspector;\n\npublic partial class App : Application\n{\n    protected override void OnStartup(StartupEventArgs e)\n    {\n        base.OnStartup(e);\n\n        // Initialize the WPF Visual Tree Inspector\n        InspectorService.Initialize(Process.GetCurrentProcess().Id);\n    }\n\n    protected override void OnExit(ExitEventArgs e)\n    {\n        InspectorService.Instance?.Dispose();\n        base.OnExit(e);\n    }\n}\n```\n\nThis enables the MCP server to connect to your application via named pipes for real-time inspection.\n\n## Usage Examples\n\n### List Running WPF Applications\n\n```\nUse the wpf_list_processes tool to show all running WPF applications.\n```\n\n### Attach and Inspect Visual Tree\n\n```\nAttach to the MyApp.exe WPF application and show me the visual tree of the main window.\n```\n\n### Find Binding Errors\n\n```\nCheck the attached WPF application for any binding errors and explain what's causing them.\n```\n\n### Search for Elements\n\n```\nFind all Button elements in the visual tree that have IsEnabled set to false.\n```\n\n### Export Visual Tree\n\n```\nExport the visual tree of the current window to JSON format so I can analyze the structure.\n```\n\n## Architecture\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│                    AI Agent (Claude Code)                    │\n└─────────────────────────┬───────────────────────────────────┘\n                          │ MCP Protocol (stdio)\n                          ▼\n┌─────────────────────────────────────────────────────────────┐\n│                 WpfVisualTreeMcp Server                      │\n│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────┐  │\n│  │   MCP Handler   │  │  Tree Navigator │  │   Injector  │  │\n│  │  (Tools/Res.)   │  │   & Inspector   │  │   Manager   │  │\n│  └────────┬────────┘  └────────┬────────┘  └──────┬──────┘  │\n└───────────┼────────────────────┼───────────────────┼────────┘\n            │                    │                   │\n            └────────────────────┼───────────────────┘\n                                 │ Named Pipes / IPC\n                                 ▼\n┌─────────────────────────────────────────────────────────────┐\n│                   Target WPF Application                     │\n│  ┌─────────────────────────────────────────────────────────┐│\n│  │              Injected Inspector DLL                      ││\n│  │  • VisualTreeHelper access                              ││\n│  │  • LogicalTreeHelper access                             ││\n│  │  • Property/Binding inspection                          ││\n│  │  • Resource dictionary enumeration                      ││\n│  └─────────────────────────────────────────────────────────┘│\n└─────────────────────────────────────────────────────────────┘\n```\n\nFor detailed architecture documentation, see [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).\n\n## Available Tools\n\n| Tool | Description |\n|------|-------------|\n| `wpf_list_processes` | List all running WPF applications |\n| `wpf_attach` | Attach to a WPF application (supports `auto_inject` for DLL injection) |\n| `wpf_get_visual_tree` | Get the visual tree hierarchy (default depth: 25, max: 100) |\n| `wpf_get_element_properties` | Get all dependency properties of an element |\n| `wpf_find_elements` | Query elements by type, x:Name, **visible text**, property values and visibility; results include text, automation id, enabled/visible state and screen bounds |\n| `wpf_find_elements_deep` | Same query filters without result limit, across all windows including adorners/popups |\n| `wpf_capture_screenshot` | Capture a screenshot of the window or element (returns image); `mode='screen'` captures real on-screen pixels including open popups, dropdowns and context menus |\n| `wpf_get_bindings` | Get data bindings for an element (includes MultiBinding, converter, StringFormat) |\n| `wpf_get_binding_errors` | List all captured binding errors |\n| `wpf_clear_binding_errors` | Clear the captured binding errors list |\n| `wpf_get_data_context` | Get DataContext type, properties, INPC status, and inheritance chain |\n| `wpf_get_resources` | Enumerate resource dictionaries |\n| `wpf_get_styles` | Get applied styles and templates |\n| `wpf_watch_property` | Monitor a property for changes |\n| `wpf_evaluate_binding` | Explain **why** a property has its value — value source, and for bindings a hop-by-hop path resolution pinpointing where a broken binding fails |\n| `wpf_explain_triggers` | Evaluate Style **and ControlTemplate** triggers against the current state (condition, current value, active, setters) — 'why doesn't this trigger fire?'; and attribute a property's value to the style setter / active trigger that set it |\n| `wpf_snapshot` | Capture an element subtree's state (layout, visibility, brushes, text) under a label |\n| `wpf_diff` | Diff two snapshots — measure exactly what a change moved (property from→to, added/removed) |\n| `wpf_set_property` | **Live-edit** a dependency property at runtime (type-converted), to test a change without rebuilding. *State-changing, reversible.* |\n| `wpf_revert_property` | Undo `wpf_set_property` edits (one, filtered, or all) — restores the prior binding/value/default. |\n| `wpf_highlight_element` | Visually highlight an element |\n| `wpf_click_element` | **Click a control** — UI Automation invoke (`Invoke`/`Toggle`/`Select`/`ExpandCollapse`) by default, `physical=true` for a real OS mouse click (auto-scrolls into view), `click_type='double'/'right'` for double/right clicks. *State-changing.* |\n| `wpf_select_item` | **Select an item** in a ComboBox/ListBox/ListView/TabControl by visible text or index — works with virtualized items. *State-changing.* |\n| `wpf_wait_for` | **Wait** until an element is visible/exists/enabled/hidden, polling in the target app — no sleep-and-retry loops. |\n| `wpf_set_text` | **Set text/value** of a TextBox/ComboBox/PasswordBox — UI Automation `IValueProvider.SetValue` by default, `physical=true` to type via OS keyboard input. *State-changing.* |\n| `wpf_send_keys` | **Send a keyboard shortcut** (`Ctrl+S`, `Alt+F4`, `F5`, `Enter`, ...) to an element or the focused window. *State-changing.* |\n| `wpf_get_layout_info` | Get layout information |\n| `wpf_export_tree` | Export visual tree to XAML or JSON |\n\nFor complete tool documentation, see [docs/TOOLS_REFERENCE.md](docs/TOOLS_REFERENCE.md).\n\n## Roadmap\n\n### Phase 1: Core Inspection ✅\n- [x] Project structure and architecture\n- [x] Process discovery and enumeration\n- [x] Basic process attachment\n- [x] Visual tree navigation\n- [x] Property inspection\n- [x] Element search\n\n### Phase 2: Advanced Features ✅\n- [x] IPC communication via named pipes\n- [x] Binding analysis and error detection\n- [x] Resource dictionary enumeration\n- [x] Style and template inspection\n- [x] Property change monitoring (with notifications)\n\n### Phase 3: Interaction & Diagnostics ✅\n- [x] Element highlighting overlay\n- [x] XAML/JSON export\n- [x] Screenshot capture (returns MCP `ImageContentBlock`)\n- [x] DLL auto-injection into running WPF processes (x64/x86)\n- [x] AdornerLayer and Popup visual tree traversal\n\n### Phase 4: CLI + Driving the App ✅ *(v0.4.0 / v0.5.0)*\n- [x] Dual-mode executable (MCP stdio + one-shot CLI) *(v0.4.0)*\n- [x] Control click via UI Automation patterns *(v0.4.0)*\n- [x] Physical OS mouse click as opt-in fallback *(v0.4.0)*\n- [x] User-level Claude Code skill bundling the CLI *(v0.4.0)*\n- [x] Set text/value via UI Automation `IValueProvider` + fallbacks *(v0.5.0)*\n- [x] Physical keyboard typing with Unicode BMP support *(v0.5.0)*\n- [x] Keyboard shortcuts (`Ctrl+S`, `Alt+F4`, `F5`, ...) via OS input *(v0.5.0)*\n\n### Phase 5: Multi-architecture ✅ *(v0.6.0)*\n- [x] Cross-bitness auto-injection (64-bit server → 32-bit target)\n- [x] Architecture-matching `WpfInjectorHelper.exe` (32-bit .NET 8)\n- [x] Removes v0.5.0 known limitation; both x86 and x64 WPF apps drivable\n\n### Phase 6: Query engine & full driving ✅ *(v0.7.0)*\n- [x] Query elements by visible text, property values, visibility\n- [x] Enriched results: text, automation id, enabled/visible state, screen bounds\n- [x] `wpf_select_item` — select in ComboBox/ListBox/TabControl by text or index\n- [x] Double / right click; scroll-into-view before physical input\n- [x] Screen-mode screenshots (popups, dropdowns, context menus visible)\n- [x] Set-text read-back verification; weak element-handle cache\n- [x] Critical IPC serialization fix (request parameters were silently dropped)\n\n### Phase 7: Distribution & agent ergonomics ✅ *(v0.7.1 / v0.8.0)*\n- [x] NuGet package, installable via `dnx` / `dotnet tool install` (MCP server package type)\n- [x] Published to nuget.org (trusted publishing / OIDC) and the official MCP registry\n- [x] Binding-error capture fixed (was never wired up), IPC parameter-drop fix\n- [x] `wpf_wait_for` — wait for an element/condition, no sleep-and-retry loops\n- [x] Concurrent IPC connections (a long wait no longer blocks other commands)\n\n### Next up\n\nThe \"change → measure → is it effective?\" loop is complete: live-edit a property, then\ndiff a before/after snapshot to see exactly what moved.\n\n- [x] `wpf_set_property` / `wpf_revert_property` — live-edit a dependency property, then undo *(v0.9.0)*\n- [x] `wpf_snapshot` / `wpf_diff` — before/after snapshot to verify a change's effect *(v0.10.0)*\n- [x] `wpf_evaluate_binding` — explain why a property has its value; resolve a binding path hop-by-hop *(v0.11.0)*\n- [ ] `wpf_record` → `wpf_export_test` — record a driven workflow, export an xUnit + driver test\n- [ ] Inspector-only NuGet package for self-hosted mode (reference instead of injection)\n- [ ] Streaming binding-error / property-change notifications to the MCP client\n- [ ] WinUI 3 support\n\n**See [docs/ROADMAP.md](docs/ROADMAP.md) for the full prioritized plan** (rationale,\ndesign notes, effort, and suggested sequencing).\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request.\n\n### Development Setup\n\n1. Clone the repository:\n   ```bash\n   git clone https://github.com/faze79/WpfVisualTreeMcp.git\n   cd WpfVisualTreeMcp\n   ```\n\n2. Open in Visual Studio 2022 or VS Code:\n   ```bash\n   code .\n   # or\n   start WpfVisualTreeMcp.sln\n   ```\n\n3. Build and run tests:\n   ```bash\n   dotnet build\n   dotnet test\n   ```\n\n4. Run the sample WPF app for testing:\n   ```bash\n   dotnet run --project samples/SampleWpfApp\n   ```\n\n### Project Structure\n\n```\nWpfVisualTreeMcp/\n├── src/\n│   ├── WpfVisualTreeMcp.Server/        # MCP Server (.NET 8) - Uses official MCP SDK\n│   │   ├── Program.cs                  # Server initialization with MCP SDK\n│   │   ├── WpfTools.cs                 # 20 WPF tools (17 inspection + click/set-text/send-keys)\n│   │   ├── Cli/CliRunner.cs            # One-shot CLI front-end (v0.4.0)\n│   │   └── Services/                   # Process & IPC management\n│   ├── WpfVisualTreeMcp.Inspector/     # Injected DLL (.NET Framework 4.8)\n│   ├── WpfVisualTreeMcp.Injector/      # Managed injection logic (CreateRemoteThread; net48 + net8.0)\n│   ├── WpfVisualTreeMcp.InjectorHelper/# x86 .NET 8 helper exe for cross-arch injection (v0.6.0)\n│   ├── WpfVisualTreeMcp.Bootstrapper/  # Native C++ DLL for CLR hosting\n│   └── WpfVisualTreeMcp.Shared/        # Shared models & IPC contracts\n├── samples/\n│   └── SampleWpfApp/                   # Test application\n├── tests/\n│   └── WpfVisualTreeMcp.Tests/         # Unit tests (48 tests)\n├── publish/                            # Published server + native DLLs\n│   └── native/{x64,x86}/              # Architecture-specific bootstrapper\n└── docs/                               # Documentation\n```\n\n### Technical Details\n\n- **MCP SDK**: Built with the [official C# MCP SDK](https://github.com/modelcontextprotocol/csharp-sdk) from Microsoft/Anthropic\n- **Protocol**: JSON-RPC 2.0 over stdio transport\n- **Target Framework**: .NET 8.0 (Server) / .NET Framework 4.8 + .NET 8.0-windows (Inspector, dual-target)\n- **IPC**: Named Pipes for server-to-application communication\n- **Tools**: 28 tools auto-discovered via `[McpServerTool]` attributes (22 read-only inspection incl. `wpf_wait_for`, `wpf_snapshot`, `wpf_diff`, `wpf_evaluate_binding`, `wpf_explain_triggers` + 6 state-changing: `wpf_click_element`, `wpf_select_item`, `wpf_set_text`, `wpf_send_keys`, `wpf_set_property`, `wpf_revert_property`)\n- **CLI**: same executable runs as one-shot CLI when given a subcommand (`Program.cs` routes via `CliRunner.IsCliCommand`)\n\n## Acknowledgments\n\n- Inspired by [Snoop WPF](https://github.com/snoopwpf/snoopwpf) - the original WPF spy utility\n- Built on the [Model Context Protocol](https://modelcontextprotocol.io/) by Anthropic\n- Thanks to the .NET and WPF community\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n",
  "bytes": 23532,
  "sha": "506e2efdb1b793890acba2b4dc4c9d30a58cd83842c2986a49bd6d2559f867bf",
  "repo_slug": "faze79/wpfvisualtreemcp",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/mcp_io_github_faze79_wpf_visual_tree_7397b4bc/readme"
}