fix(test): move MCP smoke test to manual suite; harden unobfuscated detection

- Move __tests__/mcp/stdio-server-smoke.test.ts into __tests__/manual/mcp/
  so heavy decompile-on-first-run tests are excluded from the default npm
  test run; remove the now-redundant test:mcp:e2e script
- Fix misleading timeout comment on the unobfuscated-yarn throw test
  (throws before any JAR download, only needs a version JSON fetch)
- Add UNOBFUSCATED_VERSION_OVERRIDES escape hatch in VersionManager for
  future Mojang metadata anomalies
- Simplify isVersionUnobfuscated to time-gate only; drop the redundant
  version-id regex guard (client_mappings check + cutoff is sufficient)
- Extend version-manager tests to cover the exact 26.1-snapshot-1 boundary
  and a newer snapshot (26.1-snapshot-9)
- Refactor stdio-matrix test constants to a flat version list; classify
  obfuscated vs unobfuscated at runtime via isVersionUnobfuscated() rather
  than a hardcoded version-id pattern

Author: GhostTypes

__tests__/core/remap-service.test.ts

@@ -382,7 +382,7 @@ describe('JAR Remapping', () => {
       await expect(remapService.getRemappedJar(UNOBFUSCATED_TEST_VERSION, 'yarn')).rejects.toThrow(
         /yarn mappings are not supported for unobfuscated/i,
       );
-    }, 60000); // includes client JAR download on first run
+    }, 60000); // network call to fetch version JSON on first run
 
     it('should throw a clear error when requesting intermediary mappings for an unobfuscated version', async () => {
       const remapService = getRemapService();

__tests__/core/version-manager.test.ts

@@ -58,5 +58,17 @@ describe('Version Management', () => {
       const result = await versionManager.isVersionUnobfuscated(UNOBFUSCATED_TEST_VERSION);
       expect(result).toBe(true);
     }, 30000);
+
+    it('should return true for first unobfuscated boundary version (26.1-snapshot-1)', async () => {
+      const versionManager = getVersionManager();
+      const result = await versionManager.isVersionUnobfuscated('26.1-snapshot-1');
+      expect(result).toBe(true);
+    }, 30000);
+
+    it('should return true for newer unobfuscated snapshot versions (26.1-snapshot-9)', async () => {
+      const versionManager = getVersionManager();
+      const result = await versionManager.isVersionUnobfuscated('26.1-snapshot-9');
+      expect(result).toBe(true);
+    }, 30000);
   });
 });

__tests__/manual/README.md

