6 files changed, 1275 insertions, 0 deletions
diff --git a/launcher/modplatform/atlauncher/ATLPackIndex.cpp b/launcher/modplatform/atlauncher/ATLPackIndex.cpp
new file mode 100644
index 00000000..35f50b18
--- /dev/null
+++ b/launcher/modplatform/atlauncher/ATLPackIndex.cpp
@@ -0,0 +1,33 @@
+#include "ATLPackIndex.h"
+
+#include <QRegularExpression>
+
+#include "Json.h"
+
+static void loadIndexedVersion(ATLauncher::IndexedVersion & v, QJsonObject & obj)
+{
+    v.version = Json::requireString(obj, "version");
+    v.minecraft = Json::requireString(obj, "minecraft");
+}
+
+void ATLauncher::loadIndexedPack(ATLauncher::IndexedPack & m, QJsonObject & obj)
+{
+    m.id = Json::requireInteger(obj, "id");
+    m.position = Json::requireInteger(obj, "position");
+    m.name = Json::requireString(obj, "name");
+    m.type = Json::requireString(obj, "type") == "private" ?
+            ATLauncher::PackType::Private :
+            ATLauncher::PackType::Public;
+    auto versionsArr = Json::requireArray(obj, "versions");
+    for (const auto versionRaw : versionsArr)
+    {
+        auto versionObj = Json::requireObject(versionRaw);
+        ATLauncher::IndexedVersion version;
+        loadIndexedVersion(version, versionObj);
+        m.versions.append(version);
+    }
+    m.system = Json::ensureBoolean(obj, QString("system"), false);
+    m.description = Json::ensureString(obj, "description", "");
+
+    m.safeName = Json::requireString(obj, "name").replace(QRegularExpression("[^A-Za-z0-9]"), "");
+}
diff --git a/launcher/modplatform/atlauncher/ATLPackIndex.h b/launcher/modplatform/atlauncher/ATLPackIndex.h
new file mode 100644
index 00000000..405a3448
--- /dev/null
+++ b/launcher/modplatform/atlauncher/ATLPackIndex.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ATLPackManifest.h"
+
+#include <QString>
+#include <QVector>
+#include <QMetaType>
+
+namespace ATLauncher
+{
+
+struct IndexedVersion
+{
+    QString version;
+    QString minecraft;
+};
+
+struct IndexedPack
+{
+    int id;
+    int position;
+    QString name;
+    PackType type;
+    QVector<IndexedVersion> versions;
+    bool system;
+    QString description;
+
+    QString safeName;
+};
+
+void loadIndexedPack(IndexedPack & m, QJsonObject & obj);
+}
+
+Q_DECLARE_METATYPE(ATLauncher::IndexedPack)
diff --git a/launcher/modplatform/atlauncher/ATLPackInstallTask.cpp b/launcher/modplatform/atlauncher/ATLPackInstallTask.cpp
new file mode 100644
index 00000000..55087a27
--- /dev/null
+++ b/launcher/modplatform/atlauncher/ATLPackInstallTask.cpp
@@ -0,0 +1,764 @@
+#include <Env.h>
+#include <quazip.h>
+#include <QtConcurrent/QtConcurrent>
+#include <MMCZip.h>
+#include <minecraft/OneSixVersionFormat.h>
+#include <Version.h>
+#include <net/ChecksumValidator.h>
+#include "ATLPackInstallTask.h"
+
+#include "BuildConfig.h"
+#include "FileSystem.h"
+#include "Json.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
+#include "settings/INISettingsObject.h"
+#include "meta/Index.h"
+#include "meta/Version.h"
+#include "meta/VersionList.h"
+
+namespace ATLauncher {
+
+PackInstallTask::PackInstallTask(UserInteractionSupport *support, QString pack, QString version)
+{
+    m_support = support;
+    m_pack = pack;
+    m_version_name = version;
+}
+
+bool PackInstallTask::abort()
+{
+    if(abortable)
+    {
+        return jobPtr->abort();
+    }
+    return false;
+}
+
+void PackInstallTask::executeTask()
+{
+    qDebug() << "PackInstallTask::executeTask: " << QThread::currentThreadId();
+    auto *netJob = new NetJob("ATLauncher::VersionFetch");
+    auto searchUrl = QString(BuildConfig.ATL_DOWNLOAD_SERVER_URL + "packs/%1/versions/%2/Configs.json")
+            .arg(m_pack).arg(m_version_name);
+    netJob->addNetAction(Net::Download::makeByteArray(QUrl(searchUrl), &response));
+    jobPtr = netJob;
+    jobPtr->start();
+
+    QObject::connect(netJob, &NetJob::succeeded, this, &PackInstallTask::onDownloadSucceeded);
+    QObject::connect(netJob, &NetJob::failed, this, &PackInstallTask::onDownloadFailed);
+}
+
+void PackInstallTask::onDownloadSucceeded()
+{
+    qDebug() << "PackInstallTask::onDownloadSucceeded: " << QThread::currentThreadId();
+    jobPtr.reset();
+
+    QJsonParseError parse_error;
+    QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
+    if(parse_error.error != QJsonParseError::NoError) {
+        qWarning() << "Error while parsing JSON response from FTB at " << parse_error.offset << " reason: " << parse_error.errorString();
+        qWarning() << response;
+        return;
+    }
+
+    auto obj = doc.object();
+
+    ATLauncher::PackVersion version;
+    try
+    {
+        ATLauncher::loadVersion(version, obj);
+    }
+    catch (const JSONValidationError &e)
+    {
+        emitFailed(tr("Could not understand pack manifest:\n") + e.cause());
+        return;
+    }
+    m_version = version;
+
+    auto vlist = ENV.metadataIndex()->get("net.minecraft");
+    if(!vlist)
+    {
+        emitFailed(tr("Failed to get local metadata index for %1").arg("net.minecraft"));
+        return;
+    }
+
+    auto ver = vlist->getVersion(m_version.minecraft);
+    if (!ver) {
+        emitFailed(tr("Failed to get local metadata index for '%1' v%2").arg("net.minecraft").arg(m_version.minecraft));
+        return;
+    }
+    ver->load(Net::Mode::Online);
+    minecraftVersion = ver;
+
+    if(m_version.noConfigs) {
+        downloadMods();
+    }
+    else {
+        installConfigs();
+    }
+}
+
+void PackInstallTask::onDownloadFailed(QString reason)
+{
+    qDebug() << "PackInstallTask::onDownloadFailed: " << QThread::currentThreadId();
+    jobPtr.reset();
+    emitFailed(reason);
+}
+
+QString PackInstallTask::getDirForModType(ModType type, QString raw)
+{
+    switch (type) {
+        // Mod types that can either be ignored at this stage, or ignored
+        // completely.
+        case ModType::Root:
+        case ModType::Extract:
+        case ModType::Decomp:
+        case ModType::TexturePackExtract:
+        case ModType::ResourcePackExtract:
+        case ModType::MCPC:
+            return Q_NULLPTR;
+        case ModType::Forge:
+            // Forge detection happens later on, if it cannot be detected it will
+            // install a jarmod component.
+        case ModType::Jar:
+            return "jarmods";
+        case ModType::Mods:
+            return "mods";
+        case ModType::Flan:
+            return "Flan";
+        case ModType::Dependency:
+            return FS::PathCombine("mods", m_version.minecraft);
+        case ModType::Ic2Lib:
+            return FS::PathCombine("mods", "ic2");
+        case ModType::DenLib:
+            return FS::PathCombine("mods", "denlib");
+        case ModType::Coremods:
+            return "coremods";
+        case ModType::Plugins:
+            return "plugins";
+        case ModType::TexturePack:
+            return "texturepacks";
+        case ModType::ResourcePack:
+            return "resourcepacks";
+        case ModType::ShaderPack:
+            return "shaderpacks";
+        case ModType::Millenaire:
+            qWarning() << "Unsupported mod type: " + raw;
+            return Q_NULLPTR;
+        case ModType::Unknown:
+            emitFailed(tr("Unknown mod type: %1").arg(raw));
+            return Q_NULLPTR;
+    }
+
+    return Q_NULLPTR;
+}
+
+QString PackInstallTask::getVersionForLoader(QString uid)
+{
+    if(m_version.loader.recommended || m_version.loader.latest || m_version.loader.choose) {
+        auto vlist = ENV.metadataIndex()->get(uid);
+        if(!vlist)
+        {
+            emitFailed(tr("Failed to get local metadata index for %1").arg(uid));
+            return Q_NULLPTR;
+        }
+
+        if(!vlist->isLoaded()) {
+            vlist->load(Net::Mode::Online);
+        }
+
+        if(m_version.loader.recommended || m_version.loader.latest) {
+            for (int i = 0; i < vlist->versions().size(); i++) {
+                auto version = vlist->versions().at(i);
+                auto reqs = version->requires();
+
+                // filter by minecraft version, if the loader depends on a certain version.
+                // not all mod loaders depend on a given Minecraft version, so we won't do this
+                // filtering for those loaders.
+                if (m_version.loader.type != "fabric") {
+                    auto iter = std::find_if(reqs.begin(), reqs.end(), [](const Meta::Require &req) {
+                        return req.uid == "net.minecraft";
+                    });
+                    if (iter == reqs.end()) continue;
+                    if (iter->equalsVersion != m_version.minecraft) continue;
+                }
+
+                if (m_version.loader.recommended) {
+                    // first recommended build we find, we use.
+                    if (!version->isRecommended()) continue;
+                }
+
+                return version->descriptor();
+            }
+
+            emitFailed(tr("Failed to find version for %1 loader").arg(m_version.loader.type));
+            return Q_NULLPTR;
+        }
+        else if(m_version.loader.choose) {
+            // Fabric Loader doesn't depend on a given Minecraft version.
+            if (m_version.loader.type == "fabric") {
+                return m_support->chooseVersion(vlist, Q_NULLPTR);
+            }
+
+            return m_support->chooseVersion(vlist, m_version.minecraft);
+        }
+    }
+
+    if (m_version.loader.version == Q_NULLPTR || m_version.loader.version.isEmpty()) {
+        emitFailed(tr("No loader version set for modpack!"));
+        return Q_NULLPTR;
+    }
+
+    return m_version.loader.version;
+}
+
+QString PackInstallTask::detectLibrary(VersionLibrary library)
+{
+    // Try to detect what the library is
+    if (!library.server.isEmpty() && library.server.split("/").length() >= 3) {
+        auto lastSlash = library.server.lastIndexOf("/");
+        auto locationAndVersion = library.server.mid(0, lastSlash);
+        auto fileName = library.server.mid(lastSlash + 1);
+
+        lastSlash = locationAndVersion.lastIndexOf("/");
+        auto location = locationAndVersion.mid(0, lastSlash);
+        auto version = locationAndVersion.mid(lastSlash + 1);
+
+        lastSlash = location.lastIndexOf("/");
+        auto group = location.mid(0, lastSlash).replace("/", ".");
+        auto artefact = location.mid(lastSlash + 1);
+
+        return group + ":" + artefact + ":" + version;
+    }
+
+    if(library.file.contains("-")) {
+        auto lastSlash = library.file.lastIndexOf("-");
+        auto name = library.file.mid(0, lastSlash);
+        auto version = library.file.mid(lastSlash + 1).remove(".jar");
+
+        if(name == QString("guava")) {
+            return "com.google.guava:guava:" + version;
+        }
+        else if(name == QString("commons-lang3")) {
+            return "org.apache.commons:commons-lang3:" + version;
+        }
+    }
+
+    return "org.multimc.atlauncher:" + library.md5 + ":1";
+}
+
+bool PackInstallTask::createLibrariesComponent(QString instanceRoot, std::shared_ptr<PackProfile> profile)
+{
+    if(m_version.libraries.isEmpty()) {
+        return true;
+    }
+
+    QList<GradleSpecifier> exempt;
+    for(const auto & componentUid : componentsToInstall.keys()) {
+        auto componentVersion = componentsToInstall.value(componentUid);
+
+        for(const auto & library : componentVersion->data()->libraries) {
+            GradleSpecifier lib(library->rawName());
+            exempt.append(lib);
+        }
+    }
+
+    {
+        for(const auto & library : minecraftVersion->data()->libraries) {
+            GradleSpecifier lib(library->rawName());
+            exempt.append(lib);
+        }
+    }
+
+    auto uuid = QUuid::createUuid();
+    auto id = uuid.toString().remove('{').remove('}');
+    auto target_id = "org.multimc.atlauncher." + id;
+
+    auto patchDir = FS::PathCombine(instanceRoot, "patches");
+    if(!FS::ensureFolderPathExists(patchDir))
+    {
+        return false;
+    }
+    auto patchFileName = FS::PathCombine(patchDir, target_id + ".json");
+
+    auto f = std::make_shared<VersionFile>();
+    f->name = m_pack + " " + m_version_name + " (libraries)";
+
+    for(const auto & lib : m_version.libraries) {
+        auto libName = detectLibrary(lib);
+        GradleSpecifier libSpecifier(libName);
+
+        bool libExempt = false;
+        for(const auto & existingLib : exempt) {
+            if(libSpecifier.matchName(existingLib)) {
+                // If the pack specifies a newer version of the lib, use that!
+                libExempt = Version(libSpecifier.version()) >= Version(existingLib.version());
+            }
+        }
+        if(libExempt) continue;
+
+        auto library = std::make_shared<Library>();
+        library->setRawName(libName);
+
+        switch(lib.download) {
+            case DownloadType::Server:
+                library->setAbsoluteUrl(BuildConfig.ATL_DOWNLOAD_SERVER_URL + lib.url);
+                break;
+            case DownloadType::Direct:
+                library->setAbsoluteUrl(lib.url);
+                break;
+            case DownloadType::Browser:
+            case DownloadType::Unknown:
+                emitFailed(tr("Unknown or unsupported download type: %1").arg(lib.download_raw));
+                return false;
+        }
+
+        f->libraries.append(library);
+    }
+
+    if(f->libraries.isEmpty()) {
+        return true;
+    }
+
+    QFile file(patchFileName);
+    if (!file.open(QFile::WriteOnly))
+    {
+        qCritical() << "Error opening" << file.fileName()
+                    << "for reading:" << file.errorString();
+        return false;
+    }
+    file.write(OneSixVersionFormat::versionFileToJson(f).toJson());
+    file.close();
+
+    profile->appendComponent(new Component(profile.get(), target_id, f));
+    return true;
+}
+
+bool PackInstallTask::createPackComponent(QString instanceRoot, std::shared_ptr<PackProfile> profile)
+{
+    if(m_version.mainClass == QString() && m_version.extraArguments == QString()) {
+        return true;
+    }
+
+    auto uuid = QUuid::createUuid();
+    auto id = uuid.toString().remove('{').remove('}');
+    auto target_id = "org.multimc.atlauncher." + id;
+
+    auto patchDir = FS::PathCombine(instanceRoot, "patches");
+    if(!FS::ensureFolderPathExists(patchDir))
+    {
+        return false;
+    }
+    auto patchFileName = FS::PathCombine(patchDir, target_id + ".json");
+
+    QStringList mainClasses;
+    QStringList tweakers;
+    for(const auto & componentUid : componentsToInstall.keys()) {
+        auto componentVersion = componentsToInstall.value(componentUid);
+
+        if(componentVersion->data()->mainClass != QString("")) {
+            mainClasses.append(componentVersion->data()->mainClass);
+        }
+        tweakers.append(componentVersion->data()->addTweakers);
+    }
+
+    auto f = std::make_shared<VersionFile>();
+    f->name = m_pack + " " + m_version_name;
+    if(m_version.mainClass != QString() && !mainClasses.contains(m_version.mainClass)) {
+        f->mainClass = m_version.mainClass;
+    }
+
+    // Parse out tweakers
+    auto args = m_version.extraArguments.split(" ");
+    QString previous;
+    for(auto arg : args) {
+        if(arg.startsWith("--tweakClass=") || previous == "--tweakClass") {
+            auto tweakClass = arg.remove("--tweakClass=");
+            if(tweakers.contains(tweakClass)) continue;
+
+            f->addTweakers.append(tweakClass);
+        }
+        previous = arg;
+    }
+
+    if(f->mainClass == QString() && f->addTweakers.isEmpty()) {
+        return true;
+    }
+
+    QFile file(patchFileName);
+    if (!file.open(QFile::WriteOnly))
+    {
+        qCritical() << "Error opening" << file.fileName()
+                    << "for reading:" << file.errorString();
+        return false;
+    }
+    file.write(OneSixVersionFormat::versionFileToJson(f).toJson());
+    file.close();
+
+    profile->appendComponent(new Component(profile.get(), target_id, f));
+    return true;
+}
+
+void PackInstallTask::installConfigs()
+{
+    qDebug() << "PackInstallTask::installConfigs: " << QThread::currentThreadId();
+    setStatus(tr("Downloading configs..."));
+    jobPtr.reset(new NetJob(tr("Config download")));
+
+    auto path = QString("Configs/%1/%2.zip").arg(m_pack).arg(m_version_name);
+    auto url = QString(BuildConfig.ATL_DOWNLOAD_SERVER_URL + "packs/%1/versions/%2/Configs.zip")
+            .arg(m_pack).arg(m_version_name);
+    auto entry = ENV.metacache()->resolveEntry("ATLauncherPacks", path);
+    entry->setStale(true);
+
+    auto dl = Net::Download::makeCached(url, entry);
+    if (!m_version.configs.sha1.isEmpty()) {
+        auto rawSha1 = QByteArray::fromHex(m_version.configs.sha1.toLatin1());
+        dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawSha1));
+    }
+    jobPtr->addNetAction(dl);
+    archivePath = entry->getFullPath();
+
+    connect(jobPtr.get(), &NetJob::succeeded, this, [&]()
+    {
+        abortable = false;
+        jobPtr.reset();
+        extractConfigs();
+    });
+    connect(jobPtr.get(), &NetJob::failed, [&](QString reason)
+    {
+        abortable = false;
+        jobPtr.reset();
+        emitFailed(reason);
+    });
+    connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total)
+    {
+        abortable = true;
+        setProgress(current, total);
+    });
+
+    jobPtr->start();
+}
+
+void PackInstallTask::extractConfigs()
+{
+    qDebug() << "PackInstallTask::extractConfigs: " << QThread::currentThreadId();
+    setStatus(tr("Extracting configs..."));
+
+    QDir extractDir(m_stagingPath);
+
+    QuaZip packZip(archivePath);
+    if(!packZip.open(QuaZip::mdUnzip))
+    {
+        emitFailed(tr("Failed to open pack configs %1!").arg(archivePath));
+        return;
+    }
+
+    m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, archivePath, extractDir.absolutePath() + "/minecraft");
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, [&]()
+    {
+        downloadMods();
+    });
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, [&]()
+    {
+        emitAborted();
+    });
+    m_extractFutureWatcher.setFuture(m_extractFuture);
+}
+
+void PackInstallTask::downloadMods()
+{
+    qDebug() << "PackInstallTask::installMods: " << QThread::currentThreadId();
+
+    QVector<ATLauncher::VersionMod> optionalMods;
+    for (const auto& mod : m_version.mods) {
+        if (mod.optional) {
+            optionalMods.push_back(mod);
+        }
+    }
+
+    // Select optional mods, if pack contains any
+    QVector<QString> selectedMods;
+    if (!optionalMods.isEmpty()) {
+        setStatus(tr("Selecting optional mods..."));
+        selectedMods = m_support->chooseOptionalMods(optionalMods);
+    }
+
+    setStatus(tr("Downloading mods..."));
+
+    jarmods.clear();
+    jobPtr.reset(new NetJob(tr("Mod download")));
+    for(const auto& mod : m_version.mods) {
+        // skip non-client mods
+        if(!mod.client) continue;
+
+        // skip optional mods that were not selected
+        if(mod.optional && !selectedMods.contains(mod.name)) continue;
+
+        QString url;
+        switch(mod.download) {
+            case DownloadType::Server:
+                url = BuildConfig.ATL_DOWNLOAD_SERVER_URL + mod.url;
+                break;
+            case DownloadType::Browser:
+                emitFailed(tr("Unsupported download type: %1").arg(mod.download_raw));
+                return;
+            case DownloadType::Direct:
+                url = mod.url;
+                break;
+            case DownloadType::Unknown:
+                emitFailed(tr("Unknown download type: %1").arg(mod.download_raw));
+                return;
+        }
+
+        QFileInfo fileName(mod.file);
+        auto cacheName = fileName.completeBaseName() + "-" + mod.md5 + "." + fileName.suffix();
+
+        if (mod.type == ModType::Extract || mod.type == ModType::TexturePackExtract || mod.type == ModType::ResourcePackExtract) {
+            auto entry = ENV.metacache()->resolveEntry("ATLauncherPacks", cacheName);
+            entry->setStale(true);
+            modsToExtract.insert(entry->getFullPath(), mod);
+
+            auto dl = Net::Download::makeCached(url, entry);
+            if (!mod.md5.isEmpty()) {
+                auto rawMd5 = QByteArray::fromHex(mod.md5.toLatin1());
+                dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Md5, rawMd5));
+            }
+            jobPtr->addNetAction(dl);
+        }
+        else if(mod.type == ModType::Decomp) {
+            auto entry = ENV.metacache()->resolveEntry("ATLauncherPacks", cacheName);
+            entry->setStale(true);
+            modsToDecomp.insert(entry->getFullPath(), mod);
+
+            auto dl = Net::Download::makeCached(url, entry);
+            if (!mod.md5.isEmpty()) {
+                auto rawMd5 = QByteArray::fromHex(mod.md5.toLatin1());
+                dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Md5, rawMd5));
+            }
+            jobPtr->addNetAction(dl);
+        }
+        else {
+            auto relpath = getDirForModType(mod.type, mod.type_raw);
+            if(relpath == Q_NULLPTR) continue;
+
+            auto entry = ENV.metacache()->resolveEntry("ATLauncherPacks", cacheName);
+            entry->setStale(true);
+
+            auto dl = Net::Download::makeCached(url, entry);
+            if (!mod.md5.isEmpty()) {
+                auto rawMd5 = QByteArray::fromHex(mod.md5.toLatin1());
+                dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Md5, rawMd5));
+            }
+            jobPtr->addNetAction(dl);
+
+            auto path = FS::PathCombine(m_stagingPath, "minecraft", relpath, mod.file);
+            qDebug() << "Will download" << url << "to" << path;
+            modsToCopy[entry->getFullPath()] = path;
+
+            if(mod.type == ModType::Forge) {
+                auto vlist = ENV.metadataIndex()->get("net.minecraftforge");
+                if(vlist)
+                {
+                    auto ver = vlist->getVersion(mod.version);
+                    if(ver) {
+                        ver->load(Net::Mode::Online);
+                        componentsToInstall.insert("net.minecraftforge", ver);
+                        continue;
+                    }
+                }
+
+                qDebug() << "Jarmod: " + path;
+                jarmods.push_back(path);
+            }
+
+            if(mod.type == ModType::Jar) {
+                qDebug() << "Jarmod: " + path;
+                jarmods.push_back(path);
+            }
+        }
+    }
+
+    connect(jobPtr.get(), &NetJob::succeeded, this, &PackInstallTask::onModsDownloaded);
+    connect(jobPtr.get(), &NetJob::failed, [&](QString reason)
+    {
+        abortable = false;
+        jobPtr.reset();
+        emitFailed(reason);
+    });
+    connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total)
+    {
+        abortable = true;
+        setProgress(current, total);
+    });
+
+    jobPtr->start();
+}
+
+void PackInstallTask::onModsDownloaded() {
+    abortable = false;
+
+    qDebug() << "PackInstallTask::onModsDownloaded: " << QThread::currentThreadId();
+    jobPtr.reset();
+
+    if(!modsToExtract.empty() || !modsToDecomp.empty() || !modsToCopy.empty()) {
+        m_modExtractFuture = QtConcurrent::run(QThreadPool::globalInstance(), this, &PackInstallTask::extractMods, modsToExtract, modsToDecomp, modsToCopy);
+        connect(&m_modExtractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &PackInstallTask::onModsExtracted);
+        connect(&m_modExtractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, [&]()
+        {
+            emitAborted();
+        });
+        m_modExtractFutureWatcher.setFuture(m_modExtractFuture);
+    }
+    else {
+        install();
+    }
+}
+
+void PackInstallTask::onModsExtracted() {
+    qDebug() << "PackInstallTask::onModsExtracted: " << QThread::currentThreadId();
+    if(m_modExtractFuture.result()) {
+        install();
+    }
+    else {
+        emitFailed(tr("Failed to extract mods..."));
+    }
+}
+
+bool PackInstallTask::extractMods(
+    const QMap<QString, VersionMod> &toExtract,
+    const QMap<QString, VersionMod> &toDecomp,
+    const QMap<QString, QString> &toCopy
+) {
+    qDebug() << "PackInstallTask::extractMods: " << QThread::currentThreadId();
+
+    setStatus(tr("Extracting mods..."));
+    for (auto iter = toExtract.begin(); iter != toExtract.end(); iter++) {
+        auto &modPath = iter.key();
+        auto &mod = iter.value();
+
+        QString extractToDir;
+        if(mod.type == ModType::Extract) {
+            extractToDir = getDirForModType(mod.extractTo, mod.extractTo_raw);
+        }
+        else if(mod.type == ModType::TexturePackExtract) {
+            extractToDir = FS::PathCombine("texturepacks", "extracted");
+        }
+        else if(mod.type == ModType::ResourcePackExtract) {
+            extractToDir = FS::PathCombine("resourcepacks", "extracted");
+        }
+
+        QDir extractDir(m_stagingPath);
+        auto extractToPath = FS::PathCombine(extractDir.absolutePath(), "minecraft", extractToDir);
+
+        QString folderToExtract = "";
+        if(mod.type == ModType::Extract) {
+            folderToExtract = mod.extractFolder;
+            folderToExtract.remove(QRegExp("^/"));
+        }
+
+        qDebug() << "Extracting " + mod.file + " to " + extractToDir;
+        if(!MMCZip::extractDir(modPath, folderToExtract, extractToPath)) {
+            // assume error
+            return false;
+        }
+    }
+
+    for (auto iter = toDecomp.begin(); iter != toDecomp.end(); iter++) {
+        auto &modPath = iter.key();
+        auto &mod = iter.value();
+        auto extractToDir = getDirForModType(mod.decompType, mod.decompType_raw);
+
+        QDir extractDir(m_stagingPath);
+        auto extractToPath = FS::PathCombine(extractDir.absolutePath(), "minecraft", extractToDir, mod.decompFile);
+
+        qDebug() << "Extracting " + mod.decompFile + " to " + extractToDir;
+        if(!MMCZip::extractFile(modPath, mod.decompFile, extractToPath)) {
+            qWarning() << "Failed to extract" << mod.decompFile;
+            return false;
+        }
+    }
+
+    for (auto iter = toCopy.begin(); iter != toCopy.end(); iter++) {
+        auto &from = iter.key();
+        auto &to = iter.value();
+        FS::copy fileCopyOperation(from, to);
+        if(!fileCopyOperation()) {
+            qWarning() << "Failed to copy" << from << "to" << to;
+            return false;
+        }
+    }
+    return true;
+}
+
+void PackInstallTask::install()
+{
+    qDebug() << "PackInstallTask::install: " << QThread::currentThreadId();
+    setStatus(tr("Installing modpack"));
+
+    auto instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
+    auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
+    instanceSettings->suspendSave();
+    instanceSettings->registerSetting("InstanceType", "Legacy");
+    instanceSettings->set("InstanceType", "OneSix");
+
+    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
+    auto components = instance.getPackProfile();
+    components->buildingFromScratch();
+
+    // Use a component to add libraries BEFORE Minecraft
+    if(!createLibrariesComponent(instance.instanceRoot(), components)) {
+        emitFailed(tr("Failed to create libraries component"));
+        return;
+    }
+
+    // Minecraft
+    components->setComponentVersion("net.minecraft", m_version.minecraft, true);
+
+    // Loader
+    if(m_version.loader.type == QString("forge"))
+    {
+        auto version = getVersionForLoader("net.minecraftforge");
+        if(version == Q_NULLPTR) return;
+
+        components->setComponentVersion("net.minecraftforge", version, true);
+    }
+    else if(m_version.loader.type == QString("fabric"))
+    {
+        auto version = getVersionForLoader("net.fabricmc.fabric-loader");
+        if(version == Q_NULLPTR) return;
+
+        components->setComponentVersion("net.fabricmc.fabric-loader", version, true);
+    }
+    else if(m_version.loader.type != QString())
+    {
+        emitFailed(tr("Unknown loader type: ") + m_version.loader.type);
+        return;
+    }
+
+    for(const auto & componentUid : componentsToInstall.keys()) {
+        auto version = componentsToInstall.value(componentUid);
+        components->setComponentVersion(componentUid, version->version());
+    }
+
+    components->installJarMods(jarmods);
+
+    // Use a component to fill in the rest of the data
+    // todo: use more detection
+    if(!createPackComponent(instance.instanceRoot(), components)) {
+        emitFailed(tr("Failed to create pack component"));
+        return;
+    }
+
+    components->saveNow();
+
+    instance.setName(m_instName);
+    instance.setIconKey(m_instIcon);
+    instanceSettings->resumeSave();
+
+    jarmods.clear();
+    emitSucceeded();
+}
+
+}
diff --git a/launcher/modplatform/atlauncher/ATLPackInstallTask.h b/launcher/modplatform/atlauncher/ATLPackInstallTask.h
new file mode 100644
index 00000000..39e2b013
--- /dev/null
+++ b/launcher/modplatform/atlauncher/ATLPackInstallTask.h
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <meta/VersionList.h>
+#include "ATLPackManifest.h"
+
+#include "InstanceTask.h"
+#include "net/NetJob.h"
+#include "settings/INISettingsObject.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
+#include "meta/Version.h"
+
+#include <nonstd/optional>
+
+namespace ATLauncher {
+
+class UserInteractionSupport {
+
+public:
+    /**
+     * Requests a user interaction to select which optional mods should be installed.
+     */
+    virtual QVector<QString> chooseOptionalMods(QVector<ATLauncher::VersionMod> mods) = 0;
+
+    /**
+     * Requests a user interaction to select a component version from a given version list
+     * and constrained to a given Minecraft version.
+     */
+    virtual QString chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) = 0;
+
+};
+
+class PackInstallTask : public InstanceTask
+{
+Q_OBJECT
+
+public:
+    explicit PackInstallTask(UserInteractionSupport *support, QString pack, QString version);
+    virtual ~PackInstallTask(){}
+
+    bool canAbort() const override { return true; }
+    bool abort() override;
+
+protected:
+    virtual void executeTask() override;
+
+private slots:
+    void onDownloadSucceeded();
+    void onDownloadFailed(QString reason);
+
+    void onModsDownloaded();
+    void onModsExtracted();
+
+private:
+    QString getDirForModType(ModType type, QString raw);
+    QString getVersionForLoader(QString uid);
+    QString detectLibrary(VersionLibrary library);
+
+    bool createLibrariesComponent(QString instanceRoot, std::shared_ptr<PackProfile> profile);
+    bool createPackComponent(QString instanceRoot, std::shared_ptr<PackProfile> profile);
+
+    void installConfigs();
+    void extractConfigs();
+    void downloadMods();
+    bool extractMods(
+        const QMap<QString, VersionMod> &toExtract,
+        const QMap<QString, VersionMod> &toDecomp,
+        const QMap<QString, QString> &toCopy
+    );
+    void install();
+
+private:
+    UserInteractionSupport *m_support;
+
+    bool abortable = false;
+
+    NetJobPtr jobPtr;
+    QByteArray response;
+
+    QString m_pack;
+    QString m_version_name;
+    PackVersion m_version;
+
+    QMap<QString, VersionMod> modsToExtract;
+    QMap<QString, VersionMod> modsToDecomp;
+    QMap<QString, QString> modsToCopy;
+
+    QString archivePath;
+    QStringList jarmods;
+    Meta::VersionPtr minecraftVersion;
+    QMap<QString, Meta::VersionPtr> componentsToInstall;
+
+    QFuture<nonstd::optional<QStringList>> m_extractFuture;
+    QFutureWatcher<nonstd::optional<QStringList>> m_extractFutureWatcher;
+
+    QFuture<bool> m_modExtractFuture;
+    QFutureWatcher<bool> m_modExtractFutureWatcher;
+
+};
+
+}
diff --git a/launcher/modplatform/atlauncher/ATLPackManifest.cpp b/launcher/modplatform/atlauncher/ATLPackManifest.cpp
new file mode 100644
index 00000000..e25d8346
--- /dev/null
+++ b/launcher/modplatform/atlauncher/ATLPackManifest.cpp
@@ -0,0 +1,218 @@
+#include "ATLPackManifest.h"
+
+#include "Json.h"
+
+static ATLauncher::DownloadType parseDownloadType(QString rawType) {
+    if(rawType == QString("server")) {
+        return ATLauncher::DownloadType::Server;
+    }
+    else if(rawType == QString("browser")) {
+        return ATLauncher::DownloadType::Browser;
+    }
+    else if(rawType == QString("direct")) {
+        return ATLauncher::DownloadType::Direct;
+    }
+
+    return ATLauncher::DownloadType::Unknown;
+}
+
+static ATLauncher::ModType parseModType(QString rawType) {
+    // See https://wiki.atlauncher.com/mod_types
+    if(rawType == QString("root")) {
+        return ATLauncher::ModType::Root;
+    }
+    else if(rawType == QString("forge")) {
+        return ATLauncher::ModType::Forge;
+    }
+    else if(rawType == QString("jar")) {
+        return ATLauncher::ModType::Jar;
+    }
+    else if(rawType == QString("mods")) {
+        return ATLauncher::ModType::Mods;
+    }
+    else if(rawType == QString("flan")) {
+        return ATLauncher::ModType::Flan;
+    }
+    else if(rawType == QString("dependency") || rawType == QString("depandency")) {
+        return ATLauncher::ModType::Dependency;
+    }
+    else if(rawType == QString("ic2lib")) {
+        return ATLauncher::ModType::Ic2Lib;
+    }
+    else if(rawType == QString("denlib")) {
+        return ATLauncher::ModType::DenLib;
+    }
+    else if(rawType == QString("coremods")) {
+        return ATLauncher::ModType::Coremods;
+    }
+    else if(rawType == QString("mcpc")) {
+        return ATLauncher::ModType::MCPC;
+    }
+    else if(rawType == QString("plugins")) {
+        return ATLauncher::ModType::Plugins;
+    }
+    else if(rawType == QString("extract")) {
+        return ATLauncher::ModType::Extract;
+    }
+    else if(rawType == QString("decomp")) {
+        return ATLauncher::ModType::Decomp;
+    }
+    else if(rawType == QString("texturepack")) {
+        return ATLauncher::ModType::TexturePack;
+    }
+    else if(rawType == QString("resourcepack")) {
+        return ATLauncher::ModType::ResourcePack;
+    }
+    else if(rawType == QString("shaderpack")) {
+        return ATLauncher::ModType::ShaderPack;
+    }
+    else if(rawType == QString("texturepackextract")) {
+        return ATLauncher::ModType::TexturePackExtract;
+    }
+    else if(rawType == QString("resourcepackextract")) {
+        return ATLauncher::ModType::ResourcePackExtract;
+    }
+    else if(rawType == QString("millenaire")) {
+        return ATLauncher::ModType::Millenaire;
+    }
+
+    return ATLauncher::ModType::Unknown;
+}
+
+static void loadVersionLoader(ATLauncher::VersionLoader & p, QJsonObject & obj) {
+    p.type = Json::requireString(obj, "type");
+    p.choose = Json::ensureBoolean(obj, QString("choose"), false);
+
+    auto metadata = Json::requireObject(obj, "metadata");
+    p.latest = Json::ensureBoolean(metadata, QString("latest"), false);
+    p.recommended = Json::ensureBoolean(metadata, QString("recommended"), false);
+
+    // Minecraft Forge
+    if (p.type == "forge") {
+        p.version = Json::ensureString(metadata, "version", "");
+    }
+
+    // Fabric Loader
+    if (p.type == "fabric") {
+        p.version = Json::ensureString(metadata, "loader", "");
+    }
+}
+
+static void loadVersionLibrary(ATLauncher::VersionLibrary & p, QJsonObject & obj) {
+    p.url = Json::requireString(obj, "url");
+    p.file = Json::requireString(obj, "file");
+    p.md5 = Json::requireString(obj, "md5");
+
+    p.download_raw = Json::requireString(obj, "download");
+    p.download = parseDownloadType(p.download_raw);
+
+    p.server = Json::ensureString(obj, "server", "");
+}
+
+static void loadVersionConfigs(ATLauncher::VersionConfigs & p, QJsonObject & obj) {
+    p.filesize = Json::requireInteger(obj, "filesize");
+    p.sha1 = Json::requireString(obj, "sha1");
+}
+
+static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) {
+    p.name = Json::requireString(obj, "name");
+    p.version = Json::requireString(obj, "version");
+    p.url = Json::requireString(obj, "url");
+    p.file = Json::requireString(obj, "file");
+    p.md5 = Json::ensureString(obj, "md5", "");
+
+    p.download_raw = Json::requireString(obj, "download");
+    p.download = parseDownloadType(p.download_raw);
+
+    p.type_raw = Json::requireString(obj, "type");
+    p.type = parseModType(p.type_raw);
+
+    // This contributes to the Minecraft Forge detection, where we rely on mod.type being "Forge"
+    // when the mod represents Forge. As there is little difference between "Jar" and "Forge, some
+    // packs regretfully use "Jar". This will correct the type to "Forge" in these cases (as best
+    // it can).
+    if(p.name == QString("Minecraft Forge") && p.type == ATLauncher::ModType::Jar) {
+        p.type_raw = "forge";
+        p.type = ATLauncher::ModType::Forge;
+    }
+
+    if(obj.contains("extractTo")) {
+        p.extractTo_raw = Json::requireString(obj, "extractTo");
+        p.extractTo = parseModType(p.extractTo_raw);
+        p.extractFolder = Json::ensureString(obj, "extractFolder", "").replace("%s%", "/");
+    }
+
+    if(obj.contains("decompType")) {
+        p.decompType_raw = Json::requireString(obj, "decompType");
+        p.decompType = parseModType(p.decompType_raw);
+        p.decompFile = Json::requireString(obj, "decompFile");
+    }
+
+    p.description = Json::ensureString(obj, QString("description"), "");
+    p.optional = Json::ensureBoolean(obj, QString("optional"), false);
+    p.recommended = Json::ensureBoolean(obj, QString("recommended"), false);
+    p.selected = Json::ensureBoolean(obj, QString("selected"), false);
+    p.hidden = Json::ensureBoolean(obj, QString("hidden"), false);
+    p.library = Json::ensureBoolean(obj, QString("library"), false);
+    p.group = Json::ensureString(obj, QString("group"), "");
+    if(obj.contains("depends")) {
+        auto dependsArr = Json::requireArray(obj, "depends");
+        for (const auto depends : dependsArr) {
+            p.depends.append(Json::requireString(depends));
+        }
+    }
+
+    p.client = Json::ensureBoolean(obj, QString("client"), false);
+
+    // computed
+    p.effectively_hidden = p.hidden || p.library;
+}
+
+void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj)
+{
+    v.version = Json::requireString(obj, "version");
+    v.minecraft = Json::requireString(obj, "minecraft");
+    v.noConfigs = Json::ensureBoolean(obj, QString("noConfigs"), false);
+
+    if(obj.contains("mainClass")) {
+        auto main = Json::requireObject(obj, "mainClass");
+        v.mainClass = Json::ensureString(main, "mainClass", "");
+    }
+
+    if(obj.contains("extraArguments")) {
+        auto arguments = Json::requireObject(obj, "extraArguments");
+        v.extraArguments = Json::ensureString(arguments, "arguments", "");
+    }
+
+    if(obj.contains("loader")) {
+        auto loader = Json::requireObject(obj, "loader");
+        loadVersionLoader(v.loader, loader);
+    }
+
+    if(obj.contains("libraries")) {
+        auto libraries = Json::requireArray(obj, "libraries");
+        for (const auto libraryRaw : libraries)
+        {
+            auto libraryObj = Json::requireObject(libraryRaw);
+            ATLauncher::VersionLibrary target;
+            loadVersionLibrary(target, libraryObj);
+            v.libraries.append(target);
+        }
+    }
+
+    if(obj.contains("mods")) {
+        auto mods = Json::requireArray(obj, "mods");
+        for (const auto modRaw : mods)
+        {
+            auto modObj = Json::requireObject(modRaw);
+            ATLauncher::VersionMod mod;
+            loadVersionMod(mod, modObj);
+            v.mods.append(mod);
+        }
+    }
+
+    if(obj.contains("configs")) {
+        auto configsObj = Json::requireObject(obj, "configs");
+        loadVersionConfigs(v.configs, configsObj);
+    }
+}
diff --git a/launcher/modplatform/atlauncher/ATLPackManifest.h b/launcher/modplatform/atlauncher/ATLPackManifest.h
new file mode 100644
index 00000000..ead216a5
--- /dev/null
+++ b/launcher/modplatform/atlauncher/ATLPackManifest.h
@@ -0,0 +1,125 @@
+#pragma once
+
+#include <QString>
+#include <QVector>
+#include <QJsonObject>
+
+namespace ATLauncher
+{
+
+enum class PackType
+{
+    Public,
+    Private
+};
+
+enum class ModType
+{
+    Root,
+    Forge,
+    Jar,
+    Mods,
+    Flan,
+    Dependency,
+    Ic2Lib,
+    DenLib,
+    Coremods,
+    MCPC,
+    Plugins,
+    Extract,
+    Decomp,
+    TexturePack,
+    ResourcePack,
+    ShaderPack,
+    TexturePackExtract,
+    ResourcePackExtract,
+    Millenaire,
+    Unknown
+};
+
+enum class DownloadType
+{
+    Server,
+    Browser,
+    Direct,
+    Unknown
+};
+
+struct VersionLoader
+{
+    QString type;
+    bool latest;
+    bool recommended;
+    bool choose;
+
+    QString version;
+};
+
+struct VersionLibrary
+{
+    QString url;
+    QString file;
+    QString server;
+    QString md5;
+    DownloadType download;
+    QString download_raw;
+};
+
+struct VersionMod
+{
+    QString name;
+    QString version;
+    QString url;
+    QString file;
+    QString md5;
+    DownloadType download;
+    QString download_raw;
+    ModType type;
+    QString type_raw;
+
+    ModType extractTo;
+    QString extractTo_raw;
+    QString extractFolder;
+
+    ModType decompType;
+    QString decompType_raw;
+    QString decompFile;
+
+    QString description;
+    bool optional;
+    bool recommended;
+    bool selected;
+    bool hidden;
+    bool library;
+    QString group;
+    QVector<QString> depends;
+
+    bool client;
+
+    // computed
+    bool effectively_hidden;
+};
+
+struct VersionConfigs
+{
+    int filesize;
+    QString sha1;
+};
+
+struct PackVersion
+{
+    QString version;
+    QString minecraft;
+    bool noConfigs;
+    QString mainClass;
+    QString extraArguments;
+
+    VersionLoader loader;
+    QVector<VersionLibrary> libraries;
+    QVector<VersionMod> mods;
+    VersionConfigs configs;
+};
+
+void loadVersion(PackVersion & v, QJsonObject & obj);
+
+}