@adhisang/minecraft-modding-mcp 1.2.1 → 2.1.0

package/dist/mod-remap-service.js

@@ -1,19 +1,20 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, statSync, rmSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
-import { createError, ERROR_CODES } from "./errors.js";
+import { createError, ERROR_CODES, isAppError } from "./errors.js";
 import { log } from "./logger.js";
 import { resolveTinyMappingFile } from "./mapping-service.js";
 import { resolveMojangTinyFile } from "./mojang-tiny-mapping-service.js";
 import { analyzeModJar } from "./mod-analyzer.js";
 import { normalizePathForHost } from "./path-converter.js";
+import { listJarEntries, readJarEntryAsBuffer } from "./source-jar-reader.js";
 import { remapJar } from "./tiny-remapper-service.js";
 import { resolveTinyRemapperJar } from "./tiny-remapper-resolver.js";
 function normalizeTargetNamespace(target) {
     return target === "yarn" ? "yarn" : "mojang";
 }
-function sourceNamespaceForLoader(loader) {
+function defaultSourceNamespaceForLoader(loader) {
     if (loader === "fabric" || loader === "quilt") {
         return "intermediary";
     }
@@ -35,6 +36,81 @@ function extractMinecraftVersion(dependencies) {
     const match = mcDep.versionRange.match(/(\d+\.\d+(?:\.\d+)?)/);
     return match?.[1];
 }
+function countMatches(input, pattern) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    let count = 0;
+    while (globalPattern.exec(input)) {
+        count += 1;
+    }
+    return count;
+}
+async function detectFabricLikeInputNamespace(inputJar) {
+    const warnings = [];
+    const classEntries = (await listJarEntries(inputJar))
+        .filter((entry) => entry.endsWith(".class"))
+        .slice(0, 24);
+    if (classEntries.length === 0) {
+        warnings.push("Could not inspect class entries to detect input mapping; assuming intermediary.");
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    let mojangScore = 0;
+    let intermediaryScore = 0;
+    for (const entry of classEntries) {
+        let text = "";
+        try {
+            text = (await readJarEntryAsBuffer(inputJar, entry)).toString("latin1");
+        }
+        catch {
+            continue;
+        }
+        mojangScore += countMatches(text, /net\/minecraft\/(?:advancements|client|commands|core|data|gametest|nbt|network|recipe|resources|server|sounds|stats|tags|util|world)\//g) * 3;
+        intermediaryScore += countMatches(text, /net\/minecraft\/class_\d+/g) * 3;
+        intermediaryScore += countMatches(text, /\b(?:method|field)_\d+\b/g);
+    }
+    if (mojangScore > intermediaryScore && mojangScore > 0) {
+        return {
+            fromNamespace: "mojang",
+            warnings
+        };
+    }
+    if (intermediaryScore > mojangScore && intermediaryScore > 0) {
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    warnings.push("Could not confidently detect whether the input jar uses intermediary or mojang names; assuming intermediary.");
+    return {
+        fromNamespace: "intermediary",
+        warnings
+    };
+}
+async function detectInputNamespaceForLoader(inputJar, loader) {
+    if (loader === "fabric" || loader === "quilt") {
+        return detectFabricLikeInputNamespace(inputJar);
+    }
+    return {
+        fromNamespace: defaultSourceNamespaceForLoader(loader),
+        warnings: []
+    };
+}
+function resolveOutputJarPath(input, normalizedInput, modId, modVersion) {
+    const defaultOutputName = `${modId ?? "mod"}-${modVersion ?? "0"}-${input.targetMapping}.jar`;
+    return input.outputJar
+        ? normalizePathForHost(input.outputJar, undefined, "outputJar")
+        : join(dirname(normalizedInput), defaultOutputName);
+}
+function copyJarToDestination(sourceJar, destinationJar) {
+    if (sourceJar === destinationJar) {
+        return;
+    }
+    mkdirSync(dirname(destinationJar), { recursive: true });
+    copyFileSync(sourceJar, destinationJar);
+}
 function buildCacheKey(inputJar, fromNamespace, targetNamespace, mcVersion) {
     const stat = statSync(inputJar, { throwIfNoEntry: false });
     const signature = stat ? `${stat.mtimeMs}:${stat.size}` : "unknown";
@@ -71,7 +147,9 @@ export async function remapModJar(input, config) {
             details: { inputJar: normalizedInput }
         });
     }
-    const fromNamespace = sourceNamespaceForLoader(analysis.loader);
+    const namespaceDetection = await detectInputNamespaceForLoader(normalizedInput, analysis.loader);
+    warnings.push(...namespaceDetection.warnings);
+    const fromNamespace = namespaceDetection.fromNamespace;
     // 3. Determine MC version
     const mcVersion = input.mcVersion ?? extractMinecraftVersion(analysis.dependencies);
     if (!mcVersion) {
@@ -85,21 +163,32 @@ export async function remapModJar(input, config) {
             }
         });
     }
+    const outputJar = resolveOutputJarPath(input, normalizedInput, analysis.modId, analysis.modVersion);
     // 4. Check cache after mapping context is known
     const cacheKey = buildCacheKey(normalizedInput, fromNamespace, resolvedTargetNamespace, mcVersion);
     const cacheDir = join(config.cacheDir, "remapped-mods");
     mkdirSync(cacheDir, { recursive: true });
     const cachedOutput = join(cacheDir, `${cacheKey}.jar`);
     if (existsSync(cachedOutput)) {
-        const outputJar = input.outputJar
-            ? normalizePathForHost(input.outputJar, undefined, "outputJar")
+        const cacheHitOutputJar = input.outputJar
+            ? outputJar
             : cachedOutput;
-        if (outputJar !== cachedOutput) {
-            const { copyFileSync } = await import("node:fs");
-            mkdirSync(dirname(outputJar), { recursive: true });
-            copyFileSync(cachedOutput, outputJar);
-        }
-        log("info", "remap.cache-hit", { inputJar: normalizedInput, outputJar });
+        copyJarToDestination(cachedOutput, cacheHitOutputJar);
+        log("info", "remap.cache-hit", { inputJar: normalizedInput, outputJar: cacheHitOutputJar });
+        return {
+            outputJar: cacheHitOutputJar,
+            mcVersion,
+            fromMapping: fromNamespace,
+            targetMapping: input.targetMapping,
+            resolvedTargetNamespace,
+            durationMs: Date.now() - startedAt,
+            warnings: [...warnings, "Result served from cache."]
+        };
+    }
+    if (fromNamespace === resolvedTargetNamespace) {
+        copyJarToDestination(normalizedInput, outputJar);
+        copyJarToDestination(normalizedInput, cachedOutput);
+        warnings.push(`Input JAR already uses ${fromNamespace} names; output is a copy of the input JAR.`);
         return {
             outputJar,
             mcVersion,
@@ -107,9 +196,23 @@ export async function remapModJar(input, config) {
             targetMapping: input.targetMapping,
             resolvedTargetNamespace,
             durationMs: Date.now() - startedAt,
-            warnings: ["Result served from cache."]
+            warnings
         };
     }
+    if (fromNamespace === "mojang" && resolvedTargetNamespace === "yarn") {
+        throw createError({
+            code: ERROR_CODES.REMAP_FAILED,
+            message: "Mojang-mapped Fabric/Quilt input jars cannot be remapped to yarn with the available mapping files.",
+            details: {
+                inputJar: normalizedInput,
+                mcVersion,
+                fromMapping: fromNamespace,
+                targetMapping: input.targetMapping,
+                resolvedTargetNamespace,
+                nextAction: 'Use targetMapping="mojang" for Mojang-mapped inputs, or rebuild the mod against intermediary mappings before requesting yarn output.'
+            }
+        });
+    }
     // 5. Resolve tiny-remapper
     const tinyRemapperJar = await resolveTinyRemapperJar(config.cacheDir, config.tinyRemapperJarPath);
     // 6. Resolve mapping file and remap
@@ -125,30 +228,39 @@ export async function remapModJar(input, config) {
         toNamespace = "mojang";
         warnings.push(...mojangTiny.warnings);
     }
-    // 7. Determine output path
-    const modId = analysis.modId ?? "mod";
-    const modVersion = analysis.modVersion ?? "0";
-    const defaultOutputName = `${modId}-${modVersion}-${input.targetMapping}.jar`;
-    const outputJar = input.outputJar
-        ? normalizePathForHost(input.outputJar, undefined, "outputJar")
-        : join(dirname(normalizedInput), defaultOutputName);
     mkdirSync(dirname(outputJar), { recursive: true });
     // 8. Use temporary directory for intermediate work
     const tempDir = join(tmpdir(), `mcp-remap-${cacheKey.slice(0, 12)}`);
     mkdirSync(tempDir, { recursive: true });
     try {
         const tempOutput = join(tempDir, "remapped.jar");
-        await remapJar(tinyRemapperJar, {
-            inputJar: normalizedInput,
-            outputJar: tempOutput,
-            mappingsFile,
-            fromNamespace,
-            toNamespace,
-            timeoutMs: config.remapTimeoutMs,
-            maxMemoryMb: config.remapMaxMemoryMb
-        });
+        try {
+            await remapJar(tinyRemapperJar, {
+                inputJar: normalizedInput,
+                outputJar: tempOutput,
+                mappingsFile,
+                fromNamespace,
+                toNamespace,
+                timeoutMs: config.remapTimeoutMs,
+                maxMemoryMb: config.remapMaxMemoryMb
+            });
+        }
+        catch (caughtError) {
+            if (isAppError(caughtError)) {
+                throw createError({
+                    code: caughtError.code,
+                    message: caughtError.message,
+                    details: {
+                        ...(caughtError.details ?? {}),
+                        fromMapping: fromNamespace,
+                        targetMapping: input.targetMapping,
+                        resolvedTargetNamespace
+                    }
+                });
+            }
+            throw caughtError;
+        }
         // Copy to final destination and cache
-        const { copyFileSync } = await import("node:fs");
         copyFileSync(tempOutput, outputJar);
         if (outputJar !== cachedOutput) {
             mkdirSync(dirname(cachedOutput), { recursive: true });

package/dist/mojang-tiny-mapping-service.js

@@ -30,13 +30,13 @@ function parseProguardMappings(text) {
         const classMatch = /^(.+?)\s+->\s+(.+):$/.exec(line);
         if (classMatch) {
             const mojangFqn = normalizeFqn(classMatch[1] ?? "");
-            const officialInternal = normalizeInternalName(classMatch[2] ?? "");
-            if (!mojangFqn || !officialInternal) {
+            const obfuscatedInternal = normalizeInternalName(classMatch[2] ?? "");
+            if (!mojangFqn || !obfuscatedInternal) {
                 currentClass = undefined;
                 continue;
             }
             currentClass = mojangFqn;
-            classes.push({ mojangFqn, officialInternal });
+            classes.push({ mojangFqn, obfuscatedInternal });
             continue;
         }
         if (!currentClass) {
@@ -47,14 +47,14 @@ function parseProguardMappings(text) {
             continue;
         }
         const leftRaw = stripLineInfo(line.slice(0, arrowIndex));
-        const officialName = line.slice(arrowIndex + 4).trim();
-        if (!leftRaw || !officialName) {
+        const obfuscatedName = line.slice(arrowIndex + 4).trim();
+        if (!leftRaw || !obfuscatedName) {
             continue;
         }
         members.push({
             ownerMojangFqn: currentClass,
             leftSignature: leftRaw,
-            officialName
+            obfuscatedName
         });
     }
     return { classes, members };
@@ -164,8 +164,8 @@ function normalizeMemberMappings(rawMappings, classMap, warnings) {
     const seen = new Set();
     for (const mapping of rawMappings) {
         for (const member of mapping.members) {
-            const ownerOfficial = classMap.get(normalizeFqn(member.ownerMojangFqn));
-            if (!ownerOfficial) {
+            const ownerObfuscated = classMap.get(normalizeFqn(member.ownerMojangFqn));
+            if (!ownerObfuscated) {
                 warnings.push(`Skipping member mapping for "${member.ownerMojangFqn}" because class mapping is missing.`);
                 continue;
             }
@@ -183,7 +183,7 @@ function normalizeMemberMappings(rawMappings, classMap, warnings) {
                 record = {
                     kind: "m",
                     descriptor,
-                    officialName: member.officialName,
+                    obfuscatedName: member.obfuscatedName,
                     mojangName
                 };
             }
@@ -203,19 +203,19 @@ function normalizeMemberMappings(rawMappings, classMap, warnings) {
                 record = {
                     kind: "f",
                     descriptor,
-                    officialName: member.officialName,
+                    obfuscatedName: member.obfuscatedName,
                     mojangName
                 };
             }
-            const dedupeKey = `${ownerOfficial}|${record.kind}|${record.officialName}|` +
+            const dedupeKey = `${ownerObfuscated}|${record.kind}|${record.obfuscatedName}|` +
                 `${record.mojangName}|${record.descriptor}`;
             if (seen.has(dedupeKey)) {
                 continue;
             }
             seen.add(dedupeKey);
-            const list = membersByOwner.get(ownerOfficial) ?? [];
+            const list = membersByOwner.get(ownerObfuscated) ?? [];
             list.push(record);
-            membersByOwner.set(ownerOfficial, list);
+            membersByOwner.set(ownerObfuscated, list);
         }
     }
     return membersByOwner;
@@ -225,38 +225,38 @@ function mergeClasses(rawMappings, warnings) {
     for (const mapping of rawMappings) {
         for (const clazz of mapping.classes) {
             const mojang = normalizeFqn(clazz.mojangFqn);
-            const official = normalizeInternalName(clazz.officialInternal);
+            const obfuscated = normalizeInternalName(clazz.obfuscatedInternal);
             const existing = classMap.get(mojang);
-            if (existing && existing !== official) {
-                warnings.push(`Conflicting class mapping for "${mojang}" (${existing} vs ${official}); keeping first.`);
+            if (existing && existing !== obfuscated) {
+                warnings.push(`Conflicting class mapping for "${mojang}" (${existing} vs ${obfuscated}); keeping first.`);
                 continue;
             }
-            classMap.set(mojang, official);
+            classMap.set(mojang, obfuscated);
         }
     }
     return classMap;
 }
 function renderTinyV2(classMap, membersByOwner) {
     const classEntries = [...classMap.entries()]
-        .map(([mojangFqn, officialInternal]) => ({
-        officialInternal,
+        .map(([mojangFqn, obfuscatedInternal]) => ({
+        obfuscatedInternal,
         mojangInternal: mojangFqn.replace(/\./g, "/")
     }))
-        .sort((left, right) => left.officialInternal.localeCompare(right.officialInternal));
-    const lines = ["tiny\t2\t0\tofficial\tmojang"];
+        .sort((left, right) => left.obfuscatedInternal.localeCompare(right.obfuscatedInternal));
+    const lines = ["tiny\t2\t0\tobfuscated\tmojang"];
     for (const entry of classEntries) {
-        lines.push(`c\t${entry.officialInternal}\t${entry.mojangInternal}`);
-        const members = [...(membersByOwner.get(entry.officialInternal) ?? [])].sort((left, right) => {
+        lines.push(`c\t${entry.obfuscatedInternal}\t${entry.mojangInternal}`);
+        const members = [...(membersByOwner.get(entry.obfuscatedInternal) ?? [])].sort((left, right) => {
             if (left.kind !== right.kind) {
                 return left.kind.localeCompare(right.kind);
             }
-            if (left.officialName !== right.officialName) {
-                return left.officialName.localeCompare(right.officialName);
+            if (left.obfuscatedName !== right.obfuscatedName) {
+                return left.obfuscatedName.localeCompare(right.obfuscatedName);
             }
             return left.descriptor.localeCompare(right.descriptor);
         });
         for (const member of members) {
-            lines.push(`\t${member.kind}\t${member.descriptor}\t${member.officialName}\t${member.mojangName}`);
+            lines.push(`\t${member.kind}\t${member.descriptor}\t${member.obfuscatedName}\t${member.mojangName}`);
         }
     }
     return `${lines.join("\n")}\n`;

package/dist/path-resolver.js

@@ -2,12 +2,35 @@ import { realpathSync, statSync } from "node:fs";
 import { extname, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { normalizePathForHost } from "./path-converter.js";
-import { createError, ERROR_CODES } from "./errors.js";
+import { createError, ERROR_CODES, isAppError } from "./errors.js";
 const INVALID_ENTRY = /(^|\/|\\)\.\.(\/|\\|$)/;
 export function normalizeJarPath(jarPath) {
     const normalizedInput = normalizePathForHost(jarPath, undefined, "jarPath");
     const absolute = resolve(normalizedInput);
-    const stats = statSync(absolute);
+    let stats;
+    try {
+        stats = statSync(absolute, { throwIfNoEntry: false });
+    }
+    catch (cause) {
+        if (isAppError(cause)) {
+            throw cause;
+        }
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Could not access jar "${normalizedInput}".`,
+            details: {
+                jarPath: normalizedInput,
+                reason: cause instanceof Error ? cause.message : String(cause)
+            }
+        });
+    }
+    if (!stats) {
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Jar not found: "${normalizedInput}".`,
+            details: { jarPath: normalizedInput }
+        });
+    }
     if (!stats.isFile()) {
         throw createError({
             code: ERROR_CODES.JAR_NOT_FOUND,
@@ -22,8 +45,22 @@ export function normalizeJarPath(jarPath) {
             details: { jarPath: normalizedInput }
         });
     }
-    const resolved = realpathSync(absolute);
-    return resolved;
+    try {
+        return realpathSync(absolute);
+    }
+    catch (cause) {
+        if (isAppError(cause)) {
+            throw cause;
+        }
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Could not resolve jar "${normalizedInput}".`,
+            details: {
+                jarPath: normalizedInput,
+                reason: cause instanceof Error ? cause.message : String(cause)
+            }
+        });
+    }
 }
 export function resolveJarPathWithSymlinkCheck(jarPath) {
     const resolvedPath = normalizeJarPath(jarPath);

package/dist/registry-service.d.ts

@@ -3,6 +3,8 @@ import type { Config } from "./types.js";
 export type GetRegistryDataInput = {
     version: string;
     registry?: string;
+    includeData?: boolean;
+    maxEntriesPerRegistry?: number;
 };
 export type RegistryEntry = {
     protocol_id: number;
@@ -15,8 +17,11 @@ export type GetRegistryDataOutput = {
     version: string;
     registry?: string;
     registries?: string[];
-    data: Record<string, RegistryData> | RegistryData;
+    data?: Record<string, RegistryData> | RegistryData;
     entryCount: number;
+    returnedEntryCount?: number;
+    registryEntryCounts?: Record<string, number>;
+    dataTruncated?: boolean;
     warnings: string[];
 };
 export declare class RegistryService {
@@ -26,4 +31,8 @@ export declare class RegistryService {
     constructor(config: Config, versionService: VersionService);
     getRegistryData(input: GetRegistryDataInput): Promise<GetRegistryDataOutput>;
     private loadRegistries;
+    private loadExistingRegistries;
+    private readRegistryFileOrThrow;
+    private isInvalidRegistrySnapshot;
+    private cacheRegistries;
 }