vitaminmcp 3.2.0 → 3.2.1

package/checksums.json

@@ -1,14 +1,14 @@
 {
-  "version": "3.2.0",
+  "version": "3.2.1",
   "jars": {
-    "mcp-server.jar": "19e54259d2afb5171b6af61fb9b5e8dc41178807eef9886b0105568cab26cab6"
+    "mcp-server.jar": "b9af85303677bfe1e792259c5efab2763bd0fbafa12c1d468f7b034c563ba021"
   },
   "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": "0932bb6677cf9ff8657905a193e8f36f2943a4bba2b1597817f7ac192b575524",
+    "bot-runner-linux-x64": "a488c2f97c8c63f46bfb40e192af6939d3f49af1c61426974eb36cc3688a4db4",
+    "bot-runner-linux-arm64": "492fb73d79fd8db5d391567eb5b093c8f48bbd39b9bd669061c30c10dafc829f",
+    "bot-runner-darwin-x64": "b5fa212b25d001938384015fb22d5168977974d38105746b2c3a7a2b73aabd09",
+    "bot-runner-darwin-arm64": "e426feeac28baea547f5010ac47a33f50c401419bce258c4492408a87eec83bd",
     "bot-runner-viewer-win-x64.tgz": "e39a36cdf92b9223aa7c9610f8231afc7a577e8ed007bc3571895bd945baf3e1"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitaminmcp",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "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/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 };
+}