merged from 0.6.7 codebase

13 files changed, 863 insertions, 492 deletions

diff --git a/api/logic/modplatform/flame/FileResolvingTask.cpp b/api/logic/modplatform/flame/FileResolvingTask.cpp
index efc73621..295574f0 100644
--- a/api/logic/modplatform/flame/FileResolvingTask.cpp
+++ b/api/logic/modplatform/flame/FileResolvingTask.cpp
@@ -1,117 +1,63 @@
 #include "FileResolvingTask.h"
 #include "Json.h"
 
-const char * metabase = "https://cursemeta.dries007.net";
+namespace {
+    const char * metabase = "https://cursemeta.dries007.net";
+}
 
 Flame::FileResolvingTask::FileResolvingTask(Flame::Manifest& toProcess)
-	: m_toProcess(toProcess)
+    : m_toProcess(toProcess)
 {
 }
 
 void Flame::FileResolvingTask::executeTask()
 {
-	setStatus(tr("Resolving mod IDs..."));
-	setProgress(0, m_toProcess.files.size());
-	m_dljob.reset(new NetJob("Mod id resolver"));
-	results.resize(m_toProcess.files.size());
-	int index = 0;
-	for(auto & file: m_toProcess.files)
-	{
-		auto projectIdStr = QString::number(file.projectId);
-		auto fileIdStr = QString::number(file.fileId);
-		QString metaurl = QString("%1/%2/%3.json").arg(metabase, projectIdStr, fileIdStr);
-		auto dl = Net::Download::makeByteArray(QUrl(metaurl), &results[index]);
-		m_dljob->addNetAction(dl);
-		index ++;
-	}
-	connect(m_dljob.get(), &NetJob::finished, this, &Flame::FileResolvingTask::netJobFinished);
-	m_dljob->start();
+    setStatus(tr("Resolving mod IDs..."));
+    setProgress(0, m_toProcess.files.size());
+    m_dljob.reset(new NetJob("Mod id resolver"));
+    results.resize(m_toProcess.files.size());
+    int index = 0;
+    for(auto & file: m_toProcess.files)
+    {
+        auto projectIdStr = QString::number(file.projectId);
+        auto fileIdStr = QString::number(file.fileId);
+        QString metaurl = QString("%1/%2/%3.json").arg(metabase, projectIdStr, fileIdStr);
+        auto dl = Net::Download::makeByteArray(QUrl(metaurl), &results[index]);
+        m_dljob->addNetAction(dl);
+        index ++;
+    }
+    connect(m_dljob.get(), &NetJob::finished, this, &Flame::FileResolvingTask::netJobFinished);
+    m_dljob->start();
 }
 
 void Flame::FileResolvingTask::netJobFinished()
 {
-	bool failed = false;
-	int index = 0;
-	for(auto & bytes: results)
-	{
-		try
-		{
-			auto doc = Json::requireDocument(bytes);
-			auto obj = Json::requireObject(doc);
-			auto & out = m_toProcess.files[index];
-			// result code signifies true failure.
-			if(obj.contains("code"))
-			{
-				qCritical() << "Resolving of" << out.projectId << out.fileId << "failed because of a negative result:";
-				qCritical() << bytes;
-				failed = true;
-				continue;
-			}
-			out.fileName = Json::requireString(obj, "FileNameOnDisk");
-			QString rawUrl = Json::requireString(obj, "DownloadURL");
-			out.url = QUrl(rawUrl, QUrl::TolerantMode);
-			if(!out.url.isValid())
-			{
-				throw JSONValidationError(QString("Invalid URL: %1").arg(rawUrl));
-			}
-			// This is a piece of a Flame project JSON pulled out into the file metadata (here) for convenience
-			// It is also optional
-			QJsonObject projObj = Json::ensureObject(obj, "_Project", {});
-			if(!projObj.isEmpty())
-			{
-				QString strType = Json::ensureString(projObj, "PackageType", "mod").toLower();
-				if(strType == "singlefile")
-				{
-					out.type = File::Type::SingleFile;
-				}
-				else if(strType == "ctoc")
-				{
-					out.type = File::Type::Ctoc;
-				}
-				else if(strType == "cmod2")
-				{
-					out.type = File::Type::Cmod2;
-				}
-				else if(strType == "mod")
-				{
-					out.type = File::Type::Mod;
-				}
-				else if(strType == "folder")
-				{
-					out.type = File::Type::Folder;
-				}
-				else if(strType == "modpack")
-				{
-					out.type = File::Type::Modpack;
-				}
-				else
-				{
-					qCritical() << "Resolving of" << out.projectId << out.fileId << "failed because of unknown file type:" << strType;
-					out.type = File::Type::Unknown;
-					failed = true;
-					continue;
-				}
-				out.targetFolder = Json::ensureString(projObj, "Path", "mods");
-			}
-			out.resolved = true;
-		}
-		catch(JSONValidationError & e)
-		{
-			auto & out = m_toProcess.files[index];
-			qCritical() << "Resolving of" << out.projectId << out.fileId << "failed because of a parsing error:";
-			qCritical() << e.cause();
-			qCritical() << "JSON:";
-			qCritical() << bytes;
-			failed = true;
-		}
-		index++;
-	}
-	if(!failed)
-	{
-		emitSucceeded();
-	}
-	else
-	{
-		emitFailed(tr("Some mod ID resolving tasks failed."));
-	}
+    bool failed = false;
+    int index = 0;
+    for(auto & bytes: results)
+    {
+        auto & out = m_toProcess.files[index];
+        try
+        {
+            failed &= (!out.parseFromBytes(bytes));
+        }
+        catch (const JSONValidationError &e)
+        {
+
+            qCritical() << "Resolving of" << out.projectId << out.fileId << "failed because of a parsing error:";
+            qCritical() << e.cause();
+            qCritical() << "JSON:";
+            qCritical() << bytes;
+            failed = true;
+        }
+        index++;
+    }
+    if(!failed)
+    {
+        emitSucceeded();
+    }
+    else
+    {
+        emitFailed(tr("Some mod ID resolving tasks failed."));
+    }
 }
diff --git a/api/logic/modplatform/flame/FileResolvingTask.h b/api/logic/modplatform/flame/FileResolvingTask.h
index 00658452..5679b907 100644
--- a/api/logic/modplatform/flame/FileResolvingTask.h
+++ b/api/logic/modplatform/flame/FileResolvingTask.h
@@ -10,23 +10,25 @@ namespace Flame
 {
 class MULTIMC_LOGIC_EXPORT FileResolvingTask : public Task
 {
-	Q_OBJECT
+    Q_OBJECT
 public:
-	explicit FileResolvingTask(Flame::Manifest &toProcess);
-	const Flame::Manifest &getResults() const
-	{
-		return m_toProcess;
-	}
+    explicit FileResolvingTask(Flame::Manifest &toProcess);
+    virtual ~FileResolvingTask() {};
+
+    const Flame::Manifest &getResults() const
+    {
+        return m_toProcess;
+    }
 
 protected:
-	virtual void executeTask() override;
+    virtual void executeTask() override;
 
 protected slots:
-	void netJobFinished();
+    void netJobFinished();
 
 private: /* data */
-	Flame::Manifest m_toProcess;
-	QVector<QByteArray> results;
-	NetJobPtr m_dljob;
+    Flame::Manifest m_toProcess;
+    QVector<QByteArray> results;
+    NetJobPtr m_dljob;
 };
 }
