15 files changed, 1817 insertions, 5 deletions

diff --git a/api/logic/modplatform/atlauncher/ATLPackIndex.cpp b/api/logic/modplatform/atlauncher/ATLPackIndex.cpp
new file mode 100644
index 00000000..35f50b18
--- /dev/null
+++ b/api/logic/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/api/logic/modplatform/atlauncher/ATLPackIndex.h b/api/logic/modplatform/atlauncher/ATLPackIndex.h
new file mode 100644
index 00000000..5e2e6487
--- /dev/null
+++ b/api/logic/modplatform/atlauncher/ATLPackIndex.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "ATLPackManifest.h"
+
+#include <QString>
+#include <QVector>
+#include <QMetaType>
+
+#include "multimc_logic_export.h"
+
+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;
+};
+
+MULTIMC_LOGIC_EXPORT void loadIndexedPack(IndexedPack & m, QJsonObject & obj);
+}
+
+Q_DECLARE_METATYPE(ATLauncher::IndexedPack)
diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp
new file mode 100644
index 00000000..25c6d58d
--- /dev/null
+++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.cpp
@@ -0,0 +1,682 @@
+#include <Env.h>
+#include <quazip.h>
+#include <QtConcurrent/QtConcurrent>
+#include <MMCZip.h>
+#include <minecraft/OneSixVersionFormat.h>
+#include <Version.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(QString pack, QString version)
+{
+    m_pack = pack;
+    m_version_name = version;
+}
+
+bool PackInstallTask::abort()
+{
+    return true;
+}
+
+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 ") + "net.minecraft");
+        return;
+    }
+
+    auto ver = vlist->getVersion(m_version.minecraft);
+    if (!ver) {
+        emitFailed(tr("Failed to get local metadata index for ") + "net.minecraft" + " " + 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: ") + 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 ") + uid);
+            return Q_NULLPTR;
+        }
+
+        // todo: filter by Minecraft version
+
+        if(m_version.loader.recommended) {
+            return vlist.get()->getRecommended().get()->descriptor();
+        }
+        else if(m_version.loader.latest) {
+            return vlist.get()->at(0)->descriptor();
+        }
+        else if(m_version.loader.choose) {
+            // todo: implement
+        }
+    }
+
+    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: ") + 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);
+
+    jobPtr->addNetAction(Net::Download::makeCached(url, entry));
+    archivePath = entry->getFullPath();
+
+    connect(jobPtr.get(), &NetJob::succeeded, this, [&]()
+    {
+        jobPtr.reset();
+        extractConfigs();
+    });
+    connect(jobPtr.get(), &NetJob::failed, [&](QString reason)
+    {
+        jobPtr.reset();
+        emitFailed(reason);
+    });
+    connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total)
+    {
+        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();
+    setStatus(tr("Downloading mods..."));
+
+    jarmods.clear();
+    jobPtr.reset(new NetJob(tr("Mod download")));
+    for(const auto& mod : m_version.mods) {
+        // skip optional mods for now
+        if(mod.optional) 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: ") + mod.download_raw);
+                return;
+            case DownloadType::Direct:
+                url = mod.url;
+                break;
+            case DownloadType::Unknown:
+                emitFailed(tr("Unknown download type: ") + 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);
+            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);
+            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);
+            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)
+    {
+        jobPtr.reset();
+        emitFailed(reason);
+    });
+    connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total)
+    {
+        setProgress(current, total);
+    });
+
+    jobPtr->start();
+}
+
+void PackInstallTask::onModsDownloaded() {
+    qDebug() << "PackInstallTask::onModsDownloaded: " << QThread::currentThreadId();
+    jobPtr.reset();
+
+    if(modsToExtract.size() || modsToDecomp.size() || modsToCopy.size()) {
+        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)) {
+        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)) {
+        return;
+    }
+
+    components->saveNow();
+
+    instance.setName(m_instName);
+    instance.setIconKey(m_instIcon);
+    instanceSettings->resumeSave();
+
+    jarmods.clear();
+    emitSucceeded();
+}
+
+}
diff --git a/api/logic/modplatform/atlauncher/ATLPackInstallTask.h b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h
new file mode 100644
index 00000000..78544bab
--- /dev/null
+++ b/api/logic/modplatform/atlauncher/ATLPackInstallTask.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <meta/VersionList.h>
+#include "ATLPackManifest.h"
+
+#include "InstanceTask.h"
+#include "multimc_logic_export.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 MULTIMC_LOGIC_EXPORT PackInstallTask : public InstanceTask
+{
+Q_OBJECT
+
+public:
+    explicit PackInstallTask(QString pack, QString version);
+    virtual ~PackInstallTask(){}
+
+    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:
+    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;
+
+    QFuture<bool> m_decompFuture;
+    QFutureWatcher<bool> m_decompFutureWatcher;
+
+};
+
+}
diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.cpp b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp
new file mode 100644
index 00000000..84389330
--- /dev/null
+++ b/api/logic/modplatform/atlauncher/ATLPackManifest.cpp
@@ -0,0 +1,180 @@
+#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.latest = Json::ensureBoolean(obj, QString("latest"), false);
+    p.choose = Json::ensureBoolean(obj, QString("choose"), false);
+    p.recommended = Json::ensureBoolean(obj, QString("recommended"), false);
+
+    auto metadata = Json::requireObject(obj, "metadata");
+    p.version = Json::requireString(metadata, "version");
+}
+
+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 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.optional = Json::ensureBoolean(obj, QString("optional"), false);
+}
+
+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);
+        }
+    }
+
+    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);
+    }
+}
diff --git a/api/logic/modplatform/atlauncher/ATLPackManifest.h b/api/logic/modplatform/atlauncher/ATLPackManifest.h
new file mode 100644
index 00000000..1adf889b
--- /dev/null
+++ b/api/logic/modplatform/atlauncher/ATLPackManifest.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <QString>
+#include <QVector>
+#include <QJsonObject>
+#include <multimc_logic_export.h>
+
+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;
+
+    bool optional;
+};
+
+struct PackVersion
+{
+    QString version;
+    QString minecraft;
+    bool noConfigs;
+    QString mainClass;
+    QString extraArguments;
+
+    VersionLoader loader;
+    QVector<VersionLibrary> libraries;
+    QVector<VersionMod> mods;
+};
+
+MULTIMC_LOGIC_EXPORT void loadVersion(PackVersion & v, QJsonObject & obj);
+
+}
diff --git a/api/logic/modplatform/legacy_ftb/PackInstallTask.cpp b/api/logic/modplatform/legacy_ftb/PackInstallTask.cpp
index 9bf6c76a..c77f3250 100644
--- a/api/logic/modplatform/legacy_ftb/PackInstallTask.cpp
+++ b/api/logic/modplatform/legacy_ftb/PackInstallTask.cpp
@@ -121,6 +121,7 @@ void PackInstallTask::install()
 
     QString instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
     auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
