@xmcl/forge-installer/index.js

"use strict";
function __export(m) {
    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const installer_1 = require("@xmcl/installer");
const net_1 = require("@xmcl/net");
const task_1 = __importDefault(require("@xmcl/task"));
const unzip_1 = __importDefault(require("@xmcl/unzip"));
const util_1 = require("@xmcl/util");
const version_1 = require("@xmcl/version");
const path = __importStar(require("path"));
async function findMainClass(lib) {
    const zip = await unzip_1.default.open(lib, { lazyEntries: true });
    const [manifest] = await zip.filterEntries(["META-INF/MANIFEST.MF"]);
    let mainClass;
    if (manifest) {
        const content = await zip.readEntry(manifest).then((b) => b.toString());
        const mainClassPair = content.split("\n").map((l) => l.split(": ")).filter((arr) => arr[0] === "Main-Class")[0];
        if (mainClassPair) {
            mainClass = mainClassPair[1].trim();
        }
    }
    zip.close();
    return mainClass;
}
var ForgeInstaller;
(function (ForgeInstaller) {
    ForgeInstaller.DEFAULT_FORGE_MAVEN = "http://files.minecraftforge.net";
    /**
     * Diagnose for specific forge version. Majorly for the current installer forge. (mcversion >= 1.13)
     *
     * Don't use this with the version less than 1.13
     * @param versionOrProfile If the version string present, it will try to find the installer profile under version folder. Otherwise it will use presented installer profile to diagnose
     * @param minecraft The minecraft location.
     */
    async function diagnoseForgeVersion(versionOrProfile, minecraft) {
        const version = typeof versionOrProfile === "string" ? versionOrProfile : versionOrProfile.version;
        const mc = util_1.MinecraftFolder.from(minecraft);
        const verRoot = mc.getVersionRoot(version);
        const versionJsonPath = mc.getVersionJson(version);
        const diag = {
            badProcessedFiles: [],
            missingInstallDependencies: [],
            badVersionJson: false,
            missingBinpatch: false,
            badInstall: false,
            missingSrgJar: false,
            missingMinecraftExtraJar: false,
            missingForgePatchesJar: false,
        };
        let prof;
        if (typeof versionOrProfile === "string") {
            const installProfPath = path.join(verRoot, "install_profile.json");
            if (await util_1.vfs.exists(installProfPath)) {
                prof = JSON.parse(await util_1.vfs.readFile(installProfPath).then((b) => b.toString()));
            }
        }
        else {
            prof = versionOrProfile;
        }
        if (prof) {
            const processedProfile = postProcessInstallProfile(mc, prof);
            for (const proc of processedProfile.processors) {
                if (proc.outputs) {
                    let bad = false;
                    for (const file in proc.outputs) {
                        if (!await util_1.vfs.validate(file, { algorithm: "sha1", hash: proc.outputs[file].replace(/\'/g, "") })) {
                            bad = true;
                            break;
                        }
                    }
                    if (bad) {
                        diag.badProcessedFiles.push(proc);
                    }
                }
            }
            // if we have to process file, we have to check if the forge deps are ready
            if (diag.badProcessedFiles.length !== 0) {
                const libValidMask = await Promise.all(processedProfile.libraries.map(async (lib) => {
                    const artifact = lib.downloads.artifact;
                    const libPath = mc.getLibraryByPath(artifact.path);
                    if (await util_1.vfs.exists(libPath)) {
                        return artifact.sha1 ? util_1.vfs.validate(libPath) : true;
                    }
                    return false;
                }));
                const missingLibraries = processedProfile.libraries.filter((_, i) => !libValidMask[i]);
                diag.missingInstallDependencies.push(...missingLibraries);
                const validClient = await util_1.vfs.stat(processedProfile.data.BINPATCH.client).then((s) => s.size !== 0).catch((_) => false);
                if (!validClient) {
                    diag.missingBinpatch = true;
                    diag.badInstall = true;
                }
            }
        }
        if (await util_1.vfs.exists(versionJsonPath)) {
            const versionJSON = JSON.parse(await util_1.vfs.readFile(versionJsonPath).then((b) => b.toString()));
            if (versionJSON.arguments && versionJSON.arguments.game) {
                const args = versionJSON.arguments.game;
                const forgeVersion = args.indexOf("--fml.forgeVersion") + 1;
                const mcVersion = args.indexOf("--fml.mcVersion") + 1;
                const mcpVersion = args.indexOf("--fml.mcpVersion") + 1;
                if (!forgeVersion || !mcVersion || !mcpVersion) {
                    diag.badVersionJson = true;
                    diag.badInstall = true;
                }
                else {
                    const srgPath = mc.getLibraryByPath(`net/minecraft/client/${mcVersion}-${mcpVersion}/client-${mcVersion}-${mcpVersion}-srg.jar`);
                    const extraPath = mc.getLibraryByPath(`net/minecraft/client/${mcVersion}/client-${mcVersion}-extra.jar`);
                    const forgePatchPath = mc.getLibraryByPath(`net/minecraftforge/forge/${mcVersion}-${forgeVersion}/forge-${mcVersion}-${forgeVersion}-client.jar`);
                    diag.missingSrgJar = await util_1.vfs.missing(srgPath);
                    diag.missingMinecraftExtraJar = await util_1.vfs.missing(extraPath);
                    diag.missingForgePatchesJar = await util_1.vfs.missing(forgePatchPath);
                }
            }
            else {
                diag.badVersionJson = true;
                diag.badInstall = true;
            }
        }
        else {
            diag.badVersionJson = true;
            diag.badInstall = true;
        }
        return diag;
    }
    ForgeInstaller.diagnoseForgeVersion = diagnoseForgeVersion;
    /**
     * Post processing function for new forge installer (mcversion >= 1.13). You can use this with `ForgeInstaller.diagnose`.
     *
     * @param mc The minecraft location
     * @param proc The processor
     * @param java The java executor
     */
    async function postProcess(mc, proc, java) {
        const jarRealPath = mc.getLibraryByPath(version_1.Version.getLibraryInfo(proc.jar).path);
        const mainClass = await findMainClass(jarRealPath);
        if (!mainClass) {
            throw new Error(`Cannot find main class for processor ${proc.jar}.`);
        }
        const cp = [...proc.classpath, proc.jar].map(version_1.Version.getLibraryInfo).map((p) => mc.getLibraryByPath(p.path)).join(path.delimiter);
        const cmd = ["-cp", cp, mainClass, ...proc.args];
        await java(cmd);
        let failed = false;
        if (proc.outputs) {
            for (const file in proc.outputs) {
                if (!await util_1.vfs.validate(file, { algorithm: "sha1", hash: proc.outputs[file].replace(/\'/g, "") })) {
                    console.error(`Fail to process ${proc.jar} @ ${file} since its validation failed.`);
                    failed = true;
                }
            }
        }
        if (failed) {
            console.error(`Java arguments: ${JSON.stringify(cmd)}`);
            throw new Error(`Fail to process post processing since its validation failed.`);
        }
    }
    ForgeInstaller.postProcess = postProcess;
    function postProcessInstallProfile(mc, installProfile) {
        function processValue(v) {
            if (v.match(/^\[.+\]$/g)) {
                const targetId = v.substring(1, v.length - 1);
                return mc.getLibraryByPath(version_1.Version.getLibraryInfo(targetId).path);
            }
            return v;
        }
        function processMapping(data, m) {
            m = processValue(m);
            if (m.match(/^{.+}$/g)) {
                const key = m.substring(1, m.length - 1);
                m = data[key].client;
            }
            return m;
        }
        const profile = JSON.parse(JSON.stringify(installProfile));
        profile.data.MINECRAFT_JAR = {
            client: mc.getVersionJar(profile.minecraft),
            server: "",
        };
        for (const key in profile.data) {
            const value = profile.data[key];
            value.client = processValue(value.client);
            value.server = processValue(value.server);
            if (key === "BINPATCH") {
                const verRoot = mc.getVersionRoot(profile.version);
                value.client = path.join(verRoot, value.client);
                value.server = path.join(verRoot, value.server);
            }
        }
        for (const proc of profile.processors) {
            proc.args = proc.args.map((a) => processMapping(profile.data, a));
            if (proc.outputs) {
                const replacedOutput = {};
                for (const key in proc.outputs) {
                    replacedOutput[processMapping(profile.data, key)] = processMapping(profile.data, proc.outputs[key]);
                }
                proc.outputs = replacedOutput;
            }
        }
        return profile;
    }
    /**
     * Install for forge installer step 2 and 3.
     * @param version The version string or installer profile
     * @param minecraft The minecraft location
     */
    function installByInstallerPartialTask(version, minecraft, option = {}) {
        return task_1.default.create("installForge", async (context) => {
            const mc = util_1.MinecraftFolder.from(minecraft);
            let prof;
            let ver;
            if (typeof version === "string") {
                const versionRoot = mc.getVersionRoot(version);
                prof = await util_1.vfs.readFile(path.join(versionRoot, "install_profile.json")).then((b) => b.toString()).then(JSON.parse);
            }
            else {
                prof = version;
            }
            ver = await util_1.vfs.readFile(mc.getVersionJson(prof.version)).then((b) => b.toString()).then(JSON.parse);
            await installByInstallerPartialWork(mc, prof, ver, option.java || util_1.JavaExecutor.createSimple("java"), option)(context);
        });
    }
    ForgeInstaller.installByInstallerPartialTask = installByInstallerPartialTask;
    /**
     * Install for forge installer step 2 and 3.
     * @param version The version string or installer profile
     * @param minecraft The minecraft location
     */
    async function installByInstallerPartial(version, minecraft, option = {}) {
        return installByInstallerPartialTask(version, minecraft, option).execute();
    }
    ForgeInstaller.installByInstallerPartial = installByInstallerPartial;
    function installByInstallerPartialWork(mc, profile, versionJson, java, installLibOption) {
        return async (context) => {
            profile = postProcessInstallProfile(mc, profile);
            const parsedLibs = version_1.Version.resolveLibraries([...profile.libraries, ...versionJson.libraries]);
            await context.execute("downloadLibraries", installer_1.Installer.installLibrariesDirectTask(parsedLibs, mc, installLibOption).work);
            await context.execute("postProcessing", async (ctx) => {
                ctx.update(0, profile.processors.length);
                let i = 0;
                const errs = [];
                for (const proc of profile.processors) {
                    try {
                        await postProcess(mc, proc, java);
                    }
                    catch (e) {
                        errs.push(e);
                    }
                    ctx.update(i += 1, profile.processors.length);
                }
                i += 1;
                ctx.update(i, profile.processors.length);
                if (errs.length !== 0) {
                    throw new Error(`Fail to post processing`);
                }
            });
        };
    }
    function installByInstallerTask(version, minecraft, maven, installLibOption, java, tempDir, clearTempDir = true) {
        return async (context) => {
            const mc = typeof minecraft === "string" ? new util_1.MinecraftFolder(minecraft) : minecraft;
            const forgeVersion = `${version.mcversion}-${version.version}`;
            let versionId;
            const installerURLFallback = `${maven}/maven/net/minecraftforge/forge/${forgeVersion}/forge-${forgeVersion}-installer.jar`;
            const installerURL = `${maven}${version.installer.path}`;
            function downloadInstallerTask(installer, dest) {
                return async (ctx) => {
                    let inStream;
                    if (await util_1.vfs.validate(dest, { algorithm: "md5", hash: version.installer.md5 }, { algorithm: "sha1", hash: version.installer.sha1 })) {
                        inStream = util_1.vfs.createReadStream(dest);
                    }
                    if (!inStream) {
                        inStream = net_1.got.stream(installer, {
                            method: "GET",
                            headers: { connection: "keep-alive" },
                        }).on("error", () => { })
                            .on("downloadProgress", (progress) => { ctx.update(progress.transferred, progress.total); });
                        inStream.pipe(util_1.vfs.createWriteStream(dest));
                    }
                    return inStream.pipe(unzip_1.default.createParseStream({ lazyEntries: true }))
                        .wait();
                };
            }
            const temp = tempDir || await util_1.vfs.mkdtemp(mc.root + path.sep);
            await util_1.vfs.ensureDir(temp);
            const installJar = path.join(temp, "forge-installer.jar");
            let profile;
            let versionJson;
            async function processVersion(zip, installProfileEntry, versionEntry, clientDataEntry) {
                profile = await zip.readEntry(installProfileEntry).then((b) => b.toString()).then(JSON.parse);
                versionJson = await zip.readEntry(versionEntry).then((b) => b.toString()).then(JSON.parse);
                versionId = versionJson.id;
                const rootPath = mc.getVersionRoot(versionJson.id);
                const jsonPath = path.join(rootPath, `${versionJson.id}.json`);
                const installJsonPath = path.join(rootPath, `install_profile.json`);
                const clientDataPath = path.join(rootPath, profile.data.BINPATCH.client);
                await util_1.vfs.ensureFile(jsonPath);
                await util_1.vfs.writeFile(installJsonPath, JSON.stringify(profile));
                await util_1.vfs.writeFile(jsonPath, JSON.stringify(versionJson));
                await util_1.vfs.ensureFile(clientDataPath);
                const stream = await zip.openEntry(clientDataEntry);
                await util_1.vfs.waitStream(stream.pipe(util_1.vfs.createWriteStream(clientDataPath)));
            }
            async function processExtractLibrary(s, p) {
                const file = mc.getLibraryByPath(p);
                await util_1.vfs.ensureFile(file);
                await util_1.vfs.waitStream(s.pipe(util_1.vfs.createWriteStream(file)));
            }
            try {
                let zip;
                try {
                    zip = await context.execute("downloadInstaller", downloadInstallerTask(installerURL, installJar));
                }
                catch (_a) {
                    zip = await context.execute("downloadInstaller", downloadInstallerTask(installerURLFallback, installJar));
                }
                const [forgeEntry, forgeUniversalEntry, clientDataEntry, installProfileEntry, versionEntry] = await zip.filterEntries([
                    `maven/net/minecraftforge/forge/${forgeVersion}/forge-${forgeVersion}.jar`,
                    `maven/net/minecraftforge/forge/${forgeVersion}/forge-${forgeVersion}-universal.jar`,
                    "data/client.lzma",
                    "install_profile.json",
                    "version.json"
                ]);
                if (!forgeEntry) {
                    throw new Error("Missing forge jar entry");
                }
                if (!forgeUniversalEntry) {
                    throw new Error("Missing forge universal entry");
                }
                if (!installProfileEntry) {
                    throw new Error("Missing install profile");
                }
                if (!versionEntry) {
                    throw new Error("Missing version entry");
                }
                await processExtractLibrary(await zip.openEntry(forgeEntry), forgeEntry.fileName);
                await processExtractLibrary(await zip.openEntry(forgeUniversalEntry), forgeUniversalEntry.fileName);
                await processVersion(zip, installProfileEntry, versionEntry, clientDataEntry);
                await installByInstallerPartialWork(mc, profile, versionJson, java, installLibOption)(context);
                return versionId;
            }
            catch (e) {
                if (clearTempDir) {
                    await util_1.vfs.remove(temp);
                }
                throw e;
            }
        };
    }
    function installByUniversalTask(version, minecraft, maven, checkDependecies) {
        return async (context) => {
            const mc = typeof minecraft === "string" ? new util_1.MinecraftFolder(minecraft) : minecraft;
            const forgeVersion = `${version.mcversion}-${version.version}`;
            const jarPath = mc.getLibraryByPath(`net/minecraftforge/forge/${forgeVersion}/forge-${forgeVersion}.jar`);
            let fullVersion;
            let realJarPath;
            const universalURLFallback = `${maven}/maven/net/minecraftforge/forge/${forgeVersion}/forge-${forgeVersion}-universal.jar`;
            const universalURL = `${maven}${version.universal.path}`;
            await context.execute("installForgeJar", async () => {
                if (await util_1.vfs.exists(jarPath)) {
                    const valid = await util_1.vfs.validate(jarPath, { algorithm: "md5", hash: version.universal.md5 }, { algorithm: "sha1", hash: version.universal.sha1 });
                    if (valid) {
                        return;
                    }
                }
                try {
                    await context.execute("downloadJar", net_1.downloadFileWork({ url: universalURL, destination: jarPath }));
                }
                catch (_a) {
                    await context.execute("redownloadJar", net_1.downloadFileWork({ url: universalURLFallback, destination: jarPath }));
                }
            });
            await context.execute("installForgeJson", async () => {
                const zip = await unzip_1.default.open(jarPath, { lazyEntries: true });
                const [versionEntry] = await zip.filterEntries(["version.json"]);
                if (versionEntry) {
                    const buf = await zip.readEntry(versionEntry);
                    const raw = JSON.parse(buf.toString());
                    const id = raw.id;
                    fullVersion = id;
                    const rootPath = mc.getVersionRoot(fullVersion);
                    realJarPath = mc.getLibraryByPath(version_1.Version.getLibraryInfo(raw.libraries.find((l) => l.name.startsWith("net.minecraftforge:forge"))).path);
                    await util_1.vfs.ensureDir(rootPath);
                    await util_1.vfs.writeFile(path.join(rootPath, `${id}.json`), buf);
                }
                else {
                    throw new Error(`Cannot install forge json for ${version.version} since the version json is missing!`);
                }
            });
            if (realJarPath !== jarPath) {
                await util_1.vfs.ensureFile(realJarPath);
                await util_1.vfs.copyFile(jarPath, realJarPath);
                await util_1.vfs.unlink(jarPath);
            }
            if (checkDependecies) {
                const resolvedVersion = await version_1.Version.parse(minecraft, fullVersion);
                context.execute("installDependencies", installer_1.Installer.installDependenciesTask(resolvedVersion).work);
            }
            return fullVersion;
        };
    }
    /**
     * Install forge to target location.
     * Installation task for forge with mcversion >= 1.13 requires java installed on your pc.
     * @param version The forge version meta
     */
    function install(version, minecraft, option) {
        return installTask(version, minecraft, option).execute();
    }
    ForgeInstaller.install = install;
    /**
     * Install forge to target location.
     * Installation task for forge with mcversion >= 1.13 requires java installed on your pc.
     * @param version The forge version meta
     */
    function installTask(version, minecraft, option = {}) {
        let byInstaller = true;
        try {
            const minorVersion = Number.parseInt(version.mcversion.split(".")[1], 10);
            byInstaller = minorVersion >= 13;
        }
        catch (_a) { }
        const work = byInstaller ? installByInstallerTask(version, minecraft, option.maven || ForgeInstaller.DEFAULT_FORGE_MAVEN, option, option.java || util_1.JavaExecutor.createSimple("java"), option.tempDir, option.clearTempDirAfterInstall)
            : installByUniversalTask(version, minecraft, option.maven || ForgeInstaller.DEFAULT_FORGE_MAVEN, option.forceInstallDependencies === true);
        return task_1.default.create("installForge", work);
    }
    ForgeInstaller.installTask = installTask;
})(ForgeInstaller = exports.ForgeInstaller || (exports.ForgeInstaller = {}));
__export(require("./forgeweb"));
exports.default = ForgeInstaller;
//# sourceMappingURL=index.js.map