Merge pull request #4 from Indemnity83/fix/unobfuscated-version-support

fix: handle unobfuscated Minecraft versions (26.1+)

Author: GhostTypes

__tests__/core/mojang-downloader.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { MOJANG_VERSION_MANIFEST_URL } from '../../src/parsers/version-manifest.js';
+import type { VersionJson, VersionManifest } from '../../src/types/minecraft.js';
+
+const { mockFetchJson } = vi.hoisted(() => ({
+  mockFetchJson: vi.fn(),
+}));
+
+vi.mock('../../src/downloaders/http-client.js', () => ({
+  downloadFile: vi.fn(),
+  fetchJson: mockFetchJson,
+}));
+
+import { MojangDownloader } from '../../src/downloaders/mojang-downloader.js';
+
+const VERSION_ID = 'unit-test-version';
+const VERSION_JSON_URL = 'https://example.com/unit-test-version.json';
+
+const TEST_MANIFEST: VersionManifest = {
+  latest: {
+    release: VERSION_ID,
+    snapshot: VERSION_ID,
+  },
+  versions: [
+    {
+      id: VERSION_ID,
+      type: 'release',
+      url: VERSION_JSON_URL,
+      time: '2026-01-01T00:00:00+00:00',
+      releaseTime: '2026-01-01T00:00:00+00:00',
+      sha1: 'manifest-sha1',
+      complianceLevel: 1,
+    },
+  ],
+};
+
+const TEST_VERSION_JSON: VersionJson = {
+  id: VERSION_ID,
+  type: 'release',
+  time: '2026-01-01T00:00:00+00:00',
+  releaseTime: '2026-01-01T00:00:00+00:00',
+  mainClass: 'net.minecraft.client.main.Main',
+  downloads: {
+    client: {
+      sha1: 'client-sha1',
+      size: 1,
+      url: 'https://example.com/client.jar',
+    },
+  },
+  libraries: [],
+};
+
+describe('MojangDownloader', () => {
+  beforeEach(() => {
+    mockFetchJson.mockReset();
+  });
+
+  it('should cache version JSON fetches per version', async () => {
+    mockFetchJson.mockImplementation(async (url: string) => {
+      if (url === MOJANG_VERSION_MANIFEST_URL) {
+        return TEST_MANIFEST;
+      }
+
+      if (url === VERSION_JSON_URL) {
+        return TEST_VERSION_JSON;
+      }
+
+      throw new Error(`Unexpected URL: ${url}`);
+    });
+
+    const downloader = new MojangDownloader();
+
+    const [first, second] = await Promise.all([
+      downloader.getVersionJson(VERSION_ID),
+      downloader.getVersionJson(VERSION_ID),
+    ]);
+
+    expect(first).toEqual(TEST_VERSION_JSON);
+    expect(second).toEqual(TEST_VERSION_JSON);
+
+    const requestedUrls = mockFetchJson.mock.calls.map(([url]) => String(url));
+    expect(requestedUrls.filter((url) => url === MOJANG_VERSION_MANIFEST_URL)).toHaveLength(1);
+    expect(requestedUrls.filter((url) => url === VERSION_JSON_URL)).toHaveLength(1);
+  });
+
+  it('should clear failed version JSON promises so retries can succeed', async () => {
+    let versionJsonAttempts = 0;
+
+    mockFetchJson.mockImplementation(async (url: string) => {
+      if (url === MOJANG_VERSION_MANIFEST_URL) {
+        return TEST_MANIFEST;
+      }
+
+      if (url === VERSION_JSON_URL) {
+        versionJsonAttempts += 1;
+        if (versionJsonAttempts === 1) {
+          throw new Error('Transient version JSON failure');
+        }
+
+        return TEST_VERSION_JSON;
+      }
+
+      throw new Error(`Unexpected URL: ${url}`);
+    });
+
+    const downloader = new MojangDownloader();
+
+    await expect(downloader.getVersionJson(VERSION_ID)).rejects.toThrow(
+      'Transient version JSON failure',
+    );
+    await expect(downloader.getVersionJson(VERSION_ID)).resolves.toEqual(TEST_VERSION_JSON);
+
+    const requestedUrls = mockFetchJson.mock.calls.map(([url]) => String(url));
+    expect(requestedUrls.filter((url) => url === MOJANG_VERSION_MANIFEST_URL)).toHaveLength(1);
+    expect(requestedUrls.filter((url) => url === VERSION_JSON_URL)).toHaveLength(2);
+  });
+});

