# Rider Debug

> Claude Code skill + CLI that lets an AI agent drive Rider's MCP debugger to debug a running Unity Editor at runtime, no session restart needed.

- **Type:** MCP server
- **Install:** `agentstack add mcp-yhc509-rider-debug`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [yhc509](https://agentstack.voostack.com/s/yhc509)
- **Installs:** 0
- **Category:** [Developer Tools](https://agentstack.voostack.com/c/developer-tools)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [yhc509](https://github.com/yhc509)
- **Source:** https://github.com/yhc509/rider-debug

## Install

```sh
agentstack add mcp-yhc509-rider-debug
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# rider-debug

A Claude Code skill + CLI that lets an AI agent drive Rider's MCP debugger
against a running Unity Editor — set breakpoints, inspect variables, step
execution — without restarting the agent session.

## Why

Two questions I wanted to answer:

1. Can an agent automate debugging on its own?
2. Can an agent *prove a hypothesis* by stepping through a live process,
   instead of only reading the code?

This is personal R&D. I haven't leaned on it in production work yet — most of
the bugs I hit there are hard to reproduce and the per-session token cost is
high. I expect to actually use it in my own side projects when the chance
comes up.

## Design notes

It's a thin wrapper over the [Debugger MCP Server][plugin] plugin, but the
wrapping is the point:

- **No MCP registration.** A registered MCP server loads its tool definitions
  into context and has to be active — and activating one mid-session means
  starting a new session. This connects to the debugger over SSE + JSON-RPC on
  demand, so the agent can start debugging in the session it's already in.
- **Token-filtered output at the CLI layer.** Variable dumps and tool catalogs
  are condensed before they reach the model (`get_vars --simple --names=...`, a
  24h schema cache), so a debugging loop doesn't burn context.

This is the same idea Anthropic describes in
[Code execution with MCP][anthropic]: wrap MCP tools in code so their
definitions aren't all loaded upfront and intermediate results are filtered
before they hit the model context.

## What's mine vs. what it depends on

- **Depends on:** the [Debugger MCP Server][plugin] plugin — the actual
  debugger engine (breakpoints, variable reads, execution control). Note the
  plugin lists Rider as *untested*; this skill wires it to a Rider + Unity
  setup, which is where the limitation below surfaced.
- **What's here:** a spec-compliant SSE + JSON-RPC client, the on-demand
  connection that skips MCP registration, output filtering / schema caching,
  and convenience wrappers (batch breakpoints, variable name filters).

## Usage

```bash
python3 rider-cli check                                   # connectivity check
python3 rider-cli list_tools                              # tool list (24h cache)
python3 rider-cli  '{"key":"val"}'                  # call a debugger tool
```

Typical flow:

1. `check` → if it errors, make sure Rider is running with the Debugger MCP
   Server plugin.
2. `list_run_configurations` → `start_debug_session '{"configuration":"Attach to Unity Editor"}'`
3. `set_breakpoint '{"project_path":"...","file_path":"...","line":42}'`
   (conditional: add `"condition":"..."`, logpoint: add `"log_message"` +
   `"suspend_policy":"none"`, batch: `batch_breakpoint '[...]'`)
4. On hit: `get_vars '{"session_id":"ID"}' --simple --names=foo,bar`,
   `get_stack_trace`
5. Control: `resume_execution`, `step_over`, `step_into`, `step_out`
6. Cleanup: `remove_breakpoint`, `stop_debug_session`

See [`SKILL.md`](SKILL.md) for the full agent-facing instructions.

## Limitations

- `evaluate_expression` / `set_variable` time out against Unity. Workaround:
  read with `get_variables`, edit in the Rider UI, or use logpoints
  (`log_message` + `suspend_policy:"none"`).

## License

[Apache 2.0](LICENSE).

[plugin]: https://plugins.jetbrains.com/plugin/29233-debugger-mcp-server
[anthropic]: https://www.anthropic.com/engineering/code-execution-with-mcp

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [yhc509](https://github.com/yhc509)
- **Source:** [yhc509/rider-debug](https://github.com/yhc509/rider-debug)
- **License:** Apache-2.0

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-yhc509-rider-debug
- Seller: https://agentstack.voostack.com/s/yhc509
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.