diff --git a/api/logic/modplatform/flame/PackManifest.cpp b/api/logic/modplatform/flame/PackManifest.cpp
index 6a9324fe..1db0a161 100644
--- a/api/logic/modplatform/flame/PackManifest.cpp
+++ b/api/logic/modplatform/flame/PackManifest.cpp
@@ -3,64 +3,124 @@
 
 static void loadFileV1(Flame::File & f, QJsonObject & file)
 {
-	f.projectId = Json::requireInteger(file, "projectID");
-	f.fileId = Json::requireInteger(file, "fileID");
-	f.required = Json::ensureBoolean(file, QString("required"), true);
+    f.projectId = Json::requireInteger(file, "projectID");
+    f.fileId = Json::requireInteger(file, "fileID");
+    f.required = Json::ensureBoolean(file, QString("required"), true);
 }
 
 static void loadModloaderV1(Flame::Modloader & m, QJsonObject & modLoader)
 {
-	m.id = Json::requireString(modLoader, "id");
-	m.primary = Json::ensureBoolean(modLoader, QString("primary"), false);
+    m.id = Json::requireString(modLoader, "id");
+    m.primary = Json::ensureBoolean(modLoader, QString("primary"), false);
 }
 
 static void loadMinecraftV1(Flame::Minecraft & m, QJsonObject & minecraft)
 {
-	m.version = Json::requireString(minecraft, "version");
-	// extra libraries... apparently only used for a custom Minecraft launcher in the 1.2.5 FTB retro pack
-	// intended use is likely hardcoded in the 'Flame' client, the manifest says nothing
-	m.libraries = Json::ensureString(minecraft, QString("libraries"), QString());
-	auto arr = Json::ensureArray(minecraft, "modLoaders", QJsonArray());
-	for (const auto & item : arr)
-	{
-		auto obj = Json::requireObject(item);
-		Flame::Modloader loader;
-		loadModloaderV1(loader, obj);
-		m.modLoaders.append(loader);
-	}
+    m.version = Json::requireString(minecraft, "version");
+    // extra libraries... apparently only used for a custom Minecraft launcher in the 1.2.5 FTB retro pack
+    // intended use is likely hardcoded in the 'Flame' client, the manifest says nothing
+    m.libraries = Json::ensureString(minecraft, QString("libraries"), QString());
+    auto arr = Json::ensureArray(minecraft, "modLoaders", QJsonArray());
+    for (const auto & item : arr)
+    {
+        auto obj = Json::requireObject(item);
+        Flame::Modloader loader;
+        loadModloaderV1(loader, obj);
+        m.modLoaders.append(loader);
+    }
 }
 
 static void loadManifestV1(Flame::Manifest & m, QJsonObject & manifest)
 {
-	auto mc = Json::requireObject(manifest, "minecraft");
-	loadMinecraftV1(m.minecraft, mc);
-	m.name = Json::ensureString(manifest, QString("name"), "Unnamed");
-	m.version = Json::ensureString(manifest, QString("version"), QString());
-	m.author = Json::ensureString(manifest, QString("author"), "Anonymous Coward");
-	auto arr = Json::ensureArray(manifest, "files", QJsonArray());
-	for (const auto & item : arr)
-	{
-		auto obj = Json::requireObject(item);
-		Flame::File file;
-		loadFileV1(file, obj);
-		m.files.append(file);
-	}
-	m.overrides = Json::ensureString(manifest, "overrides", "overrides");
+    auto mc = Json::requireObject(manifest, "minecraft");
+    loadMinecraftV1(m.minecraft, mc);
+    m.name = Json::ensureString(manifest, QString("name"), "Unnamed");
+    m.version = Json::ensureString(manifest, QString("version"), QString());
+    m.author = Json::ensureString(manifest, QString("author"), "Anonymous Coward");
+    auto arr = Json::ensureArray(manifest, "files", QJsonArray());
+    for (const auto & item : arr)
+    {
+        auto obj = Json::requireObject(item);
+        Flame::File file;
+        loadFileV1(file, obj);
+        m.files.append(file);
+    }
+    m.overrides = Json::ensureString(manifest, "overrides", "overrides");
 }
 
 void Flame::loadManifest(Flame::Manifest & m, const QString &filepath)
 {
-	auto doc = Json::requireDocument(filepath);
-	auto obj = Json::requireObject(doc);
-	m.manifestType = Json::requireString(obj, "manifestType");
-	if(m.manifestType != "minecraftModpack")
-	{
-		throw JSONValidationError("Not a modpack manifest!");
-	}
-	m.manifestVersion = Json::requireInteger(obj, "manifestVersion");
-	if(m.manifestVersion != 1)
-	{
-		throw JSONValidationError(QString("Unknown manifest version (%1)").arg(m.manifestVersion));
-	}
-	loadManifestV1(m, obj);
+    auto doc = Json::requireDocument(filepath);
+    auto obj = Json::requireObject(doc);
+    m.manifestType = Json::requireString(obj, "manifestType");
+    if(m.manifestType != "minecraftModpack")
+    {
+        throw JSONValidationError("Not a modpack manifest!");
+    }
+    m.manifestVersion = Json::requireInteger(obj, "manifestVersion");
+    if(m.manifestVersion != 1)
+    {
+        throw JSONValidationError(QString("Unknown manifest version (%1)").arg(m.manifestVersion));
+    }
+    loadManifestV1(m, obj);
+}
+
+bool Flame::File::parseFromBytes(const QByteArray& bytes)
+{
+    auto doc = Json::requireDocument(bytes);
+    auto obj = Json::requireObject(doc);
+    // result code signifies true failure.
+    if(obj.contains("code"))
+    {
+        qCritical() << "Resolving of" << projectId << fileId << "failed because of a negative result:";
+        qCritical() << bytes;
+        return false;
+    }
+    fileName = Json::requireString(obj, "FileNameOnDisk");
+    QString rawUrl = Json::requireString(obj, "DownloadURL");
+    url = QUrl(rawUrl, QUrl::TolerantMode);
+    if(!url.isValid())
+    {
+        throw JSONValidationError(QString("Invalid URL: %1").arg(rawUrl));
+    }
+    // This is a piece of a Flame project JSON pulled out into the file metadata (here) for convenience
+    // It is also optional
+    QJsonObject projObj = Json::ensureObject(obj, "_Project", {});
+    if(!projObj.isEmpty())
+    {
+        QString strType = Json::ensureString(projObj, "PackageType", "mod").toLower();
+        if(strType == "singlefile")
+        {
+            type = File::Type::SingleFile;
+        }
+        else if(strType == "ctoc")
+        {
+            type = File::Type::Ctoc;
+        }
+        else if(strType == "cmod2")
+        {
+            type = File::Type::Cmod2;
+        }
+        else if(strType == "mod")
+        {
+            type = File::Type::Mod;
+        }
+        else if(strType == "folder")
+        {
+            type = File::Type::Folder;
+        }
+        else if(strType == "modpack")
+        {
+            type = File::Type::Modpack;
+        }
+        else
+        {
+            qCritical() << "Resolving of" << projectId << fileId << "failed because of unknown file type:" << strType;
+            type = File::Type::Unknown;
+            return false;
+        }
+        targetFolder = Json::ensureString(projObj, "Path", "mods");
+    }
+    resolved = true;
+    return true;
 }