+    instanceSettings->suspendSave();
     instanceSettings->registerSetting("InstanceType", "Legacy");
     instanceSettings->set("InstanceType", "OneSix");
 
diff --git a/api/logic/modplatform/legacy_ftb/PackInstallTask.h b/api/logic/modplatform/legacy_ftb/PackInstallTask.h
index 1eec1880..7868d1c4 100644
--- a/api/logic/modplatform/legacy_ftb/PackInstallTask.h
+++ b/api/logic/modplatform/legacy_ftb/PackInstallTask.h
@@ -8,6 +8,8 @@
 #include "meta/VersionList.h"
 #include "PackHelpers.h"
 
+#include <nonstd/optional>
+
 namespace LegacyFTB {
 
 class MULTIMC_LOGIC_EXPORT PackInstallTask : public InstanceTask
@@ -40,8 +42,8 @@ private slots:
 private: /* data */
     bool abortable = false;
     std::unique_ptr<QuaZip> m_packZip;
-    QFuture<QStringList> m_extractFuture;
-    QFutureWatcher<QStringList> m_extractFutureWatcher;
+    QFuture<nonstd::optional<QStringList>> m_extractFuture;
+    QFutureWatcher<nonstd::optional<QStringList>> m_extractFutureWatcher;
     NetJobPtr netJobContainer;
     QString archivePath;
 
diff --git a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp
index fdfe560a..dc2b05fe 100644
--- a/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp
+++ b/api/logic/modplatform/modpacksch/FTBPackInstallTask.cpp
@@ -91,6 +91,7 @@ void PackInstallTask::install()
 
     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");
 
@@ -117,22 +118,26 @@ void PackInstallTask::install()
         if(file.serverOnly) continue;
 
         auto relpath = FS::PathCombine("minecraft", file.path, file.name);
-        auto path = FS::PathCombine(m_stagingPath , relpath);
+        auto path = FS::PathCombine(m_stagingPath, relpath);
 
         qDebug() << "Will download" << file.url << "to" << path;
         auto dl = Net::Download::makeFile(file.url, path);
         jobPtr->addNetAction(dl);
     }
