Skip to content
Back to search

bedmcp

MarketplaceWorks with Claude CodeGitHub

bedmcp: test Minecraft Bedrock add-ons in the real game from Claude Code.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/senyugamer--bedmcp/badge.svg)](/listings/senyugamer--bedmcp)

HTML

<a href="/listings/senyugamer--bedmcp"><img src="/api/listings/senyugamer--bedmcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

As a Claude Code plugin (MCP server + skill):

/plugin marketplace add SenyuGamer/bedmcp
/plugin install bedmcp@bedmcp

Then restart Claude Code (or run `/reload-plugins`), open your add-on's folder and ask Claude to run `setup_check`. It lists what bedmcp found and the fix for anything missing.

Or by hand, without the plugin:

git clone https://github.com/SenyuGamer/bedmcp
cd bedmcp
npm install
claude mcp add bedmcp --scope user -- node <path to bedmcp>\src\index.mjs

(Copy `skills/live-test` into your project's `.claude/skills/` to get the skill.)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 12 lines
  1. {
  2. "name": "bedmcp",
  3. "owner": { "name": "SenyuGamer" },
  4. "description": "bedmcp: test Minecraft Bedrock add-ons in the real game from Claude Code.",
  5. "plugins": [
  6. {
  7. "name": "bedmcp",
  8. "source": "./",
  9. "description": "Real-game test loop for Minecraft Bedrock add-ons (Windows, Be.D.D. + LeviLamina)."
  10. }
  11. ]
  12. }
README.md · README · 178 lines
  1. # bedmcp
  2. Let Claude test your Minecraft Bedrock add-on **in the real game**.
  3. bedmcp is an MCP server for Claude Code. It runs a real Minecraft Bedrock client in the background
  4. (through [Be.D.D.](https://github.com/LiteLDev/BeDD)) and a local test server (Bedrock Dedicated
  5. Server + [LeviLamina](https://github.com/LiteLDev/LeviLamina)). Claude can then:
  6. - rebuild your packs, reload scripts and rejoin the world in about 10 s;
  7. - read the screen as text, click menus and forms, type, take screenshots;
  8. - move, look, use items and blocks, run server commands, read the logs;
  9. - add bot players (GameTest simulated players) to test multiplayer logic with one client.
  10. Each Claude session gets its own client, its own server and its own copy of your world, so several
  11. chats can test at once. Your project's files and world are never changed.
  12. It also ships a skill, `live-test`, that tells Claude which cycle to use for which change.
  13. ## Requirements
  14. - **Windows 10/11** and **Node.js 22+**.
  15. - **Minecraft Bedrock 1.26.60 (GDK)**, owned and signed in.
  16. - **[LeviLauncher](https://github.com/LiteLDev/LeviLauncher) 1.1+**, with an instance of 1.26.60 that
  17. has **LeviLamina 26.60.x**. Start it once and sign in.
  18. - **[Be.D.D.](https://github.com/LiteLDev/BeDD/releases) 0.4+**: run `bedd-windows-x64-setup.exe`.
  19. bedmcp follows the game version Be.D.D. supports (1.26.60 for Be.D.D. 0.4). Disk: about 800 MB per
  20. client clone and 600 MB per test server (one of each per parallel session).
  21. ## Install
  22. As a Claude Code plugin (MCP server + skill):
  23. ```
  24. /plugin marketplace add SenyuGamer/bedmcp
  25. /plugin install bedmcp@bedmcp
  26. ```
  27. Then restart Claude Code (or run `/reload-plugins`), open your add-on's folder and ask Claude to run
  28. `setup_check`. It lists what bedmcp found and the fix for anything missing.
  29. Or by hand, without the plugin:
  30. ```
  31. git clone https://github.com/SenyuGamer/bedmcp
  32. cd bedmcp
  33. npm install
  34. claude mcp add bedmcp --scope user -- node <path to bedmcp>\src\index.mjs
  35. ```
  36. (Copy `skills/live-test` into your project's `.claude/skills/` to get the skill.)
  37. ## Your project
  38. Open Claude Code in your add-on's folder. Without any config bedmcp looks for:
  39. - **Packs**: every folder with a `manifest.json` up to 3 levels down (behavior packs: `data` or
  40. `script` modules; resource packs: `resources`).
  41. - **World**: the only world folder in `worlds/`.
  42. For anything else, add a `bedmcp.json` in the project root (see
  43. [bedmcp.example.json](bedmcp.example.json)). Every key is optional:
  44. | Key | What |
  45. |---|---|
  46. | `world` | the world to test in: a world folder (relative path), or a name in `worlds/` |
  47. | `behaviorPacks`, `resourcePacks` | pack folders, if the search above does not find the right ones |
  48. | `build` | build steps run by `build_packs` / `dev_cycle`: `[{ "cmd", "args", "cwd" }]` |
  49. | `serverProperties` | `server.properties` keys for the test server (`gamemode`, `difficulty` ...) |
  50. | `variants` | several games or maps in one repository (below) |
  51. The world needs the **Beta APIs** experiment if your scripts (or the bots) use beta modules.
  52. **BDS-style projects.** If the project folder is itself a server folder (`server.properties`,
  53. `development_behavior_packs`, `development_resource_packs`, `worlds/`), bedmcp uses it as it is: its
  54. world (`level-name`), its pack folders, its `config/` and its game settings. If you also run that
  55. server by hand, bedmcp sees it and never copies or touches the world while it runs.
  56. **Variants.** One repository with several games, each with its own world and settings:
  57. ```json
  58. "variants": {
  59. "lobby": { "label": "Lobby", "hint": "lobby map, code in src/lobby", "world": "worlds/Lobby" },
  60. "arena": { "label": "Arena", "world": "worlds/Arena",
  61. "properties": { "view-distance": "8" },
  62. "config": { "default/variables.json": { "mode": "ARENA" } } }
  63. }
  64. ```
  65. Claude passes `variant` on its first `dev_cycle`; only that session's test server is set up for it
  66. (`properties` go to its `server.properties`, `config` JSON is merged over the project's `config/`).
  67. ## Machine settings
  68. Optional, in `%USERPROFILE%\.bedmcp\config.json` (`BEDMCP_HOME` moves the folder; `BEDMCP_CONFIG`
  69. points to one file instead):
  70. | Key | Default |
  71. |---|---|
  72. | `bedd` | `%LOCALAPPDATA%\Programs\BeDD\BeDD.exe` |
  73. | `beddHome` | `%USERPROFILE%\.bedd` (Be.D.D.'s data: clones, servers) |
  74. | `stateDir` | `%USERPROFILE%\.bedd\bedmcp` (sessions, locks, world backups) |
  75. | `maxClients` | `3` parallel sessions |
  76. | `server` | `{ "name": "bedmcp", "port": 19140 }`; slot N uses `bedmcp-N` and port 19140 + 2(N-1) |
  77. | `hotMod` | `true` (BedmcpHot, below) |
  78. | `bots` | `true` (the bot pack) |
  79. | `projects` | `{ "<folder>": { ...bedmcp.json keys } }`, for projects you can't add a file to |
  80. ## Tools
  81. - Setup: `setup_check`, `server_sessions`
  82. - Loop: `dev_cycle` (build, reload, leave, rejoin, screenshot)
  83. - Server: `server_start`, `server_stop`, `server_restart`, `server_command`, `server_logs`, `build_packs`, `world_import`
  84. - Client: `game_launch`, `game_stop`, `game_status`, `game_join`, `game_leave`, `session_stop`, `pack_sync`
  85. - See: `screenshot`, `ui_read`, `wait_for_screen`, `player_state`, `entities`
  86. - Act: `ui_click`, `ui_type`, `ui_scroll`, `interact_block`, `teleport`, `look`, `move`, `hotbar`, `mouse_button`, `game_action`, `key`, `type_text`, `mouse`, `client_chat`, `release_input`
  87. - Multiplayer: `bot`
  88. - Anything else: `bedd_call` (a raw Be.D.D. WebSocket op)
  89. ## How it works
  90. - **One client and one server per session.** Every client clone signs in with the same Microsoft
  91. account, and a server that already had one clone of that account refuses another one. So each
  92. session (each Claude chat) claims a slot: client clone `<version>-N` and server `bedmcp-N`.
  93. - **Test servers.** The first is made with `BeDD.exe server init` on first use (BDS + LeviLamina +
  94. Be.D.D.'s server module, several minutes); the others are copies of it. bedmcp's
  95. [server.properties](server.properties) is applied on top (offline mode, NetherNet on 127.0.0.1).
  96. Servers run under Be.D.D., so they outlive the MCP; bedmcp stops them only with `stop` and never
  97. kills one (that can corrupt a world).
  98. - **Your packs** are linked (junctions), never copied: every build is live on every test server. In
  99. a non-BDS project they are linked one by one and turned on in the world copy.
  100. - **Your world** is copied fresh at every server start; the old copy is backed up to
  101. `stateDir\backups` (newest 10 per server).
  102. - **The client loads your resource packs from disk** (a link in the clone, listed as a global pack),
  103. so a join downloads nothing and every rejoin reloads them: an RP change is a leave + rejoin.
  104. - **Bots** are bedmcp's own behavior pack (`botpack/`), added to the test server's world copy only.
  105. Requests go through `/scriptevent bedmcp:bot`; the reply comes back as the output of the pack's
  106. custom command `/bedmcp:botreply`.
  107. ### BedmcpHot
  108. `mod/` is a small LeviLamina client mod that bedmcp installs into every clone. A leave + rejoin
  109. normally runs two full resource reloads: the title screen's packs on leave, the world's on join. The
  110. mod skips the first one, so a rejoin takes ~8 s instead of ~12 s. `"hotMod": false` turns it off.
  111. The built mod is in `mod/bin`. To build it (LLVM 22 on PATH, [xmake](https://xmake.io); the link step
  112. stores only the `.pdb` file name in the DLL, `/PDBALTPATH:%_PDB%`, so no build-machine path ships):
  113. ```
  114. cd mod
  115. xmake f -y -m release -p windows -a x64
  116. xmake -y
  117. ```
  118. ## Limits
  119. - Windows only, and one game version at a time (Be.D.D.'s).
  120. - Bots have no screen (no forms, HUD), no player properties, and their entity taps may not raise
  121. `playerInteractWithEntity`. They cover server logic, not what a second player sees.
  122. - One client per session: two real players on one server need two Microsoft accounts.
  123. ## Development
  124. ```
  125. node scripts/try.mjs # list the tools
  126. set BEDMCP_DAEMON_PORT=7788 && node scripts/daemon.mjs # one session; POST http://127.0.0.1:7788/<tool> with JSON
  127. curl -X POST http://127.0.0.1:7788/quit # end it: closes its client, stops its server
  128. ```
  129. ## License
  130. MIT ([LICENSE](LICENSE)). The built client mod contains header code of LeviLamina (LGPL-3.0),
  131. nlohmann/json and EnTT (MIT): see [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
  132. ## Credits
  133. Built on [Be.D.D.](https://github.com/LiteLDev/BeDD), [LeviLamina](https://github.com/LiteLDev/LeviLamina)
  134. and [LeviLauncher](https://github.com/LiteLDev/LeviLauncher) by LiteLDev. Not affiliated with Mojang or Microsoft.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.