__tests__/core/remap-service-unit.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { TinyRemapper } from '../../src/java/tiny-remapper.js';
+import type { MappingService } from '../../src/services/mapping-service.js';
+import { RemapService } from '../../src/services/remap-service.js';
+import type { VersionManager } from '../../src/services/version-manager.js';
+
+describe('RemapService (unit)', () => {
+  it('should fail before downloading JAR for unsupported mappings on unobfuscated versions', async () => {
+    const remapService = new RemapService();
+
+    const isVersionUnobfuscated = vi.fn().mockResolvedValue(true);
+    const getVersionJar = vi.fn().mockResolvedValue('raw-client.jar');
+
+    Reflect.set(remapService, 'versionManager', {
+      isVersionUnobfuscated,
+      getVersionJar,
+    } as Pick<VersionManager, 'isVersionUnobfuscated' | 'getVersionJar'>);
+
+    await expect(remapService.getRemappedJar('__vitest_unobf_yarn__', 'yarn')).rejects.toThrow(
+      /yarn mappings are not supported for unobfuscated/i,
+    );
+
+    expect(isVersionUnobfuscated).toHaveBeenCalledWith('__vitest_unobf_yarn__');
+    expect(getVersionJar).not.toHaveBeenCalled();
+  });
+
+  it('should return the raw client JAR for unobfuscated mojmap requests without remapping', async () => {
+    const remapService = new RemapService();
+
+    const isVersionUnobfuscated = vi.fn().mockResolvedValue(true);
+    const getVersionJar = vi.fn().mockResolvedValue('raw-client.jar');
+    const getMappings = vi.fn();
+    const remap = vi.fn();
+
+    Reflect.set(remapService, 'versionManager', {
+      isVersionUnobfuscated,
+      getVersionJar,
+    } as Pick<VersionManager, 'isVersionUnobfuscated' | 'getVersionJar'>);
+    Reflect.set(remapService, 'mappingService', { getMappings } as Pick<
+      MappingService,
+      'getMappings'
+    >);
+    Reflect.set(remapService, 'tinyRemapper', { remap } as Pick<TinyRemapper, 'remap'>);
+
+    const result = await remapService.getRemappedJar('__vitest_unobf_mojmap__', 'mojmap');
+
+    expect(result).toBe('raw-client.jar');
+    expect(getVersionJar).toHaveBeenCalledTimes(1);
+    expect(getMappings).not.toHaveBeenCalled();
+    expect(remap).not.toHaveBeenCalled();
+  });
+
+  it('should continue remapping normally for obfuscated versions', async () => {
+    const remapService = new RemapService();
+
+    const isVersionUnobfuscated = vi.fn().mockResolvedValue(false);
+    const getVersionJar = vi.fn().mockResolvedValue('input.jar');
+    const getMappings = vi.fn().mockResolvedValue('intermediary.tiny');
+    const remap = vi.fn().mockResolvedValue(undefined);
+
+    Reflect.set(remapService, 'versionManager', {
+      isVersionUnobfuscated,
+      getVersionJar,
+    } as Pick<VersionManager, 'isVersionUnobfuscated' | 'getVersionJar'>);
+    Reflect.set(remapService, 'mappingService', { getMappings } as Pick<
+      MappingService,
+      'getMappings'
+    >);
+    Reflect.set(remapService, 'tinyRemapper', { remap } as Pick<TinyRemapper, 'remap'>);
+
+    const result = await remapService.getRemappedJar('__vitest_obf_intermediary__', 'intermediary');
+
+    expect(isVersionUnobfuscated).toHaveBeenCalledWith('__vitest_obf_intermediary__');
+    expect(getVersionJar).toHaveBeenCalledTimes(1);
+    expect(getMappings).toHaveBeenCalledWith('__vitest_obf_intermediary__', 'intermediary');
+    expect(remap).toHaveBeenCalledTimes(1);
+    expect(result).toContain('__vitest_obf_intermediary__');
+    expect(result).toContain('intermediary');
+  });
+});

__tests__/core/remap-service.test.ts

@@ -5,7 +5,7 @@ import { getCacheManager } from '../../src/cache/cache-manager.js';
 import { verifyJavaVersion } from '../../src/java/java-process.js';
 import { getDecompileService } from '../../src/services/decompile-service.js';
 import { getRemapService } from '../../src/services/remap-service.js';