+
     connect(jobPtr.get(), &NetJob::succeeded, this, [&]()
     {
         jobPtr.reset();
         emitSucceeded();
     });
-
     connect(jobPtr.get(), &NetJob::failed, [&](QString reason)
     {
         jobPtr.reset();
-        emitFailed(reason);
+
+        // FIXME: Temporarily ignore file download failures (matching FTB's installer),
+        // while FTB's data is fucked.
+        qWarning() << "Failed to download files for modpack: " + reason;
+        emitSucceeded();
     });
     connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total)
     {
diff --git a/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp b/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp
new file mode 100644
index 00000000..96e1804d
--- /dev/null
+++ b/api/logic/modplatform/technic/SingleZipPackInstallTask.cpp
@@ -0,0 +1,129 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SingleZipPackInstallTask.h"
+
+#include "Env.h"
+#include "MMCZip.h"
+#include "TechnicPackProcessor.h"
+
+#include <QtConcurrent>
+#include <FileSystem.h>
+
+Technic::SingleZipPackInstallTask::SingleZipPackInstallTask(const QUrl &sourceUrl, const QString &minecraftVersion)
+{
+    m_sourceUrl = sourceUrl;
+    m_minecraftVersion = minecraftVersion;
+}
+
+void Technic::SingleZipPackInstallTask::executeTask()
+{
+    setStatus(tr("Downloading modpack:\n%1").arg(m_sourceUrl.toString()));
+
+    const QString path = m_sourceUrl.host() + '/' + m_sourceUrl.path();
+    auto entry = ENV.metacache()->resolveEntry("general", path);
+    entry->setStale(true);
+    m_filesNetJob.reset(new NetJob(tr("Modpack download")));
+    m_filesNetJob->addNetAction(Net::Download::makeCached(m_sourceUrl, entry));
+    m_archivePath = entry->getFullPath();
+    auto job = m_filesNetJob.get();
+    connect(job, &NetJob::succeeded, this, &Technic::SingleZipPackInstallTask::downloadSucceeded);
+    connect(job, &NetJob::progress, this, &Technic::SingleZipPackInstallTask::downloadProgressChanged);
+    connect(job, &NetJob::failed, this, &Technic::SingleZipPackInstallTask::downloadFailed);
+    m_filesNetJob->start();
+}
+
+void Technic::SingleZipPackInstallTask::downloadSucceeded()
+{
+    setStatus(tr("Extracting modpack"));
+    QDir extractDir(FS::PathCombine(m_stagingPath, ".minecraft"));
+    qDebug() << "Attempting to create instance from" << m_archivePath;
+
+    // open the zip and find relevant files in it
+    m_packZip.reset(new QuaZip(m_archivePath));
+    if (!m_packZip->open(QuaZip::mdUnzip))
+    {
+        emitFailed(tr("Unable to open supplied modpack zip file."));
+        return;
+    }
+    m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractSubDir, m_packZip.get(), QString(""), extractDir.absolutePath());
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &Technic::SingleZipPackInstallTask::extractFinished);
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &Technic::SingleZipPackInstallTask::extractAborted);
+    m_extractFutureWatcher.setFuture(m_extractFuture);
+    m_filesNetJob.reset();
+}
+
+void Technic::SingleZipPackInstallTask::downloadFailed(QString reason)
+{
+    emitFailed(reason);
+    m_filesNetJob.reset();
+}
+
+void Technic::SingleZipPackInstallTask::downloadProgressChanged(qint64 current, qint64 total)
+{
+    setProgress(current / 2, total);
+}
+
+void Technic::SingleZipPackInstallTask::extractFinished()
+{
+    m_packZip.reset();
+    if (!m_extractFuture.result())
+    {
+        emitFailed(tr("Failed to extract modpack"));
+        return;
+    }
+    QDir extractDir(m_stagingPath);
+
+    qDebug() << "Fixing permissions for extracted pack files...";
+    QDirIterator it(extractDir, QDirIterator::Subdirectories);
+    while (it.hasNext())
+    {
+        auto filepath = it.next();
+        QFileInfo file(filepath);
+        auto permissions = QFile::permissions(filepath);
+        auto origPermissions = permissions;
+        if (file.isDir())
+        {
+            // Folder +rwx for current user
+            permissions |= QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser | QFileDevice::Permission::ExeUser;
+        }
+        else
+        {
+            // File +rw for current user
+            permissions |= QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser;
+        }
+        if (origPermissions != permissions)
+        {
+            if (!QFile::setPermissions(filepath, permissions))
+            {
+                logWarning(tr("Could not fix permissions for %1").arg(filepath));
+            }
+            else
+            {
+                qDebug() << "Fixed" << filepath;
+            }
+        }
+    }
+
+    shared_qobject_ptr<Technic::TechnicPackProcessor> packProcessor = new Technic::TechnicPackProcessor();
+    connect(packProcessor.get(), &Technic::TechnicPackProcessor::succeeded, this, &Technic::SingleZipPackInstallTask::emitSucceeded);
+    connect(packProcessor.get(), &Technic::TechnicPackProcessor::failed, this, &Technic::SingleZipPackInstallTask::emitFailed);
+    packProcessor->run(m_globalSettings, m_instName, m_instIcon, m_stagingPath, m_minecraftVersion);
+}
+
+void Technic::SingleZipPackInstallTask::extractAborted()
+{
+    emitFailed(tr("Instance import has been aborted."));
+}
diff --git a/api/logic/modplatform/technic/SingleZipPackInstallTask.h b/api/logic/modplatform/technic/SingleZipPackInstallTask.h
new file mode 100644
index 00000000..c56b9e46
--- /dev/null
+++ b/api/logic/modplatform/technic/SingleZipPackInstallTask.h
@@ -0,0 +1,60 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "InstanceTask.h"
+#include "net/NetJob.h"
+#include "multimc_logic_export.h"
+
+#include "quazip.h"
+
+#include <QFutureWatcher>
+#include <QStringList>
+#include <QUrl>
+
+#include <nonstd/optional>
+
+namespace Technic {
+
+class MULTIMC_LOGIC_EXPORT SingleZipPackInstallTask : public InstanceTask
+{
+    Q_OBJECT
+
+public:
+    SingleZipPackInstallTask(const QUrl &sourceUrl, const QString &minecraftVersion);
+
+protected:
+    void executeTask() override;
+
+
+private slots:
+    void downloadSucceeded();
+    void downloadFailed(QString reason);
+    void downloadProgressChanged(qint64 current, qint64 total);
+    void extractFinished();
+    void extractAborted();
+
+private:
+    QUrl m_sourceUrl;
+    QString m_minecraftVersion;
+    QString m_archivePath;
+    NetJobPtr m_filesNetJob;
+    std::unique_ptr<QuaZip> m_packZip;
+    QFuture<nonstd::optional<QStringList>> m_extractFuture;
+    QFutureWatcher<nonstd::optional<QStringList>> m_extractFutureWatcher;
+};
+
+} // namespace Technic
diff --git a/api/logic/modplatform/technic/SolderPackInstallTask.cpp b/api/logic/modplatform/technic/SolderPackInstallTask.cpp
new file mode 100644
index 00000000..1d17073c
--- /dev/null
+++ b/api/logic/modplatform/technic/SolderPackInstallTask.cpp
@@ -0,0 +1,195 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SolderPackInstallTask.h"
+
+#include <FileSystem.h>
+#include <Json.h>
+#include <QtConcurrentRun>
+#include <MMCZip.h>
+#include "TechnicPackProcessor.h"
+
+Technic::SolderPackInstallTask::SolderPackInstallTask(const QUrl &sourceUrl, const QString &minecraftVersion)
+{
+    m_sourceUrl = sourceUrl;
+    m_minecraftVersion = minecraftVersion;
+}
+
+void Technic::SolderPackInstallTask::executeTask()
+{
+    setStatus(tr("Finding recommended version:\n%1").arg(m_sourceUrl.toString()));
+    m_filesNetJob.reset(new NetJob(tr("Finding recommended version")));
+    m_filesNetJob->addNetAction(Net::Download::makeByteArray(m_sourceUrl, &m_response));
+    auto job = m_filesNetJob.get();
+    connect(job, &NetJob::succeeded, this, &Technic::SolderPackInstallTask::versionSucceeded);
+    connect(job, &NetJob::failed, this, &Technic::SolderPackInstallTask::downloadFailed);
+    m_filesNetJob->start();
+}
+
+void Technic::SolderPackInstallTask::versionSucceeded()
+{
+    try
+    {
+        QJsonDocument doc = Json::requireDocument(m_response);
+        QJsonObject obj = Json::requireObject(doc);
+        QString version = Json::requireString(obj, "recommended", "__placeholder__");
+        m_sourceUrl = m_sourceUrl.toString() + '/' + version;
+    }
+    catch (const JSONValidationError &e)
+    {
+        emitFailed(e.cause());
+        m_filesNetJob.reset();
+        return;
+    }
+
+    setStatus(tr("Resolving modpack files:\n%1").arg(m_sourceUrl.toString()));
+    m_filesNetJob.reset(new NetJob(tr("Resolving modpack files")));
+    m_filesNetJob->addNetAction(Net::Download::makeByteArray(m_sourceUrl, &m_response));
+    auto job = m_filesNetJob.get();
+    connect(job, &NetJob::succeeded, this, &Technic::SolderPackInstallTask::fileListSucceeded);
+    connect(job, &NetJob::failed, this, &Technic::SolderPackInstallTask::downloadFailed);
+    m_filesNetJob->start();
+}
+
+void Technic::SolderPackInstallTask::fileListSucceeded()
+{
+    setStatus(tr("Downloading modpack:"));
+    QStringList modUrls;
+    try
+    {
+        QJsonDocument doc = Json::requireDocument(m_response);
+        QJsonObject obj = Json::requireObject(doc);
+        QString minecraftVersion = Json::ensureString(obj, "minecraft", QString(), "__placeholder__");
+        if (!minecraftVersion.isEmpty())
+            m_minecraftVersion = minecraftVersion;
+        QJsonArray mods = Json::requireArray(obj, "mods", "'mods'");
+        for (auto mod: mods)
+        {
+            QJsonObject modObject = Json::requireObject(mod);
+            modUrls.append(Json::requireString(modObject, "url", "'url'"));
+        }
+    }
+    catch (const JSONValidationError &e)
+    {
+        emitFailed(e.cause());
+        m_filesNetJob.reset();
+        return;
+    }
+    m_filesNetJob.reset(new NetJob(tr("Downloading modpack")));
+    int i = 0;
+    for (auto &modUrl: modUrls)
+    {
+        auto path = FS::PathCombine(m_outputDir.path(), QString("%1").arg(i));
+        m_filesNetJob->addNetAction(Net::Download::makeFile(modUrl, path));
+        i++;
+    }
+
+    m_modCount = modUrls.size();
+
+    connect(m_filesNetJob.get(), &NetJob::succeeded, this, &Technic::SolderPackInstallTask::downloadSucceeded);
+    connect(m_filesNetJob.get(), &NetJob::progress, this, &Technic::SolderPackInstallTask::downloadProgressChanged);
+    connect(m_filesNetJob.get(), &NetJob::failed, this, &Technic::SolderPackInstallTask::downloadFailed);
+    m_filesNetJob->start();
+}
+
+void Technic::SolderPackInstallTask::downloadSucceeded()
+{
+    setStatus(tr("Extracting modpack"));
+    m_filesNetJob.reset();
+    m_extractFuture = QtConcurrent::run([this]()
+    {
+        int i = 0;
+        QString extractDir = FS::PathCombine(m_stagingPath, ".minecraft");
+        FS::ensureFolderPathExists(extractDir);
+
+        while (m_modCount > i)
+        {
+            auto path = FS::PathCombine(m_outputDir.path(), QString("%1").arg(i));
+            if (!MMCZip::extractDir(path, extractDir))
+            {
+                return false;
+            }
+            i++;
+        }
+        return true;
+    });
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &Technic::SolderPackInstallTask::extractFinished);
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &Technic::SolderPackInstallTask::extractAborted);
+    m_extractFutureWatcher.setFuture(m_extractFuture);
+}
+
+void Technic::SolderPackInstallTask::downloadFailed(QString reason)
+{
+    emitFailed(reason);
+    m_filesNetJob.reset();
+}
+
+void Technic::SolderPackInstallTask::downloadProgressChanged(qint64 current, qint64 total)
+{
+    setProgress(current / 2, total);
+}
+
+void Technic::SolderPackInstallTask::extractFinished()
+{
+    if (!m_extractFuture.result())
+    {
+        emitFailed(tr("Failed to extract modpack"));
+        return;
+    }
+    QDir extractDir(m_stagingPath);
+
+    qDebug() << "Fixing permissions for extracted pack files...";
+    QDirIterator it(extractDir, QDirIterator::Subdirectories);
+    while (it.hasNext())
+    {
+        auto filepath = it.next();
+        QFileInfo file(filepath);
+        auto permissions = QFile::permissions(filepath);
+        auto origPermissions = permissions;
+        if(file.isDir())
+        {
+            // Folder +rwx for current user
+            permissions |= QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser | QFileDevice::Permission::ExeUser;
+        }
+        else
+        {
+            // File +rw for current user
+            permissions |= QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser;
+        }
+        if(origPermissions != permissions)
+        {
+            if(!QFile::setPermissions(filepath, permissions))
+            {
+                logWarning(tr("Could not fix permissions for %1").arg(filepath));
+            }
+            else
+            {
+                qDebug() << "Fixed" << filepath;
+            }
+        }
+    }
+
+    shared_qobject_ptr<Technic::TechnicPackProcessor> packProcessor = new Technic::TechnicPackProcessor();
+    connect(packProcessor.get(), &Technic::TechnicPackProcessor::succeeded, this, &Technic::SolderPackInstallTask::emitSucceeded);
+    connect(packProcessor.get(), &Technic::TechnicPackProcessor::failed, this, &Technic::SolderPackInstallTask::emitFailed);
+    packProcessor->run(m_globalSettings, m_instName, m_instIcon, m_stagingPath, m_minecraftVersion, true);
+}
+
+void Technic::SolderPackInstallTask::extractAborted()
+{
+    emitFailed(tr("Instance import has been aborted."));
+    return;
+}
+
diff --git a/api/logic/modplatform/technic/SolderPackInstallTask.h b/api/logic/modplatform/technic/SolderPackInstallTask.h
new file mode 100644
index 00000000..0fe6cb83
--- /dev/null
+++ b/api/logic/modplatform/technic/SolderPackInstallTask.h
@@ -0,0 +1,55 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <InstanceTask.h>
+#include <net/NetJob.h>
+#include <tasks/Task.h>
+
+#include <QUrl>
+
+namespace Technic
+{
+    class MULTIMC_LOGIC_EXPORT SolderPackInstallTask : public InstanceTask
+    {
+        Q_OBJECT
+    public:
+        explicit SolderPackInstallTask(const QUrl &sourceUrl, const QString &minecraftVersion);
+
+    protected:
+        //! Entry point for tasks.
+        virtual void executeTask() override;
+
+    private slots:
+        void versionSucceeded();
+        void fileListSucceeded();
+        void downloadSucceeded();
+        void downloadFailed(QString reason);
+        void downloadProgressChanged(qint64 current, qint64 total);
+        void extractFinished();
+        void extractAborted();
+
+    private:
+        NetJobPtr m_filesNetJob;
+        QUrl m_sourceUrl;
+        QString m_minecraftVersion;
+        QByteArray m_response;
+        QTemporaryDir m_outputDir;
+        int m_modCount;
+        QFuture<bool> m_extractFuture;
+        QFutureWatcher<bool> m_extractFutureWatcher;
+    };
+}
diff --git a/api/logic/modplatform/technic/TechnicPackProcessor.cpp b/api/logic/modplatform/technic/TechnicPackProcessor.cpp
new file mode 100644
index 00000000..52979b7c
--- /dev/null
+++ b/api/logic/modplatform/technic/TechnicPackProcessor.cpp
@@ -0,0 +1,208 @@
+/* Copyright 2020-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "TechnicPackProcessor.h"
+
+#include <FileSystem.h>
+#include <Json.h>
+#include <minecraft/MinecraftInstance.h>
+#include <minecraft/PackProfile.h>
+#include <quazip.h>
+#include <quazipdir.h>
+#include <quazipfile.h>
+#include <settings/INISettingsObject.h>
+
+#include <memory>
+
+void Technic::TechnicPackProcessor::run(SettingsObjectPtr globalSettings, const QString &instName, const QString &instIcon, const QString &stagingPath, const QString &minecraftVersion, const bool isSolder)
+{
+    QString minecraftPath = FS::PathCombine(stagingPath, ".minecraft");
+    QString configPath = FS::PathCombine(stagingPath, "instance.cfg");
+    auto instanceSettings = std::make_shared<INISettingsObject>(configPath);
+    instanceSettings->registerSetting("InstanceType", "Legacy");
+    instanceSettings->set("InstanceType", "OneSix");
+    MinecraftInstance instance(globalSettings, instanceSettings, stagingPath);
+
+    instance.setName(instName);
+
+    if (instIcon != "default")
+    {
+        instance.setIconKey(instIcon);
+    }
+
+    auto components = instance.getPackProfile();
+    components->buildingFromScratch();
+
+    QByteArray data;
+
+    QString modpackJar = FS::PathCombine(minecraftPath, "bin", "modpack.jar");
+    QString versionJson = FS::PathCombine(minecraftPath, "bin", "version.json");
+    QString fmlMinecraftVersion;
+    if (QFile::exists(modpackJar))
+    {
+        QuaZip zipFile(modpackJar);
+        if (!zipFile.open(QuaZip::mdUnzip))
+        {
+            emit failed(tr("Unable to open \"bin/modpack.jar\" file!"));
+            return;
+        }
+        QuaZipDir zipFileRoot(&zipFile, "/");
+        if (zipFileRoot.exists("/version.json"))
+        {
+            if (zipFileRoot.exists("/fmlversion.properties"))
+            {
+                zipFile.setCurrentFile("fmlversion.properties");
+                QuaZipFile file(&zipFile);
+                if (!file.open(QIODevice::ReadOnly))
+                {
+                    emit failed(tr("Unable to open \"fmlversion.properties\"!"));
+                    return;
+                }
+                QByteArray fmlVersionData = file.readAll();
+                file.close();
+                INIFile iniFile;
+                iniFile.loadFile(fmlVersionData);
+                // If not present, this evaluates to a null string
+                fmlMinecraftVersion = iniFile["fmlbuild.mcversion"].toString();
+            }
+            zipFile.setCurrentFile("version.json", QuaZip::csSensitive);
+            QuaZipFile file(&zipFile);
+            if (!file.open(QIODevice::ReadOnly))
+            {
+                emit failed(tr("Unable to open \"version.json\"!"));
+                return;
+            }
+            data = file.readAll();
+            file.close();
+        }
+        else
+        {
+            if (minecraftVersion.isEmpty())
+                emit failed(tr("Could not find \"version.json\" inside \"bin/modpack.jar\", but minecraft version is unknown"));
+            components->setComponentVersion("net.minecraft", minecraftVersion, true);
+            components->installJarMods({modpackJar});
+
+            // Forge for 1.4.7 and for 1.5.2 require extra libraries.
+            // Figure out the forge version and add it as a component
+            // (the code still comes from the jar mod installed above)
+            if (zipFileRoot.exists("/forgeversion.properties"))
+            {
+                zipFile.setCurrentFile("forgeversion.properties", QuaZip::csSensitive);
+                QuaZipFile file(&zipFile);
+                if (!file.open(QIODevice::ReadOnly))
+                {
+                    // Really shouldn't happen, but error handling shall not be forgotten
+                    emit failed(tr("Unable to open \"forgeversion.properties\""));
+                    return;
+                }
+                QByteArray forgeVersionData = file.readAll();
+                file.close();
+                INIFile iniFile;
+                iniFile.loadFile(forgeVersionData);
+                QString major, minor, revision, build;
+                major = iniFile["forge.major.number"].toString();
+                minor = iniFile["forge.minor.number"].toString();
+                revision = iniFile["forge.revision.number"].toString();
+                build = iniFile["forge.build.number"].toString();
+
+                if (major.isEmpty() || minor.isEmpty() || revision.isEmpty() || build.isEmpty())
+                {
+                    emit failed(tr("Invalid \"forgeversion.properties\"!"));
+                    return;
+                }
+
+                components->setComponentVersion("net.minecraftforge", major + '.' + minor + '.' + revision + '.' + build);
+            }
+
+            components->saveNow();
+            emit succeeded();
+            return;
+        }
+    }
+    else if (QFile::exists(versionJson))
+    {
+        QFile file(versionJson);
+        if (!file.open(QIODevice::ReadOnly))
+        {
+            emit failed(tr("Unable to open \"version.json\"!"));
+            return;
+        }
+        data = file.readAll();
+        file.close();
+    }
+    else
+    {
+        // This is the "Vanilla" modpack, excluded by the search code
+        emit failed(tr("Unable to find a \"version.json\"!"));
+        return;
+    }
+
+    try
+    {
+        QJsonDocument doc = Json::requireDocument(data);
+        QJsonObject root = Json::requireObject(doc, "version.json");
+        QString minecraftVersion = Json::ensureString(root, "inheritsFrom", QString(), "");
+        if (minecraftVersion.isEmpty())
+        {
+            if (fmlMinecraftVersion.isEmpty())
+            {
+                emit failed(tr("Could not understand \"version.json\":\ninheritsFrom is missing"));
+                return;
+            }
+            minecraftVersion = fmlMinecraftVersion;
+        }
+        components->setComponentVersion("net.minecraft", minecraftVersion, true);
+        for (auto library: Json::ensureArray(root, "libraries", {}))
+        {
+            if (!library.isObject())
+            {
+                continue;
+            }
+
+            auto libraryObject = Json::ensureObject(library, {}, "");
+            auto libraryName = Json::ensureString(libraryObject, "name", "", "");
+
+            if (libraryName.startsWith("net.minecraftforge:forge:") && libraryName.contains('-'))
+            {
+                QString libraryVersion = libraryName.section(':', 2);
+                if (!libraryVersion.startsWith("1.7.10-"))
+                {
+                    components->setComponentVersion("net.minecraftforge", libraryName.section('-', 1));
+                }
+                else
+                {
+                    // 1.7.10 versions sometimes look like 1.7.10-10.13.4.1614-1.7.10, this filters out the 10.13.4.1614 part
+                    components->setComponentVersion("net.minecraftforge", libraryName.section('-', 1, 1));
+                }
+            }
+            else if (libraryName.startsWith("net.minecraftforge:minecraftforge:"))
+            {
+                components->setComponentVersion("net.minecraftforge", libraryName.section(':', 2));
+            }
+            else if (libraryName.startsWith("net.fabricmc:fabric-loader:"))
+            {
+                components->setComponentVersion("net.fabricmc.fabric-loader", libraryName.section(':', 2));
+            }
+        }
+    }
+    catch (const JSONValidationError &e)
+    {
+        emit failed(tr("Could not understand \"version.json\":\n") + e.cause());
+        return;
+    }
+
+    components->saveNow();
+    emit succeeded();
+}
diff --git a/api/logic/modplatform/technic/TechnicPackProcessor.h b/api/logic/modplatform/technic/TechnicPackProcessor.h
new file mode 100644
index 00000000..2ad803b3
--- /dev/null
+++ b/api/logic/modplatform/technic/TechnicPackProcessor.h
@@ -0,0 +1,35 @@
+/* Copyright 2020-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <QString>
+#include "settings/SettingsObject.h"
+
+namespace Technic
+{
+    // not exporting it, only used in SingleZipPackInstallTask, InstanceImportTask and SolderPackInstallTask
+    class TechnicPackProcessor : public QObject
+    {
+        Q_OBJECT
+
+    signals:
+        void succeeded();
+        void failed(QString reason);
+
+    public:
+        void run(SettingsObjectPtr globalSettings, const QString &instName, const QString &instIcon, const QString &stagingPath, const QString &minecraftVersion=QString(), const bool isSolder = false);
+    };
+}