diff --git a/api/logic/modplatform/flame/PackManifest.h b/api/logic/modplatform/flame/PackManifest.h
index 1a5254a8..02f39f0e 100644
--- a/api/logic/modplatform/flame/PackManifest.h
+++ b/api/logic/modplatform/flame/PackManifest.h
@@ -8,51 +8,54 @@ namespace Flame
 {
 struct File
 {
-	int projectId = 0;
-	int fileId = 0;
-	// NOTE: the opposite to 'optional'. This is at the time of writing unused.
-	bool required = true;
-
-	// our
-	bool resolved = false;
-	QString fileName;
-	QUrl url;
-	QString targetFolder = QLatin1Literal("mods");
-	enum class Type
-	{
-		Unknown,
-		Folder,
-		Ctoc,
-		SingleFile,
-		Cmod2,
-		Modpack,
-		Mod
-	} type = Type::Mod;
+    // NOTE: throws JSONValidationError
+    bool parseFromBytes(const QByteArray &bytes);
+
+    int projectId = 0;
+    int fileId = 0;
+    // NOTE: the opposite to 'optional'. This is at the time of writing unused.
+    bool required = true;
+
+    // our
+    bool resolved = false;
+    QString fileName;
+    QUrl url;
+    QString targetFolder = QLatin1Literal("mods");
+    enum class Type
+    {
+        Unknown,
+        Folder,
+        Ctoc,
+        SingleFile,
+        Cmod2,
+        Modpack,
+        Mod
+    } type = Type::Mod;
 };
 
 struct Modloader
 {
-	QString id;
-	bool primary = false;
+    QString id;
+    bool primary = false;
 };
 
 struct Minecraft
 {
-	QString version;
-	QString libraries;
-	QVector<Flame::Modloader> modLoaders;
+    QString version;
+    QString libraries;
+    QVector<Flame::Modloader> modLoaders;
 };
 
 struct Manifest
 {
-	QString manifestType;
-	int manifestVersion = 0;
-	Flame::Minecraft minecraft;
-	QString name;
-	QString version;
-	QString author;
-	QVector<Flame::File> files;
-	QString overrides;
+    QString manifestType;
+    int manifestVersion = 0;
+    Flame::Minecraft minecraft;
+    QString name;
+    QString version;
+    QString author;
+    QVector<Flame::File> files;
+    QString overrides;
 };
 
 void loadManifest(Flame::Manifest & m, const QString &filepath);
diff --git a/api/logic/modplatform/flame/UrlResolvingTask.cpp b/api/logic/modplatform/flame/UrlResolvingTask.cpp
new file mode 100644
index 00000000..efea350c
--- /dev/null
+++ b/api/logic/modplatform/flame/UrlResolvingTask.cpp
@@ -0,0 +1,175 @@
+#include "UrlResolvingTask.h"
+#include <QtXml>
+#include <Json.h>
+
+
+namespace {
+    const char * metabase = "https://cursemeta.dries007.net";
+}
+
+Flame::UrlResolvingTask::UrlResolvingTask(const QString& toProcess)
+    : m_url(toProcess)
+{
+}
+
+void Flame::UrlResolvingTask::executeTask()
+{
+    resolveUrl();
+}
+
+void Flame::UrlResolvingTask::resolveUrl()
+{
+    setStatus(tr("Resolving URL..."));
+    setProgress(0, 1);
+    QUrl actualUrl(m_url);
+    if(actualUrl.host() != "www.curseforge.com") {
+        emitFailed(tr("Not a Twitch URL."));
+        return;
+    }
+    m_dljob.reset(new NetJob("URL resolver"));
+
+    bool weAreDigging = false;
+    needle = QString();
+
+    if(m_url.startsWith("https://")) {
+        if(m_url.endsWith("?client=y")) {
+            // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download?client=y
+            // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download/2697088?client=y
+            m_url.chop(9);
+            // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download
+            // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download/2697088
+        }
+        if(m_url.endsWith("/download")) {
+            // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download -> need to dig inside html...
+            weAreDigging = true;
+            needle = m_url;
+            needle.replace("https://", "twitch://");
+            needle.replace("/download", "/download-client/");
+            m_url.append("?client=y");
+        } else if (m_url.contains("/download/")) {
+            // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download/2697088
+            m_url.replace("/download/", "/download-client/");
+        }
+    }
+    else if(m_url.startsWith("twitch://")) {
+        // twitch://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download-client/2697088
+        m_url.replace(0, 9, "https://");
+        // https://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download-client/2697088
+    }
+    auto dl = Net::Download::makeByteArray(QUrl(m_url), &results);
+    m_dljob->addNetAction(dl);
+    if(weAreDigging) {
+        connect(m_dljob.get(), &NetJob::finished, this, &Flame::UrlResolvingTask::processHTML);
+    } else {
+        connect(m_dljob.get(), &NetJob::finished, this, &Flame::UrlResolvingTask::processCCIP);
+    }
+    m_dljob->start();
+}
+
+void Flame::UrlResolvingTask::processHTML()
+{
+    QString htmlDoc = QString::fromUtf8(results);
+    auto index = htmlDoc.indexOf(needle);
+    if(index < 0) {
+        emitFailed(tr("Couldn't find the needle in the haystack..."));
+        return;
+    }
+    auto indexStart = index;
+    int indexEnd = -1;
+    while((index + 1) < htmlDoc.size() && htmlDoc[index] != '"') {
+        index ++;
+        if(htmlDoc[index] == '"') {
+            indexEnd = index;
+            break;
+        }
+    }
+    if(indexEnd > 0) {
+        QString found = htmlDoc.mid(indexStart, indexEnd - indexStart);
+        qDebug() << "Found needle: " << found;
+        // twitch://www.curseforge.com/minecraft/modpacks/ftb-sky-odyssey/download-client/2697088
+        m_url = found;
+        resolveUrl();
+        return;
+    }
+    emitFailed(tr("Couldn't find the end of the needle in the haystack..."));
+    return;
+}
+
+void Flame::UrlResolvingTask::processCCIP()
+{
+    QDomDocument doc;
+    if (!doc.setContent(results)) {
+        qDebug() << results;
+        emitFailed(tr("Resolving failed."));
+        return;
+    }
+    auto packageNode = doc.namedItem("package");
+    if(!packageNode.isElement()) {
+        emitFailed(tr("Resolving failed: missing package root element."));
+        return;
+    }
+    auto projectNode = packageNode.namedItem("project");
+    if(!projectNode.isElement()) {
+        emitFailed(tr("Resolving failed: missing project element."));
+        return;
+    }
+    auto attribs = projectNode.attributes();
+
+    auto projectIdNode = attribs.namedItem("id");
+    if(!projectIdNode.isAttr()) {
+        emitFailed(tr("Resolving failed: missing id attribute."));
+        return;
+    }
+    auto fileIdNode = attribs.namedItem("file");
+    if(!fileIdNode.isAttr()) {
+        emitFailed(tr("Resolving failed: missing file attribute."));
+        return;
+    }
+
+    auto projectId = projectIdNode.nodeValue();
+    auto fileId = fileIdNode.nodeValue();
+    bool success = true;
+    m_result.projectId = projectId.toInt(&success);
+    if(!success) {
+        emitFailed(tr("Failed to resove projectId as a number."));
+        return;
+    }
+    m_result.fileId = fileId.toInt(&success);
+    if(!success) {
+        emitFailed(tr("Failed to resove fileId as a number."));
+        return;
+    }
+    qDebug() << "Resolved" << m_url << "as" << m_result.projectId << "/" << m_result.fileId;
+    resolveIDs();
+}
+
+void Flame::UrlResolvingTask::resolveIDs()
+{
+    setStatus(tr("Resolving mod IDs..."));
+    m_dljob.reset(new NetJob("Mod id resolver"));
+    auto projectIdStr = QString::number(m_result.projectId);
+    auto fileIdStr = QString::number(m_result.fileId);
+    QString metaurl = QString("%1/%2/%3.json").arg(metabase, projectIdStr, fileIdStr);
+    auto dl = Net::Download::makeByteArray(QUrl(metaurl), &results);
+    m_dljob->addNetAction(dl);
+    connect(m_dljob.get(), &NetJob::finished, this, &Flame::UrlResolvingTask::processCursemeta);
+    m_dljob->start();
+}
+
+void Flame::UrlResolvingTask::processCursemeta()
+{
+    try {
+        if(m_result.parseFromBytes(results)) {
+            emitSucceeded();
+            qDebug() << results;
+            return;
+        }
+    } catch (const JSONValidationError &e) {
+
+        qCritical() << "Resolving of" << m_result.projectId << m_result.fileId << "failed because of a parsing error:";
+        qCritical() << e.cause();
+        qCritical() << "JSON:";
+        qCritical() << results;
+    }
+    emitFailed(tr("Failed to resolve the modpack file."));
+}
diff --git a/api/logic/modplatform/flame/UrlResolvingTask.h b/api/logic/modplatform/flame/UrlResolvingTask.h
new file mode 100644
index 00000000..98b78f67
--- /dev/null
+++ b/api/logic/modplatform/flame/UrlResolvingTask.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "tasks/Task.h"
+#include "net/NetJob.h"
+#include "PackManifest.h"
+
+#include "multimc_logic_export.h"
+
+namespace Flame
+{
+class MULTIMC_LOGIC_EXPORT UrlResolvingTask : public Task
+{
+    Q_OBJECT
+public:
+    explicit UrlResolvingTask(const QString &toProcess);
+    virtual ~UrlResolvingTask() {};
+
+    const Flame::File &getResults() const
+    {
+        return m_result;
+    }
+
+protected:
+    virtual void executeTask() override;
+
+protected slots:
+    void processCCIP();
+    void processHTML();
+    void processCursemeta();
+
+private:
+    void resolveUrl();
+    void resolveIDs();
+
+private: /* data */
+    QString m_url;
+    QString needle;
+    Flame::File m_result;
+    QByteArray results;
+    NetJobPtr m_dljob;
+};
+}
+
diff --git a/api/logic/modplatform/ftb/FtbPackFetchTask.cpp b/api/logic/modplatform/ftb/FtbPackFetchTask.cpp
index 5588a7fd..fe3f3fac 100644
--- a/api/logic/modplatform/ftb/FtbPackFetchTask.cpp
+++ b/api/logic/modplatform/ftb/FtbPackFetchTask.cpp
@@ -1,117 +1,168 @@
 #include "FtbPackFetchTask.h"
 #include <QDomDocument>
+#include "FtbPrivatePackManager.h"
 
-FtbPackFetchTask::FtbPackFetchTask()
-{
-}
-
-FtbPackFetchTask::~FtbPackFetchTask()
-{
-}
+#include "net/URLConstants.h"
 
 void FtbPackFetchTask::fetch()
 {
-	NetJob *netJob = new NetJob("FtbModpackFetch");
+    publicPacks.clear();
+    thirdPartyPacks.clear();
+
+    NetJob *netJob = new NetJob("FtbModpackFetch");
 
-	QUrl publicPacksUrl = QUrl("https://ftb.cursecdn.com/FTB2/static/modpacks.xml");
-	qDebug() << "Downloading public version info from" << publicPacksUrl.toString();
-	netJob->addNetAction(Net::Download::makeByteArray(publicPacksUrl, &publicModpacksXmlFileData));
+    QUrl publicPacksUrl = QUrl(URLConstants::FTB_CDN_BASE_URL + "static/modpacks.xml");
+    qDebug() << "Downloading public version info from" << publicPacksUrl.toString();
+    netJob->addNetAction(Net::Download::makeByteArray(publicPacksUrl, &publicModpacksXmlFileData));
 
-	QUrl thirdPartyUrl = QUrl("https://ftb.cursecdn.com/FTB2/static/thirdparty.xml");
-	qDebug() << "Downloading thirdparty version info from" << thirdPartyUrl.toString();
-	netJob->addNetAction(Net::Download::makeByteArray(thirdPartyUrl, &thirdPartyModpacksXmlFileData));
+    QUrl thirdPartyUrl = QUrl(URLConstants::FTB_CDN_BASE_URL + "static/thirdparty.xml");
+    qDebug() << "Downloading thirdparty version info from" << thirdPartyUrl.toString();
+    netJob->addNetAction(Net::Download::makeByteArray(thirdPartyUrl, &thirdPartyModpacksXmlFileData));
 
-	QObject::connect(netJob, &NetJob::succeeded, this, &FtbPackFetchTask::fileDownloadFinished);
-	QObject::connect(netJob, &NetJob::failed, this, &FtbPackFetchTask::fileDownloadFailed);
+    QObject::connect(netJob, &NetJob::succeeded, this, &FtbPackFetchTask::fileDownloadFinished);
+    QObject::connect(netJob, &NetJob::failed, this, &FtbPackFetchTask::fileDownloadFailed);
 
-	jobPtr.reset(netJob);
-	netJob->start();
+    jobPtr.reset(netJob);
+    netJob->start();
 }
 
-void FtbPackFetchTask::fileDownloadFinished()
+void FtbPackFetchTask::fetchPrivate(const QStringList & toFetch)
 {
-	jobPtr.reset();
-
-	QStringList failedLists;
-
-	if(!parseAndAddPacks(publicModpacksXmlFileData, FtbPackType::Public, publicPacks)) {
-		failedLists.append(tr("Public Packs"));
-	}
-
-	if(!parseAndAddPacks(thirdPartyModpacksXmlFileData, FtbPackType::ThirdParty, thirdPartyPacks)) {
-		failedLists.append(tr("Third Party Packs"));
-	}
+    QString privatePackBaseUrl = URLConstants::FTB_CDN_BASE_URL + "static/%1.xml";
+
+    for (auto &packCode: toFetch)
+    {
+        QByteArray *data = new QByteArray();
+        NetJob *job = new NetJob("Fetching private pack");
+        job->addNetAction(Net::Download::makeByteArray(privatePackBaseUrl.arg(packCode), data));
+
+        QObject::connect(job, &NetJob::succeeded, this, [this, job, data, packCode]
+        {
+            FtbModpackList packs;
+            parseAndAddPacks(*data, FtbPackType::Private, packs);
+            foreach(FtbModpack currentPack, packs)
+            {
+                currentPack.packCode = packCode;
+                emit privateFileDownloadFinished(currentPack);
+            }
+
+            job->deleteLater();
+
+            data->clear();
+            delete data;
+        });
+
+        QObject::connect(job, &NetJob::failed, this, [this, job, packCode, data](QString reason)
+        {
+            emit privateFileDownloadFailed(reason, packCode);
+            job->deleteLater();
+
+            data->clear();
+            delete data;
+        });
+
+        job->start();
+    }
+}
 
-	if(failedLists.size() > 0) {
-		emit failed(QString("Failed to download some pack lists:%1").arg(failedLists.join("\n- ")));
-	} else {
-		emit finished(publicPacks, thirdPartyPacks);
-	}
+void FtbPackFetchTask::fileDownloadFinished()
+{
+    jobPtr.reset();
+
+    QStringList failedLists;
+
+    if(!parseAndAddPacks(publicModpacksXmlFileData, FtbPackType::Public, publicPacks))
+    {
+        failedLists.append(tr("Public Packs"));
+    }
+
+    if(!parseAndAddPacks(thirdPartyModpacksXmlFileData, FtbPackType::ThirdParty, thirdPartyPacks))
+    {
+        failedLists.append(tr("Third Party Packs"));
+    }
+
+    if(failedLists.size() > 0)
+    {
+        emit failed(tr("Failed to download some pack lists: %1").arg(failedLists.join("\n- ")));
+    }
+    else
+    {
+        emit finished(publicPacks, thirdPartyPacks);
+    }
 }
 
 bool FtbPackFetchTask::parseAndAddPacks(QByteArray &data, FtbPackType packType, FtbModpackList &list)
 {
-	QDomDocument doc;
-
-	QString errorMsg = "Unknown error.";
-	int errorLine = -1;
-	int errorCol = -1;
-
-	if(!doc.setContent(data, false, &errorMsg, &errorLine, &errorCol)){
-		auto fullErrMsg = QString("Failed to fetch modpack data: %s %d:%d!").arg(errorMsg, errorLine, errorCol);
-		qWarning() << fullErrMsg;
-		data.clear();
-		return false;
-	}
-
-	QDomNodeList nodes = doc.elementsByTagName("modpack");
-	for(int i = 0; i < nodes.length(); i++) {
-		QDomElement element = nodes.at(i).toElement();
-
-		FtbModpack modpack;
-		modpack.name = element.attribute("name");
-		modpack.currentVersion = element.attribute("version");
-		modpack.mcVersion = element.attribute("mcVersion");
-		modpack.description = element.attribute("description");
-		modpack.mods = element.attribute("mods");
-		modpack.logo = element.attribute("logo");
-		modpack.oldVersions = element.attribute("oldVersions").split(";");
-		modpack.broken = false;
-		modpack.bugged = false;
-
-		//remove empty if the xml is bugged
-		for(QString curr : modpack.oldVersions) {
-			if(curr.isNull() || curr.isEmpty()) {
-				modpack.oldVersions.removeAll(curr);
-				modpack.bugged = true;
-				qWarning() << "Removed some empty versions from" << modpack.name;
-			}
-		}
-
-		if(modpack.oldVersions.size() < 1) {
-			if(!modpack.currentVersion.isNull() && !modpack.currentVersion.isEmpty()) {
-				modpack.oldVersions.append(modpack.currentVersion);
-				qWarning() << "Added current version to oldVersions because oldVersions was empty! (" + modpack.name + ")";
-			} else {
-				modpack.broken = true;
-				qWarning() << "Broken pack:" << modpack.name << " => No valid version!";
-			}
-		}
-
-		modpack.author = element.attribute("author");
-
-		modpack.dir = element.attribute("dir");
-		modpack.file = element.attribute("url");
-
-		modpack.type = packType;
-
-		list.append(modpack);
-	}
-
-	return true;
+    QDomDocument doc;
+
+    QString errorMsg = "Unknown error.";
+    int errorLine = -1;
+    int errorCol = -1;
+
+    if(!doc.setContent(data, false, &errorMsg, &errorLine, &errorCol))
+    {
+        auto fullErrMsg = QString("Failed to fetch modpack data: %1 %2:3d!").arg(errorMsg, errorLine, errorCol);
+        qWarning() << fullErrMsg;
+        data.clear();
+        return false;
+    }
+
+    QDomNodeList nodes = doc.elementsByTagName("modpack");
+    for(int i = 0; i < nodes.length(); i++)
+    {
+        QDomElement element = nodes.at(i).toElement();
+
+        FtbModpack modpack;
+        modpack.name = element.attribute("name");
+        modpack.currentVersion = element.attribute("version");
+        modpack.mcVersion = element.attribute("mcVersion");
+        modpack.description = element.attribute("description");
+        modpack.mods = element.attribute("mods");
+        modpack.logo = element.attribute("logo");
+        modpack.oldVersions = element.attribute("oldVersions").split(";");
+        modpack.broken = false;
+        modpack.bugged = false;
+
+        //remove empty if the xml is bugged
+        for(QString curr : modpack.oldVersions)
+        {
+            if(curr.isNull() || curr.isEmpty())
+            {
+                modpack.oldVersions.removeAll(curr);
+                modpack.bugged = true;
+                qWarning() << "Removed some empty versions from" << modpack.name;
+            }
+        }
+
+        if(modpack.oldVersions.size() < 1)
+        {
+            if(!modpack.currentVersion.isNull() && !modpack.currentVersion.isEmpty())
+            {
+                modpack.oldVersions.append(modpack.currentVersion);
+                qWarning() << "Added current version to oldVersions because oldVersions was empty! (" + modpack.name + ")";
+            }
+            else
+            {
+                modpack.broken = true;
+                qWarning() << "Broken pack:" << modpack.name << " => No valid version!";
+            }
+        }
+
+        modpack.author = element.attribute("author");
+
+        modpack.dir = element.attribute("dir");
+        modpack.file = element.attribute("url");
+
+        modpack.type = packType;
+
+        list.append(modpack);
+    }
+
+    return true;
 }
 
-void FtbPackFetchTask::fileDownloadFailed(QString reason){
-	qWarning() << "Fetching FtbPacks failed: " << reason;
-	emit failed(reason);
+void FtbPackFetchTask::fileDownloadFailed(QString reason)
+{
+    qWarning() << "Fetching FtbPacks failed:" << reason;
+    emit failed(reason);
 }
diff --git a/api/logic/modplatform/ftb/FtbPackFetchTask.h b/api/logic/modplatform/ftb/FtbPackFetchTask.h
index b5635b12..f955fe83 100644
--- a/api/logic/modplatform/ftb/FtbPackFetchTask.h
+++ b/api/logic/modplatform/ftb/FtbPackFetchTask.h
@@ -8,30 +8,33 @@
 
 class MULTIMC_LOGIC_EXPORT FtbPackFetchTask : public QObject {
 
-	Q_OBJECT
+    Q_OBJECT
 
 public:
-	FtbPackFetchTask();
-	virtual ~FtbPackFetchTask();
+    FtbPackFetchTask() = default;
+    virtual ~FtbPackFetchTask() = default;
 
-	void fetch();
+    void fetch();
+    void fetchPrivate(const QStringList &toFetch);
 
 private:
-	NetJobPtr jobPtr;
+    NetJobPtr jobPtr;
 
-	QByteArray publicModpacksXmlFileData;
-	QByteArray thirdPartyModpacksXmlFileData;
+    QByteArray publicModpacksXmlFileData;
+    QByteArray thirdPartyModpacksXmlFileData;
 
-	bool parseAndAddPacks(QByteArray &data, FtbPackType packType, FtbModpackList &list);
-	FtbModpackList publicPacks;
-	FtbModpackList thirdPartyPacks;
+    bool parseAndAddPacks(QByteArray &data, FtbPackType packType, FtbModpackList &list);
+    FtbModpackList publicPacks;
+    FtbModpackList thirdPartyPacks;
 
 protected slots:
-	void fileDownloadFinished();
-	void fileDownloadFailed(QString reason);
+    void fileDownloadFinished();
+    void fileDownloadFailed(QString reason);
 
 signals:
-	void finished(FtbModpackList publicPacks, FtbModpackList thirdPartyPacks);
-	void failed(QString reason);
+    void finished(FtbModpackList publicPacks, FtbModpackList thirdPartyPacks);
+    void failed(QString reason);
 
+    void privateFileDownloadFinished(FtbModpack modpack);
+    void privateFileDownloadFailed(QString reason, QString packCode);
 };
diff --git a/api/logic/modplatform/ftb/FtbPackInstallTask.cpp b/api/logic/modplatform/ftb/FtbPackInstallTask.cpp
index b57c2092..4962bcac 100644
--- a/api/logic/modplatform/ftb/FtbPackInstallTask.cpp
+++ b/api/logic/modplatform/ftb/FtbPackInstallTask.cpp
@@ -9,190 +9,199 @@
 #include "minecraft/ComponentList.h"
 #include "minecraft/GradleSpecifier.h"
 
+#include "net/URLConstants.h"
+
 FtbPackInstallTask::FtbPackInstallTask(FtbModpack pack, QString version)
 {
-	m_pack = pack;
-	m_version = version;
+    m_pack = pack;
+    m_version = version;
 }
 
 void FtbPackInstallTask::executeTask()
 {
-	downloadPack();
+    downloadPack();
 }
 
 void FtbPackInstallTask::downloadPack()
 {
-	setStatus(tr("Downloading zip for %1").arg(m_pack.name));
-
-	auto packoffset = QString("%1/%2/%3").arg(m_pack.dir, m_version.replace(".", "_"), m_pack.file);
-	auto entry = ENV.metacache()->resolveEntry("FTBPacks", packoffset);
-	NetJob *job = new NetJob("Download FTB Pack");
-
-	entry->setStale(true);
-	QString url = QString("http://ftb.cursecdn.com/FTB2/modpacks/%1").arg(packoffset);
-	job->addNetAction(Net::Download::makeCached(url, entry));
-	archivePath = entry->getFullPath();
-
-	netJobContainer.reset(job);
-	connect(job, &NetJob::succeeded, this, &FtbPackInstallTask::onDownloadSucceeded);
-	connect(job, &NetJob::failed, this, &FtbPackInstallTask::onDownloadFailed);
-	connect(job, &NetJob::progress, this, &FtbPackInstallTask::onDownloadProgress);
-	job->start();
-
-	progress(1, 4);
+    setStatus(tr("Downloading zip for %1").arg(m_pack.name));
+
+    auto packoffset = QString("%1/%2/%3").arg(m_pack.dir, m_version.replace(".", "_"), m_pack.file);
+    auto entry = ENV.metacache()->resolveEntry("FTBPacks", packoffset);
+    NetJob *job = new NetJob("Download FTB Pack");
+
+    entry->setStale(true);
+    QString url;
+    if(m_pack.type == FtbPackType::Private)
+    {
+        url = QString(URLConstants::FTB_CDN_BASE_URL + "privatepacks/%1").arg(packoffset);
+    }
+    else
+    {
+        url = QString(URLConstants::FTB_CDN_BASE_URL + "modpacks/%1").arg(packoffset);
+    }
+    job->addNetAction(Net::Download::makeCached(url, entry));
+    archivePath = entry->getFullPath();
+
+    netJobContainer.reset(job);
+    connect(job, &NetJob::succeeded, this, &FtbPackInstallTask::onDownloadSucceeded);
+    connect(job, &NetJob::failed, this, &FtbPackInstallTask::onDownloadFailed);
+    connect(job, &NetJob::progress, this, &FtbPackInstallTask::onDownloadProgress);
+    job->start();
+
+    progress(1, 4);
 }
 
 void FtbPackInstallTask::onDownloadSucceeded()
 {
-	abortable = false;
-	unzip();
+    abortable = false;
+    unzip();
 }
 
 void FtbPackInstallTask::onDownloadFailed(QString reason)
 {
-	emitFailed(reason);
+    abortable = false;
+    emitFailed(reason);
 }
 
 void FtbPackInstallTask::onDownloadProgress(qint64 current, qint64 total)
 {
-	abortable = true;
-	progress(current, total * 4);
-	setStatus(tr("Downloading zip for %1 (%2\%)").arg(m_pack.name).arg(current / 10));
+    abortable = true;
+    progress(current, total * 4);
+    setStatus(tr("Downloading zip for %1 (%2%)").arg(m_pack.name).arg(current / 10));
 }
 
 void FtbPackInstallTask::unzip()
 {
-	progress(2, 4);
-	setStatus(tr("Extracting modpack"));
-	QDir extractDir(m_stagingPath);
-
-	m_packZip.reset(new QuaZip(archivePath));
-	if(!m_packZip->open(QuaZip::mdUnzip))
-	{
-		emitFailed(tr("Failed to open modpack file %1!").arg(archivePath));
-		return;
-	}
-
-	m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, archivePath, extractDir.absolutePath() + "/unzip");
-	connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &FtbPackInstallTask::onUnzipFinished);
-	connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &FtbPackInstallTask::onUnzipCanceled);
-	m_extractFutureWatcher.setFuture(m_extractFuture);
+    progress(2, 4);
+    setStatus(tr("Extracting modpack"));
+    QDir extractDir(m_stagingPath);
+
+    m_packZip.reset(new QuaZip(archivePath));
+    if(!m_packZip->open(QuaZip::mdUnzip))
+    {
+        emitFailed(tr("Failed to open modpack file %1!").arg(archivePath));
+        return;
+    }
+
+    m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, archivePath, extractDir.absolutePath() + "/unzip");
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &FtbPackInstallTask::onUnzipFinished);
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &FtbPackInstallTask::onUnzipCanceled);
+    m_extractFutureWatcher.setFuture(m_extractFuture);
 }
 
 void FtbPackInstallTask::onUnzipFinished()
 {
-	install();
+    install();
 }
 
 void FtbPackInstallTask::onUnzipCanceled()
 {
-	emitAborted();
+    emitAborted();
 }
 
 void FtbPackInstallTask::install()
 {
-	progress(3, 4);
-	setStatus(tr("Installing modpack"));
-	QDir unzipMcDir(m_stagingPath + "/unzip/minecraft");
-	if(unzipMcDir.exists())
-	{
-		//ok, found minecraft dir, move contents to instance dir
-		if(!QDir().rename(m_stagingPath + "/unzip/minecraft", m_stagingPath + "/.minecraft"))
-		{
-			emitFailed(tr("Failed to move unzipped minecraft!"));
-			return;
-		}
-	}
-
-	QString instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
-	auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
-	instanceSettings->registerSetting("InstanceType", "Legacy");
-	instanceSettings->set("InstanceType", "OneSix");
-
-	MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
-	auto components = instance.getComponentList();
-	components->buildingFromScratch();
-	components->setComponentVersion("net.minecraft", m_pack.mcVersion, true);
-
-	bool fallback = true;
-
-	//handle different versions
-	QFile packJson(m_stagingPath + "/.minecraft/pack.json");
-	QDir jarmodDir = QDir(m_stagingPath + "/unzip/instMods");
-	if(packJson.exists())
-	{
-		packJson.open(QIODevice::ReadOnly | QIODevice::Text);
-		QJsonDocument doc = QJsonDocument::fromJson(packJson.readAll());
-		packJson.close();
-
-		//we only care about the libs
-		QJsonArray libs = doc.object().value("libraries").toArray();
-
-		foreach (const QJsonValue &value, libs)
-		{
-			QString nameValue = value.toObject().value("name").toString();
-			if(!nameValue.startsWith("net.minecraftforge"))
-			{
-				continue;
-			}
-
-			GradleSpecifier forgeVersion(nameValue);
-
-			components->setComponentVersion("net.minecraftforge", forgeVersion.version().replace(m_pack.mcVersion, "").replace("-", ""));
-			packJson.remove();
-			fallback = false;
-			break;
-		}
-
-	}
-
-	if(jarmodDir.exists())
-	{
-		qDebug() << "Found jarmods, installing...";
-
-		QStringList jarmods;
-		for (auto info: jarmodDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files))
-		{
-			qDebug() << "Jarmod:" << info.fileName();
-			jarmods.push_back(info.absoluteFilePath());
-		}
-
-		components->installJarMods(jarmods);
-		fallback = false;
-	}
-
-	//just nuke unzip directory, it s not needed anymore
-	FS::deletePath(m_stagingPath + "/unzip");
-
-	if(fallback)
-	{
-		//TODO: Some fallback mechanism... or just keep failing!
-		emitFailed(tr("No installation method found!"));
-		return;
-	}
-
-	components->saveNow();
-
-	progress(4, 4);
-
-	instance.init();
-	instance.setName(m_instName);
-	if(m_instIcon == "default")
-	{
-		m_instIcon = "ftb_logo";
-	}
-	instance.setIconKey(m_instIcon);
-	instance.setGroupInitial(m_instGroup);
-	instanceSettings->resumeSave();
-
-	emitSucceeded();
+    progress(3, 4);
+    setStatus(tr("Installing modpack"));
+    QDir unzipMcDir(m_stagingPath + "/unzip/minecraft");
+    if(unzipMcDir.exists())
+    {
+        //ok, found minecraft dir, move contents to instance dir
+        if(!QDir().rename(m_stagingPath + "/unzip/minecraft", m_stagingPath + "/.minecraft"))
+        {
+            emitFailed(tr("Failed to move unzipped minecraft!"));
+            return;
+        }
+    }
+
+    QString instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
+    auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
+    instanceSettings->registerSetting("InstanceType", "Legacy");
+    instanceSettings->set("InstanceType", "OneSix");
+
+    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
+    auto components = instance.getComponentList();
+    components->buildingFromScratch();
+    components->setComponentVersion("net.minecraft", m_pack.mcVersion, true);
+
+    bool fallback = true;
+
+    //handle different versions
+    QFile packJson(m_stagingPath + "/.minecraft/pack.json");
+    QDir jarmodDir = QDir(m_stagingPath + "/unzip/instMods");
+    if(packJson.exists())
+    {
+        packJson.open(QIODevice::ReadOnly | QIODevice::Text);
+        QJsonDocument doc = QJsonDocument::fromJson(packJson.readAll());
+        packJson.close();
+
+        //we only care about the libs
+        QJsonArray libs = doc.object().value("libraries").toArray();
+
+        foreach (const QJsonValue &value, libs)
+        {
+            QString nameValue = value.toObject().value("name").toString();
+            if(!nameValue.startsWith("net.minecraftforge"))
+            {
+                continue;
+            }
+
+            GradleSpecifier forgeVersion(nameValue);
+
+            components->setComponentVersion("net.minecraftforge", forgeVersion.version().replace(m_pack.mcVersion, "").replace("-", ""));
+            packJson.remove();
+            fallback = false;
+            break;
+        }
+
+    }
+
+    if(jarmodDir.exists())
+    {
+        qDebug() << "Found jarmods, installing...";
+
+        QStringList jarmods;
+        for (auto info: jarmodDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files))
+        {
+            qDebug() << "Jarmod:" << info.fileName();
+            jarmods.push_back(info.absoluteFilePath());
+        }
+
+        components->installJarMods(jarmods);
+        fallback = false;
+    }
+
+    //just nuke unzip directory, it s not needed anymore
+    FS::deletePath(m_stagingPath + "/unzip");
+
+    if(fallback)
+    {
+        //TODO: Some fallback mechanism... or just keep failing!
+        emitFailed(tr("No installation method found!"));
+        return;
+    }
+
+    components->saveNow();
+
+    progress(4, 4);
+
+    instance.setName(m_instName);
+    if(m_instIcon == "default")
+    {
+        m_instIcon = "ftb_logo";
+    }
+    instance.setIconKey(m_instIcon);
+    instanceSettings->resumeSave();
+
+    emitSucceeded();
 }
 
 bool FtbPackInstallTask::abort()
 {
-	if(abortable)
-	{
-		return netJobContainer->abort();
-	}
-	return false;
+    if(abortable)
+    {
+        return netJobContainer->abort();
+    }
+    return false;
 }
