vitaminmcp 3.2.0 → 3.2.2

package/checksums.json

@@ -1,14 +1,14 @@
 {
-  "version": "3.2.0",
+  "version": "3.2.2",
   "jars": {
-    "mcp-server.jar": "19e54259d2afb5171b6af61fb9b5e8dc41178807eef9886b0105568cab26cab6"
+    "mcp-server.jar": "ccc3d22de5b86b77acd3a253d406943a22c50226b8ca7cdfb5f103086ccfc520"
   },
   "assets": {
-    "bot-runner-win-x64.exe": "e79b3e4a3e5ce571d5f18f199265ef2bf2de4b94102fc537c48055687d93c501",
-    "bot-runner-linux-x64": "75ec38cbd3facd07734ab147ef3ac7feae4bcfa909b39e5d2baf422b5e52c044",
-    "bot-runner-linux-arm64": "f9f35216e07ff75f3f27729068af3afd40da1fb1b5126a92cfab512ae7fb8631",
-    "bot-runner-darwin-x64": "15116f74ac073944683de21c0ee4e91f87ad079edfeed12121c54547f84ac859",
-    "bot-runner-darwin-arm64": "bd71e5b21f5a33f81411f99a7137abb0663f355f6ef54e17504bb6087b965fc6",
+    "bot-runner-win-x64.exe": "8da5317732e3c1a3a3a7a41aeb1e075551a914c37ad3f46a8fd5c2f986d9313c",
+    "bot-runner-linux-x64": "8c54d6a84ea6b0da06ecaaf91bb1da7206a54f1a1ad6bd0ec8ee00f17e87e55e",
+    "bot-runner-linux-arm64": "70e2c29c63806d9692c8d9e531618d92b1326d5f1d242d2303c8a79aee637084",
+    "bot-runner-darwin-x64": "eac2673b2c12ad99c840e3d826a86956972a84a4f54750b116b7caf2a787065a",
+    "bot-runner-darwin-arm64": "3869506c398dfb05a46b760bf6d76a919107132274201db5439b003e05874907",
     "bot-runner-viewer-win-x64.tgz": "e39a36cdf92b9223aa7c9610f8231afc7a577e8ed007bc3571895bd945baf3e1"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitaminmcp",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "mcpName": "io.github.Backas03/vitaminmcp",
   "description": "MCP server for testing Minecraft plugins: drives a real Paper server and real protocol bots from an AI agent.",
   "keywords": [

package/runner/runner.mjs

@@ -6,6 +6,11 @@
  *
  *   node runner.mjs <host> <port> [protocol]
  *
+ * Without a protocol it pings the server. VITAMINMCP_SERVER_VERSION, when set, is the Minecraft
+ * version the agent reports, and it wins over a ping that disagrees (see `selectProtocol`). It is
+ * an environment variable rather than an argument so a runner and an MCP server of different
+ * releases still understand each other's command line.
+ *
  * Everything it prints on stdout is protocol. Diagnostics go to stderr, which the MCP server
  * inherits — a stray `console.log` here is a desynchronised session, not a stray log line.
  */
@@ -14,7 +19,7 @@ import { createInterface } from 'node:readline';
 import { BotRegistry } from './src/bots.mjs';
 import { Dispatch } from './src/dispatch.mjs';
 import * as protocol from './src/protocol.mjs';
-import { pingProtocol, versionForProtocol } from './src/version.mjs';
+import { pingProtocol, selectProtocol, versionForProtocol } from './src/version.mjs';
 
 // stdout is the protocol channel; a dependency's console.log (mineflayer did this on 26.1, with a
 // stack trace) desynchronises every later reply. `write` below is the only path to stdout.
@@ -32,10 +37,24 @@ async function main() {
   const host = argv[0];
   const port = Number(argv[1]);
 
+  const serverVersion = process.env.VITAMINMCP_SERVER_VERSION || undefined;
+
   let bots;
   let negotiated;
+  let pinged;
   try {
-    negotiated = argv.length > 2 ? Number(argv[2]) : await pingProtocol(host, port);
+    if (argv.length > 2) {
+      negotiated = Number(argv[2]);
+    } else {
+      ({ protocol: negotiated, pinged } = selectProtocol(await pingProtocol(host, port), serverVersion));
+    }
+    if (pinged !== undefined) {
+      process.stderr.write(
+        `The server-list ping answered protocol ${pinged}, but the agent reports Minecraft `
+          + `${serverVersion} (protocol ${negotiated}). Something in front of the server answered `
+          + `the ping, a proxy or ViaVersion; using ${negotiated}.\n`,
+      );
+    }
     bots = new BotRegistry(host, port, versionForProtocol(negotiated));
   } catch (error) {
     // The Java side reads this line and reports it as the reason the runner did not start, so it
@@ -45,7 +64,10 @@ async function main() {
     process.exit(1);
   }
 
-  write(protocol.encode(protocol.READY, String(negotiated)));
+  // A third field only when the ping disagreed, so the line a caller already parses is unchanged.
+  write(pinged === undefined
+    ? protocol.encode(protocol.READY, String(negotiated))
+    : protocol.encode(protocol.READY, String(negotiated), String(pinged)));
 
   const dispatch = new Dispatch(bots);
   const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });

package/runner/src/actions.mjs

@@ -141,26 +141,16 @@ function delay(millis) {
 /** Runs a command as the bot. The leading slash is not part of the packet. */
 export function command(bot, name, line) {
   requireInWorld(bot, name);
-  bot._client.write('chat_command', {
-    command: line.startsWith('/') ? line.slice(1) : line,
-    timestamp: BigInt(Date.now()),
-    salt: 0n,
-    argumentSignatures: [],
-    messageCount: 0,
-    acknowledged: Buffer.alloc(3),
-    checksum: 0,
-  });
+  bot.chat(line.startsWith('/') ? line : `/${line}`);
 }
 
-/**
- * Says something in chat.
- *
- * Through `/say`, exactly as the Java runner does it. A bot cannot send a signed chat message
- * without a Mojang key, and an unsigned one is refused from 1.19 on, so the command is the only
- * route that reaches the same listeners.
- */
+/** Sends player chat through the library's signing and acknowledgement implementation. */
 export function chat(bot, name, message) {
-  command(bot, name, `say ${message}`);
+  requireInWorld(bot, name);
+  if (message.startsWith('/')) {
+    throw new Error('Use the command action for slash commands; chat sends player chat.');
+  }
+  bot.chat(message);
 }
 
 /** Right-clicks a block — which is how a container or a plugin menu gets opened. */

package/runner/src/version.mjs

@@ -76,3 +76,39 @@ export function versionForProtocol(protocol) {
       .join(', ')}). It supports ${mc.supportedVersions.join(', ')}.`,
   );
 }
+
+/**
+ * The protocol a Minecraft version speaks, from minecraft-data's table of every release it has
+ * heard of. That table is wider than the versions it carries data for, so a release the runner
+ * cannot speak yet still has a number here.
+ */
+export function protocolForVersion(minecraftVersion) {
+  return minecraftData.versionsByMinecraftVersion?.pc?.[minecraftVersion]?.version;
+}
+
+/**
+ * Which protocol to speak: the one the agent says its server runs, over the one the ping answered.
+ *
+ * A ping is answered by whatever holds the port, and two common things answer it with the
+ * protocol the ping was written in rather than the server's own: a proxy that echoes it, and
+ * ViaVersion with ViaBackwards, which rewrites the status reply to the client's protocol whenever
+ * it can translate. The ping is written in PING_VERSION, so either one made the runner join as
+ * 1.21.1 — on a 26.x server, through a chain of translations, without a word. The agent runs inside
+ * the server, and nothing answers for it.
+ *
+ * Without a version from the agent the ping decides, as it always did. `pinged` is returned only
+ * when the two disagree, so the caller can say so.
+ */
+export function selectProtocol(pinged, serverVersion) {
+  if (!serverVersion) {
+    return { protocol: pinged };
+  }
+  const declared = protocolForVersion(serverVersion);
+  if (declared === undefined) {
+    throw new Error(
+      `The agent reports Minecraft ${serverVersion}, which this runner's minecraft-data does not `
+        + 'know: the dependency is older than the server.',
+    );
+  }
+  return declared === pinged ? { protocol: declared } : { protocol: declared, pinged };
+}