-import { TEST_MAPPING, TEST_VERSION } from '../test-constants.js';
+import { TEST_MAPPING, TEST_VERSION, UNOBFUSCATED_TEST_VERSION } from '../test-constants.js';
 
 /**
  * JAR Remapping Tests
@@ -279,7 +279,7 @@ describe('JAR Remapping', () => {
       const source = await decompileService.getClassSource(
         TEST_VERSION,
         'net.minecraft.world.entity.Entity',
-        'mojmap'
+        'mojmap',
       );
 
       expect(source).toBeDefined();
@@ -301,7 +301,7 @@ describe('JAR Remapping', () => {
       const source = await decompileService.getClassSource(
         TEST_VERSION,
         'net.minecraft.world.entity.Entity',
-        'mojmap'
+        'mojmap',
       );
 
       expect(source).toBeDefined();
@@ -318,7 +318,7 @@ describe('JAR Remapping', () => {
       const source = await decompileService.getClassSource(
         TEST_VERSION,
         'net.minecraft.server.MinecraftServer',
-        'mojmap'
+        'mojmap',
       );
 
       expect(source).toBeDefined();
@@ -342,7 +342,7 @@ describe('JAR Remapping', () => {
       const source = await decompileService.getClassSource(
         TEST_VERSION,
         'net.minecraft.entity.Entity',
-        'yarn'
+        'yarn',
       );
 
       expect(source).toBeDefined();
@@ -361,7 +361,7 @@ describe('JAR Remapping', () => {
       const source = await decompileService.getClassSource(
         TEST_VERSION,
         'net.minecraft.entity.Entity',
-        'yarn'
+        'yarn',
       );
 
       expect(source).toBeDefined();
@@ -374,4 +374,30 @@ describe('JAR Remapping', () => {
       expect(intermediaryFieldCount).toBeLessThan(20);
     }, 60000);
   });
+
+  describe('Unobfuscated version handling', () => {
+    // 26.1+ snapshots ship without obfuscation - no intermediary or Yarn mappings exist.
+    it('should throw a clear error when requesting yarn mappings for an unobfuscated version', async () => {
+      const remapService = getRemapService();
+      await expect(remapService.getRemappedJar(UNOBFUSCATED_TEST_VERSION, 'yarn')).rejects.toThrow(
+        /yarn mappings are not supported for unobfuscated/i,
+      );
+    }, 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();
+      await expect(
+        remapService.getRemappedJar(UNOBFUSCATED_TEST_VERSION, 'intermediary'),
+      ).rejects.toThrow(/intermediary mappings are not supported for unobfuscated/i);
+    }, 60000);
+
+    it('should return the raw client JAR for mojmap on an unobfuscated version', async () => {
+      const remapService = getRemapService();
+      const jarPath = await remapService.getRemappedJar(UNOBFUSCATED_TEST_VERSION, 'mojmap');
+      expect(jarPath).toBeDefined();
+      expect(existsSync(jarPath)).toBe(true);
+      // The returned path is the raw client JAR, not a remapped copy
+      expect(jarPath).not.toContain('remapped');
+    }, 60000);
+  });
 });

__tests__/core/version-manager.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { MojangDownloader } from '../../src/downloaders/mojang-downloader.js';
 import { getVersionManager } from '../../src/services/version-manager.js';
-import { TEST_VERSION } from '../test-constants.js';
+import { TEST_VERSION, UNOBFUSCATED_TEST_VERSION } from '../test-constants.js';
 
 /**
  * Version Management Tests
@@ -36,4 +36,39 @@ describe('Version Management', () => {
 
     expect(exists).toBe(false);
   }, 30000);
+
+  describe('Unobfuscated version detection', () => {
+    it('should return false for obfuscated versions', async () => {
+      const versionManager = getVersionManager();
+      // TEST_VERSION (1.21.11) is an obfuscated release - client_mappings present
+      const result = await versionManager.isVersionUnobfuscated(TEST_VERSION);
+      expect(result).toBe(false);
+    }, 30000);
+
+    it('should return false for legacy obfuscated versions without client_mappings metadata', async () => {
+      const versionManager = getVersionManager();
+      // Early 1.14.x versions can omit client_mappings while still being obfuscated.
+      const result = await versionManager.isVersionUnobfuscated('1.14.3');
+      expect(result).toBe(false);
+    }, 30000);
+
+    it('should return true for unobfuscated versions (26.1+)', async () => {
+      const versionManager = getVersionManager();
+      // 26.1 snapshots ship without obfuscation - no client_mappings in version JSON
+      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);
+  });
 });