diff --git a/api/logic/modplatform/ftb/FtbPackInstallTask.h b/api/logic/modplatform/ftb/FtbPackInstallTask.h
index 0bfba3d6..3319025e 100644
--- a/api/logic/modplatform/ftb/FtbPackInstallTask.h
+++ b/api/logic/modplatform/ftb/FtbPackInstallTask.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "InstanceTask.h"
-#include "BaseInstanceProvider.h"
 #include "net/NetJob.h"
 #include "quazip.h"
 #include "quazipdir.h"
@@ -9,41 +8,41 @@
 #include "meta/VersionList.h"
 #include "modplatform/ftb/PackHelpers.h"
 
-class MULTIMC_LOGIC_EXPORT FtbPackInstallTask : public InstanceTask {
-
-	Q_OBJECT
+class MULTIMC_LOGIC_EXPORT FtbPackInstallTask : public InstanceTask
+{
+    Q_OBJECT
 
 public:
-	explicit FtbPackInstallTask(FtbModpack pack, QString version);
-	virtual ~FtbPackInstallTask(){}
+    explicit FtbPackInstallTask(FtbModpack pack, QString version);
+    virtual ~FtbPackInstallTask(){}
 
-	bool abort() override;
+    bool abort() override;
 
 protected:
-	//! Entry point for tasks.
-	virtual void executeTask() override;
+    //! Entry point for tasks.
+    virtual void executeTask() override;
 
 private:
-	void downloadPack();
-	void unzip();
-	void install();
+    void downloadPack();
+    void unzip();
+    void install();
 
 private slots:
-	void onDownloadSucceeded();
-	void onDownloadFailed(QString reason);
-	void onDownloadProgress(qint64 current, qint64 total);
+    void onDownloadSucceeded();
+    void onDownloadFailed(QString reason);
+    void onDownloadProgress(qint64 current, qint64 total);
 
-	void onUnzipFinished();
-	void onUnzipCanceled();
+    void onUnzipFinished();
+    void onUnzipCanceled();
 
 private: /* data */
-	bool abortable = false;
-	std::unique_ptr<QuaZip> m_packZip;
-	QFuture<QStringList> m_extractFuture;
-	QFutureWatcher<QStringList> m_extractFutureWatcher;
-	NetJobPtr netJobContainer;
-	QString archivePath;
-
-	FtbModpack m_pack;
-	QString m_version;
+    bool abortable = false;
+    std::unique_ptr<QuaZip> m_packZip;
+    QFuture<QStringList> m_extractFuture;
+    QFutureWatcher<QStringList> m_extractFutureWatcher;
+    NetJobPtr netJobContainer;
+    QString archivePath;
+
+    FtbModpack m_pack;
+    QString m_version;
 };
diff --git a/api/logic/modplatform/ftb/FtbPrivatePackManager.cpp b/api/logic/modplatform/ftb/FtbPrivatePackManager.cpp
new file mode 100644
index 00000000..c3477cec
--- /dev/null
+++ b/api/logic/modplatform/ftb/FtbPrivatePackManager.cpp
@@ -0,0 +1,37 @@
+#include "FtbPrivatePackManager.h"
+
+#include <QDebug>
+
+#include "FileSystem.h"
+
+void FtbPrivatePackManager::load()
+{
+    try
+    {
+        currentPacks = QString::fromUtf8(FS::read(m_filename)).split('\n', QString::SkipEmptyParts).toSet();
+        dirty = false;
+    }
+    catch(...)
+    {
+        currentPacks = {};
+        qWarning() << "Failed to read third party FTB pack codes from" << m_filename;
+    }
+}
+
+void FtbPrivatePackManager::save() const
+{
+    if(!dirty)
+    {
+        return;
+    }
+    try
+    {
+        QStringList list = currentPacks.toList();
+        FS::write(m_filename, list.join('\n').toUtf8());
+        dirty = false;
+    }
+    catch(...)
+    {
+        qWarning() << "Failed to write third party FTB pack codes to" << m_filename;
+    }
+}
diff --git a/api/logic/modplatform/ftb/FtbPrivatePackManager.h b/api/logic/modplatform/ftb/FtbPrivatePackManager.h
new file mode 100644
index 00000000..388224d6
--- /dev/null
+++ b/api/logic/modplatform/ftb/FtbPrivatePackManager.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <QSet>
+#include <QString>
+#include <QFile>
+#include "multimc_logic_export.h"
+
+class MULTIMC_LOGIC_EXPORT FtbPrivatePackManager
+{
+public:
+    ~FtbPrivatePackManager()
+    {
+        save();
+    }
+    void load();
+    void save() const;
+    bool empty() const
+    {
+        return currentPacks.empty();
+    }
+    const QSet<QString> &getCurrentPackCodes() const
+    {
+        return currentPacks;
+    }
+    void add(const QString &code)
+    {
+        currentPacks.insert(code);
+        dirty = true;
+    }
+    void remove(const QString &code)
+    {
+        currentPacks.remove(code);
+        dirty = true;
+    }
+
+private:
+    QSet<QString> currentPacks;
+    QString m_filename = "private_packs.txt";
+    mutable bool dirty = false;
+};
diff --git a/api/logic/modplatform/ftb/PackHelpers.h b/api/logic/modplatform/ftb/PackHelpers.h
index 39b65927..4306caee 100644
--- a/api/logic/modplatform/ftb/PackHelpers.h
+++ b/api/logic/modplatform/ftb/PackHelpers.h
@@ -6,30 +6,33 @@
 #include <QMetaType>
 
 //Header for structs etc...
-enum FtbPackType {
-	Public,
-	ThirdParty,
-	Private
+enum class FtbPackType
+{
+    Public,
+    ThirdParty,
+    Private
 };
 
-struct FtbModpack {
-	QString name;
-	QString description;
-	QString author;
-	QStringList oldVersions;
-	QString currentVersion;
-	QString mcVersion;
-	QString mods;
-	QString logo;
-
-	//Technical data
-	QString dir;
-	QString file; //<- Url in the xml, but doesn't make much sense
-
-	bool bugged = false;
-	bool broken = false;
-
-	FtbPackType type;
+struct FtbModpack
+{
+    QString name;
+    QString description;
+    QString author;
+    QStringList oldVersions;
+    QString currentVersion;
+    QString mcVersion;
+    QString mods;
+    QString logo;
+
+    //Technical data
+    QString dir;
+    QString file; //<- Url in the xml, but doesn't make much sense
+
+    bool bugged = false;
+    bool broken = false;
+
+    FtbPackType type;
+    QString packCode;
 };
 
 //We need it for the proxy model