@@ -81,6 +81,9 @@ Example:
 cross-env MCP_E2E_VERSIONS=1.21.11,1.20.1,26.1-snapshot-1,26.1-snapshot-9 npm run test:manual:mcp
 ```
 
+Versions are classified at runtime using Mojang metadata via
+`VersionManager.isVersionUnobfuscated()`, not by hardcoded version-id patterns.
+
 Default matrix includes:
 - `1.21.11`
 - `1.21.10`

__tests__/manual/mcp/stdio-matrix.test.ts

@@ -4,9 +4,23 @@ import {
   createMcpSession,
   extractFirstText,
 } from '../../helpers/mcp-stdio.js';
+import { getVersionManager } from '../../../src/services/version-manager.js';
 import { parseMatrixVersionsFromEnv } from './test-constants.js';
 
-const { obfuscatedVersions, unobfuscatedVersions } = parseMatrixVersionsFromEnv();
+const matrixVersions = parseMatrixVersionsFromEnv();
+const unobfuscatedCache = new Map<string, boolean>();
+
+async function isUnobfuscatedVersion(version: string): Promise<boolean> {
+  const cached = unobfuscatedCache.get(version);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const versionManager = getVersionManager();
+  const result = await versionManager.isVersionUnobfuscated(version);
+  unobfuscatedCache.set(version, result);
+  return result;
+}
 
 /**
  * Manual matrix for true MCP stdio E2E validation.
@@ -45,8 +59,10 @@ describe('Manual MCP Stdio Matrix', () => {
     expect(resources.resources.length).toBeGreaterThan(0);
   }, 30000);
 
-  for (const version of obfuscatedVersions) {
-    it(`should decompile ${version} with yarn over stdio`, async () => {
+  for (const version of matrixVersions) {
+    it(`should enforce expected yarn behavior for ${version} over stdio`, async () => {
+      const unobfuscated = await isUnobfuscatedVersion(version);
+
       const result = await session.client.callTool(
         {
           name: 'decompile_minecraft_version',
@@ -60,21 +76,31 @@ describe('Manual MCP Stdio Matrix', () => {
         longRequest,
       );
 
-      expect(result.isError).not.toBe(true);
       const text = extractFirstText(result.content);
-      expect(text).toContain(version);
-      expect(text).toContain('yarn');
-      expect(text).toMatch(/completed|classes/i);
+      if (unobfuscated) {
+        expect(result.isError).toBe(true);
+        expect(text).toContain('mojmap');
+        expect(text).toMatch(/use ['"]mojmap['"] mapping/i);
+      } else {
+        expect(result.isError).not.toBe(true);
+        expect(text).toContain(version);
+        expect(text).toContain('yarn');
+        expect(text).toMatch(/completed|classes/i);
+      }
     }, 900000);
 
-    it(`should return Entity source for ${version} via stdio`, async () => {
+    it(`should return MinecraftServer source for ${version} using the expected mapping over stdio`, async () => {
+      const unobfuscated = await isUnobfuscatedVersion(version);
+      const mapping = unobfuscated ? 'mojmap' : 'yarn';
+      const className = 'net.minecraft.server.MinecraftServer';
+
       const result = await session.client.callTool(
         {
           name: 'get_minecraft_source',
           arguments: {
             version,
-            className: 'net.minecraft.entity.Entity',
-            mapping: 'yarn',
+            className,
+            mapping,
           },
         },
         undefined,
@@ -83,50 +109,7 @@ describe('Manual MCP Stdio Matrix', () => {
 
       expect(result.isError).not.toBe(true);
       const text = extractFirstText(result.content);
-      expect(text).toContain('class Entity');
+      expect(text).toContain('class MinecraftServer');
     }, 600000);
   }
-
-  for (const unobfuscatedVersion of unobfuscatedVersions) {
-    it(`should reject yarn for unobfuscated ${unobfuscatedVersion} over stdio`, async () => {
-      const result = await session.client.callTool(
-        {
-          name: 'decompile_minecraft_version',
-          arguments: {
-            version: unobfuscatedVersion,
-            mapping: 'yarn',
-            force: false,
-          },
-        },
-        undefined,
-        longRequest,
-      );
-
-      expect(result.isError).toBe(true);
-      const text = extractFirstText(result.content);
-      expect(text).toContain('mojmap');
-      expect(text).toMatch(/use ['"]mojmap['"] mapping/i);
-    }, 120000);
-
-    it(`should decompile unobfuscated ${unobfuscatedVersion} with mojmap over stdio`, async () => {
-      const result = await session.client.callTool(
-        {
-          name: 'decompile_minecraft_version',
-          arguments: {
-            version: unobfuscatedVersion,
-            mapping: 'mojmap',
-            force: false,
-          },
-        },
-        undefined,
-        longRequest,
-      );
-
-      expect(result.isError).not.toBe(true);
-      const text = extractFirstText(result.content);
-      expect(text).toContain(unobfuscatedVersion);
-      expect(text).toContain('mojmap');
-      expect(text).toMatch(/completed|classes/i);
-    }, 900000);
-  }
 });

__tests__/mcp/stdio-server-smoke.test.ts …__/manual/mcp/stdio-server-smoke.test.ts__tests__/mcp/stdio-server-smoke.test.ts renamed to __tests__/manual/mcp/stdio-server-smoke.test.ts __tests__/mcp/stdio-server-smoke.test.ts renamed to __tests__/manual/mcp/stdio-server-smoke.test.ts

@@ -1,41 +1,21 @@
-export const DEFAULT_OBFUSCATED_MATRIX_VERSIONS = [
+export const DEFAULT_MATRIX_VERSIONS = [
   '1.21.11',
   '1.21.10',
   '1.20.1',
   '1.19.4',
-] as const;
-export const DEFAULT_UNOBFUSCATED_MATRIX_VERSIONS = [
   '26.1-snapshot-1',
   '26.1-snapshot-8',
   '26.1-snapshot-9',
 ] as const;
 
-function isUnobfuscatedSnapshot(version: string): boolean {
-  return /^26\.1-snapshot-\d+$/.test(version);
-}
-
-export function parseMatrixVersionsFromEnv(): {
-  obfuscatedVersions: string[];
-  unobfuscatedVersions: string[];
-} {
+export function parseMatrixVersionsFromEnv(): string[] {
   const envList = process.env.MCP_E2E_VERSIONS?.trim();
   if (!envList) {
-    return {
-      obfuscatedVersions: [...DEFAULT_OBFUSCATED_MATRIX_VERSIONS],
-      unobfuscatedVersions: [...DEFAULT_UNOBFUSCATED_MATRIX_VERSIONS],
-    };
+    return [...DEFAULT_MATRIX_VERSIONS];
   }
 
-  const requested = envList
+  return envList
     .split(',')
     .map((value) => value.trim())
     .filter(Boolean);
-
-  const obfuscatedVersions = requested.filter((version) => !isUnobfuscatedSnapshot(version));
-  const unobfuscatedVersions = requested.filter(isUnobfuscatedSnapshot);
-
-  return {
-    obfuscatedVersions,
-    unobfuscatedVersions,
-  };
 }

__tests__/manual/mcp/test-constants.ts

@@ -15,7 +15,6 @@
     "inspect": "npm run build && npx @modelcontextprotocol/inspector node dist/index.js",
     "inspect:dev": "npx @modelcontextprotocol/inspector tsx src/index.ts",
     "test": "vitest",
-    "test:mcp:e2e": "vitest __tests__/mcp",
     "test:ui": "vitest --ui",
     "test:manual": "vitest --config vitest.manual.config.ts",
     "test:manual:mcp": "vitest --config vitest.manual.config.ts __tests__/manual/mcp",

package.json

@@ -13,6 +13,11 @@ export class VersionManager {
    * 26.1-snapshot-1 released at this timestamp and removed client obfuscation.
    */
   private static readonly UNOBFUSCATED_CUTOFF_MS = Date.parse('2025-12-16T12:42:29+00:00');
+  /**
+   * Emergency overrides for Mojang metadata anomalies.
+   * Keyed by exact version id from version JSON.
+   */
+  private static readonly UNOBFUSCATED_VERSION_OVERRIDES: Readonly<Record<string, boolean>> = {};
 
   private downloader = getMojangDownloader();
   private cache = getCacheManager();
@@ -151,30 +156,40 @@ export class VersionManager {
   /**
    * Check if a Minecraft version ships an unobfuscated JAR.
    *
-   * Starting with Minecraft 26.1 snapshots, Mojang stopped obfuscating the
-   * client JAR. These versions have no `client_mappings` entry in their
-   * version JSON because there is nothing to reverse-map.
+   * Mojang's authoritative signal is the presence/absence of `client_mappings`
+   * in the version JSON:
+   * - present: obfuscated client JAR (reverse mapping required)
+   * - absent: potentially unobfuscated client JAR
    *
    * Important: some older obfuscated versions (e.g. early 1.14.x) also lack
-   * `client_mappings` metadata, so missing metadata alone is not sufficient.
+   * `client_mappings` metadata, so we also gate by the known 26.1 cutover time.
    */
   async isVersionUnobfuscated(version: string): Promise<boolean> {
     const versionJson = await this.downloader.getVersionJson(version);
+
+    const override = VersionManager.UNOBFUSCATED_VERSION_OVERRIDES[versionJson.id];
+    if (override !== undefined) {
+      logger.warn(
+        `Using unobfuscated override for ${versionJson.id}: ${override ? 'unobfuscated' : 'obfuscated'}`,
+      );
+      return override;
+    }
+
     if (versionJson.downloads.client_mappings) {
       return false;
     }
 
-    // Early 1.14.x releases can be missing client_mappings metadata while still obfuscated.
-    // Treat versions as unobfuscated only after the known 26.1 cutover and only for modern ids.
+    // Early legacy versions can be missing client_mappings while still obfuscated.
+    // Treat missing client_mappings as unobfuscated only at/after the known cutover.
     const releaseTimeMs = Date.parse(versionJson.releaseTime);
-    const isAfterUnobfuscatedCutover =
-      Number.isFinite(releaseTimeMs) && releaseTimeMs >= VersionManager.UNOBFUSCATED_CUTOFF_MS;
-
-    const modernVersionId = /^(\d+)\.(\d+)(?:\.\d+)?(?:-snapshot-\d+)?$/.exec(versionJson.id);
-    const modernMajor = modernVersionId ? Number.parseInt(modernVersionId[1], 10) : Number.NaN;
-    const isModernUnobfuscatedSeries = Number.isFinite(modernMajor) && modernMajor >= 26;
+    if (!Number.isFinite(releaseTimeMs)) {
+      logger.warn(
+        `Version ${versionJson.id} has invalid releaseTime '${versionJson.releaseTime}', defaulting to obfuscated`,
+      );
+      return false;
+    }
 
-    return isAfterUnobfuscatedCutover && isModernUnobfuscatedSeries;
+    return releaseTimeMs >= VersionManager.UNOBFUSCATED_CUTOFF_MS;
   }
 
   /**