feat: Show restore dialog when settings fail to load (#6662)

Co-authored-by: pajlada <rasmus.karlsson@pajlada.com>
Tested-by: pajlada <rasmus.karlsson@pajlada.com>
Tested-by: Mm2PL <mm2pl+gh@kotmisia.pl>
Reported-by: w3bprinz
Reported-by: cqmpact
Reviewed-by: pajlada <rasmus.karlsson@pajlada.com>
Reviewed-by: Mm2PL <mm2pl+gh@kotmisia.pl>

Author: Nerixyz

CHANGELOG.md

@@ -22,6 +22,7 @@
 - Minor: Added broadcaster-only `/poll`, `/cancelpoll`, and `/endpoll` commands. (#6583, #6605)
 - Minor: Added broadcaster-only `/prediction`, `/cancelprediction`, `/lockprediction`, and `/completeprediction` commands. (#6583, #6612, #6632, #6749)
 - Minor: Added support for BetterTTV Pro subscriber badges. (#6625, #6724)
+- Minor: Added backup restore dialog if settings fail to load. (#6662)
 - Minor: Added `debug.traceback` for plugins. (#6652)
 - Minor: Added title and duration options for `/clip` command. (#6669)
 - Minor: Added the ability to filter on messages by the author's external badges (example: `author.external_badges contains "chatterino:Top Donator"` or `author.external_badges contains "frankerfacez:bot"`). (#6709)

mocks/include/mocks/BaseApplication.hpp

@@ -20,7 +20,7 @@ class BaseApplication : public EmptyApplication
 {
 public:
     BaseApplication()
-        : settings(this->args, this->settingsDir.path())
+        : settings(this->args, this->settingsDir.path(), /*isTest=*/true)
         , updates(this->paths_, this->settings)
         , theme(this->paths_)
         , fonts(this->settings)
@@ -29,7 +29,7 @@ class BaseApplication : public EmptyApplication
 
     explicit BaseApplication(const QString &settingsData)
         : EmptyApplication(settingsData)
-        , settings(this->args, this->settingsDir.path())
+        , settings(this->args, this->settingsDir.path(), /*isTest=*/true)
         , updates(this->paths_, this->settings)
         , theme(this->paths_)
         , fonts(this->settings)

src/CMakeLists.txt

@@ -541,6 +541,8 @@ set(SOURCE_FILES
         util/AbandonObject.hpp
         util/AttachToConsole.cpp
         util/AttachToConsole.hpp
+        util/Backup.cpp
+        util/Backup.hpp
         util/BadgeRegistry.cpp
         util/BadgeRegistry.hpp
         util/CancellationToken.hpp
@@ -707,6 +709,8 @@ set(SOURCE_FILES
         widgets/dialogs/QualityPopup.hpp
         widgets/dialogs/ReplyThreadPopup.cpp
         widgets/dialogs/ReplyThreadPopup.hpp
+        widgets/dialogs/RestoreBackupsDialog.cpp
+        widgets/dialogs/RestoreBackupsDialog.hpp
         widgets/dialogs/SelectChannelDialog.cpp
         widgets/dialogs/SelectChannelDialog.hpp
         widgets/dialogs/SelectChannelFiltersDialog.cpp

src/singletons/Settings.cpp

@@ -15,13 +15,15 @@
 #include "controllers/nicknames/Nickname.hpp"
 #include "debug/Benchmark.hpp"
 #include "pajlada/settings/signalargs.hpp"
+#include "util/Backup.hpp"
 #include "util/WindowsHelper.hpp"
 
 #include <pajlada/signals/scoped-connection.hpp>
 
 namespace {
 
 using namespace chatterino;
+using namespace Qt::Literals;
 
 template <typename T>
 void initializeSignalVector(pajlada::Signals::SignalHolder &signalHolder,
@@ -148,7 +150,8 @@ bool Settings::toggleMutedChannel(const QString &channelName)
 
 Settings *Settings::instance_ = nullptr;
 
-Settings::Settings(const Args &args, const QString &settingsDirectory)
+Settings::Settings(const Args &args, const QString &settingsDirectory,
+                   bool isTest)
     : prevInstance_(Settings::instance_)
     , disableSaving(args.dontSaveSettings)
 {
@@ -157,7 +160,43 @@ Settings::Settings(const Args &args, const QString &settingsDirectory)
     // get global instance of the settings library
     auto settingsInstance = pajlada::Settings::SettingManager::getInstance();
 
-    settingsInstance->load(qPrintable(settingsPath));
+    if (isTest)
+    {
+        settingsInstance->load(qPrintable(settingsPath));
+    }
+    else
+    {
+        backup::loadWithBackups(
+            backup::FileData{
+                .fileName = u"settings.json"_s,
+                .directory = settingsDirectory,
+                .fileKind = u"Settings"_s,
+                .fileDescription =
+                    u"This file contains the main application settings such as accounts and hotkeys."_s,
+            },
+            [&]() -> ExpectedStr<void> {
+                using LoadError = pajlada::Settings::SettingManager::LoadError;
+                auto err = settingsInstance->load(qPrintable(settingsPath));
+                switch (err)
+                {
+                    case LoadError::NoError:
+                        return {};  // ok
+                    case LoadError::CannotOpenFile:
+                        return makeUnexpected(u"Failed to open '" %
+                                              settingsPath % '\'');
+                    case LoadError::FileHandleError:
+                        return makeUnexpected("File handle error");
+                    case LoadError::FileReadError:
+                        return makeUnexpected("Failed to read file");
+                    case LoadError::FileSeekError:
+                        return makeUnexpected("Failed to seek in file");
+                    case LoadError::JSONParseError:
+                        return makeUnexpected("File contained malformed JSON");
+                }
+                assert(false);
+                return makeUnexpected("Unknown error");
+            });
+    }
 
     settingsInstance->setBackupEnabled(true);
     settingsInstance->setBackupSlots(9);

src/singletons/Settings.hpp

@@ -127,7 +127,8 @@ class Settings
     bool disableSaving;
 
 public:
-    Settings(const Args &args, const QString &settingsDirectory);
+    Settings(const Args &args, const QString &settingsDirectory,
+             bool isTest = false);
     ~Settings();
 
     static Settings &instance();

src/util/Backup.cpp

@@ -0,0 +1,140 @@
+// SPDX-FileCopyrightText: 2026 Contributors to Chatterino <https://chatterino.com>
+//
+// SPDX-License-Identifier: MIT
+
+#include "util/Backup.hpp"
+
+#include "common/QLogging.hpp"
+#include "util/Expected.hpp"
+#include "util/FilesystemHelpers.hpp"
+#include "widgets/dialogs/RestoreBackupsDialog.hpp"
+
+#include <pajlada/settings/settingmanager.hpp>
+#include <QDir>
+#include <QRegularExpression>
+
+#include <algorithm>
+
+namespace {
+
+QRegularExpression regexForFile(const QString &file)
+{
+    return QRegularExpression(
+        QStringView(u"^%1\\.bkp-\\d+$").arg(QRegularExpression::escape(file)));
+}
+
+bool anyBackupsOf(const QString &directory, const QString &filename)
+{
+    QDir fileDir(directory);
+    if (!fileDir.exists())
+    {
+        return false;
+    }
+
+    auto regex = regexForFile(filename);
+    return std::ranges::any_of(fileDir.entryList(QDir::Files),
+                               [&](const auto &entry) {
+                                   return regex.match(entry).hasMatch();
+                               });
+}
+
+}  // namespace
+
+namespace chatterino::backup {
+
+std::vector<BackupFile> findBackupsFor(const QString &directory,
+                                       const QString &filename)
+{
+    QDir fileDir(directory);
+    if (!fileDir.exists())
+    {
+        return {};
+    }
+    auto dst = qStringToStdPath(fileDir.filePath(filename));
+
+    auto regex = regexForFile(filename);
+    std::vector<BackupFile> backups;
+    const auto entries = fileDir.entryInfoList(QDir::Files, QDir::Time);
+    auto testSM = pajlada::Settings::SettingManager();
+    testSM.saveMethod =
+        pajlada::Settings::SettingManager::SaveMethod::SaveManually;
+
+    for (const auto &entry : entries)
+    {
+        if (!regex.match(entry.fileName()).hasMatch())
+        {
+            continue;
+        }
+        auto canonicalPath = entry.filesystemCanonicalFilePath();
+
+        BackupState state = BackupState::UnableToRead;
+        using LoadError = pajlada::Settings::SettingManager::LoadError;
+
+        auto res = testSM.loadFrom(canonicalPath);
+        switch (res)
+        {
+            case LoadError::NoError:
+                state = BackupState::Ok;
+                break;
+
+            case LoadError::CannotOpenFile:
+            case LoadError::FileHandleError:
+            case LoadError::FileReadError:
+            case LoadError::FileSeekError:
+                state = BackupState::UnableToRead;
+                break;
+
+            case LoadError::JSONParseError:
+                state = BackupState::BadContents;
+                break;
+
+            case LoadError::SavingFromTemporaryFileFailed:
+                // should never happen, temporary file loading/saving is not enabled
+                assert(false);
+                break;
+        }
+
+        backups.emplace_back(BackupFile{
+            .path = canonicalPath,
+            .dstPath = dst,
+            .lastModified = entry.lastModified(),
+            .fileSize = entry.size(),
+            .state = state,
+        });
+    }
+
+    return backups;
+}
+
+void loadWithBackups(const FileData &fileData,
+                     const std::function<ExpectedStr<void>()> &load)
+{
+    while (true)
+    {
+        auto loadResult = load();
+        if (loadResult)
+        {
+            return;
+        }
+        qCDebug(chatterinoSettings)
+            << fileData.fileKind << "failed to load:" << loadResult.error();
+
+        if (!anyBackupsOf(fileData.directory, fileData.fileName))
+        {
+            qCDebug(chatterinoSettings)
+                << "No backups for" << fileData.fileKind;
+            return;
+        }
+
+        auto *diag = new RestoreBackupsDialog(fileData, loadResult.error());
+        auto ret = diag->exec();  // we need to use exec here to block
+        if (ret != QDialog::Accepted)
+        {
+            return;  // rejected -> don't retry
+        }
+
+        qCDebug(chatterinoSettings) << "Retrying to load" << fileData.fileKind;
+    }
+}
+
+}  // namespace chatterino::backup

src/util/Backup.hpp

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2026 Contributors to Chatterino <https://chatterino.com>
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "util/Expected.hpp"
+
+#include <QDateTime>
+#include <QString>
+
+#include <filesystem>
+#include <vector>
+
+class QJsonValue;
+
+namespace chatterino {
+class Paths;
+}  // namespace chatterino
+
+namespace chatterino::backup {
+
+enum class BackupState : uint8_t {
+    /// The backup contains valid JSON
+    Ok,
+    /// The backup could not be read (e.g. invalid file permissions)
+    UnableToRead,
+    /// The backup contains invalid JSON
+    BadContents,
+};
+
+/// A backup file (e.g. `settings.json.bkp-7`) and its state.
+struct BackupFile {
+    std::filesystem::path path;
+    std::filesystem::path dstPath;
+    QDateTime lastModified;
+    qint64 fileSize = 0;
+    BackupState state = BackupState::Ok;
+};
+
+/// Specifies where to load the file from and descriptions about the file and its contents.
+struct FileData {
+    /// "settings.json", "window-layout.json"
+    QString fileName;
+    QString directory;
+    /// "Settings", "Window layout" etc.
+    QString fileKind;
+    /// "This file stores..."
+    QString fileDescription;
+};
+
+/// Find a list of backups for the given `filename` in the given `directory`.
+std::vector<BackupFile> findBackupsFor(const QString &directory,
+                                       const QString &filename);
+
+/// Attempt to load the file described in `fileData` using the `load` param.
+///
+/// If the load fails and any backups are available, spawn a restore backups dialog.
+void loadWithBackups(const FileData &fileData,
+                     const std::function<ExpectedStr<void>()> &load);
+
+}  // namespace chatterino::backup
+
+Q_DECLARE_METATYPE(chatterino::backup::BackupFile);