fix(accounts): distinguish accounts with the same profileId

Signed-off-by: so5iso4ka <so5iso4ka@icloud.com>

Author: so5iso4ka

launcher/CMakeLists.txt

@@ -223,6 +223,8 @@ set(MINECRAFT_SOURCES
     minecraft/auth/AccountData.h
     minecraft/auth/AccountList.cpp
     minecraft/auth/AccountList.h
+    minecraft/auth/AccountIdentifier.cpp
+    minecraft/auth/AccountIdentifier.h
     minecraft/auth/AuthSession.cpp
     minecraft/auth/AuthSession.h
     minecraft/auth/AuthStep.h

launcher/LaunchController.cpp

@@ -86,11 +86,11 @@ void LaunchController::decideAccount()
     // Select the account to use. If the instance has a specific account set, that will be used. Otherwise, the default account will be used
     auto* accounts = APPLICATION->accounts();
     const auto instanceAccountId = m_instance->settings()->get("InstanceAccountId").toString();
-    const auto instanceAccountIndex = accounts->findAccountByProfileId(instanceAccountId);
-    if (instanceAccountIndex == -1 || instanceAccountId.isEmpty()) {
-        m_accountToUse = accounts->defaultAccount();
+    const auto instanceAccount = accounts->findAccountById(AccountIdentifier{ instanceAccountId });
+    if (instanceAccount.found()) {
+        m_accountToUse = accounts->at(instanceAccount.index);
     } else {
-        m_accountToUse = accounts->at(instanceAccountIndex);
+        m_accountToUse = accounts->defaultAccount();
     }
 
     if (!accounts->anyAccountIsValid()) {
@@ -342,7 +342,7 @@ bool LaunchController::reauthenticateAccount(const MinecraftAccountPtr& account,
         auto* accounts = APPLICATION->accounts();
         const bool isDefault = accounts->defaultAccount() == account;
         const auto accountType = account->accountType();
-        accounts->removeAccount(accounts->index(accounts->findAccountByProfileId(account->profileId())));
+        accounts->removeAccount(accounts->index(accounts->findAccountById(AccountIdentifier{ *account }).index));
         MinecraftAccountPtr newAccount;
         switch (accountType) {
             case AccountType::MSA:

launcher/UrlUtils.cpp

@@ -1,3 +1,5 @@
+#include <QObject>
+
 #include "UrlUtils.h"
 
 bool UrlUtils::isLocalhost(const QUrl& url)
@@ -16,3 +18,37 @@ void UrlUtils::upgradeToHTTPS(QUrl& url)
         url.setScheme("https");
     }
 }
+
+QUrl UrlUtils::httpFromUserInput(QString userInput, QString* errorString)
+{
+    if (errorString) {
+        errorString->clear();
+    }
+
+    userInput = userInput.trimmed();
+
+    bool httpScheme = userInput.startsWith("http://", Qt::CaseInsensitive);
+    bool httpsScheme = userInput.startsWith("https://", Qt::CaseInsensitive);
+
+    if (userInput.contains("://") && !httpsScheme && !httpScheme) {
+        if (errorString) {
+            *errorString = QObject::tr("Invalid URL scheme");
+        }
+        return {};
+    }
+
+    QUrl deducedUrl = QUrl::fromUserInput(userInput);
+
+    if (!deducedUrl.isValid() || deducedUrl.isLocalFile() || deducedUrl.host().isEmpty()) {
+        if (errorString) {
+            *errorString = QObject::tr("Invalid URL");
+        }
+        return {};
+    }
+
+    if (!httpsScheme && !httpScheme) {
+        deducedUrl.setScheme("https");
+    }
+
+    return deducedUrl;
+}

launcher/UrlUtils.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include <QString>
 #include <QUrl>
 
 namespace UrlUtils {
 bool isLocalhost(const QUrl& url);
 bool isUnsafe(const QUrl& url);
 void upgradeToHTTPS(QUrl& url);
-}
+QUrl httpFromUserInput(QString userInput, QString* errorString);
+}  // namespace UrlUtils

launcher/minecraft/auth/AccountIdentifier.cpp

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Freesm Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 so5iso4ka <so5iso4ka@icloud.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QSet>
+#include <utility>
+
+#include "MinecraftAccount.h"
+#include "UrlUtils.h"
+
+#include "AccountIdentifier.h"
+
+AccountIdentifier::AccountIdentifier(const QString& str)
+{
+    const auto firstSep = str.indexOf(':');
+    if (firstSep == -1) {
+        m_profileId = str;
+        return;
+    }
+
+    m_profileId = str.left(firstSep);
+
+    const auto secondSep = str.indexOf(':', firstSep + 1);
+    if (secondSep == -1) {
+        m_accountType = str.mid(firstSep + 1);
+        return;
+    }
+
+    m_accountType = str.mid(firstSep + 1, secondSep - firstSep - 1);
+    m_authUrl = str.mid(secondSep + 1);
+}
+
+AccountIdentifier::AccountIdentifier(QString profileId, QString accountType, QString authUrl)
+    : m_profileId(std::move(profileId)), m_accountType(std::move(accountType)), m_authUrl(std::move(authUrl))
+{}
+
+AccountIdentifier::AccountIdentifier(const MinecraftAccount& account)
+    : m_profileId(account.profileId()), m_accountType(account.typeString()), m_authUrl(account.accountData()->authUrl)
+{}
+
+bool AccountIdentifier::isValid() const
+{
+    if (m_profileId.size() != 32)
+        return false;
+
+    static const QSet<QString> validAccountTypes = { "", "msa", "elyby", "custom", "offline" };
+    if (!validAccountTypes.contains(m_accountType))
+        return false;
+
+    if (m_accountType == "custom" && !m_authUrl.isEmpty()) {
+        QString errorString;
+        UrlUtils::httpFromUserInput(m_authUrl, &errorString);
+        if (!errorString.isEmpty())
+            return false;
+    }
+
+    return true;
+}
+
+QString AccountIdentifier::profileId() const
+{
+    return m_profileId;
+}
+
+QString AccountIdentifier::accountType() const
+{
+    return m_accountType;
+}
+
+QString AccountIdentifier::authUrl() const
+{
+    if (m_authUrl.isEmpty())
+        return {};
+    return UrlUtils::httpFromUserInput(m_authUrl, nullptr).toString(QUrl::StripTrailingSlash);
+}
+
+bool AccountIdentifier::matches(const MinecraftAccount& account) const
+{
+    if (!isValid())
+        return false;
+
+    if (account.profileId() != m_profileId)
+        return false;
+
+    if (!m_accountType.isEmpty() && m_accountType != account.typeString())
+        return false;
+
+    if (m_accountType == "custom" && !m_authUrl.isEmpty()) {
+        if (authUrl() != account.accountData()->authUrl)
+            return false;
+    }
+
+    return true;
+}

launcher/minecraft/auth/AccountIdentifier.h

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Freesm Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 so5iso4ka <so5iso4ka@icloud.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QString>
+
+class MinecraftAccount;
+
+/*!
+ * Account identifier that can disambiguate profile ID conflicts when type/auth URL are present.
+ */
+class AccountIdentifier {
+   public:
+    AccountIdentifier() = delete;
+
+    /*!
+     * Constructs identifier from user provided input.
+     * If input is invalid, isValid() considered to be false.
+     *
+     * @param str "ProfileID[:type[:AuthURL]]" formatted string, where ProfileID is the Minecraft profile ID, type is account type (msa /
+     * elyby / custom / offline) and AuthURL is authlib-injector auth URL, used for matching only custom accounts.
+     * Only first two ':' characters are separators.
+     */
+    explicit AccountIdentifier(const QString& str);
+
+    /*!
+     * Constructs identifier from profile ID, account type and authlib-injector auth URL.
+     *
+     * @param profileId Minecraft profile ID
+     * @param accountType Account type ("msa" / "elyby" / "custom" / "offline" / "")
+     * @param authUrl authlib-injector auth URL, used for matching only custom accounts
+     */
+    explicit AccountIdentifier(QString profileId, QString accountType, QString authUrl = {});
+
+    /*!
+     * Constructs identifier from existing Minecraft account.
+     *
+     * @param account a valid Minecraft account
+     */
+    explicit AccountIdentifier(const MinecraftAccount& account);
+
+    /*!
+     * @return whether the identifier is valid
+     */
+    bool isValid() const;
+
+    /*!
+     * @return profile ID
+     */
+    QString profileId() const;
+
+    /*!
+     * @return account type string
+     */
+    QString accountType() const;
+
+    /*!
+     * @return authlib-injector auth URL
+     */
+    QString authUrl() const;
+
+    /*!
+     * Matches specified account with identifier. Returns false if the identifier is not valid.
+     * Empty account type matches any account with the same profile ID.
+     * For custom accounts, a non-empty auth URL must also match.
+     *
+     * @param account a valid Minecraft account
+     * @return whether the account match this identifier
+     */
+    bool matches(const MinecraftAccount& account) const;
+
+   private:
+    QString m_profileId;
+    QString m_accountType;
+    QString m_authUrl;
+};
+
+enum class AccountFindError { NoError, InvalidId, NotFound, Ambiguous };
+
+struct AccountFindResult {
+    int index = -1;
+    AccountFindError error = AccountFindError::NotFound;
+
+    bool found() const { return index >= 0 && error == AccountFindError::NoError; }
+};