ci: fix build

Reviewed-on: #10

.cargo/config.toml

@@ -2,5 +2,8 @@
 [target.'cfg(windows)']
 rustflags = ["-C", "link-args=/STACK:16777220", "--cfg", "tokio_unstable"]
 
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld"
+
 [build]
 rustflags = ["--cfg", "tokio_unstable"]

.github/workflows/astralrinth-build.yml

@@ -114,6 +114,14 @@ jobs:
         run: |
           rm -rf target/release/bundle
           rm -rf target/*/release/bundle || true
+      
+      - name: 🌍 Load environment variables for build.rs
+        shell: bash
+        run: |
+          echo "Loading .env.prod..."
+          set -a
+          source packages/app-lib/.env.prod
+          set +a
 
       # - name: 🔨 Build macOS app
       #   if: matrix.platform == 'macos-latest'

Cargo.lock

@@ -8983,6 +8983,7 @@ dependencies = [
  "data-url",
  "dirs",
  "discord-rich-presence",
+ "dotenvy",
  "dunce",
  "either",
  "encoding_rs",
@@ -9037,6 +9038,8 @@ dependencies = [
  "dashmap",
  "either",
  "enumset",
+ "hyper 1.6.0",
+ "hyper-util",
  "native-dialog",
  "paste",
  "serde",

Cargo.toml

@@ -67,6 +67,7 @@ heck = "0.5.0"
 hex = "0.4.3"
 hickory-resolver = "0.25.2"
 hmac = "0.12.1"
+hyper = "1.6.0"
 hyper-rustls = { version = "0.27.7", default-features = false, features = [
   "http1",
   "native-tokio",

apps/app-frontend/src/App.vue

@@ -61,9 +61,10 @@ import { renderString } from '@modrinth/utils'
 import { useFetch } from '@/helpers/fetch.js'
 // import { check } from '@tauri-apps/plugin-updater'
 import NavButton from '@/components/ui/NavButton.vue'
-import { get as getCreds, login, logout } from '@/helpers/mr_auth.js'
+import { cancelLogin, get as getCreds, login, logout } from '@/helpers/mr_auth.js'
 import { get_user } from '@/helpers/cache.js'
 import AppSettingsModal from '@/components/ui/modal/AppSettingsModal.vue'
+import AuthGrantFlowWaitModal from '@/components/ui/modal/AuthGrantFlowWaitModal.vue'
 // import PromotionWrapper from '@/components/ui/PromotionWrapper.vue'
 // import { hide_ads_window, init_ads_window } from '@/helpers/ads.js'
 import FriendsList from '@/components/ui/friends/FriendsList.vue'
@@ -283,6 +284,8 @@ const incompatibilityWarningModal = ref()
 
 const credentials = ref()
 
+const modrinthLoginFlowWaitModal = ref()
+
 async function fetchCredentials() {
   const creds = await getCreds().catch(handleError)
   if (creds && creds.user_id) {
@@ -292,8 +295,24 @@ async function fetchCredentials() {
 }
 
 async function signIn() {
-  await login().catch(handleError)
-  await fetchCredentials()
+  modrinthLoginFlowWaitModal.value.show()
+
+  try {
+    await login()
+    await fetchCredentials()
+  } catch (error) {
+    if (
+      typeof error === 'object' &&
+      typeof error['message'] === 'string' &&
+      error.message.includes('Login canceled')
+    ) {
+      // Not really an error due to being a result of user interaction, show nothing
+    } else {
+      handleError(error)
+    }
+  } finally {
+    modrinthLoginFlowWaitModal.value.hide()
+  }
 }
 
 async function logOut() {
@@ -422,6 +441,9 @@ function handleAuxClick(e) {
     <Suspense>
       <AppSettingsModal ref="settingsModal" />
     </Suspense>
+    <Suspense>
+      <AuthGrantFlowWaitModal ref="modrinthLoginFlowWaitModal" @flow-cancel="cancelLogin" />
+    </Suspense>
     <Suspense>
       <InstanceCreationModal ref="installationModal" />
     </Suspense>

apps/app-frontend/src/components/ui/AccountsCard.vue

@@ -37,7 +37,7 @@
         <Button v-tooltip="'Add offline account'" icon-only @click="showOfflineLoginModal()">
           <PirateIcon />
         </Button>
-        <Button v-tooltip="'Log via Ely.by'" icon-only @click="loginViaElyBy()">
+        <Button v-tooltip="'Log via Ely.by'" icon-only @click="showElybyLoginModal()">
           <ElyByIcon v-if="!elybyLoginDisabled" />
           <SpinnerIcon v-else class="animate-spin" />
         </Button>
@@ -64,35 +64,84 @@
         <Button v-tooltip="'Add offline account'" icon-only @click="showOfflineLoginModal()">
           <PirateIcon />
         </Button>
-        <Button v-tooltip="'Log via Ely.by'" icon-only @click="loginViaElyBy()">
+        <Button v-tooltip="'Log via Ely.by'" icon-only @click="showElybyLoginModal()">
           <ElyByIcon v-if="!elybyLoginDisabled" />
           <SpinnerIcon v-else class="animate-spin" />
         </Button>
       </div>
     </Card>
   </transition>
-  <ModalWrapper ref="addOfflineModal" class="modal" header="Add new offline account">
+  <ModalWrapper ref="addElybyModal" class="modal" header="Authenticate with Ely.by">
+    <ModalWrapper ref="requestElybyTwoFactorCodeModal" class="modal"
+      header="Ely.by requested 2FA code for authentication">
+      <div class="flex flex-col gap-4 px-6 py-5">
+        <label class="label">Enter your 2FA code</label>
+        <input v-model="elybyTwoFactorCode" type="text" placeholder="Your 2FA code here..." class="input" />
+        <div class="mt-6 ml-auto">
+          <Button icon-only color="primary" class="continue-button" @click="addElybyProfile()">
+            Continue
+          </Button>
+        </div>
+      </div>
+    </ModalWrapper>
     <div class="flex flex-col gap-4 px-6 py-5">
-      <label class="label">Enter your player name</label>
-      <input 
-        type="text" 
-        v-model="offlinePlayerName" 
-        placeholder="Your player name here..." 
-        class="input"
-      />
+      <label class="label">Enter your player name or email (preferred)</label>
+      <input v-model="elybyLogin" type="text" placeholder="Your player name or email here..." class="input" />
+      <label class="label">Enter your password</label>
+      <input v-model="elybyPassword" type="password" placeholder="Your password here..." class="input" />
       <div class="mt-6 ml-auto">
-        <Button 
-          icon-only 
-          color="primary" 
-          @click="addOfflineProfile()" 
-          class="continue-button"
-        >
+        <Button icon-only color="primary" class="continue-button" @click="addElybyProfile()">
           Login
         </Button>
       </div>
     </div>
   </ModalWrapper>
-  <ModalWrapper ref="inputErrorModal" class="modal" header="Error while proceeding">
+  <ModalWrapper ref="addOfflineModal" class="modal" header="Add new offline account">
+    <div class="flex flex-col gap-4 px-6 py-5">
+      <label class="label">Enter your player name</label>
+      <input v-model="offlinePlayerName" type="text" placeholder="Your player name here..." class="input" />
+      <div class="mt-6 ml-auto">
+        <Button icon-only color="primary" class="continue-button" @click="addOfflineProfile()">
+          Login
+        </Button>
+      </div>
+    </div>
+  </ModalWrapper>
+  <ModalWrapper 
+    ref="authenticationElybyErrorModal"
+    class="modal"
+    header="Error while proceeding authentication event with Ely.by">
+    <div class="flex flex-col gap-4 px-6 py-5">
+      <label class="text-base font-medium text-red-700">
+        An error occurred while logging in.
+      </label>
+
+      <div class="mt-6 ml-auto">
+        <Button color="primary" class="retry-button" @click="retryAddElybyProfile">
+          Try again
+        </Button>
+      </div>
+    </div>
+  </ModalWrapper>
+  <ModalWrapper ref="inputElybyErrorModal" class="modal" header="Error while proceeding input event with Ely.by">
+    <div class="flex flex-col gap-4 px-6 py-5">
+      <label class="text-base font-medium text-red-700">
+        An error occurred while adding the Ely.by account. Please follow the instructions below.
+      </label>
+
+      <ul class="list-disc list-inside text-sm space-y-1">
+        <li>Check that you have entered the correct player name or email.</li>
+        <li>Check that you have entered the correct password.</li>
+      </ul>
+
+      <div class="mt-6 ml-auto">
+        <Button color="primary" class="retry-button" @click="retryAddElybyProfile">
+          Try again
+        </Button>
+      </div>
+    </div>
+  </ModalWrapper>
+  <ModalWrapper ref="inputErrorModal" class="modal" header="Error while proceeding input event with offline account">
     <div class="flex flex-col gap-4 px-6 py-5">
       <label class="text-base font-medium text-red-700">
         An error occurred while adding the offline account. Please follow the instructions below.
@@ -107,11 +156,7 @@
       </ul>
 
       <div class="mt-6 ml-auto">
-        <Button 
-          color="primary" 
-          @click="retryAddOfflineProfile"
-          class="retry-button"
-        >
+        <Button color="primary" class="retry-button" @click="retryAddOfflineProfile">
           Try again
         </Button>
       </div>
@@ -130,7 +175,7 @@ import {
   TrashIcon,
   PirateIcon as Offline,
   MicrosoftIcon as License,
-  ElyByIcon as ElyBy,
+  ElyByIcon as Elyby,
   MicrosoftIcon,
   PirateIcon,
   ElyByIcon,
@@ -139,6 +184,8 @@ import {
 import { Avatar, Button, Card } from '@modrinth/ui'
 import { ref, computed, onMounted, onBeforeUnmount, onUnmounted } from 'vue'
 import {
+  elyby_auth_authenticate,
+  elyby_login,
   offline_login,
   users,
   remove_user,
@@ -170,10 +217,18 @@ const elybyLoginDisabled = ref(false)
 const defaultUser = ref()
 
 // [AR] • Feature
+const clientToken = "astralrinth"
 const addOfflineModal = ref(null)
+const addElybyModal = ref(null)
+const requestElybyTwoFactorCodeModal = ref(null)
+const authenticationElybyErrorModal = ref(null)
+const inputElybyErrorModal = ref(null)
 const inputErrorModal = ref(null)
 const exceptionErrorModal = ref(null)
 const offlinePlayerName = ref('')
+const elybyLogin = ref('')
+const elybyPassword = ref('')
+const elybyTwoFactorCode = ref('')
 const minOfflinePlayerNameLength = 2
 const maxOfflinePlayerNameLength = 20
 
@@ -185,7 +240,7 @@ function getAccountType(account) {
     case 'pirate':
       return Offline
     case 'elyby':
-      return ElyBy
+      return Elyby
   }
 }
 
@@ -194,12 +249,38 @@ function showOfflineLoginModal() {
   addOfflineModal.value?.show()
 }
 
+// [AR] • Feature
+function showElybyLoginModal() {
+  addElybyModal.value?.show()
+}
+
 // [AR] • Feature
 function retryAddOfflineProfile() {
   inputErrorModal.value?.hide()
+  clearOfflineFields()
   showOfflineLoginModal()
 }
 
+// [AR] • Feature
+function retryAddElybyProfile() {
+  authenticationElybyErrorModal.value?.hide()
+  inputElybyErrorModal.value?.hide()
+  clearElybyFields()
+  showElybyLoginModal()
+}
+
+// [AR] • Feature
+function clearElybyFields() {
+  elybyLogin.value = ''
+  elybyPassword.value = ''
+  elybyTwoFactorCode.value = ''
+}
+
+// [AR] • Feature
+function clearOfflineFields() {
+  offlinePlayerName.value = ''
+}
+
 // [AR] • Feature
 async function addOfflineProfile() {
   const name = offlinePlayerName.value.trim()
@@ -208,7 +289,7 @@ async function addOfflineProfile() {
   if (!isValidName) {
     addOfflineModal.value?.hide()
     inputErrorModal.value?.show()
-    offlinePlayerName.value = ''
+    clearOfflineFields()
     return
   }
 
@@ -227,16 +308,82 @@ async function addOfflineProfile() {
     handleError(error)
     exceptionErrorModal.value?.show()
   } finally {
-    offlinePlayerName.value = ''
+    clearOfflineFields()
   }
 }
 
 // [AR] • Feature
-// TODO:
-async function loginViaElyBy() {
+async function addElybyProfile() {
+  if (!elybyLogin.value || !elybyPassword.value) {
+    addElybyModal.value?.hide()
+    inputElybyErrorModal.value?.show()
+    clearElybyFields()
+    return
+  }
   elybyLoginDisabled.value = true
-  console.log("Login via Ely.by clicked!")
-  elybyLoginDisabled.value = false
+
+  const login = elybyLogin.value.trim()
+  let password = elybyPassword.value.trim()
+  const twoFactorCode = elybyTwoFactorCode.value.trim()
+  if (password && twoFactorCode) {
+    password = `${password}:${twoFactorCode}`
+  }
+
+  try {
+    const raw_result = await elyby_auth_authenticate(
+      login,
+      password,
+      clientToken
+    )
+
+    const json_data = JSON.parse(raw_result)
+
+    console.log(json_data?.error)
+    console.log(json_data?.errorMessage)
+
+    if (!json_data.accessToken) {
+      if (
+        json_data.error === 'ForbiddenOperationException' &&
+        json_data.errorMessage?.includes('two factor')
+      ) {
+        requestElybyTwoFactorCodeModal.value?.show()
+        return
+      }
+
+      addElybyModal.value?.hide()
+      requestElybyTwoFactorCodeModal.value?.hide()
+      authenticationElybyErrorModal.value?.show()
+      return
+    }
+
+    const accessToken = json_data.accessToken
+    const selectedProfileId = convertRawStringToUUIDv4(json_data.selectedProfile.id)
+    const selectedProfileName = json_data.selectedProfile.name
+
+    const result = await elyby_login(selectedProfileId, selectedProfileName, accessToken)
+
+    addElybyModal.value?.hide()
+    requestElybyTwoFactorCodeModal.value?.hide()
+
+    clearElybyFields()
+
+    await setAccount(result)
+    await refreshValues()
+  } catch (err) {
+    handleError(err)
+    exceptionErrorModal.value?.show()
+  } finally {
+    elybyLoginDisabled.value = false
+  }
+}
+
+// [AR] • Feature
+function convertRawStringToUUIDv4(rawId) {
+  if (rawId.length !== 32) {
+    console.warn('Invalid UUID string:', rawId)
+    return rawId
+  }
+  return `${rawId.slice(0, 8)}-${rawId.slice(8, 12)}-${rawId.slice(12, 16)}-${rawId.slice(16, 20)}-${rawId.slice(20)}`
 }
 
 const equippedSkin = ref(null)

apps/app-frontend/src/components/ui/CurseForgeProfileImportModal.vue

@@ -0,0 +1,401 @@
+<template>
+  <ModalWrapper ref="modal" :header="'Import from CurseForge Profile Code'">
+    <div class="modal-body">
+      <div class="input-row">
+        <p class="input-label">Profile Code</p>
+        <div class="iconified-input">
+          <SearchIcon aria-hidden="true" class="text-lg" />
+          <input
+            ref="codeInput"
+            v-model="profileCode"
+            autocomplete="off"
+            class="h-12 card-shadow"
+            spellcheck="false"
+            type="text"
+            placeholder="Enter CurseForge profile code"
+            maxlength="20"
+            @keyup.enter="importProfile"
+          />
+          <Button v-if="profileCode" class="r-btn" @click="() => (profileCode = '')">
+            <XIcon />
+          </Button>
+        </div>
+      </div>
+      
+      <div v-if="metadata && !importing" class="profile-info">
+        <h3>Profile Information</h3>
+        <p><strong>Name:</strong> {{ metadata.name }}</p>
+      </div>
+      
+      <div v-if="error" class="error-message">
+        <p>{{ error }}</p>
+      </div>
+      
+      <div v-if="importing && importProgress.visible" class="progress-section">
+        <div class="progress-info">
+          <span class="progress-text">{{ importProgress.message }}</span>
+          <span class="progress-percentage">{{ Math.floor(importProgress.percentage) }}%</span>
+        </div>
+        <div class="progress-bar-container">
+          <div
+            class="progress-bar" 
+            :style="{ width: `${importProgress.percentage}%` }"
+          ></div>
+        </div>
+      </div>
+      
+      <div class="button-row">
+        <Button @click="hide" :disabled="importing">
+          <XIcon />
+          Cancel
+        </Button>
+        <Button 
+          v-if="!metadata" 
+          @click="fetchMetadata" 
+          :disabled="!profileCode.trim() || fetching"
+          color="secondary"
+        >
+          <SearchIcon v-if="!fetching" />
+          {{ fetching ? 'Checking...' : 'Check Profile' }}
+        </Button>
+        <Button 
+          v-if="metadata" 
+          @click="importProfile" 
+          :disabled="importing"
+          color="primary"
+        >
+          <DownloadIcon v-if="!importing" />
+          {{ importing ? 'Importing...' : 'Import Profile' }}
+        </Button>
+      </div>
+    </div>
+  </ModalWrapper>
+</template>
+
+<script setup>
+import { ref, nextTick, onMounted, onUnmounted } from 'vue'
+import { useRouter } from 'vue-router'
+import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
+import { Button } from '@modrinth/ui'
+import { 
+  XIcon, 
+  SearchIcon, 
+  DownloadIcon 
+} from '@modrinth/assets'
+import { 
+  fetch_curseforge_profile_metadata, 
+  import_curseforge_profile 
+} from '@/helpers/import.js'
+import { handleError } from '@/store/notifications.js'
+import { trackEvent } from '@/helpers/analytics'
+import { loading_listener } from '@/helpers/events.js'
+
+const props = defineProps({
+  closeParent: {
+    type: Function,
+    default: null
+  }
+})
+
+const router = useRouter()
+const modal = ref(null)
+const codeInput = ref(null)
+const profileCode = ref('')
+const metadata = ref(null)
+const fetching = ref(false)
+const importing = ref(false)
+const error = ref('')
+const importProgress = ref({
+  visible: false,
+  percentage: 0,
+  message: 'Starting import...',
+  totalMods: 0,
+  downloadedMods: 0
+})
+
+let unlistenLoading = null
+let activeLoadingBarId = null
+let progressFallbackTimer = null
+
+defineExpose({
+  show: () => {
+    profileCode.value = ''
+    metadata.value = null
+    fetching.value = false
+    importing.value = false
+    error.value = ''
+    importProgress.value = {
+      visible: false,
+      percentage: 0,
+      message: 'Starting import...',
+      totalMods: 0,
+      downloadedMods: 0
+    }
+    modal.value?.show()
+    
+    nextTick(() => {
+      setTimeout(() => {
+        codeInput.value?.focus()
+      }, 100)
+    })
+    
+    trackEvent('CurseForgeProfileImportStart', { source: 'ImportModal' })
+  },
+})
+
+const hide = () => {
+  modal.value?.hide()
+}
+
+const fetchMetadata = async () => {
+  if (!profileCode.value.trim()) return
+  
+  fetching.value = true
+  error.value = ''
+  
+  try {
+    const result = await fetch_curseforge_profile_metadata(profileCode.value.trim())
+    metadata.value = result
+    trackEvent('CurseForgeProfileMetadataFetched', { 
+      profileCode: profileCode.value.trim() 
+    })
+  } catch (err) {
+    console.error('Failed to fetch CurseForge profile metadata:', err)
+    error.value = 'Failed to fetch profile information. Please check the code and try again.'
+    handleError(err)
+  } finally {
+    fetching.value = false
+  }
+}
+
+const importProfile = async () => {
+  if (!profileCode.value.trim()) return
+  
+  importing.value = true
+  error.value = ''
+  activeLoadingBarId = null // Reset for new import session
+  importProgress.value = {
+    visible: true,
+    percentage: 0,
+    message: 'Starting import...',
+    totalMods: 0,
+    downloadedMods: 0
+  }
+  
+  // Fallback progress timer in case loading events don't work
+  progressFallbackTimer = setInterval(() => {
+    if (importing.value && importProgress.value.percentage < 90) {
+      // Slowly increment progress as a fallback
+      importProgress.value.percentage = Math.min(90, importProgress.value.percentage + 1)
+    }
+  }, 1000)
+  
+  try {
+    const { result, profilePath } = await import_curseforge_profile(profileCode.value.trim())
+    
+    trackEvent('CurseForgeProfileImported', { 
+      profileCode: profileCode.value.trim() 
+    })
+    
+    hide()
+    
+    // Close the parent modal if provided
+    if (props.closeParent) {
+      props.closeParent()
+    }
+    
+    // Navigate to the imported profile
+    await router.push(`/instance/${encodeURIComponent(profilePath)}`)
+  } catch (err) {
+    console.error('Failed to import CurseForge profile:', err)
+    error.value = 'Failed to import profile. Please try again.'
+    handleError(err)
+  } finally {
+    importing.value = false
+    importProgress.value.visible = false
+    if (progressFallbackTimer) {
+      clearInterval(progressFallbackTimer)
+      progressFallbackTimer = null
+    }
+    activeLoadingBarId = null
+  }
+}
+
+onMounted(async () => {
+  // Listen for loading events to update progress
+  unlistenLoading = await loading_listener((event) => {
+    console.log('Loading event received:', event) // Debug log
+    
+    // Handle all loading events that could be related to CurseForge profile import
+    const isCurseForgeEvent = event.event?.type === 'curseforge_profile_download'
+    const hasProfileName = event.event?.profile_name && importing.value
+    
+    if ((isCurseForgeEvent || hasProfileName) && importing.value) {
+      // Store the loading bar ID for this import session
+      if (!activeLoadingBarId) {
+        activeLoadingBarId = event.loader_uuid
+      }
+      
+      // Only process events for our current import session
+      if (event.loader_uuid === activeLoadingBarId) {
+        if (event.fraction !== null && event.fraction !== undefined) {
+          const baseProgress = (event.fraction || 0) * 100
+          
+          // Calculate custom progress based on the message
+          let finalProgress = baseProgress
+          const message = event.message || 'Importing profile...'
+          
+          // Custom progress calculation for different stages
+          if (message.includes('Fetching') || message.includes('metadata')) {
+            finalProgress = Math.min(10, baseProgress)
+          } else if (message.includes('Downloading profile ZIP') || message.includes('profile ZIP')) {
+            finalProgress = Math.min(15, 10 + (baseProgress - 10) * 0.5)
+          } else if (message.includes('Extracting') || message.includes('ZIP')) {
+            finalProgress = Math.min(20, 15 + (baseProgress - 15) * 0.5)
+          } else if (message.includes('Configuring') || message.includes('profile')) {
+            finalProgress = Math.min(30, 20 + (baseProgress - 20) * 0.5)
+          } else if (message.includes('Copying') || message.includes('files')) {
+            finalProgress = Math.min(40, 30 + (baseProgress - 30) * 0.5)
+          } else if (message.includes('Downloaded mod') && message.includes(' of ')) {
+            // Parse "Downloaded mod X of Y" message
+            const match = message.match(/Downloaded mod (\d+) of (\d+)/)
+            if (match) {
+              const current = parseInt(match[1])
+              const total = parseInt(match[2])
+              // Mods take 40% of progress (from 40% to 80%)
+              const modProgress = (current / total) * 40
+              finalProgress = 40 + modProgress
+            } else {
+              finalProgress = Math.min(80, 40 + (baseProgress - 40) * 0.5)
+            }
+          } else if (message.includes('Downloading mod') || message.includes('mods')) {
+            // General mod downloading stage (40% to 80%)
+            finalProgress = Math.min(80, 40 + (baseProgress - 40) * 0.4)
+          } else if (message.includes('Installing Minecraft') || message.includes('Minecraft')) {
+            finalProgress = Math.min(95, 80 + (baseProgress - 80) * 0.75)
+          } else if (message.includes('Finalizing') || message.includes('completed')) {
+            finalProgress = Math.min(100, 95 + (baseProgress - 95))
+          } else {
+            // Default: use the base progress but ensure minimum progression
+            finalProgress = Math.max(importProgress.value.percentage, baseProgress)
+          }
+          
+          importProgress.value.percentage = Math.min(100, Math.max(0, finalProgress))
+          importProgress.value.message = message
+        } else {
+          // Loading complete
+          importProgress.value.percentage = 100
+          importProgress.value.message = 'Import completed!'
+          activeLoadingBarId = null
+        }
+      }
+    }
+  })
+})
+
+onUnmounted(() => {
+  if (unlistenLoading) {
+    unlistenLoading()
+  }
+  if (progressFallbackTimer) {
+    clearInterval(progressFallbackTimer)
+  }
+})
+</script>
+
+<style lang="scss" scoped>
+.modal-body {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  padding: 1rem;
+}
+
+.input-row {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.input-label {
+  font-weight: 600;
+  color: var(--color-contrast);
+  margin: 0;
+}
+
+.profile-info {
+  background: var(--color-bg);
+  border: 1px solid var(--color-button);
+  border-radius: var(--radius-md);
+  padding: 1rem;
+  
+  h3 {
+    margin: 0 0 0.5rem 0;
+    color: var(--color-contrast);
+  }
+  
+  p {
+    margin: 0.25rem 0;
+    color: var(--color-base);
+  }
+}
+
+.error-message {
+  background: var(--color-red);
+  border: 1px solid var(--color-red);
+  border-radius: var(--radius-md);
+  padding: 0.75rem;
+  
+  p {
+    margin: 0;
+    color: var(--color-contrast);
+    font-weight: 500;
+  }
+}
+
+.progress-section {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.progress-info {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  
+  .progress-text {
+    color: var(--color-base);
+    font-size: 0.875rem;
+  }
+  
+  .progress-percentage {
+    color: var(--color-contrast);
+    font-size: 0.875rem;
+    font-weight: 600;
+  }
+}
+
+.progress-bar-container {
+  width: 100%;
+  height: 4px;
+  background: var(--color-button);
+  border-radius: 2px;
+  overflow: hidden;
+}
+
+.progress-bar {
+  height: 100%;
+  background: var(--color-brand);
+  border-radius: 2px;
+  transition: width 0.3s ease;
+  min-width: 0;
+}
+
+.button-row {
+  display: flex;
+  gap: 0.5rem;
+  justify-content: flex-end;
+  margin-top: auto;
+}
+</style>

apps/app-frontend/src/components/ui/InstanceCreationModal.vue

@@ -163,6 +163,14 @@
         <div v-else class="table-content empty">No profiles found</div>
       </div>
       <div class="button-row">
+        <Button
+          v-if="selectedProfileType.name === 'Curseforge'"
+          @click="showCurseForgeProfileModal"
+          :disabled="loading"
+        >
+          <CodeIcon />
+          Import from Profile Code
+        </Button>
         <Button
           :disabled="
             loading ||
@@ -194,10 +202,12 @@
       </div>
     </div>
   </ModalWrapper>
+  <CurseForgeProfileImportModal ref="curseforgeProfileModal" :close-parent="hide" />
 </template>
 
 <script setup>
 import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
+import CurseForgeProfileImportModal from '@/components/ui/CurseForgeProfileImportModal.vue'
 import {
   CodeIcon,
   FolderOpenIcon,
@@ -283,6 +293,11 @@ const hide = () => {
     unlistener.value = null
   }
 }
+
+const showCurseForgeProfileModal = () => {
+  curseforgeProfileModal.value?.show()
+}
+
 onUnmounted(() => {
   if (unlistener.value) {
     unlistener.value()
@@ -305,12 +320,16 @@ const [
   get_game_versions().then(shallowRef).catch(handleError),
   get_loaders()
     .then((value) =>
-      value
-        .filter((item) => item.supported_project_types.includes('modpack'))
-        .map((item) => item.name.toLowerCase()),
+      ref(
+        value
+          .filter((item) => item.supported_project_types.includes('modpack'))
+          .map((item) => item.name.toLowerCase()),
+      ),
     )
-    .then(ref)
-    .catch(handleError),
+    .catch((err) => {
+      handleError(err)
+      return ref([])
+    }),
 ])
 loaders.value.unshift('vanilla')
 
@@ -334,6 +353,7 @@ const game_versions = computed(() => {
 })
 
 const modal = ref(null)
+const curseforgeProfileModal = ref(null)
 
 const check_valid = computed(() => {
   return (

apps/app-frontend/src/components/ui/modal/AuthGrantFlowWaitModal.vue

@@ -0,0 +1,42 @@
+<script setup lang="ts">
+import { LogInIcon, SpinnerIcon } from '@modrinth/assets'
+import { ref } from 'vue'
+import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
+
+defineProps({
+  onFlowCancel: {
+    type: Function,
+    default() {
+      return async () => {}
+    },
+  },
+})
+
+const modal = ref()
+
+function show() {
+  modal.value.show()
+}
+
+function hide() {
+  modal.value.hide()
+}
+
+defineExpose({ show, hide })
+</script>
+<template>
+  <ModalWrapper ref="modal" @hide="onFlowCancel">
+    <template #title>
+      <span class="items-center gap-2 text-lg font-extrabold text-contrast">
+        <LogInIcon /> Sign in
+      </span>
+    </template>
+
+    <div class="flex justify-center gap-2">
+      <SpinnerIcon class="w-12 h-12 animate-spin" />
+    </div>
+    <p class="text-sm text-secondary">
+      Please sign in at the browser window that just opened to continue.
+    </p>
+  </ModalWrapper>
+</template>

apps/app-frontend/src/helpers/auth.js

@@ -17,6 +17,24 @@ export async function offline_login(name) {
   return await invoke('plugin:auth|offline_login', { name: name })
 }
 
+// [AR] • Feature
+export async function elyby_login(uuid, login, accessToken) {
+  return await invoke('plugin:auth|elyby_login', {
+    uuid,
+    login,
+    accessToken
+  })
+}
+
+// [AR] • Feature
+export async function elyby_auth_authenticate(login, password, clientToken) {
+  return await invoke('plugin:auth|elyby_auth_authenticate', {
+    login,
+    password,
+    clientToken,
+  })
+}
+
 /**
  * Authenticate a user with Hydra - part 1.
  * This begins the authentication flow quasi-synchronously.

apps/app-frontend/src/helpers/import.js

@@ -61,3 +61,31 @@ export async function is_valid_importable_instance(instanceFolder, launcherType)
 export async function get_default_launcher_path(launcherType) {
   return await invoke('plugin:import|get_default_launcher_path', { launcherType })
 }
+
+/// Fetch CurseForge profile metadata from profile code
+/// eg: fetch_curseforge_profile_metadata("eSrNlKNo")
+export async function fetch_curseforge_profile_metadata(profileCode) {
+  return await invoke('plugin:import|fetch_curseforge_profile_metadata', { profileCode })
+}
+
+/// Import a CurseForge profile from profile code
+/// eg: import_curseforge_profile("eSrNlKNo")
+export async function import_curseforge_profile(profileCode) {
+  try {
+    // First, fetch the profile metadata to get the actual name
+    const metadata = await fetch_curseforge_profile_metadata(profileCode)
+
+    // create a basic, empty instance using the actual profile name
+    const profilePath = await create(metadata.name, '1.19.4', 'vanilla', 'latest', null, true)
+
+    const result = await invoke('plugin:import|import_curseforge_profile', {
+      profilePath,
+      profileCode,
+    })
+
+    // Return the profile path for navigation
+    return { result, profilePath }
+  } catch (error) {
+    throw error
+  }
+}

apps/app-frontend/src/helpers/mr_auth.js

@@ -16,3 +16,7 @@ export async function logout() {
 export async function get() {
   return await invoke('plugin:mr-auth|get')
 }
+
+export async function cancelLogin() {
+  return await invoke('plugin:mr-auth|cancel_modrinth_login')
+}

apps/app-frontend/src/helpers/utils.js

@@ -10,20 +10,20 @@ export async function getOS() {
   return await invoke('plugin:utils|get_os')
 }
 
-// [AR] Feature
-export async function initUpdateLauncher(downloadurl, filename, ostype, autoupdatesupported) {
-  console.log('Downloading build', downloadurl, filename, ostype, autoupdatesupported)
-  return await invoke('plugin:utils|init_update_launcher', { downloadurl, filename, ostype, autoupdatesupported })
+// [AR] Feature. Updater
+export async function initUpdateLauncher(downloadUrl, filename, osType, autoUpdateSupported) {
+  console.log('Downloading build', downloadUrl, filename, osType, autoUpdateSupported)
+  return await invoke('plugin:utils|init_update_launcher', { downloadUrl, filename, osType, autoUpdateSupported })
 }
 
-// [AR] Patch fix
+// [AR] Migration. Patch
 export async function applyMigrationFix(eol) {
   return await invoke('plugin:utils|apply_migration_fix', { eol })
 }
 
-// [AR] Feature
-export async function initAuthlibPatching(minecraftversion, ismojang) {
-  return await invoke('plugin:utils|init_authlib_patching', { minecraftversion, ismojang })
+// [AR] Feature. Ely.by
+export async function initAuthlibPatching(minecraftVersion, isMojang) {
+  return await invoke('plugin:utils|init_authlib_patching', { minecraftVersion, isMojang })
 }
 
 export async function openPath(path) {

apps/app-playground/src/main.rs

@@ -15,7 +15,7 @@ pub async fn authenticate_run() -> theseus::Result<Credentials> {
     println!("A browser window will now open, follow the login flow there.");
     let login = minecraft_auth::begin_login().await?;
 
-    println!("Open URL {} in a browser", login.redirect_uri.as_str());
+    println!("Open URL {} in a browser", login.auth_request_uri.as_str());
 
     println!("Please enter URL code: ");
     let mut input = String::new();

apps/app/Cargo.toml

@@ -31,6 +31,8 @@ thiserror.workspace = true
 daedalus.workspace = true
 chrono.workspace = true
 either.workspace = true
+hyper = { workspace = true, features = ["server"] }
+hyper-util.workspace = true
 
 url.workspace = true
 urlencoding.workspace = true

apps/app/build.rs

@@ -13,6 +13,8 @@ fn main() {
                 InlinedPlugin::new()
                     .commands(&[
                         "offline_login",
+                        "elyby_login",
+                        "elyby_auth_authenticate",
                         "login",
                         "remove_user",
                         "get_default_user",
@@ -49,6 +51,8 @@ fn main() {
                 "import",
                 InlinedPlugin::new()
                     .commands(&[
+                        "fetch_curseforge_profile_metadata",
+                        "import_curseforge_profile",
                         "get_importable_instances",
                         "import_instance",
                         "is_valid_importable_instance",
@@ -121,7 +125,12 @@ fn main() {
             .plugin(
                 "mr-auth",
                 InlinedPlugin::new()
-                    .commands(&["modrinth_login", "logout", "get"])
+                    .commands(&[
+                        "modrinth_login",
+                        "logout",
+                        "get",
+                        "cancel_modrinth_login",
+                    ])
                     .default_permission(
                         DefaultPermissionRule::AllowAllCommands,
                     ),

apps/app/capabilities/plugins.json

@@ -19,13 +19,10 @@
     "window-state:default",
     "window-state:allow-restore-state",
     "window-state:allow-save-window-state",
-    
+
     {
       "identifier": "http:default",
-      "allow": [
-        { "url": "https://modrinth.com/*" },
-        { "url": "https://*.modrinth.com/*" }
-      ]
+      "allow": [{ "url": "https://modrinth.com/*" }, { "url": "https://*.modrinth.com/*" }]
     },
 
     "auth:default",

apps/app/src/api/auth.rs

@@ -2,12 +2,15 @@ use crate::api::Result;
 use chrono::{Duration, Utc};
 use tauri::plugin::TauriPlugin;
 use tauri::{Manager, Runtime, UserAttentionType};
+use tauri_plugin_http::reqwest::Client;
 use theseus::prelude::*;
 
 pub fn init<R: Runtime>() -> TauriPlugin<R> {
     tauri::plugin::Builder::<R>::new("auth")
         .invoke_handler(tauri::generate_handler![
             offline_login,
+            elyby_login,
+            elyby_auth_authenticate,
             login,
             remove_user,
             get_default_user,
@@ -17,14 +20,65 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
         .build()
 }
 
+/// ### AR • Feature
 /// Create new offline user
-/// This is custom function from Astralium Org.
 #[tauri::command]
 pub async fn offline_login(name: &str) -> Result<Credentials> {
     let credentials = minecraft_auth::offline_auth(name).await?;
     Ok(credentials)
 }
 
+/// ### AR • Feature
+/// Create new Ely.by user
+#[tauri::command]
+pub async fn elyby_login(
+    uuid: uuid::Uuid,
+    login: &str,
+    access_token: &str
+) -> Result<Credentials> {
+    let credentials = minecraft_auth::elyby_auth(uuid, login, access_token).await?;
+    Ok(credentials)
+}
+
+/// ### AR • Feature
+/// Authenticate Ely.by user
+#[tauri::command]
+pub async fn elyby_auth_authenticate(
+    login: &str,
+    password: &str,
+    client_token: &str,
+) -> Result<String> {
+    let client = Client::new();
+    let auth_body = serde_json::json!({
+        "username": login,
+        "password": password,
+        "clientToken": client_token,
+    });
+
+    let response = match client
+        .post("https://authserver.ely.by/auth/authenticate")
+        .header("Content-Type", "application/json")
+        .json(&auth_body)
+        .send()
+        .await
+    {
+        Ok(resp) => resp,
+        Err(e) => {
+            tracing::error!("[AR] • Failed to send request: {}", e);
+            return Ok("".to_string());
+        }
+    };
+
+    let text = match response.text().await {
+        Ok(body) => body,
+        Err(e) => {
+            tracing::error!("[AR] • Failed to read response text: {}", e);
+            return Ok("".to_string());
+        }
+    };
+    Ok(text)
+}
+
 /// Authenticate a user with Hydra - part 1
 /// This begins the authentication flow quasi-synchronously, returning a URL to visit (that the user will sign in at)
 #[tauri::command]
@@ -42,7 +96,7 @@ pub async fn login<R: Runtime>(
     let window = tauri::WebviewWindowBuilder::new(
         &app,
         "signin",
-        tauri::WebviewUrl::External(flow.redirect_uri.parse().map_err(
+        tauri::WebviewUrl::External(flow.auth_request_uri.parse().map_err(
             |_| {
                 theseus::ErrorKind::OtherError(
                     "Error parsing auth redirect URL".to_string(),
@@ -86,6 +140,7 @@ pub async fn login<R: Runtime>(
     window.close()?;
     Ok(None)
 }
+
 #[tauri::command]
 pub async fn remove_user(user: uuid::Uuid) -> Result<()> {
     Ok(minecraft_auth::remove_user(user).await?)

apps/app/src/api/import.rs

@@ -2,6 +2,11 @@ use std::path::PathBuf;
 
 use crate::api::Result;
 use theseus::pack::import::ImportLauncherType;
+use theseus::pack::import::curseforge_profile::{
+    CurseForgeProfileMetadata,
+    fetch_curseforge_profile_metadata as fetch_cf_metadata,
+    import_curseforge_profile as import_cf_profile,
+};
 
 use theseus::pack::import;
 
@@ -12,6 +17,8 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
             import_instance,
             is_valid_importable_instance,
             get_default_launcher_path,
+            fetch_curseforge_profile_metadata,
+            import_curseforge_profile,
         ])
         .build()
 }
@@ -68,3 +75,24 @@ pub async fn get_default_launcher_path(
 ) -> Result<Option<PathBuf>> {
     Ok(import::get_default_launcher_path(launcher_type))
 }
+
+/// Fetch CurseForge profile metadata from profile code
+/// eg: fetch_curseforge_profile_metadata("eSrNlKNo")
+#[tauri::command]
+pub async fn fetch_curseforge_profile_metadata(
+    profile_code: String,
+) -> Result<CurseForgeProfileMetadata> {
+    Ok(fetch_cf_metadata(&profile_code).await?)
+}
+
+/// Import a CurseForge profile from profile code
+/// profile_path should be a blank profile for this purpose- if the function fails, it will be deleted
+/// eg: import_curseforge_profile("profile-path", "eSrNlKNo")
+#[tauri::command]
+pub async fn import_curseforge_profile(
+    profile_path: String,
+    profile_code: String,
+) -> Result<()> {
+    import_cf_profile(&profile_code, &profile_path).await?;
+    Ok(())
+}

apps/app/src/api/mod.rs

@@ -21,6 +21,8 @@ pub mod cache;
 pub mod friends;
 pub mod worlds;
 
+mod oauth_utils;
+
 pub type Result<T> = std::result::Result<T, TheseusSerializableError>;
 
 // // Main returnable Theseus GUI error

apps/app/src/api/mr_auth.rs

@@ -1,79 +1,70 @@
 use crate::api::Result;
-use chrono::{Duration, Utc};
+use crate::api::TheseusSerializableError;
+use crate::api::oauth_utils;
+use tauri::Manager;
+use tauri::Runtime;
 use tauri::plugin::TauriPlugin;
-use tauri::{Manager, Runtime, UserAttentionType};
+use tauri_plugin_opener::OpenerExt;
 use theseus::prelude::*;
+use tokio::sync::oneshot;
 
 pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
     tauri::plugin::Builder::new("mr-auth")
-        .invoke_handler(tauri::generate_handler![modrinth_login, logout, get,])
+        .invoke_handler(tauri::generate_handler![
+            modrinth_login,
+            logout,
+            get,
+            cancel_modrinth_login,
+        ])
         .build()
 }
 
 #[tauri::command]
 pub async fn modrinth_login<R: Runtime>(
     app: tauri::AppHandle<R>,
-) -> Result<Option<ModrinthCredentials>> {
-    let redirect_uri = mr_auth::authenticate_begin_flow();
+) -> Result<ModrinthCredentials> {
+    let (auth_code_recv_socket_tx, auth_code_recv_socket) = oneshot::channel();
+    let auth_code = tokio::spawn(oauth_utils::auth_code_reply::listen(
+        auth_code_recv_socket_tx,
+    ));
 
-    let start = Utc::now();
+    let auth_code_recv_socket = auth_code_recv_socket.await.unwrap()?;
 
-    if let Some(window) = app.get_webview_window("modrinth-signin") {
-        window.close()?;
-    }
+    let auth_request_uri = format!(
+        "{}?launcher=true&ipver={}&port={}",
+        mr_auth::authenticate_begin_flow(),
+        if auth_code_recv_socket.is_ipv4() {
+            "4"
+        } else {
+            "6"
+        },
+        auth_code_recv_socket.port()
+    );
 
-    let window = tauri::WebviewWindowBuilder::new(
-        &app,
-        "modrinth-signin",
-        tauri::WebviewUrl::External(redirect_uri.parse().map_err(|_| {
-            theseus::ErrorKind::OtherError(
-                "Error parsing auth redirect URL".to_string(),
+    app.opener()
+        .open_url(auth_request_uri, None::<&str>)
+        .map_err(|e| {
+            TheseusSerializableError::Theseus(
+                theseus::ErrorKind::OtherError(format!(
+                    "Failed to open auth request URI: {e}"
+                ))
+                .into(),
             )
-            .as_error()
-        })?),
-    )
-    .min_inner_size(420.0, 632.0)
-    .inner_size(420.0, 632.0)
-    .max_inner_size(420.0, 632.0)
-    .zoom_hotkeys_enabled(false)
-    .title("Sign into Modrinth")
-    .always_on_top(true)
-    .center()
-    .build()?;
+        })?;
 
-    window.request_user_attention(Some(UserAttentionType::Critical))?;
+    let Some(auth_code) = auth_code.await.unwrap()? else {
+        return Err(TheseusSerializableError::Theseus(
+            theseus::ErrorKind::OtherError("Login canceled".into()).into(),
+        ));
+    };
 
-    while (Utc::now() - start) < Duration::minutes(10) {
-        if window.title().is_err() {
-            // user closed window, cancelling flow
-            return Ok(None);
-        }
+    let credentials = mr_auth::authenticate_finish_flow(&auth_code).await?;
 
-        if window
-            .url()?
-            .as_str()
-            .starts_with("https://launcher-files.modrinth.com")
-        {
-            let url = window.url()?;
-
-            let code = url.query_pairs().find(|(key, _)| key == "code");
-
-            window.close()?;
-
-            return if let Some((_, code)) = code {
-                let val = mr_auth::authenticate_finish_flow(&code).await?;
-
-                Ok(Some(val))
-            } else {
-                Ok(None)
-            };
-        }
-
-        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+    if let Some(main_window) = app.get_window("main") {
+        main_window.set_focus().ok();
     }
 
-    window.close()?;
-    Ok(None)
+    Ok(credentials)
 }
 
 #[tauri::command]
@@ -85,3 +76,8 @@ pub async fn logout() -> Result<()> {
 pub async fn get() -> Result<Option<ModrinthCredentials>> {
     Ok(theseus::mr_auth::get_credentials().await?)
 }
+
+#[tauri::command]
+pub fn cancel_modrinth_login() {
+    oauth_utils::auth_code_reply::stop_listeners();
+}

apps/app/src/api/oauth_utils/auth_code_reply.rs

@@ -0,0 +1,159 @@
+//! A minimal OAuth 2.0 authorization code grant flow redirection/reply loopback URI HTTP
+//! server implementation, compliant with [RFC 6749]'s authorization code grant flow and
+//! [RFC 8252]'s best current practices for OAuth 2.0 in native apps.
+//!
+//! This server is needed for the step 4 of the OAuth authentication dance represented in
+//! figure 1 of [RFC 8252].
+//!
+//! Further reading: https://www.oauth.com/oauth2-servers/oauth-native-apps/redirect-urls-for-native-apps/
+//!
+//! [RFC 6749]: https://datatracker.ietf.org/doc/html/rfc6749
+//! [RFC 8252]: https://datatracker.ietf.org/doc/html/rfc8252
+
+use std::{
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    sync::{LazyLock, Mutex},
+    time::Duration,
+};
+
+use hyper::body::Incoming;
+use hyper_util::rt::{TokioIo, TokioTimer};
+use theseus::ErrorKind;
+use tokio::{
+    net::TcpListener,
+    sync::{broadcast, oneshot},
+};
+
+static SERVER_SHUTDOWN: LazyLock<broadcast::Sender<()>> =
+    LazyLock::new(|| broadcast::channel(1024).0);
+
+/// Starts a temporary HTTP server to receive OAuth 2.0 authorization code grant flow redirects
+/// on a loopback interface with an ephemeral port. The caller can know the bound socket address
+/// by listening on the counterpart channel for `listen_socket_tx`.
+///
+/// If the server is stopped before receiving an authorization code, `Ok(None)` is returned.
+pub async fn listen(
+    listen_socket_tx: oneshot::Sender<Result<SocketAddr, theseus::Error>>,
+) -> Result<Option<String>, theseus::Error> {
+    // IPv4 is tried first for the best compatibility and performance with most systems.
+    // IPv6 is also tried in case IPv4 is not available. Resolving "localhost" is avoided
+    // to prevent failures deriving from improper name resolution setup. Any available
+    // ephemeral port is used to prevent conflicts with other services. This is all as per
+    // RFC 8252's recommendations
+    const ANY_LOOPBACK_SOCKET: &[SocketAddr] = &[
+        SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0),
+        SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 0),
+    ];
+
+    let listener = match TcpListener::bind(ANY_LOOPBACK_SOCKET).await {
+        Ok(listener) => {
+            listen_socket_tx
+                .send(listener.local_addr().map_err(|e| {
+                    ErrorKind::OtherError(format!(
+                        "Failed to get auth code reply socket address: {e}"
+                    ))
+                    .into()
+                }))
+                .ok();
+
+            listener
+        }
+        Err(e) => {
+            let error_msg =
+                format!("Failed to bind auth code reply socket: {e}");
+
+            listen_socket_tx
+                .send(Err(ErrorKind::OtherError(error_msg.clone()).into()))
+                .ok();
+
+            return Err(ErrorKind::OtherError(error_msg).into());
+        }
+    };
+
+    let mut auth_code = Mutex::new(None);
+    let mut shutdown_notification = SERVER_SHUTDOWN.subscribe();
+
+    while auth_code.get_mut().unwrap().is_none() {
+        let client_socket = tokio::select! {
+            biased;
+            _ = shutdown_notification.recv() => {
+                break;
+            }
+            conn_accept_result = listener.accept() => {
+                match conn_accept_result {
+                    Ok((socket, _)) => socket,
+                    Err(e) => {
+                        tracing::warn!("Failed to accept auth code reply: {e}");
+                        continue;
+                    }
+                }
+            }
+        };
+
+        if let Err(e) = hyper::server::conn::http1::Builder::new()
+            .keep_alive(false)
+            .header_read_timeout(Duration::from_secs(5))
+            .timer(TokioTimer::new())
+            .auto_date_header(false)
+            .serve_connection(
+                TokioIo::new(client_socket),
+                hyper::service::service_fn(|req| handle_reply(req, &auth_code)),
+            )
+            .await
+        {
+            tracing::warn!("Failed to handle auth code reply: {e}");
+        }
+    }
+
+    Ok(auth_code.into_inner().unwrap())
+}
+
+/// Stops any active OAuth 2.0 authorization code grant flow reply listening HTTP servers.
+pub fn stop_listeners() {
+    SERVER_SHUTDOWN.send(()).ok();
+}
+
+async fn handle_reply(
+    req: hyper::Request<Incoming>,
+    auth_code_out: &Mutex<Option<String>>,
+) -> Result<hyper::Response<String>, hyper::http::Error> {
+    if req.method() != hyper::Method::GET {
+        return hyper::Response::builder()
+            .status(hyper::StatusCode::METHOD_NOT_ALLOWED)
+            .header("Allow", "GET")
+            .body("".into());
+    }
+
+    // The authorization code is guaranteed to be sent as a "code" query parameter
+    // in the request URI query string as per RFC 6749 § 4.1.2
+    let auth_code = req.uri().query().and_then(|query_string| {
+        query_string
+            .split('&')
+            .filter_map(|query_pair| query_pair.split_once('='))
+            .find_map(|(key, value)| (key == "code").then_some(value))
+    });
+
+    let response = if let Some(auth_code) = auth_code {
+        *auth_code_out.lock().unwrap() = Some(auth_code.to_string());
+
+        hyper::Response::builder()
+            .status(hyper::StatusCode::OK)
+            .header("Content-Type", "text/html;charset=utf-8")
+            .body(
+                include_str!("auth_code_reply/page.html")
+                    .replace("{{title}}", "Success")
+                    .replace("{{message}}", "You have successfully signed in! You can close this page now."),
+            )
+    } else {
+        hyper::Response::builder()
+            .status(hyper::StatusCode::BAD_REQUEST)
+            .header("Content-Type", "text/html;charset=utf-8")
+            .body(
+                include_str!("auth_code_reply/page.html")
+                    .replace("{{title}}", "Error")
+                    .replace("{{message}}", "Authorization code not found. Please try signing in again."),
+            )
+    }?;
+
+    Ok(response)
+}

apps/app/src/api/oauth_utils/mod.rs

@@ -0,0 +1,3 @@
+//! Assorted utilities for OAuth 2.0 authorization flows.
+
+pub mod auth_code_reply;

apps/app/src/api/utils.rs

@@ -30,37 +30,37 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
         .build()
 }
 
-/// [AR] Feature
+/// [AR] Feature. Ely.by
 #[tauri::command]
 pub async fn init_authlib_patching(
-    minecraftversion: &str,
-    ismojang: bool,
+    minecraft_version: &str,
+    is_mojang: bool,
 ) -> Result<bool> {
     let result =
-        utils::init_authlib_patching(minecraftversion, ismojang).await?;
+        utils::init_authlib_patching(minecraft_version, is_mojang).await?;
     Ok(result)
 }
 
-/// [AR] Patch fix
+/// [AR] Migration. Patch
 #[tauri::command]
 pub async fn apply_migration_fix(eol: &str) -> Result<bool> {
     let result = utils::apply_migration_fix(eol).await?;
     Ok(result)
 }
 
-/// [AR] Feature
+/// [AR] Feature. Updater
 #[tauri::command]
 pub async fn init_update_launcher(
-    downloadurl: &str,
+    download_url: &str,
     filename: &str,
-    ostype: &str,
-    autoupdatesupported: bool,
+    os_type: &str,
+    auto_update_supported: bool,
 ) -> Result<()> {
     let _ = utils::init_update_launcher(
-        downloadurl,
+        download_url,
         filename,
-        ostype,
-        autoupdatesupported,
+        os_type,
+        auto_update_supported,
     )
     .await;
     Ok(())

apps/app/tauri.conf.json

@@ -63,6 +63,7 @@
         "height": 800,
         "resizable": true,
         "title": "AstralRinth",
+        "label": "main",
         "width": 1280,
         "minHeight": 700,
         "minWidth": 1100,
@@ -86,7 +87,7 @@
       "capabilities": ["core", "plugins"],
       "csp": {
         "default-src": "'self' customprotocol: asset:",
-        "connect-src": "ipc: https://git.astralium.su http://ipc.localhost https://modrinth.com https://*.modrinth.com https://*.posthog.com https://*.sentry.io https://api.mclo.gs 'self' data: blob:",
+        "connect-src": "ipc: https://git.astralium.su https://authserver.ely.by http://ipc.localhost https://modrinth.com https://*.modrinth.com https://*.posthog.com https://*.sentry.io https://api.mclo.gs 'self' data: blob:",
         "font-src": ["https://cdn-raw.modrinth.com/fonts/"],
         "img-src": "https: 'unsafe-inline' 'self' asset: http://asset.localhost http://textures.minecraft.net blob: data:",
         "style-src": "'unsafe-inline' 'self'",

apps/daedalus_client/Dockerfile

@@ -1,9 +1,19 @@
+# syntax=docker/dockerfile:1
+
 FROM rust:1.88.0 AS build
 
 WORKDIR /usr/src/daedalus
 COPY . .
-RUN cargo build --release --package daedalus_client
+RUN --mount=type=cache,target=/usr/src/daedalus/target \
+  --mount=type=cache,target=/usr/local/cargo/git/db \
+  --mount=type=cache,target=/usr/local/cargo/registry \
+  cargo build --release --package daedalus_client
 
+FROM build AS artifacts
+
+RUN --mount=type=cache,target=/usr/src/daedalus/target \
+  mkdir /daedalus \
+  && cp /usr/src/daedalus/target/release/daedalus_client /daedalus/daedalus_client
 
 FROM debian:bookworm-slim
 
@@ -11,7 +21,7 @@ RUN apt-get update \
   && apt-get install -y --no-install-recommends ca-certificates openssl \
   && rm -rf /var/lib/apt/lists/*
 
-COPY --from=build /usr/src/daedalus/target/release/daedalus_client /daedalus/daedalus_client
-WORKDIR /daedalus_client
+COPY --from=artifacts /daedalus /daedalus
 
-CMD /daedalus/daedalus_client
+WORKDIR /daedalus_client
+CMD ["/daedalus/daedalus_client"]

apps/frontend/nuxt.config.ts

@@ -34,7 +34,7 @@ const enabledLocales: string[] = [];
 /**
  * Overrides for the categories of the certain locales.
  */
-const localesCategoriesOverrides: Partial = {
+const localesCategoriesOverrides: Partial<Record<string, "fun" | "experimental">> = {
   "en-x-pirate": "fun",
   "en-x-updown": "fun",
   "en-x-lolcat": "fun",
@@ -260,28 +260,21 @@ export default defineNuxtConfig({
         const omorphiaLocales: string[] = [];
         const omorphiaLocaleSets = new Map<string, { files: { from: string }[] }>();
 
-        const externalLocales = [
-          "node_modules/@modrinth/ui/src/locales/en-US",
-          "node_modules/@modrinth/moderation/locales/en-US",
-        ];
+        for await (const localeDir of globIterate("node_modules/@modrinth/ui/src/locales/*", {
+          posix: true,
+        })) {
+          const tag = basename(localeDir);
+          omorphiaLocales.push(tag);
 
-        for (const localePath of externalLocales) {
-          for await (const localeDir of globIterate(localePath, {
-            posix: true,
-          })) {
-            const tag = basename(localeDir);
-            omorphiaLocales.push(tag);
+          const localeFiles: { from: string; format?: string }[] = [];
 
-            const localeFiles: { from: string; format?: string }[] = [];
+          omorphiaLocaleSets.set(tag, { files: localeFiles });
 
-            omorphiaLocaleSets.set(tag, { files: localeFiles });
-
-            for await (const localeFile of globIterate(`${localeDir}/*`, { posix: true })) {
-              localeFiles.push({
-                from: pathToFileURL(localeFile).toString(),
-                format: "default",
-              });
-            }
+          for await (const localeFile of globIterate(`${localeDir}/*`, { posix: true })) {
+            localeFiles.push({
+              from: pathToFileURL(localeFile).toString(),
+              format: "default",
+            });
           }
         }
 
@@ -308,7 +301,7 @@ export default defineNuxtConfig({
               format: "crowdin",
             });
           } else if (fileName === "meta.json") {
-            const meta: Record = await fs
+            const meta: Record<string, { message: string }> = await fs
               .readFile(localeFile, "utf8")
               .then((date) => JSON.parse(date));
             const localeMeta = (locale.meta ??= {});

apps/frontend/src/components/ui/ProjectMemberHeader.vue

@@ -1,442 +1,510 @@
 <template>
-  <div v-if="showInvitation" class="universal-card information invited my-4">
-    <h2>{{ getFormattedMessage(messages.invitationTitle) }}</h2>
-    <p v-if="currentMember?.project_role">
-      {{ formatMessage(messages.invitationWithRole, { role: currentMember.project_role }) }}
+  <div v-if="showInvitation" class="universal-card information invited">
+    <h2>Invitation to join project</h2>
+    <p>
+      You've been invited be a member of this project with the role of '{{ currentMember.role }}'.
     </p>
-    <p v-else>{{ getFormattedMessage(messages.invitationNoRole) }}</p>
     <div class="input-group">
-      <ButtonStyled color="brand">
-        <button class="brand-button" @click="acceptInvite()">
-          <CheckIcon />
-          {{ getFormattedMessage(messages.accept) }}
-        </button>
-      </ButtonStyled>
-      <ButtonStyled color="red">
-        <button @click="declineInvite">
-          <XIcon />
-          {{ getFormattedMessage(messages.decline) }}
-        </button>
-      </ButtonStyled>
+      <button class="iconified-button brand-button" @click="acceptInvite()">
+        <CheckIcon />
+        Accept
+      </button>
+      <button class="iconified-button danger-button" @click="declineInvite()">
+        <XIcon />
+        Decline
+      </button>
     </div>
   </div>
   <div
     v-if="
       currentMember &&
-      visibleNags.length > 0 &&
+      nags.filter((x) => x.condition).length > 0 &&
       (project.status === 'draft' || tags.rejectedStatuses.includes(project.status))
     "
-    class="universal-card my-4"
+    class="author-actions universal-card mb-4"
   >
-    <div class="flex max-w-full flex-wrap items-center gap-x-6 gap-y-4">
-      <div class="flex flex-auto flex-wrap items-center gap-x-6 gap-y-4">
-        <h2 class="my-0 mr-auto">{{ getFormattedMessage(messages.publishingChecklist) }}</h2>
+    <div class="header__row">
+      <div class="header__title">
+        <h2>Publishing checklist</h2>
+        <div class="checklist">
+          <span class="checklist__title">Progress:</span>
+          <div class="checklist__items">
+            <div
+              v-for="nag in nags"
+              :key="`checklist-${nag.id}`"
+              v-tooltip="nag.title"
+              :aria-label="nag.title"
+              :class="'circle ' + (!nag.condition ? 'done' : '') + nag.status"
+              class="circle"
+            >
+              <CheckIcon v-if="!nag.condition" />
+              <AsteriskIcon v-else-if="nag.status === 'required'" />
+              <LightBulbIcon v-else-if="nag.status === 'suggestion'" />
+              <ScaleIcon v-else-if="nag.status === 'review'" />
+            </div>
+          </div>
+        </div>
       </div>
       <div class="input-group">
-        <ButtonStyled circular>
-          <button :class="!collapsed && '[&>svg]:rotate-180'" @click="toggleCollapsed()">
-            <DropdownIcon class="duration-250 transition-transform ease-in-out" />
-          </button>
-        </ButtonStyled>
+        <button
+          :class="{ 'not-collapsed': !collapsed }"
+          class="square-button"
+          @click="toggleCollapsed()"
+        >
+          <DropdownIcon />
+        </button>
       </div>
     </div>
-    <div v-if="!collapsed" class="grid-display width-16 mt-4">
-      <div v-for="nag in visibleNags" :key="nag.id" class="grid-display__item">
-        <span class="flex items-center gap-2 font-semibold">
-          <component
-            :is="nag.icon || getDefaultIcon(nag.status)"
-            v-tooltip="getStatusTooltip(nag.status)"
-            :class="[
-              'h-4 w-4',
-              nag.status === 'required' && 'text-red',
-              nag.status === 'warning' && 'text-orange',
-              nag.status === 'suggestion' && 'text-purple',
-            ]"
-            :aria-label="getStatusTooltip(nag.status)"
+    <div v-if="!collapsed" class="grid-display width-16">
+      <div
+        v-for="nag in nags.filter((x) => x.condition && !x.hide)"
+        :key="nag.id"
+        class="grid-display__item"
+      >
+        <span class="label">
+          <AsteriskIcon
+            v-if="nag.status === 'required'"
+            v-tooltip="'Required'"
+            :class="nag.status"
+            aria-label="Required"
           />
-          {{ getFormattedMessage(nag.title) }}
-        </span>
-        {{ getNagDescription(nag) }}
+          <LightBulbIcon
+            v-else-if="nag.status === 'suggestion'"
+            v-tooltip="'Suggestion'"
+            :class="nag.status"
+            aria-label="Suggestion"
+          />
+          <ScaleIcon
+            v-else-if="nag.status === 'review'"
+            v-tooltip="'Review'"
+            :class="nag.status"
+            aria-label="Review"
+          />{{ nag.title }}</span
+        >
+        {{ nag.description }}
         <NuxtLink
-          v-if="nag.link && shouldShowLink(nag)"
+          v-if="nag.link"
+          :class="{ invisible: nag.link.hide }"
           :to="`/${project.project_type}/${project.slug ? project.slug : project.id}/${
             nag.link.path
           }`"
           class="goto-link"
         >
-          {{ getFormattedMessage(nag.link.title) }}
+          {{ nag.link.title }}
           <ChevronRightIcon aria-hidden="true" class="featured-header-chevron" />
         </NuxtLink>
-        <ButtonStyled
-          v-if="nag.status === 'special-submit-action' && nag.id === 'submit-for-review'"
-          color="orange"
-          @click="submitForReview"
+        <button
+          v-else-if="nag.action"
+          :disabled="nag.action.disabled()"
+          class="btn btn-orange"
+          @click="nag.action.onClick"
         >
-          <button
-            :disabled="!canSubmitForReview"
-            v-tooltip="
-              !canSubmitForReview ? getFormattedMessage(messages.submitChecklistTooltip) : undefined
-            "
-          >
-            <SendIcon />
-            {{ getFormattedMessage(messages.submitForReview) }}
-          </button>
-        </ButtonStyled>
+          <SendIcon />
+          {{ nag.action.title }}
+        </button>
       </div>
     </div>
   </div>
 </template>
 
-<script setup lang="ts">
+<script setup>
 import {
   ChevronRightIcon,
   CheckIcon,
   XIcon,
   AsteriskIcon,
   LightBulbIcon,
-  TriangleAlertIcon,
-  DropdownIcon,
   SendIcon,
   ScaleIcon,
+  DropdownIcon,
 } from "@modrinth/assets";
+import { formatProjectType } from "@modrinth/utils";
 import { acceptTeamInvite, removeTeamMember } from "~/helpers/teams.js";
-import { nags } from "@modrinth/moderation";
-import { ButtonStyled } from "@modrinth/ui";
-import { useVIntl, defineMessages, type MessageDescriptor } from "@vintl/vintl";
-import type { Nag, NagContext, NagStatus } from "@modrinth/moderation";
-import type { Project, User, Version } from "@modrinth/utils";
-import type { Component } from "vue";
 
-interface Tags {
-  rejectedStatuses: string[];
-}
+const props = defineProps({
+  project: {
+    type: Object,
+    required: true,
+  },
+  versions: {
+    type: Array,
+    default() {
+      return [];
+    },
+  },
+  currentMember: {
+    type: Object,
+    default: null,
+  },
+  allMembers: {
+    type: Object,
+    default: null,
+  },
+  isSettings: {
+    type: Boolean,
+    default: false,
+  },
+  collapsed: {
+    type: Boolean,
+    default: false,
+  },
+  routeName: {
+    type: String,
+    default: "",
+  },
+  auth: {
+    type: Object,
+    required: true,
+  },
+  tags: {
+    type: Object,
+    required: true,
+  },
+  setProcessing: {
+    type: Function,
+    default() {
+      return () => {
+        addNotification({
+          group: "main",
+          title: "An error occurred",
+          text: "setProcessing function not found",
+          type: "error",
+        });
+      };
+    },
+  },
+  toggleCollapsed: {
+    type: Function,
+    default() {
+      return () => {
+        addNotification({
+          group: "main",
+          title: "An error occurred",
+          text: "toggleCollapsed function not found",
+          type: "error",
+        });
+      };
+    },
+  },
+  updateMembers: {
+    type: Function,
+    default() {
+      return () => {
+        addNotification({
+          group: "main",
+          title: "An error occurred",
+          text: "updateMembers function not found",
+          type: "error",
+        });
+      };
+    },
+  },
+});
 
-interface Auth {
-  user: {
-    id: string;
-  };
-}
+const featuredGalleryImage = computed(() => props.project.gallery.find((img) => img.featured));
 
-interface Member {
-  accepted?: boolean;
-  project_role?: string;
-  user?: Partial<User>;
-}
-
-interface Props {
-  project: Project;
-  versions?: Version[];
-  currentMember?: Member | null;
-  allMembers?: Member[] | null;
-  isSettings?: boolean;
-  collapsed?: boolean;
-  routeName?: string;
-  auth: Auth;
-  tags: Tags;
-  setProcessing?: (processing: boolean) => void;
-  toggleCollapsed?: () => void;
-  updateMembers?: () => void | Promise<void>;
-}
-
-const messages = defineMessages({
-  invitationTitle: {
-    id: "project-member-header.invitation-title",
-    defaultMessage: "Invitation to join project",
+const nags = computed(() => [
+  {
+    condition: props.versions.length < 1,
+    title: "Upload a version",
+    id: "upload-version",
+    description: "At least one version is required for a project to be submitted for review.",
+    status: "required",
+    link: {
+      path: "versions",
+      title: "Visit versions page",
+      hide: props.routeName === "type-id-versions",
+    },
   },
-  invitationWithRole: {
-    id: "project-member-header.invitation-with-role",
-    defaultMessage: "You've been invited be a member of this project with the role of '{role}'.",
+  {
+    condition:
+      props.project.body === "" || props.project.body.startsWith("# Placeholder description"),
+    title: "Add a description",
+    id: "add-description",
+    description:
+      "A description that clearly describes the project's purpose and function is required.",
+    status: "required",
+    link: {
+      path: "settings/description",
+      title: "Visit description settings",
+      hide: props.routeName === "type-id-settings-description",
+    },
   },
-  invitationNoRole: {
-    id: "project-member-header.invitation-no-role",
-    defaultMessage:
-      "You've been invited to join this project. Please accept or decline the invitation.",
+  {
+    condition: !props.project.icon_url,
+    title: "Add an icon",
+    id: "add-icon",
+    description:
+      "Your project should have a nice-looking icon to uniquely identify your project at a glance.",
+    status: "suggestion",
+    link: {
+      path: "settings",
+      title: "Visit general settings",
+      hide: props.routeName === "type-id-settings",
+    },
   },
-  accept: {
-    id: "project-member-header.accept",
-    defaultMessage: "Accept",
+  {
+    condition: props.project.gallery.length === 0 || !featuredGalleryImage,
+    title: "Feature a gallery image",
+    id: "feature-gallery-image",
+    description: "Featured gallery images may be the first impression of many users.",
+    status: "suggestion",
+    link: {
+      path: "gallery",
+      title: "Visit gallery page",
+      hide: props.routeName === "type-id-gallery",
+    },
   },
-  decline: {
-    id: "project-member-header.decline",
-    defaultMessage: "Decline",
+  {
+    hide: props.project.versions.length === 0,
+    condition: props.project.categories.length < 1,
+    title: "Select tags",
+    id: "select-tags",
+    description: "Select all tags that apply to your project.",
+    status: "suggestion",
+    link: {
+      path: "settings/tags",
+      title: "Visit tag settings",
+      hide: props.routeName === "type-id-settings-tags",
+    },
   },
-  publishingChecklist: {
-    id: "project-member-header.publishing-checklist",
-    defaultMessage: "Publishing checklist",
+  {
+    condition: !(
+      props.project.issues_url ||
+      props.project.source_url ||
+      props.project.wiki_url ||
+      props.project.discord_url ||
+      props.project.donation_urls.length > 0
+    ),
+    title: "Add external links",
+    id: "add-links",
+    description:
+      "Add any relevant links targeted outside of Modrinth, such as sources, issues, or a Discord invite.",
+    status: "suggestion",
+    link: {
+      path: "settings/links",
+      title: "Visit links settings",
+      hide: props.routeName === "type-id-settings-links",
+    },
   },
-  submitForReview: {
-    id: "project-member-header.submit-for-review",
-    defaultMessage: "Submit for review",
+  {
+    hide:
+      props.project.versions.length === 0 ||
+      props.project.project_type === "resourcepack" ||
+      props.project.project_type === "plugin" ||
+      props.project.project_type === "shader" ||
+      props.project.project_type === "datapack",
+    condition:
+      props.project.client_side === "unknown" ||
+      props.project.server_side === "unknown" ||
+      (props.project.client_side === "unsupported" && props.project.server_side === "unsupported"),
+    title: "Select supported environments",
+    id: "select-environments",
+    description: `Select if the ${formatProjectType(
+      props.project.project_type,
+    ).toLowerCase()} functions on the client-side and/or server-side.`,
+    status: "required",
+    link: {
+      path: "settings",
+      title: "Visit general settings",
+      hide: props.routeName === "type-id-settings",
+    },
   },
-  submitForReviewDesc: {
-    id: "project-member-header.submit-for-review-desc",
-    defaultMessage:
+  {
+    condition: props.project.license.id === "LicenseRef-Unknown",
+    title: "Select license",
+    id: "select-license",
+    description: `Select the license your ${formatProjectType(
+      props.project.project_type,
+    ).toLowerCase()} is distributed under.`,
+    status: "required",
+    link: {
+      path: "settings/license",
+      title: "Visit license settings",
+      hide: props.routeName === "type-id-settings-license",
+    },
+  },
+  {
+    condition: props.project.status === "draft",
+    title: "Submit for review",
+    id: "submit-for-review",
+    description:
       "Your project is only viewable by members of the project. It must be reviewed by moderators in order to be published.",
+    status: "review",
+    link: null,
+    action: {
+      onClick: submitForReview,
+      title: "Submit for review",
+      disabled: () => nags.value.filter((x) => x.condition && x.status === "required").length > 0,
+    },
   },
-  resubmitForReview: {
-    id: "project-member-header.resubmit-for-review",
-    defaultMessage: "Resubmit for review",
+  {
+    hide: props.project.stats === "draft",
+    condition: props.tags.rejectedStatuses.includes(props.project.status),
+    title: "Resubmit for review",
+    id: "resubmit-for-review",
+    description: `Your project has been ${props.project.status} by
+            Modrinth's staff. In most cases, you can resubmit for review after
+            addressing the staff's message.`,
+    status: "review",
+    link: {
+      path: "moderation",
+      title: "Visit moderation page",
+      hide: props.routeName === "type-id-moderation",
+    },
   },
-  resubmitForReviewDesc: {
-    id: "project-member-header.resubmit-for-review-desc",
-    defaultMessage:
-      "Your project has been {status} by Modrinth's staff. In most cases, you can resubmit for review after addressing the staff's message.",
-  },
-  visitModerationPage: {
-    id: "project-member-header.visit-moderation-page",
-    defaultMessage: "Visit moderation page",
-  },
-  submitChecklistTooltip: {
-    id: "project-member-header.submit-checklist-tooltip",
-    defaultMessage: "You must complete the required steps in the publishing checklist!",
-  },
-  successJoin: {
-    id: "project-member-header.success-join",
-    defaultMessage: "You have joined the project team",
-  },
-  errorJoin: {
-    id: "project-member-header.error-join",
-    defaultMessage: "Failed to accept team invitation",
-  },
-  successDecline: {
-    id: "project-member-header.success-decline",
-    defaultMessage: "You have declined the team invitation",
-  },
-  errorDecline: {
-    id: "project-member-header.error-decline",
-    defaultMessage: "Failed to decline team invitation",
-  },
-  success: {
-    id: "project-member-header.success",
-    defaultMessage: "Success",
-  },
-  error: {
-    id: "project-member-header.error",
-    defaultMessage: "Error",
-  },
-  required: {
-    id: "project-member-header.required",
-    defaultMessage: "Required",
-  },
-  warning: {
-    id: "project-member-header.warning",
-    defaultMessage: "Warning",
-  },
-  suggestion: {
-    id: "project-member-header.suggestion",
-    defaultMessage: "Suggestion",
-  },
-});
+]);
 
-const { formatMessage } = useVIntl();
-
-function getNagDescription(nag: Nag): string {
-  if (typeof nag.description === "function") {
-    return nag.description(nagContext.value);
-  }
-  return formatMessage(nag.description);
-}
-
-function getFormattedMessage(message: string | MessageDescriptor): string {
-  if (typeof message === "string") {
-    return message;
-  }
-  return formatMessage(message);
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  versions: () => [],
-  currentMember: null,
-  allMembers: null,
-  isSettings: false,
-  collapsed: false,
-  routeName: "",
-});
-
-const emit = defineEmits<{
-  toggleCollapsed: [];
-  updateMembers: [];
-  setProcessing: [processing: boolean];
-}>();
-
-const nagContext = computed<NagContext>(() => ({
-  project: props.project,
-  versions: props.versions,
-  currentMember: props.currentMember as User,
-  currentRoute: props.routeName,
-  tags: props.tags,
-  submitProject: submitForReview,
-}));
-
-const canSubmitForReview = computed(() => {
-  return (
-    applicableNags.value.filter((nag) => nag.status === "required" && !isNagComplete(nag))
-      .length === 0
-  );
-});
-
-async function submitForReview() {
-  if (canSubmitForReview) {
-    await setProcessing(true);
-  }
-}
-
-const applicableNags = computed<Nag[]>(() => {
-  return nags.filter((nag) => {
-    return nag.shouldShow(nagContext.value);
-  });
-});
-
-function isNagComplete(nag: Nag): boolean {
-  const context = nagContext.value;
-  return !nag.shouldShow(context);
-}
-
-const visibleNags = computed<Nag[]>(() => {
-  const finalNags = applicableNags.value.filter((nag) => !isNagComplete(nag));
-
-  if (props.project.status === "draft") {
-    finalNags.push({
-      id: "submit-for-review",
-      title: messages.submitForReview,
-      description: () => formatMessage(messages.submitForReviewDesc),
-      status: "special-submit-action",
-      shouldShow: (ctx) => ctx.project.status === "draft",
-    });
-  }
-
-  if (props.tags.rejectedStatuses.includes(props.project.status)) {
-    finalNags.push({
-      id: "resubmit-for-review",
-      title: messages.resubmitForReview,
-      description: (ctx) =>
-        formatMessage(messages.resubmitForReviewDesc, { status: ctx.project.status }),
-      status: "special-submit-action",
-      shouldShow: (ctx) => ctx.tags.rejectedStatuses.includes(ctx.project.status),
-      link: {
-        path: "moderation",
-        title: messages.visitModerationPage,
-        shouldShow: () => props.routeName !== "type-id-moderation",
-      },
-    });
-  }
-
-  return finalNags;
-});
-
-function shouldShowLink(nag: Nag): boolean {
-  return nag.link?.shouldShow ? nag.link.shouldShow(nagContext.value) : false;
-}
-
-function getDefaultIcon(status: NagStatus): Component {
-  switch (status) {
-    case "required":
-      return AsteriskIcon;
-    case "warning":
-      return TriangleAlertIcon;
-    case "suggestion":
-      return LightBulbIcon;
-    case "special-submit-action":
-      return ScaleIcon;
-    default:
-      return AsteriskIcon;
-  }
-}
-
-function getStatusTooltip(status: NagStatus): string {
-  switch (status) {
-    case "required":
-      return formatMessage(messages.required);
-    case "warning":
-      return formatMessage(messages.warning);
-    case "suggestion":
-      return formatMessage(messages.suggestion);
-    default:
-      return formatMessage(messages.required);
-  }
-}
-
-const showInvitation = computed<boolean>(() => {
+const showInvitation = computed(() => {
   if (props.allMembers && props.auth) {
-    const member = props.allMembers.find((x) => x?.user?.id === props.auth.user.id);
-    return !!member && !member.accepted;
+    const member = props.allMembers.find((x) => x.user.id === props.auth.user.id);
+    return member && !member.accepted;
   }
   return false;
 });
 
-function toggleCollapsed(): void {
-  if (props.toggleCollapsed) {
-    props.toggleCollapsed();
-  } else {
-    emit("toggleCollapsed");
-  }
-}
+const acceptInvite = () => {
+  acceptTeamInvite(props.project.team);
+  props.updateMembers();
+};
 
-async function updateMembers(): Promise<void> {
-  if (props.updateMembers) {
-    await props.updateMembers();
-  } else {
-    emit("updateMembers");
-  }
-}
+const declineInvite = () => {
+  removeTeamMember(props.project.team, props.auth.user.id);
+  props.updateMembers();
+};
 
-function setProcessing(processing: boolean): void {
-  if (props.setProcessing) {
-    props.setProcessing(processing);
-  } else {
-    emit("setProcessing", processing);
+const submitForReview = async () => {
+  if (
+    !props.acknowledgedMessage ||
+    nags.value.filter((x) => x.condition && x.status === "required").length === 0
+  ) {
+    await props.setProcessing();
   }
-}
-
-async function acceptInvite(): Promise<void> {
-  try {
-    setProcessing(true);
-    await acceptTeamInvite(props.project.team);
-    await updateMembers();
-    addNotification({
-      group: "main",
-      title: formatMessage(messages.success),
-      text: formatMessage(messages.successJoin),
-      type: "success",
-    });
-  } catch (error) {
-    addNotification({
-      group: "main",
-      title: formatMessage(messages.error),
-      text: formatMessage(messages.errorJoin),
-      type: "error",
-    });
-  } finally {
-    setProcessing(false);
-  }
-}
-
-async function declineInvite(): Promise<void> {
-  try {
-    setProcessing(true);
-    await removeTeamMember(props.project.team, props.auth.user.id);
-    await updateMembers();
-    addNotification({
-      group: "main",
-      title: formatMessage(messages.success),
-      text: formatMessage(messages.successDecline),
-      type: "success",
-    });
-  } catch (error) {
-    addNotification({
-      group: "main",
-      title: formatMessage(messages.error),
-      text: formatMessage(messages.errorDecline),
-      type: "error",
-    });
-  } finally {
-    setProcessing(false);
-  }
-}
+};
 </script>
 
 <style lang="scss" scoped>
-.duration-250 {
-  transition-duration: 250ms;
+.invited {
+}
+
+.author-actions {
+  margin-top: var(--spacing-card-md);
+
+  &:empty {
+    display: none;
+  }
+
+  .invisible {
+    visibility: hidden;
+  }
+
+  .header__row {
+    align-items: center;
+    column-gap: var(--spacing-card-lg);
+    row-gap: var(--spacing-card-md);
+    max-width: 100%;
+
+    .header__title {
+      display: flex;
+      flex-wrap: wrap;
+      align-items: center;
+      column-gap: var(--spacing-card-lg);
+      row-gap: var(--spacing-card-md);
+      flex-basis: min-content;
+
+      h2 {
+        margin: 0 auto 0 0;
+      }
+    }
+
+    button {
+      svg {
+        transition: transform 0.25s ease-in-out;
+      }
+
+      &.not-collapsed svg {
+        transform: rotate(180deg);
+      }
+    }
+  }
+
+  .grid-display__item .label {
+    display: flex;
+    gap: var(--spacing-card-xs);
+    align-items: center;
+
+    .required {
+      color: var(--color-red);
+    }
+
+    .suggestion {
+      color: var(--color-purple);
+    }
+
+    .review {
+      color: var(--color-orange);
+    }
+  }
+
+  .checklist {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: var(--spacing-card-xs);
+    width: fit-content;
+    flex-wrap: wrap;
+    max-width: 100%;
+
+    .checklist__title {
+      font-weight: bold;
+      margin-right: var(--spacing-card-xs);
+      color: var(--color-text-dark);
+    }
+
+    .checklist__items {
+      display: flex;
+      flex-direction: row;
+      align-items: center;
+      gap: var(--spacing-card-xs);
+      width: fit-content;
+      max-width: 100%;
+    }
+
+    .circle {
+      --circle-size: 2rem;
+      --background-color: var(--color-bg);
+      --content-color: var(--color-gray);
+      width: var(--circle-size);
+      height: var(--circle-size);
+      border-radius: 50%;
+      background-color: var(--background-color);
+      display: flex;
+      justify-content: center;
+      align-items: center;
+
+      svg {
+        color: var(--content-color);
+        width: calc(var(--circle-size) / 2);
+        height: calc(var(--circle-size) / 2);
+      }
+
+      &.required {
+        --content-color: var(--color-red);
+      }
+
+      &.suggestion {
+        --content-color: var(--color-purple);
+      }
+
+      &.review {
+        --content-color: var(--color-orange);
+      }
+
+      &.done {
+        --background-color: var(--color-green);
+        --content-color: var(--color-brand-inverted);
+      }
+    }
+  }
 }
 </style>

apps/frontend/src/components/ui/moderation/ModpackPermissionsFlow.vue

@@ -8,7 +8,7 @@
     <div v-if="!modPackData">Loading data...</div>
 
     <div v-else-if="modPackData.length === 0">
-      <p>All permissions obtained. You may skip this step!</p>
+      <p>All permissions already obtained.</p>
     </div>
 
     <div v-else-if="!modPackData[currentIndex]">
@@ -157,7 +157,7 @@ import type {
 } from "@modrinth/utils";
 import { ButtonStyled } from "@modrinth/ui";
 import { ref, computed, watch, onMounted } from "vue";
-import { useLocalStorage } from "@vueuse/core";
+import { useLocalStorage, useSessionStorage } from "@vueuse/core";
 
 const props = defineProps<{
   projectId: string;
@@ -182,7 +182,26 @@ const persistedModPackData = useLocalStorage<ModerationModpackItem[] | null>(
 
 const persistedIndex = useLocalStorage<number>(`modpack-permissions-index-${props.projectId}`, 0);
 
-const modPackData = ref<ModerationModpackItem[] | null>(null);
+const modPackData = useSessionStorage<ModerationModpackItem[] | null>(
+  `modpack-permissions-data-${props.projectId}`,
+  null,
+  {
+    serializer: {
+      read: (v: any) => (v ? JSON.parse(v) : null),
+      write: (v: any) => JSON.stringify(v),
+    },
+  },
+);
+const permanentNoFiles = useSessionStorage<ModerationModpackItem[]>(
+  `modpack-permissions-permanent-no-${props.projectId}`,
+  [],
+  {
+    serializer: {
+      read: (v: any) => (v ? JSON.parse(v) : []),
+      write: (v: any) => JSON.stringify(v),
+    },
+  },
+);
 const currentIndex = ref(0);
 
 const fileApprovalTypes: ModerationModpackPermissionApprovalType[] = [
@@ -251,7 +270,45 @@ async function fetchModPackData(): Promise<void> {
     const data = (await useBaseFetch(`moderation/project/${props.projectId}`, {
       internal: true,
     })) as ModerationModpackResponse;
+
+    const permanentNoItems: ModerationModpackItem[] = Object.entries(data.identified || {})
+      .filter(([_, file]) => file.status === "permanent-no")
+      .map(
+        ([sha1, file]): ModerationModpackItem => ({
+          sha1,
+          file_name: file.file_name,
+          type: "identified",
+          status: file.status,
+          approved: null,
+        }),
+      )
+      .sort((a, b) => a.file_name.localeCompare(b.file_name));
+
+    permanentNoFiles.value = permanentNoItems;
+
     const sortedData: ModerationModpackItem[] = [
+      ...Object.entries(data.identified || {})
+        .filter(
+          ([_, file]) =>
+            file.status !== "yes" &&
+            file.status !== "with-attribution-and-source" &&
+            file.status !== "permanent-no",
+        )
+        .map(
+          ([sha1, file]): ModerationModpackItem => ({
+            sha1,
+            file_name: file.file_name,
+            type: "identified",
+            status: file.status,
+            approved: null,
+            ...(file.status === "unidentified" && {
+              proof: "",
+              url: "",
+              title: "",
+            }),
+          }),
+        )
+        .sort((a, b) => a.file_name.localeCompare(b.file_name)),
       ...Object.entries(data.unknown_files || {})
         .map(
           ([sha1, fileName]): ModerationUnknownModpackItem => ({
@@ -310,6 +367,7 @@ async function fetchModPackData(): Promise<void> {
   } catch (error) {
     console.error("Failed to fetch modpack data:", error);
     modPackData.value = [];
+    permanentNoFiles.value = [];
     persistAll();
   }
 }
@@ -321,6 +379,14 @@ function goToPrevious(): void {
   }
 }
 
+watch(
+  modPackData,
+  (newValue) => {
+    persistedModPackData.value = newValue;
+  },
+  { deep: true },
+);
+
 function goToNext(): void {
   if (modPackData.value && currentIndex.value < modPackData.value.length) {
     currentIndex.value++;
@@ -396,6 +462,17 @@ onMounted(() => {
   }
 });
 
+watch(
+  modPackData,
+  (newValue) => {
+    if (newValue && newValue.length === 0) {
+      emit("complete");
+      clearPersistedData();
+    }
+  },
+  { immediate: true },
+);
+
 watch(
   () => props.projectId,
   () => {
@@ -406,6 +483,20 @@ watch(
     }
   },
 );
+
+function getModpackFiles(): {
+  interactive: ModerationModpackItem[];
+  permanentNo: ModerationModpackItem[];
+} {
+  return {
+    interactive: modPackData.value || [],
+    permanentNo: permanentNoFiles.value,
+  };
+}
+
+defineExpose({
+  getModpackFiles,
+});
 </script>
 
 <style scoped>

apps/frontend/src/components/ui/moderation/NewModerationChecklist.vue

@@ -240,24 +240,6 @@
             </div>
 
             <div v-else-if="generatedMessage" class="flex items-center gap-2">
-              <OverflowMenu :options="stageOptions" class="bg-transparent p-0">
-                <ButtonStyled circular>
-                  <button v-tooltip="`Stages`">
-                    <ListBulletedIcon />
-                  </button>
-                </ButtonStyled>
-
-                <template
-                  v-for="opt in stageOptions.filter(
-                    (opt) => 'id' in opt && 'text' in opt && 'icon' in opt,
-                  )"
-                  #[opt.id]
-                  :key="opt.id"
-                >
-                  <component :is="opt.icon" v-if="opt.icon" class="mr-2" />
-                  {{ opt.text }}
-                </template>
-              </OverflowMenu>
               <ButtonStyled>
                 <button @click="goBackToStages">
                   <LeftArrowIcon aria-hidden="true" />
@@ -368,21 +350,26 @@ import {
   DropdownSelect,
   MarkdownEditor,
 } from "@modrinth/ui";
-import { type Project, renderHighlightedString, type ModerationJudgements } from "@modrinth/utils";
+import {
+  type Project,
+  renderHighlightedString,
+  type ModerationJudgements,
+  type ModerationModpackItem,
+} from "@modrinth/utils";
 import { computedAsync, useLocalStorage } from "@vueuse/core";
-import type {
-  Action,
-  MultiSelectChipsAction,
-  DropdownAction,
-  ButtonAction,
-  ToggleAction,
-  ConditionalButtonAction,
-  Stage,
+import {
+  type Action,
+  type MultiSelectChipsAction,
+  type DropdownAction,
+  type ButtonAction,
+  type ToggleAction,
+  type ConditionalButtonAction,
+  type Stage,
+  finalPermissionMessages,
 } from "@modrinth/moderation";
+import * as prettier from "prettier";
 import ModpackPermissionsFlow from "./ModpackPermissionsFlow.vue";
 import KeybindsModal from "./ChecklistKeybindsModal.vue";
-import { finalPermissionMessages } from "@modrinth/moderation/data/modpack-permissions-stage";
-import prettier from "prettier";
 
 const keybindsModal = ref<InstanceType<typeof KeybindsModal>>();
 
@@ -419,7 +406,6 @@ const done = ref(false);
 
 function handleModpackPermissionsComplete() {
   modpackPermissionsComplete.value = true;
-  nextStage();
 }
 
 const emit = defineEmits<{
@@ -823,6 +809,31 @@ const isAnyVisibleInputs = computed(() => {
   });
 });
 
+function getModpackFilesFromStorage(): {
+  interactive: ModerationModpackItem[];
+  permanentNo: ModerationModpackItem[];
+} {
+  try {
+    const sessionData = sessionStorage.getItem(`modpack-permissions-data-${props.project.id}`);
+    const interactive = sessionData ? (JSON.parse(sessionData) as ModerationModpackItem[]) : [];
+
+    const permanentNoData = sessionStorage.getItem(
+      `modpack-permissions-permanent-no-${props.project.id}`,
+    );
+    const permanentNo = permanentNoData
+      ? (JSON.parse(permanentNoData) as ModerationModpackItem[])
+      : [];
+
+    return {
+      interactive: interactive || [],
+      permanentNo: permanentNo || [],
+    };
+  } catch (error) {
+    console.warn("Failed to parse session storage modpack data:", error);
+    return { interactive: [], permanentNo: [] };
+  }
+}
+
 async function assembleFullMessage() {
   const messageParts: MessagePart[] = [];
 
@@ -1092,13 +1103,14 @@ async function generateMessage() {
     const baseMessage = await assembleFullMessage();
     let fullMessage = baseMessage;
 
-    if (
-      props.project.project_type === "modpack" &&
-      Object.keys(modpackJudgements.value).length > 0
-    ) {
-      const modpackMessage = generateModpackMessage(modpackJudgements.value);
-      if (modpackMessage) {
-        fullMessage = baseMessage ? `${baseMessage}\n\n${modpackMessage}` : modpackMessage;
+    if (props.project.project_type === "modpack") {
+      const modpackFilesData = getModpackFilesFromStorage();
+
+      if (modpackFilesData.interactive.length > 0 || modpackFilesData.permanentNo.length > 0) {
+        const modpackMessage = generateModpackMessage(modpackFilesData);
+        if (modpackMessage) {
+          fullMessage = baseMessage ? `${baseMessage}\n\n${modpackMessage}` : modpackMessage;
+        }
       }
     }
 
@@ -1129,25 +1141,32 @@ async function generateMessage() {
   }
 }
 
-function generateModpackMessage(judgements: ModerationJudgements) {
+function generateModpackMessage(allFiles: {
+  interactive: ModerationModpackItem[];
+  permanentNo: ModerationModpackItem[];
+}) {
   const issues = [];
 
-  const attributeMods = [];
-  const noMods = [];
-  const permanentNoMods = [];
-  const unidentifiedMods = [];
+  const attributeMods: string[] = [];
+  const noMods: string[] = [];
+  const permanentNoMods: string[] = [];
+  const unidentifiedMods: string[] = [];
 
-  for (const [, judgement] of Object.entries(judgements)) {
-    if (judgement.status === "with-attribution") {
-      attributeMods.push(judgement.file_name);
-    } else if (judgement.status === "no") {
-      noMods.push(judgement.file_name);
-    } else if (judgement.status === "permanent-no") {
-      permanentNoMods.push(judgement.file_name);
-    } else if (judgement.status === "unidentified") {
-      unidentifiedMods.push(judgement.file_name);
+  allFiles.interactive.forEach((file) => {
+    if (file.status === "unidentified") {
+      if (file.approved === "no") {
+        unidentifiedMods.push(file.file_name);
+      }
+    } else if (file.status === "with-attribution" && file.approved === "no") {
+      attributeMods.push(file.file_name);
+    } else if (file.status === "no" && file.approved === "no") {
+      noMods.push(file.file_name);
     }
-  }
+  });
+
+  allFiles.permanentNo.forEach((file) => {
+    permanentNoMods.push(file.file_name);
+  });
 
   if (
     attributeMods.length > 0 ||
@@ -1157,6 +1176,12 @@ function generateModpackMessage(judgements: ModerationJudgements) {
   ) {
     issues.push("## Copyrighted content");
 
+    if (unidentifiedMods.length > 0) {
+      issues.push(
+        `${finalPermissionMessages.unidentified}\n${unidentifiedMods.map((mod) => `- ${mod}`).join("\n")}`,
+      );
+    }
+
     if (attributeMods.length > 0) {
       issues.push(
         `${finalPermissionMessages["with-attribution"]}\n${attributeMods.map((mod) => `- ${mod}`).join("\n")}`,
@@ -1172,12 +1197,6 @@ function generateModpackMessage(judgements: ModerationJudgements) {
         `${finalPermissionMessages["permanent-no"]}\n${permanentNoMods.map((mod) => `- ${mod}`).join("\n")}`,
       );
     }
-
-    if (unidentifiedMods.length > 0) {
-      issues.push(
-        `${finalPermissionMessages["unidentified"]}\n${unidentifiedMods.map((mod) => `- ${mod}`).join("\n")}`,
-      );
-    }
   }
 
   return issues.join("\n\n");

apps/frontend/src/locales/en-US/index.json

@@ -533,69 +533,6 @@
   "profile.user-id": {
     "message": "User ID: {id}"
   },
-  "project-member-header.accept": {
-    "message": "Accept"
-  },
-  "project-member-header.decline": {
-    "message": "Decline"
-  },
-  "project-member-header.error": {
-    "message": "Error"
-  },
-  "project-member-header.error-decline": {
-    "message": "Failed to decline team invitation"
-  },
-  "project-member-header.error-join": {
-    "message": "Failed to accept team invitation"
-  },
-  "project-member-header.invitation-no-role": {
-    "message": "You've been invited to join this project. Please accept or decline the invitation."
-  },
-  "project-member-header.invitation-title": {
-    "message": "Invitation to join project"
-  },
-  "project-member-header.invitation-with-role": {
-    "message": "You've been invited be a member of this project with the role of '{role}'."
-  },
-  "project-member-header.publishing-checklist": {
-    "message": "Publishing checklist"
-  },
-  "project-member-header.required": {
-    "message": "Required"
-  },
-  "project-member-header.resubmit-for-review": {
-    "message": "Resubmit for review"
-  },
-  "project-member-header.resubmit-for-review-desc": {
-    "message": "Your project has been {status} by Modrinth's staff. In most cases, you can resubmit for review after addressing the staff's message."
-  },
-  "project-member-header.submit-checklist-tooltip": {
-    "message": "You must complete the required steps in the publishing checklist!"
-  },
-  "project-member-header.submit-for-review": {
-    "message": "Submit for review"
-  },
-  "project-member-header.submit-for-review-desc": {
-    "message": "Your project is only viewable by members of the project. It must be reviewed by moderators in order to be published."
-  },
-  "project-member-header.success": {
-    "message": "Success"
-  },
-  "project-member-header.success-decline": {
-    "message": "You have declined the team invitation"
-  },
-  "project-member-header.success-join": {
-    "message": "You have joined the project team"
-  },
-  "project-member-header.suggestion": {
-    "message": "Suggestion"
-  },
-  "project-member-header.visit-moderation-page": {
-    "message": "Visit moderation page"
-  },
-  "project-member-header.warning": {
-    "message": "Warning"
-  },
   "project-type.collection.plural": {
     "message": "Collections"
   },

apps/frontend/src/pages/[type]/[id]/settings/description.vue

@@ -22,10 +22,6 @@
         "
         :on-image-upload="onUploadHandler"
       />
-      <div v-if="descriptionWarning" class="flex items-center gap-1.5 text-orange">
-        <TriangleAlertIcon class="my-auto" />
-        {{ descriptionWarning }}
-      </div>
       <div class="input-group markdown-disclaimer">
         <button
           :disabled="!hasChanges"
@@ -42,8 +38,7 @@
 </template>
 
 <script lang="ts" setup>
-import { SaveIcon, TriangleAlertIcon } from "@modrinth/assets";
-import { MIN_DESCRIPTION_CHARS } from "@modrinth/moderation";
+import { SaveIcon } from "@modrinth/assets";
 import { MarkdownEditor } from "@modrinth/ui";
 import { type Project, type TeamMember, TeamMemberPermission } from "@modrinth/utils";
 import { computed, ref } from "vue";
@@ -58,17 +53,6 @@ const props = defineProps<{
 
 const description = ref(props.project.body);
 
-const descriptionWarning = computed(() => {
-  const text = description.value?.trim() || "";
-  const charCount = text.length;
-
-  if (charCount < MIN_DESCRIPTION_CHARS) {
-    return `It's recommended to have a description with at least ${MIN_DESCRIPTION_CHARS} characters. (${charCount}/${MIN_DESCRIPTION_CHARS})`;
-  }
-
-  return null;
-});
-
 const patchRequestPayload = computed(() => {
   const payload: {
     body?: string;

apps/frontend/src/pages/[type]/[id]/settings/index.vue

@@ -82,10 +82,6 @@
       <label for="project-summary">
         <span class="label__title">Summary</span>
       </label>
-      <div v-if="summaryWarning" class="my-2 flex items-center gap-1.5 text-orange">
-        <TriangleAlertIcon class="my-auto" />
-        {{ summaryWarning }}
-      </div>
       <div class="textarea-wrapper summary-input">
         <textarea
           id="project-summary"
@@ -244,18 +240,9 @@
 
 <script setup>
 import { formatProjectStatus, formatProjectType } from "@modrinth/utils";
-import {
-  UploadIcon,
-  SaveIcon,
-  TrashIcon,
-  XIcon,
-  IssuesIcon,
-  CheckIcon,
-  TriangleAlertIcon,
-} from "@modrinth/assets";
+import { UploadIcon, SaveIcon, TrashIcon, XIcon, IssuesIcon, CheckIcon } from "@modrinth/assets";
 import { Multiselect } from "vue-multiselect";
 import { ConfirmModal, Avatar } from "@modrinth/ui";
-import { MIN_SUMMARY_CHARS } from "@modrinth/moderation";
 import FileInput from "~/components/ui/FileInput.vue";
 
 const props = defineProps({
@@ -313,17 +300,6 @@ const hasDeletePermission = computed(() => {
   return (props.currentMember.permissions & DELETE_PROJECT) === DELETE_PROJECT;
 });
 
-const summaryWarning = computed(() => {
-  const text = summary.value?.trim() || "";
-  const charCount = text.length;
-
-  if (charCount < MIN_SUMMARY_CHARS) {
-    return `It's recommended to have a summary with at least ${MIN_SUMMARY_CHARS} characters. (${charCount}/${MIN_SUMMARY_CHARS})`;
-  }
-
-  return null;
-});
-
 const sideTypes = ["required", "optional", "unsupported"];
 
 const patchData = computed(() => {

apps/frontend/src/pages/[type]/[id]/settings/links.vue

@@ -7,16 +7,11 @@
           id="project-issue-tracker"
           title="A place for users to report bugs, issues, and concerns about your project."
         >
-          <span class="label__title">Issue tracker </span>
+          <span class="label__title">Issue tracker</span>
           <span class="label__description">
             A place for users to report bugs, issues, and concerns about your project.
           </span>
         </label>
-        <TriangleAlertIcon
-          v-if="!isIssuesUrlCommon"
-          v-tooltip="`You're using a link which isn't common for this link type.`"
-          class="size-6 animate-pulse text-orange"
-        />
         <input
           id="project-issue-tracker"
           v-model="issuesUrl"
@@ -31,16 +26,11 @@
           id="project-source-code"
           title="A page/repository containing the source code for your project"
         >
-          <span class="label__title">Source code </span>
+          <span class="label__title">Source code</span>
           <span class="label__description">
             A page/repository containing the source code for your project
           </span>
         </label>
-        <TriangleAlertIcon
-          v-if="!isSourceUrlCommon"
-          v-tooltip="`You're using a link which isn't common for this link type.`"
-          class="size-6 animate-pulse text-orange"
-        />
         <input
           id="project-source-code"
           v-model="sourceUrl"
@@ -71,14 +61,9 @@
       </div>
       <div class="adjacent-input">
         <label id="project-discord-invite" title="An invitation link to your Discord server.">
-          <span class="label__title">Discord invite </span>
+          <span class="label__title">Discord invite</span>
           <span class="label__description"> An invitation link to your Discord server. </span>
         </label>
-        <TriangleAlertIcon
-          v-if="!isDiscordUrlCommon"
-          v-tooltip="`You're using a link which isn't common for this link type.`"
-          class="size-6 animate-pulse text-orange"
-        />
         <input
           id="project-discord-invite"
           v-model="discordUrl"
@@ -138,8 +123,7 @@
 
 <script setup>
 import { DropdownSelect } from "@modrinth/ui";
-import { SaveIcon, TriangleAlertIcon } from "@modrinth/assets";
-import { isCommonUrl, commonLinkDomains } from "@modrinth/moderation";
+import { SaveIcon } from "@modrinth/assets";
 
 const tags = useTags();
 
@@ -169,21 +153,6 @@ const sourceUrl = ref(props.project.source_url);
 const wikiUrl = ref(props.project.wiki_url);
 const discordUrl = ref(props.project.discord_url);
 
-const isIssuesUrlCommon = computed(() => {
-  if (!issuesUrl.value || issuesUrl.value.trim().length === 0) return true;
-  return isCommonUrl(issuesUrl.value, commonLinkDomains.issues);
-});
-
-const isSourceUrlCommon = computed(() => {
-  if (!sourceUrl.value || sourceUrl.value.trim().length === 0) return true;
-  return isCommonUrl(sourceUrl.value, commonLinkDomains.source);
-});
-
-const isDiscordUrlCommon = computed(() => {
-  if (!discordUrl.value || discordUrl.value.trim().length === 0) return true;
-  return isCommonUrl(discordUrl.value, commonLinkDomains.discord);
-});
-
 const rawDonationLinks = JSON.parse(JSON.stringify(props.project.donation_urls));
 rawDonationLinks.push({
   id: null,

apps/frontend/src/pages/[type]/[id]/settings/tags.vue

@@ -6,31 +6,11 @@
           <span class="label__title size-card-header">Tags</span>
         </h3>
       </div>
-
-      <div
-        v-if="tooManyTagsWarning && !allTagsSelectedWarning"
-        class="my-2 flex items-center gap-1.5 text-orange"
-      >
-        <TriangleAlertIcon class="my-auto" />
-        {{ tooManyTagsWarning }}
-      </div>
-
-      <div v-if="multipleResolutionTagsWarning" class="my-2 flex items-center gap-1.5 text-orange">
-        <TriangleAlertIcon class="my-auto" />
-        {{ multipleResolutionTagsWarning }}
-      </div>
-
-      <div v-if="allTagsSelectedWarning" class="my-2 flex items-center gap-1.5 text-red">
-        <TriangleAlertIcon class="my-auto" />
-        <span>{{ allTagsSelectedWarning }}</span>
-      </div>
-
       <p>
         Accurate tagging is important to help people find your
         {{ formatProjectType(project.project_type).toLowerCase() }}. Make sure to select all tags
         that apply.
       </p>
-
       <p v-if="project.versions.length === 0" class="known-errors">
         Please upload a version first in order to select tags!
       </p>
@@ -132,181 +112,145 @@
   </div>
 </template>
 
-<script setup lang="ts">
-import { computed, ref } from "vue";
-import { StarIcon, SaveIcon, TriangleAlertIcon } from "@modrinth/assets";
-import {
-  formatCategory,
-  formatCategoryHeader,
-  formatProjectType,
-  sortedCategories,
-  type Project,
-} from "@modrinth/utils";
+<script>
+import { StarIcon, SaveIcon } from "@modrinth/assets";
+import { formatCategory, formatCategoryHeader, formatProjectType } from "@modrinth/utils";
 import Checkbox from "~/components/ui/Checkbox.vue";
 
-interface Category {
-  name: string;
-  header: string;
-  icon?: string;
-  project_type: string;
-}
+export default defineNuxtComponent({
+  components: {
+    Checkbox,
+    SaveIcon,
+    StarIcon,
+  },
+  props: {
+    project: {
+      type: Object,
+      default() {
+        return {};
+      },
+    },
+    allMembers: {
+      type: Array,
+      default() {
+        return [];
+      },
+    },
+    currentMember: {
+      type: Object,
+      default() {
+        return null;
+      },
+    },
+    patchProject: {
+      type: Function,
+      default() {
+        return () => {
+          this.$notify({
+            group: "main",
+            title: "An error occurred",
+            text: "Patch project function not found",
+            type: "error",
+          });
+        };
+      },
+    },
+  },
+  data() {
+    return {
+      selectedTags: this.$sortedCategories().filter(
+        (x) =>
+          x.project_type === this.project.actualProjectType &&
+          (this.project.categories.includes(x.name) ||
+            this.project.additional_categories.includes(x.name)),
+      ),
+      featuredTags: this.$sortedCategories().filter(
+        (x) =>
+          x.project_type === this.project.actualProjectType &&
+          this.project.categories.includes(x.name),
+      ),
+    };
+  },
+  computed: {
+    categoryLists() {
+      const lists = {};
+      this.$sortedCategories().forEach((x) => {
+        if (x.project_type === this.project.actualProjectType) {
+          const header = x.header;
+          if (!lists[header]) {
+            lists[header] = [];
+          }
+          lists[header].push(x);
+        }
+      });
+      return lists;
+    },
+    patchData() {
+      const data = {};
+      // Promote selected categories to featured if there are less than 3 featured
+      const newFeaturedTags = this.featuredTags.slice();
+      if (newFeaturedTags.length < 1 && this.selectedTags.length > newFeaturedTags.length) {
+        const nonFeaturedCategories = this.selectedTags.filter((x) => !newFeaturedTags.includes(x));
 
-interface Props {
-  project: Project & {
-    actualProjectType: string;
-  };
-  allMembers?: any[];
-  currentMember?: any;
-  patchProject?: (data: any) => void;
-}
+        nonFeaturedCategories
+          .slice(0, Math.min(nonFeaturedCategories.length, 3 - newFeaturedTags.length))
+          .forEach((x) => newFeaturedTags.push(x));
+      }
+      // Convert selected and featured categories to backend-usable arrays
+      const categories = newFeaturedTags.map((x) => x.name);
+      const additionalCategories = this.selectedTags
+        .filter((x) => !newFeaturedTags.includes(x))
+        .map((x) => x.name);
 
-const tags = useTags();
+      if (
+        categories.length !== this.project.categories.length ||
+        categories.some((value) => !this.project.categories.includes(value))
+      ) {
+        data.categories = categories;
+      }
 
-const props = withDefaults(defineProps<Props>(), {
-  allMembers: () => [],
-  currentMember: null,
-  patchProject: () => {
-    addNotification({
-      title: "An error occurred",
-      text: "Patch project function not found",
-      type: "error",
-    });
+      if (
+        additionalCategories.length !== this.project.additional_categories.length ||
+        additionalCategories.some((value) => !this.project.additional_categories.includes(value))
+      ) {
+        data.additional_categories = additionalCategories;
+      }
+
+      return data;
+    },
+    hasChanges() {
+      return Object.keys(this.patchData).length > 0;
+    },
+  },
+  methods: {
+    formatProjectType,
+    formatCategoryHeader,
+    formatCategory,
+    toggleCategory(category) {
+      if (this.selectedTags.includes(category)) {
+        this.selectedTags = this.selectedTags.filter((x) => x !== category);
+        if (this.featuredTags.includes(category)) {
+          this.featuredTags = this.featuredTags.filter((x) => x !== category);
+        }
+      } else {
+        this.selectedTags.push(category);
+      }
+    },
+    toggleFeaturedCategory(category) {
+      if (this.featuredTags.includes(category)) {
+        this.featuredTags = this.featuredTags.filter((x) => x !== category);
+      } else {
+        this.featuredTags.push(category);
+      }
+    },
+    saveChanges() {
+      if (this.hasChanges) {
+        this.patchProject(this.patchData);
+      }
+    },
   },
 });
-
-const selectedTags = ref<Category[]>(
-  sortedCategories(tags.value).filter(
-    (x: Category) =>
-      x.project_type === props.project.actualProjectType &&
-      (props.project.categories.includes(x.name) ||
-        props.project.additional_categories.includes(x.name)),
-  ),
-);
-
-const featuredTags = ref<Category[]>(
-  sortedCategories(tags.value).filter(
-    (x: Category) =>
-      x.project_type === props.project.actualProjectType &&
-      props.project.categories.includes(x.name),
-  ),
-);
-
-const categoryLists = computed(() => {
-  const lists: Record<string, Category[]> = {};
-  sortedCategories(tags.value).forEach((x: Category) => {
-    if (x.project_type === props.project.actualProjectType) {
-      const header = x.header;
-      if (!lists[header]) {
-        lists[header] = [];
-      }
-      lists[header].push(x);
-    }
-  });
-  return lists;
-});
-
-const tooManyTagsWarning = computed(() => {
-  const tagCount = selectedTags.value.length;
-  if (tagCount > 5) {
-    return `You've selected ${tagCount} tags. Consider reducing to 5 or fewer to keep your project focused and easier to discover.`;
-  }
-  return null;
-});
-
-const multipleResolutionTagsWarning = computed(() => {
-  if (props.project.project_type !== "resourcepack") return null;
-
-  const resolutionTags = selectedTags.value.filter((tag) =>
-    ["16x", "32x", "48x", "64x", "128x", "256x", "512x", "1024x"].includes(tag.name),
-  );
-
-  if (resolutionTags.length > 1) {
-    return `You've selected ${resolutionTags.length} resolution tags (${resolutionTags.map((t) => t.name).join(", ")}). Resource packs should typically only have one resolution tag.`;
-  }
-  return null;
-});
-
-const allTagsSelectedWarning = computed(() => {
-  const categoriesForProjectType = sortedCategories(tags.value).filter(
-    (x: Category) => x.project_type === props.project.actualProjectType,
-  );
-  const totalSelectedTags = selectedTags.value.length;
-
-  if (
-    totalSelectedTags === categoriesForProjectType.length &&
-    categoriesForProjectType.length > 0
-  ) {
-    return `You've selected all ${categoriesForProjectType.length} available tags. Please select only the tags that truly apply to your project.`;
-  }
-  return null;
-});
-
-const patchData = computed(() => {
-  const data: Record<string, string[]> = {};
-
-  // Promote selected categories to featured if there are less than 3 featured
-  const newFeaturedTags = featuredTags.value.slice();
-  if (newFeaturedTags.length < 1 && selectedTags.value.length > newFeaturedTags.length) {
-    const nonFeaturedCategories = selectedTags.value.filter((x) => !newFeaturedTags.includes(x));
-
-    nonFeaturedCategories
-      .slice(0, Math.min(nonFeaturedCategories.length, 3 - newFeaturedTags.length))
-      .forEach((x) => newFeaturedTags.push(x));
-  }
-
-  // Convert selected and featured categories to backend-usable arrays
-  const categories = newFeaturedTags.map((x) => x.name);
-  const additionalCategories = selectedTags.value
-    .filter((x) => !newFeaturedTags.includes(x))
-    .map((x) => x.name);
-
-  if (
-    categories.length !== props.project.categories.length ||
-    categories.some((value) => !props.project.categories.includes(value))
-  ) {
-    data.categories = categories;
-  }
-
-  if (
-    additionalCategories.length !== props.project.additional_categories.length ||
-    additionalCategories.some((value) => !props.project.additional_categories.includes(value))
-  ) {
-    data.additional_categories = additionalCategories;
-  }
-
-  return data;
-});
-
-const hasChanges = computed(() => {
-  return Object.keys(patchData.value).length > 0;
-});
-
-const toggleCategory = (category: Category) => {
-  if (selectedTags.value.includes(category)) {
-    selectedTags.value = selectedTags.value.filter((x) => x !== category);
-    if (featuredTags.value.includes(category)) {
-      featuredTags.value = featuredTags.value.filter((x) => x !== category);
-    }
-  } else {
-    selectedTags.value.push(category);
-  }
-};
-
-const toggleFeaturedCategory = (category: Category) => {
-  if (featuredTags.value.includes(category)) {
-    featuredTags.value = featuredTags.value.filter((x) => x !== category);
-  } else {
-    featuredTags.value.push(category);
-  }
-};
-
-const saveChanges = () => {
-  if (hasChanges.value) {
-    props.patchProject(patchData.value);
-  }
-};
 </script>
-
 <style lang="scss" scoped>
 .label__title {
   display: flex;

apps/frontend/src/pages/admin/billing/[id].vue

@@ -150,9 +150,26 @@
                   </template>
                 </span>
                 <span class="text-sm text-secondary">
+                  <span
+                    v-if="charge.status === 'cancelled' && $dayjs(charge.due).isBefore($dayjs())"
+                    class="font-bold"
+                  >
+                    Ended:
+                  </span>
+                  <span v-else-if="charge.status === 'cancelled'" class="font-bold">Ends:</span>
+                  <span v-else-if="charge.type === 'refund'" class="font-bold">Issued:</span>
+                  <span v-else class="font-bold">Due:</span>
                   {{ dayjs(charge.due).format("MMMM D, YYYY [at] h:mma") }}
                   <span class="text-secondary">({{ formatRelativeTime(charge.due) }}) </span>
                 </span>
+                <span v-if="charge.last_attempt != null" class="text-sm text-secondary">
+                  <span v-if="charge.status === 'failed'" class="font-bold">Last attempt:</span>
+                  <span v-else class="font-bold">Charged:</span>
+                  {{ dayjs(charge.last_attempt).format("MMMM D, YYYY [at] h:mma") }}
+                  <span class="text-secondary"
+                    >({{ formatRelativeTime(charge.last_attempt) }})
+                  </span>
+                </span>
                 <div class="flex w-full items-center gap-1 text-xs text-secondary">
                   {{ charge.status }}
                   ⋅

apps/frontend/src/pages/auth/sign-in.vue

@@ -1,6 +1,12 @@
 <template>
-  <div>
-    <template v-if="flow">
+  <div v-if="subtleLauncherRedirectUri">
+    <iframe
+      :src="subtleLauncherRedirectUri"
+      class="fixed left-0 top-0 z-[9999] m-0 h-full w-full border-0 p-0"
+    ></iframe>
+  </div>
+  <div v-else>
+    <template v-if="flow && !subtleLauncherRedirectUri">
       <label for="two-factor-code">
         <span class="label__title">{{ formatMessage(messages.twoFactorCodeLabel) }}</span>
         <span class="label__description">
@@ -189,6 +195,7 @@ const auth = await useAuth();
 const route = useNativeRoute();
 
 const redirectTarget = route.query.redirect || "";
+const subtleLauncherRedirectUri = ref();
 
 if (route.query.code && !route.fullPath.includes("new_account=true")) {
   await finishSignIn();
@@ -262,7 +269,32 @@ async function begin2FASignIn() {
 
 async function finishSignIn(token) {
   if (route.query.launcher) {
-    await navigateTo(`https://launcher-files.modrinth.com/?code=${token}`, { external: true });
+    if (!token) {
+      token = auth.value.token;
+    }
+
+    const usesLocalhostRedirectionScheme =
+      ["4", "6"].includes(route.query.ipver) && Number(route.query.port) < 65536;
+
+    const redirectUrl = usesLocalhostRedirectionScheme
+      ? `http://${route.query.ipver === "4" ? "127.0.0.1" : "[::1]"}:${route.query.port}/?code=${token}`
+      : `https://launcher-files.modrinth.com/?code=${token}`;
+
+    if (usesLocalhostRedirectionScheme) {
+      // When using this redirection scheme, the auth token is very visible in the URL to the user.
+      // While we could make it harder to find with a POST request, such is security by obscurity:
+      // the user and other applications would still be able to sniff the token in the request body.
+      // So, to make the UX a little better by not changing the displayed URL, while keeping the
+      // token hidden from very casual observation and keeping the protocol as close to OAuth's
+      // standard flows as possible, let's execute the redirect within an iframe that visually
+      // covers the entire page.
+      subtleLauncherRedirectUri.value = redirectUrl;
+    } else {
+      await navigateTo(redirectUrl, {
+        external: true,
+      });
+    }
+
     return;
   }
 

apps/frontend/src/pages/auth/sign-up.vue

@@ -247,16 +247,14 @@ async function createAccount() {
       },
     });
 
-    if (route.query.launcher) {
-      await navigateTo(`https://launcher-files.modrinth.com/?code=${res.session}`, {
-        external: true,
-      });
-      return;
-    }
-
     await useAuth(res.session);
     await useUser();
 
+    if (route.query.launcher) {
+      await navigateTo({ path: "/auth/sign-in", query: route.query });
+      return;
+    }
+
     if (route.query.redirect) {
       await navigateTo(route.query.redirect);
     } else {

apps/labrinth/.sqlx/query-cf020daa52a1316e5f60d197196b880b72c0b2a576e470d9fd7182558103d055.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "\n            SELECT\n                id, user_id, price_id, amount, currency_code, status, due, last_attempt,\n                charge_type, subscription_id,\n                -- Workaround for https://github.com/launchbadge/sqlx/issues/3336\n                subscription_interval AS \"subscription_interval?\",\n                payment_platform,\n                payment_platform_id AS \"payment_platform_id?\",\n                parent_charge_id AS \"parent_charge_id?\",\n                net AS \"net?\"\n            FROM charges\n            WHERE subscription_id = $1 AND (status = 'open' OR status = 'cancelled')",
+  "query": "\n            SELECT\n                id, user_id, price_id, amount, currency_code, status, due, last_attempt,\n                charge_type, subscription_id,\n                -- Workaround for https://github.com/launchbadge/sqlx/issues/3336\n                subscription_interval AS \"subscription_interval?\",\n                payment_platform,\n                payment_platform_id AS \"payment_platform_id?\",\n                parent_charge_id AS \"parent_charge_id?\",\n                net AS \"net?\"\n            FROM charges\n            WHERE subscription_id = $1 AND (status = 'open' OR status = 'cancelled' OR status = 'failed')",
   "describe": {
     "columns": [
       {
@@ -102,5 +102,5 @@
       true
     ]
   },
-  "hash": "99cca53fd3f35325e2da3b671532bf98b8c7ad8e7cb9158e4eb9c5bac66d20b2"
+  "hash": "cf020daa52a1316e5f60d197196b880b72c0b2a576e470d9fd7182558103d055"
 }

apps/labrinth/Dockerfile

@@ -1,8 +1,21 @@
+# syntax=docker/dockerfile:1
+
 FROM rust:1.88.0 AS build
 
 WORKDIR /usr/src/labrinth
 COPY . .
-RUN SQLX_OFFLINE=true cargo build --release --package labrinth
+RUN --mount=type=cache,target=/usr/src/labrinth/target \
+  --mount=type=cache,target=/usr/local/cargo/git/db \
+  --mount=type=cache,target=/usr/local/cargo/registry \
+  SQLX_OFFLINE=true cargo build --release --package labrinth
+
+FROM build AS artifacts
+
+RUN --mount=type=cache,target=/usr/src/labrinth/target \
+  mkdir /labrinth \
+  && cp /usr/src/labrinth/target/release/labrinth /labrinth/labrinth \
+  && cp -r /usr/src/labrinth/apps/labrinth/migrations /labrinth \
+  && cp -r /usr/src/labrinth/apps/labrinth/assets /labrinth
 
 FROM debian:bookworm-slim
 
@@ -14,10 +27,8 @@ RUN apt-get update \
   && apt-get install -y --no-install-recommends ca-certificates dumb-init curl \
   && rm -rf /var/lib/apt/lists/*
 
-COPY --from=build /usr/src/labrinth/target/release/labrinth /labrinth/labrinth
-COPY --from=build /usr/src/labrinth/apps/labrinth/migrations/* /labrinth/migrations/
-COPY --from=build /usr/src/labrinth/apps/labrinth/assets /labrinth/assets
-WORKDIR /labrinth
+COPY --from=artifacts /labrinth /labrinth
 
+WORKDIR /labrinth
 ENTRYPOINT ["dumb-init", "--"]
 CMD ["/labrinth/labrinth"]

apps/labrinth/src/database/models/charge_item.rs

@@ -197,7 +197,7 @@ impl DBCharge {
     ) -> Result<Option<DBCharge>, DatabaseError> {
         let user_subscription_id = user_subscription_id.0;
         let res = select_charges_with_predicate!(
-            "WHERE subscription_id = $1 AND (status = 'open' OR status = 'cancelled')",
+            "WHERE subscription_id = $1 AND (status = 'open' OR status = 'cancelled' OR status = 'failed')",
             user_subscription_id
         )
         .fetch_optional(exec)

packages/app-lib/.env.local

@@ -1,2 +1,10 @@
-# SQLite database file location
-DATABASE_URL=sqlite:///tmp/Modrinth/code/packages/app-lib/.sqlx/generated/state.db
+MODRINTH_URL=http://localhost:3000/
+MODRINTH_API_URL=http://127.0.0.1:8000/v2/
+MODRINTH_API_URL_V3=http://127.0.0.1:8000/v3/
+MODRINTH_SOCKET_URL=ws://127.0.0.1:8000/
+MODRINTH_LAUNCHER_META_URL=https://launcher-meta.modrinth.com/
+
+# SQLite database file used by sqlx for type checking. Uncomment this to a valid path
+# in your system and run `cargo sqlx database setup` to generate an empty database that
+# can be used for developing the app DB schema
+#DATABASE_URL=sqlite:///tmp/Modrinth/code/packages/app-lib/.sqlx/generated/state.db

packages/app-lib/.env.prod

@@ -0,0 +1,10 @@
+MODRINTH_URL=https://modrinth.com/
+MODRINTH_API_URL=https://api.modrinth.com/v2/
+MODRINTH_API_URL_V3=https://api.modrinth.com/v3/
+MODRINTH_SOCKET_URL=wss://api.modrinth.com/
+MODRINTH_LAUNCHER_META_URL=https://launcher-meta.modrinth.com/
+
+# SQLite database file used by sqlx for type checking. Uncomment this to a valid path
+# in your system and run `cargo sqlx database setup` to generate an empty database that
+# can be used for developing the app DB schema
+#DATABASE_URL=sqlite:///tmp/Modrinth/code/packages/app-lib/.sqlx/generated/state.db

packages/app-lib/.env.staging

@@ -0,0 +1,10 @@
+MODRINTH_URL=https://staging.modrinth.com/
+MODRINTH_API_URL=https://staging-api.modrinth.com/v2/
+MODRINTH_API_URL_V3=https://staging-api.modrinth.com/v3/
+MODRINTH_SOCKET_URL=wss://staging-api.modrinth.com/
+MODRINTH_LAUNCHER_META_URL=https://launcher-meta.modrinth.com/
+
+# SQLite database file used by sqlx for type checking. Uncomment this to a valid path
+# in your system and run `cargo sqlx database setup` to generate an empty database that
+# can be used for developing the app DB schema
+#DATABASE_URL=sqlite:///tmp/Modrinth/code/packages/app-lib/.sqlx/generated/state.db

packages/app-lib/Cargo.toml

@@ -82,6 +82,7 @@ ariadne.workspace = true
 winreg.workspace = true
 
 [build-dependencies]
+dotenvy.workspace = true
 dunce.workspace = true
 
 [features]

packages/app-lib/build.rs

@@ -4,12 +4,31 @@ use std::process::{Command, exit};
 use std::{env, fs};
 
 fn main() {
+    println!("cargo::rerun-if-changed=.env");
     println!("cargo::rerun-if-changed=java/gradle");
     println!("cargo::rerun-if-changed=java/src");
     println!("cargo::rerun-if-changed=java/build.gradle.kts");
     println!("cargo::rerun-if-changed=java/settings.gradle.kts");
     println!("cargo::rerun-if-changed=java/gradle.properties");
 
+    set_env();
+    build_java_jars();
+}
+
+fn set_env() {
+    for (var_name, var_value) in
+        dotenvy::dotenv_iter().into_iter().flatten().flatten()
+    {
+        if var_name == "DATABASE_URL" {
+            // The sqlx database URL is a build-time detail that should not be exposed to the crate
+            continue;
+        }
+
+        println!("cargo::rustc-env={var_name}={var_value}");
+    }
+}
+
+fn build_java_jars() {
     let out_dir =
         dunce::canonicalize(PathBuf::from(env::var_os("OUT_DIR").unwrap()))
             .unwrap();
@@ -37,6 +56,7 @@ fn main() {
         .current_dir(dunce::canonicalize("java").unwrap())
         .status()
         .expect("Failed to wait on Gradle build");
+
     if !exit_status.success() {
         println!("cargo::error=Gradle build failed with {exit_status}");
         exit(exit_status.code().unwrap_or(1));

packages/app-lib/src/api/minecraft_auth.rs

@@ -28,6 +28,16 @@ pub async fn offline_auth(
     crate::state::offline_auth(name, &state.pool).await
 }
 
+#[tracing::instrument]
+pub async fn elyby_auth(
+    uuid: uuid::Uuid,
+    login: &str,
+    access_token: &str
+) -> crate::Result<Credentials> {
+    let state = State::get().await?;
+    crate::state::elyby_auth(uuid, login, access_token, &state.pool).await
+}
+
 #[tracing::instrument]
 pub async fn get_default_user() -> crate::Result<Option<uuid::Uuid>> {
     let state = State::get().await?;

packages/app-lib/src/api/mr_auth.rs

@@ -1,7 +1,7 @@
 use crate::state::ModrinthCredentials;
 
 #[tracing::instrument]
-pub fn authenticate_begin_flow() -> String {
+pub fn authenticate_begin_flow() -> &'static str {
     crate::state::get_login_url()
 }
 

packages/app-lib/src/api/pack/import/curseforge_profile.rs

@@ -0,0 +1,604 @@
+use std::io::Cursor;
+
+use async_zip::base::read::seek::ZipFileReader;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    State,
+    event::{LoadingBarType, ProfilePayloadType},
+    prelude::ModLoader,
+    state::{LinkedData, ProfileInstallStage},
+    util::fetch::fetch,
+};
+
+use super::copy_dotminecraft;
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CurseForgeManifest {
+    pub minecraft: CurseForgeMinecraft,
+    pub manifest_type: String,
+    pub manifest_version: i32,
+    pub name: String,
+    pub version: String,
+    pub author: String,
+    pub files: Vec<CurseForgeFile>,
+    pub overrides: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CurseForgeMinecraft {
+    pub version: String,
+    pub mod_loaders: Vec<CurseForgeModLoader>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CurseForgeModLoader {
+    pub id: String,
+    pub primary: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CurseForgeFile {
+    #[serde(rename = "projectID")]
+    pub project_id: u32,
+    #[serde(rename = "fileID")]
+    pub file_id: u32,
+    pub required: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct CurseForgeProfileMetadata {
+    pub name: String,
+    pub download_url: String,
+}
+
+/// Fetch CurseForge profile metadata from profile code
+pub async fn fetch_curseforge_profile_metadata(
+    profile_code: &str,
+) -> crate::Result<CurseForgeProfileMetadata> {
+    let state = State::get().await?;
+
+    // Make initial request to get redirect URL
+    let url = format!(
+        "https://api.curseforge.com/v1/shared-profile/{}",
+        profile_code
+    );
+
+    // Try to fetch the profile - the CurseForge API should redirect to the ZIP file
+    let response = fetch(&url, None, &state.fetch_semaphore, &state.pool).await;
+
+    let download_url = match response {
+        Ok(_bytes) => {
+            // If we get bytes back, use the original URL
+            url
+        }
+        Err(e) => {
+            // If we get an error, it might contain redirect information
+            let error_msg = format!("{:?}", e);
+            if let Some(redirect_start) =
+                error_msg.find("https://shared-profile-media.forgecdn.net/")
+            {
+                let redirect_end = error_msg[redirect_start..]
+                    .find(' ')
+                    .unwrap_or(error_msg.len() - redirect_start);
+                error_msg[redirect_start..redirect_start + redirect_end]
+                    .to_string()
+            } else {
+                return Err(crate::ErrorKind::InputError(format!(
+                    "Failed to fetch CurseForge profile metadata: {}",
+                    e
+                ))
+                .into());
+            }
+        }
+    };
+
+    // Now fetch the ZIP file and extract the name from manifest.json
+    let zip_bytes =
+        fetch(&download_url, None, &state.fetch_semaphore, &state.pool).await?;
+
+    // Create a cursor for the ZIP data
+    let cursor = std::io::Cursor::new(zip_bytes);
+    let mut zip_reader =
+        ZipFileReader::with_tokio(cursor).await.map_err(|e| {
+            crate::ErrorKind::InputError(format!(
+                "Failed to read profile ZIP: {}",
+                e
+            ))
+        })?;
+
+    // Find and extract manifest.json
+    let manifest_index = zip_reader
+        .file()
+        .entries()
+        .iter()
+        .position(|f| {
+            f.filename().as_str().unwrap_or_default() == "manifest.json"
+        })
+        .ok_or_else(|| {
+            crate::ErrorKind::InputError(
+                "No manifest.json found in profile".to_string(),
+            )
+        })?;
+
+    let mut manifest_content = String::new();
+    let mut reader = zip_reader
+        .reader_with_entry(manifest_index)
+        .await
+        .map_err(|e| {
+            crate::ErrorKind::InputError(format!(
+                "Failed to read manifest.json: {}",
+                e
+            ))
+        })?;
+
+    reader.read_to_string_checked(&mut manifest_content).await?;
+
+    // Parse the manifest to get the actual name
+    let manifest: CurseForgeManifest = serde_json::from_str(&manifest_content)?;
+
+    let profile_name = if manifest.name.is_empty() {
+        format!("CurseForge Profile {}", profile_code)
+    } else {
+        manifest.name.clone()
+    };
+
+    Ok(CurseForgeProfileMetadata {
+        name: profile_name,
+        download_url,
+    })
+}
+
+/// Import a CurseForge profile from profile code
+pub async fn import_curseforge_profile(
+    profile_code: &str,
+    profile_path: &str,
+) -> crate::Result<()> {
+    let state = State::get().await?;
+
+    // Initialize loading bar
+    let loading_bar = crate::event::emit::init_loading(
+        LoadingBarType::CurseForgeProfileDownload {
+            profile_name: profile_path.to_string(),
+        },
+        100.0,
+        "Importing CurseForge profile...",
+    )
+    .await?;
+
+    // First, fetch the profile metadata to get the download URL
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        10.0,
+        Some("Fetching profile metadata..."),
+    )?;
+    let metadata = fetch_curseforge_profile_metadata(profile_code).await?;
+
+    // Download the profile ZIP file
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        5.0,
+        Some("Downloading profile ZIP..."),
+    )?;
+    let zip_bytes = fetch(
+        &metadata.download_url,
+        None,
+        &state.fetch_semaphore,
+        &state.pool,
+    )
+    .await?;
+
+    // Create a cursor for the ZIP data
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        5.0,
+        Some("Extracting ZIP contents..."),
+    )?;
+    let cursor = Cursor::new(zip_bytes);
+    let mut zip_reader =
+        ZipFileReader::with_tokio(cursor).await.map_err(|e| {
+            crate::ErrorKind::InputError(format!(
+                "Failed to read profile ZIP: {}",
+                e
+            ))
+        })?;
+
+    // Find and extract manifest.json
+    let manifest_index = zip_reader
+        .file()
+        .entries()
+        .iter()
+        .position(|f| {
+            f.filename().as_str().unwrap_or_default() == "manifest.json"
+        })
+        .ok_or_else(|| {
+            crate::ErrorKind::InputError(
+                "No manifest.json found in profile".to_string(),
+            )
+        })?;
+
+    let mut manifest_content = String::new();
+    let mut reader = zip_reader
+        .reader_with_entry(manifest_index)
+        .await
+        .map_err(|e| {
+            crate::ErrorKind::InputError(format!(
+                "Failed to read manifest.json: {}",
+                e
+            ))
+        })?;
+
+    reader.read_to_string_checked(&mut manifest_content).await?;
+
+    // Parse the manifest
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        5.0,
+        Some("Parsing profile manifest..."),
+    )?;
+    let manifest: CurseForgeManifest = serde_json::from_str(&manifest_content)?;
+
+    // Determine modloader and version
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        5.0,
+        Some("Configuring profile..."),
+    )?;
+    let (mod_loader, loader_version) = if let Some(primary_loader) =
+        manifest.minecraft.mod_loaders.iter().find(|l| l.primary)
+    {
+        parse_modloader(&primary_loader.id)
+    } else if let Some(first_loader) = manifest.minecraft.mod_loaders.first() {
+        parse_modloader(&first_loader.id)
+    } else {
+        (ModLoader::Vanilla, None)
+    };
+
+    let game_version = manifest.minecraft.version.clone();
+
+    // Get appropriate loader version if needed
+    let final_loader_version = if mod_loader != ModLoader::Vanilla {
+        crate::launcher::get_loader_version_from_profile(
+            &game_version,
+            mod_loader,
+            loader_version.as_deref(),
+        )
+        .await?
+    } else {
+        None
+    };
+
+    // Set profile data
+    crate::api::profile::edit(profile_path, |prof| {
+        prof.name = if manifest.name.is_empty() {
+            format!("CurseForge Profile {}", profile_code)
+        } else {
+            manifest.name.clone()
+        };
+        prof.install_stage = ProfileInstallStage::PackInstalling;
+        prof.game_version = game_version.clone();
+        prof.loader_version = final_loader_version.clone().map(|x| x.id);
+        prof.loader = mod_loader;
+
+        // Set linked data for modpack management
+        prof.linked_data = Some(LinkedData {
+            project_id: String::new(),
+            version_id: String::new(),
+            locked: false,
+        });
+
+        async { Ok(()) }
+    })
+    .await?;
+
+    // Create a temporary directory to extract overrides
+    let temp_dir = state
+        .directories
+        .caches_dir()
+        .join(format!("curseforge_profile_{}", profile_code));
+    tokio::fs::create_dir_all(&temp_dir).await?;
+
+    // Extract overrides directory if it exists
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        10.0,
+        Some("Extracting profile files..."),
+    )?;
+    let overrides_dir = temp_dir.join(&manifest.overrides);
+    tokio::fs::create_dir_all(&overrides_dir).await?;
+
+    // Extract all files that are in the overrides directory
+    // First collect the entries we need to extract to avoid borrowing conflicts
+    let entries_to_extract: Vec<(usize, String)> = {
+        let zip_file = zip_reader.file();
+        zip_file
+            .entries()
+            .iter()
+            .enumerate()
+            .filter_map(|(index, entry)| {
+                let file_path = entry.filename().as_str().unwrap_or_default();
+                if file_path.starts_with(&format!("{}/", manifest.overrides)) {
+                    Some((index, file_path.to_string()))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    };
+
+    // Now extract each file
+    for (index, file_path) in entries_to_extract {
+        let relative_path = file_path
+            .strip_prefix(&format!("{}/", manifest.overrides))
+            .unwrap();
+        let output_path = overrides_dir.join(relative_path);
+
+        // Create parent directories
+        if let Some(parent) = output_path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        // Extract file
+        let mut reader =
+            zip_reader.reader_with_entry(index).await.map_err(|e| {
+                crate::ErrorKind::InputError(format!(
+                    "Failed to read file {}: {}",
+                    file_path, e
+                ))
+            })?;
+
+        let mut file_content = Vec::new();
+        reader.read_to_end_checked(&mut file_content).await?;
+
+        tokio::fs::write(&output_path, file_content).await?;
+    }
+
+    // Copy overrides to profile
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        5.0,
+        Some("Copying profile files..."),
+    )?;
+    let _loading_bar = copy_dotminecraft(
+        profile_path,
+        overrides_dir,
+        &state.io_semaphore,
+        None,
+    )
+    .await?;
+
+    // Download and install mods from CurseForge
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        10.0,
+        Some("Downloading mods..."),
+    )?;
+    install_curseforge_mods(
+        &manifest.files,
+        profile_path,
+        &state,
+        &loading_bar,
+    )
+    .await?;
+
+    // Clean up temporary directory
+    tokio::fs::remove_dir_all(&temp_dir).await.ok();
+
+    // Install Minecraft if needed
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        20.0,
+        Some("Installing Minecraft..."),
+    )?;
+    if let Some(profile_val) = crate::api::profile::get(profile_path).await? {
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(_loading_bar),
+            false,
+        )
+        .await?;
+    }
+
+    // Mark the profile as fully installed
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        20.0,
+        Some("Finalizing profile..."),
+    )?;
+    crate::api::profile::edit(profile_path, |prof| {
+        prof.install_stage = ProfileInstallStage::Installed;
+        async { Ok(()) }
+    })
+    .await?;
+
+    // Emit profile sync event to trigger file system watcher refresh
+    crate::event::emit::emit_profile(profile_path, ProfilePayloadType::Synced)
+        .await?;
+
+    // Complete the loading bar
+    crate::event::emit::emit_loading(
+        &loading_bar,
+        5.0,
+        Some("Import completed!"),
+    )?;
+
+    Ok(())
+}
+
+/// Parse CurseForge modloader ID into ModLoader and version
+fn parse_modloader(id: &str) -> (ModLoader, Option<String>) {
+    if id.starts_with("forge-") {
+        let version = id.strip_prefix("forge-").unwrap_or("").to_string();
+        (ModLoader::Forge, Some(version))
+    } else if id.starts_with("fabric-") {
+        let version = id.strip_prefix("fabric-").unwrap_or("").to_string();
+        (ModLoader::Fabric, Some(version))
+    } else if id.starts_with("quilt-") {
+        let version = id.strip_prefix("quilt-").unwrap_or("").to_string();
+        (ModLoader::Quilt, Some(version))
+    } else if id.starts_with("neoforge-") {
+        let version = id.strip_prefix("neoforge-").unwrap_or("").to_string();
+        (ModLoader::NeoForge, Some(version))
+    } else {
+        (ModLoader::Vanilla, None)
+    }
+}
+
+/// Install mods from CurseForge files list
+async fn install_curseforge_mods(
+    files: &[CurseForgeFile],
+    profile_path: &str,
+    state: &State,
+    loading_bar: &crate::event::LoadingBarId,
+) -> crate::Result<()> {
+    if files.is_empty() {
+        return Ok(());
+    }
+
+    let num_files = files.len();
+    tracing::info!("Installing {} CurseForge mods", num_files);
+
+    // Download mods sequentially to track progress properly
+    for (index, file) in files.iter().enumerate() {
+        // Update progress message with current mod
+        let progress_message =
+            format!("Downloading mod {} of {}", index + 1, num_files);
+        crate::event::emit::emit_loading(
+            loading_bar,
+            0.0, // Don't increment here, just update message
+            Some(&progress_message),
+        )?;
+
+        download_curseforge_mod(file, profile_path, state).await?;
+
+        // Emit progress for each downloaded mod (20% total for mods, divided by number of mods)
+        let mod_progress = 20.0 / num_files as f64;
+        crate::event::emit::emit_loading(
+            loading_bar,
+            mod_progress,
+            Some(&format!("Downloaded mod {} of {}", index + 1, num_files)),
+        )?;
+    }
+
+    Ok(())
+}
+
+/// Download a single mod from CurseForge
+async fn download_curseforge_mod(
+    file: &CurseForgeFile,
+    profile_path: &str,
+    _state: &State,
+) -> crate::Result<()> {
+    // Log the download attempt
+    tracing::info!(
+        "Downloading CurseForge mod: project_id={}, file_id={}",
+        file.project_id,
+        file.file_id
+    );
+
+    // Get profile path and create mods directory first
+    let profile_full_path =
+        crate::api::profile::get_full_path(profile_path).await?;
+    let mods_dir = profile_full_path.join("mods");
+    tokio::fs::create_dir_all(&mods_dir).await?;
+
+    // First, get the file metadata to get the correct filename
+    let metadata_url = format!(
+        "https://www.curseforge.com/api/v1/mods/{}/files/{}",
+        file.project_id, file.file_id
+    );
+
+    tracing::info!("Fetching metadata from: {}", metadata_url);
+
+    let client = reqwest::Client::new();
+    let metadata_response =
+        client.get(&metadata_url).send().await.map_err(|e| {
+            crate::ErrorKind::InputError(format!(
+                "Failed to fetch metadata for mod {}/{}: {}",
+                file.project_id, file.file_id, e
+            ))
+        })?;
+
+    if !metadata_response.status().is_success() {
+        return Err(crate::ErrorKind::InputError(format!(
+            "HTTP error fetching metadata for mod {}/{}: {}",
+            file.project_id,
+            file.file_id,
+            metadata_response.status()
+        ))
+        .into());
+    }
+
+    // Parse the metadata JSON to get the filename
+    let metadata_json: serde_json::Value =
+        metadata_response.json().await.map_err(|e| {
+            crate::ErrorKind::InputError(format!(
+                "Failed to parse metadata JSON for mod {}/{}: {}",
+                file.project_id, file.file_id, e
+            ))
+        })?;
+
+    let original_filename = metadata_json
+        .get("data")
+        .and_then(|data| data.get("fileName"))
+        .and_then(|name| name.as_str())
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| {
+            // Fallback to the old format if API response is unexpected
+            format!("mod_{}_{}.jar", file.project_id, file.file_id)
+        });
+
+    tracing::info!("Original filename: {}", original_filename);
+
+    // Now download the mod using the direct download URL
+    let download_url = format!(
+        "https://www.curseforge.com/api/v1/mods/{}/files/{}/download",
+        file.project_id, file.file_id
+    );
+
+    tracing::info!("Downloading from: {}", download_url);
+
+    let response = client.get(&download_url).send().await.map_err(|e| {
+        crate::ErrorKind::InputError(format!(
+            "Failed to download mod {}/{}: {}",
+            file.project_id, file.file_id, e
+        ))
+    })?;
+
+    if !response.status().is_success() {
+        return Err(crate::ErrorKind::InputError(format!(
+            "HTTP error downloading mod {}/{}: {}",
+            file.project_id,
+            file.file_id,
+            response.status()
+        ))
+        .into());
+    }
+
+    // Write the file with its original name
+    let final_path = mods_dir.join(&original_filename);
+    let bytes = response.bytes().await.map_err(|e| {
+        crate::ErrorKind::InputError(format!(
+            "Failed to read response bytes for mod {}/{}: {}",
+            file.project_id, file.file_id, e
+        ))
+    })?;
+
+    tokio::fs::write(&final_path, &bytes).await.map_err(|e| {
+        crate::ErrorKind::InputError(format!(
+            "Failed to write mod file {:?}: {}",
+            final_path, e
+        ))
+    })?;
+
+    tracing::info!(
+        "Successfully downloaded mod: {} ({} bytes)",
+        original_filename,
+        bytes.len()
+    );
+
+    Ok(())
+}

packages/app-lib/src/api/pack/import/mod.rs

@@ -19,6 +19,7 @@ use crate::{
 
 pub mod atlauncher;
 pub mod curseforge;
+pub mod curseforge_profile;
 pub mod gdlauncher;
 pub mod mmc;
 

packages/app-lib/src/config.rs

@@ -1,13 +0,0 @@
-//! Configuration structs
-
-// pub const MODRINTH_URL: &str = "https://staging.modrinth.com/";
-// pub const MODRINTH_API_URL: &str = "https://staging-api.modrinth.com/v2/";
-// pub const MODRINTH_API_URL_V3: &str = "https://staging-api.modrinth.com/v3/";
-
-pub const MODRINTH_URL: &str = "https://modrinth.com/";
-pub const MODRINTH_API_URL: &str = "https://api.modrinth.com/v2/";
-pub const MODRINTH_API_URL_V3: &str = "https://api.modrinth.com/v3/";
-
-pub const MODRINTH_SOCKET_URL: &str = "wss://api.modrinth.com/";
-
-pub const META_URL: &str = "https://launcher-meta.modrinth.com/";

packages/app-lib/src/event/mod.rs

@@ -176,6 +176,9 @@ pub enum LoadingBarType {
         import_location: PathBuf,
         profile_name: String,
     },
+    CurseForgeProfileDownload {
+        profile_name: String,
+    },
     CheckingForUpdates,
     LauncherUpdate {
         version: String,

packages/app-lib/src/launcher/mod.rs

@@ -6,7 +6,7 @@ use crate::launcher::download::download_log_config;
 use crate::launcher::io::IOError;
 use crate::profile::QuickPlayType;
 use crate::state::{
-    AccountType, Credentials, JavaVersion, ProcessMetadata, ProfileInstallStage
+    AccountType, Credentials, JavaVersion, ProcessMetadata, ProfileInstallStage,
 };
 use crate::util::{io, utils};
 use crate::{State, get_resource_file, process, state as st};
@@ -637,18 +637,27 @@ pub async fn launch_minecraft(
     if credentials.account_type == AccountType::Pirate.as_lowercase_str() {
         if version_jar == "1.16.4" || version_jar == "1.16.5" {
             let invalid_url = "https://invalid.invalid";
-            tracing::info!("[AR] • The launcher detected the launch of {} on the offline account. Applying multiplayer fixes.", version_jar);
+            tracing::info!(
+                "[AR] • The launcher detected the launch of {} on the offline account. Applying offline multiplayer fixes.",
+                version_jar
+            );
             command.arg("-Dminecraft.api.env=custom");
             command.arg(format!("-Dminecraft.api.auth.host={}", invalid_url));
-            command.arg(format!("-Dminecraft.api.account.host={}", invalid_url));
-            command.arg(format!("-Dminecraft.api.session.host={}", invalid_url));
-            command.arg(format!("-Dminecraft.api.services.host={}", invalid_url));
+            command
+                .arg(format!("-Dminecraft.api.account.host={}", invalid_url));
+            command
+                .arg(format!("-Dminecraft.api.session.host={}", invalid_url));
+            command
+                .arg(format!("-Dminecraft.api.services.host={}", invalid_url));
         }
-    } else if credentials.account_type == AccountType::ElyBy.as_lowercase_str() {
-        tracing::info!("[AR] • The launcher detected the launch of {} on the ElyBy account. Applying ElyBy Java Injector.", version_jar);
-        let path_buf = utils::get_or_download_ely_by_injector().await?;
+    } else if credentials.account_type == AccountType::ElyBy.as_lowercase_str()
+    {
+        tracing::info!(
+            "[AR] • The launcher detected the launch of {} on the Ely.by account. Applying Ely.by Java Injector.",
+            version_jar
+        );
+        let path_buf = utils::get_or_download_elyby_injector().await?;
         let path = path_buf.to_str().unwrap();
-        tracing::info!("[AR] • ElyBy Java Injector path: {}", path);
         command.arg(format!("-javaagent:{}=ely.by", path));
     }
 
@@ -751,10 +760,10 @@ pub async fn launch_minecraft(
 
     // [AR] Feature
     let selected_phrase = ACTIVE_STATE.choose(&mut rand::thread_rng()).unwrap();
-        let _ = state
-            .discord_rpc
-            .set_activity(&format!("{} {}", selected_phrase, profile.name), true)
-            .await;
+    let _ = state
+        .discord_rpc
+        .set_activity(&format!("{} {}", selected_phrase, profile.name), true)
+        .await;
 
     let _ = state
         .friends_socket

packages/app-lib/src/lib.rs

@@ -11,7 +11,6 @@ and launching Modrinth mod packs
 pub mod util; // [AR] Refactor
 
 mod api;
-mod config;
 mod error;
 mod event;
 mod launcher;

packages/app-lib/src/state/cache.rs

@@ -1,4 +1,3 @@
-use crate::config::{META_URL, MODRINTH_API_URL, MODRINTH_API_URL_V3};
 use crate::state::ProjectType;
 use crate::util::fetch::{FetchSemaphore, fetch_json, sha1_async};
 use chrono::{DateTime, Utc};
@@ -8,6 +7,7 @@ use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use sqlx::SqlitePool;
 use std::collections::HashMap;
+use std::env;
 use std::fmt::Display;
 use std::hash::Hash;
 use std::path::{Path, PathBuf};
@@ -945,7 +945,7 @@ impl CachedEntry {
             CacheValueType::Project => {
                 fetch_original_values!(
                     Project,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "projects",
                     CacheValue::Project
                 )
@@ -953,7 +953,7 @@ impl CachedEntry {
             CacheValueType::Version => {
                 fetch_original_values!(
                     Version,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "versions",
                     CacheValue::Version
                 )
@@ -961,7 +961,7 @@ impl CachedEntry {
             CacheValueType::User => {
                 fetch_original_values!(
                     User,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "users",
                     CacheValue::User
                 )
@@ -969,7 +969,7 @@ impl CachedEntry {
             CacheValueType::Team => {
                 let mut teams = fetch_many_batched::<Vec<TeamMember>>(
                     Method::GET,
-                    MODRINTH_API_URL_V3,
+                    env!("MODRINTH_API_URL_V3"),
                     "teams?ids=",
                     &keys,
                     fetch_semaphore,
@@ -1008,7 +1008,7 @@ impl CachedEntry {
             CacheValueType::Organization => {
                 let mut orgs = fetch_many_batched::<Organization>(
                     Method::GET,
-                    MODRINTH_API_URL_V3,
+                    env!("MODRINTH_API_URL_V3"),
                     "organizations?ids=",
                     &keys,
                     fetch_semaphore,
@@ -1063,7 +1063,7 @@ impl CachedEntry {
             CacheValueType::File => {
                 let mut versions = fetch_json::<HashMap<String, Version>>(
                     Method::POST,
-                    &format!("{MODRINTH_API_URL}version_files"),
+                    concat!(env!("MODRINTH_API_URL"), "version_files"),
                     None,
                     Some(serde_json::json!({
                         "algorithm": "sha1",
@@ -1119,7 +1119,11 @@ impl CachedEntry {
                     .map(|x| {
                         (
                             x.key().to_string(),
-                            format!("{META_URL}{}/v0/manifest.json", x.key()),
+                            format!(
+                                "{}{}/v0/manifest.json",
+                                env!("MODRINTH_LAUNCHER_META_URL"),
+                                x.key()
+                            ),
                         )
                     })
                     .collect::<Vec<_>>();
@@ -1154,7 +1158,7 @@ impl CachedEntry {
             CacheValueType::MinecraftManifest => {
                 fetch_original_value!(
                     MinecraftManifest,
-                    META_URL,
+                    env!("MODRINTH_LAUNCHER_META_URL"),
                     format!(
                         "minecraft/v{}/manifest.json",
                         daedalus::minecraft::CURRENT_FORMAT_VERSION
@@ -1165,7 +1169,7 @@ impl CachedEntry {
             CacheValueType::Categories => {
                 fetch_original_value!(
                     Categories,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "tag/category",
                     CacheValue::Categories
                 )
@@ -1173,7 +1177,7 @@ impl CachedEntry {
             CacheValueType::ReportTypes => {
                 fetch_original_value!(
                     ReportTypes,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "tag/report_type",
                     CacheValue::ReportTypes
                 )
@@ -1181,7 +1185,7 @@ impl CachedEntry {
             CacheValueType::Loaders => {
                 fetch_original_value!(
                     Loaders,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "tag/loader",
                     CacheValue::Loaders
                 )
@@ -1189,7 +1193,7 @@ impl CachedEntry {
             CacheValueType::GameVersions => {
                 fetch_original_value!(
                     GameVersions,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "tag/game_version",
                     CacheValue::GameVersions
                 )
@@ -1197,7 +1201,7 @@ impl CachedEntry {
             CacheValueType::DonationPlatforms => {
                 fetch_original_value!(
                     DonationPlatforms,
-                    MODRINTH_API_URL,
+                    env!("MODRINTH_API_URL"),
                     "tag/donation_platform",
                     CacheValue::DonationPlatforms
                 )
@@ -1297,14 +1301,12 @@ impl CachedEntry {
                     }
                 });
 
-                let version_update_url =
-                    format!("{MODRINTH_API_URL}version_files/update");
                 let variations =
                     futures::future::try_join_all(filtered_keys.iter().map(
                         |((loaders_key, game_version), hashes)| {
                             fetch_json::<HashMap<String, Version>>(
                                 Method::POST,
-                                &version_update_url,
+                                concat!(env!("MODRINTH_API_URL"), "version_files/update"),
                                 None,
                                 Some(serde_json::json!({
                                     "algorithm": "sha1",
@@ -1368,7 +1370,11 @@ impl CachedEntry {
                     .map(|x| {
                         (
                             x.key().to_string(),
-                            format!("{MODRINTH_API_URL}search{}", x.key()),
+                            format!(
+                                "{}search{}",
+                                env!("MODRINTH_API_URL"),
+                                x.key()
+                            ),
                         )
                     })
                     .collect::<Vec<_>>();

packages/app-lib/src/state/friends.rs

@@ -1,4 +1,3 @@
-use crate::config::{MODRINTH_API_URL_V3, MODRINTH_SOCKET_URL};
 use crate::data::ModrinthCredentials;
 use crate::event::FriendPayload;
 use crate::event::emit::emit_friend;
@@ -77,7 +76,8 @@ impl FriendsSocket {
 
         if let Some(credentials) = credentials {
             let mut request = format!(
-                "{MODRINTH_SOCKET_URL}_internal/launcher_socket?code={}",
+                "{}_internal/launcher_socket?code={}",
+                env!("MODRINTH_SOCKET_URL"),
                 credentials.session
             )
             .into_client_request()?;
@@ -303,7 +303,7 @@ impl FriendsSocket {
     ) -> crate::Result<Vec<UserFriend>> {
         fetch_json(
             Method::GET,
-            &format!("{MODRINTH_API_URL_V3}friends"),
+            concat!(env!("MODRINTH_API_URL_V3"), "friends"),
             None,
             None,
             semaphore,
@@ -328,7 +328,7 @@ impl FriendsSocket {
     ) -> crate::Result<()> {
         fetch_advanced(
             Method::POST,
-            &format!("{MODRINTH_API_URL_V3}friend/{user_id}"),
+            &format!("{}friend/{user_id}", env!("MODRINTH_API_URL_V3")),
             None,
             None,
             None,
@@ -349,7 +349,7 @@ impl FriendsSocket {
     ) -> crate::Result<()> {
         fetch_advanced(
             Method::DELETE,
-            &format!("{MODRINTH_API_URL_V3}friend/{user_id}"),
+            &format!("{}friend/{user_id}", env!("MODRINTH_API_URL_V3")),
             None,
             None,
             None,

packages/app-lib/src/state/minecraft_auth.rs

@@ -85,21 +85,18 @@ pub struct MinecraftLoginFlow {
     pub verifier: String,
     pub challenge: String,
     pub session_id: String,
-    pub redirect_uri: String,
+    pub auth_request_uri: String,
 }
 
 #[tracing::instrument]
 pub async fn login_begin(
     exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
 ) -> crate::Result<MinecraftLoginFlow> {
-    let (pair, current_date, valid_date) =
-        DeviceTokenPair::refresh_and_get_device_token(Utc::now(), false, exec)
-            .await?;
+    let (pair, current_date) =
+        DeviceTokenPair::refresh_and_get_device_token(Utc::now(), exec).await?;
 
     let verifier = generate_oauth_challenge();
-    let mut hasher = sha2::Sha256::new();
-    hasher.update(&verifier);
-    let result = hasher.finalize();
+    let result = sha2::Sha256::digest(&verifier);
     let challenge = BASE64_URL_SAFE_NO_PAD.encode(result);
 
     match sisu_authenticate(
@@ -110,46 +107,15 @@ pub async fn login_begin(
     )
     .await
     {
-        Ok((session_id, redirect_uri)) => Ok(MinecraftLoginFlow {
-            verifier,
-            challenge,
-            session_id,
-            redirect_uri: redirect_uri.value.msa_oauth_redirect,
-        }),
-        Err(err) => {
-            if !valid_date {
-                let (pair, current_date, _) =
-                    DeviceTokenPair::refresh_and_get_device_token(
-                        Utc::now(),
-                        false,
-                        exec,
-                    )
-                    .await?;
-
-                let verifier = generate_oauth_challenge();
-                let mut hasher = sha2::Sha256::new();
-                hasher.update(&verifier);
-                let result = hasher.finalize();
-                let challenge = BASE64_URL_SAFE_NO_PAD.encode(result);
-
-                let (session_id, redirect_uri) = sisu_authenticate(
-                    &pair.token.token,
-                    &challenge,
-                    &pair.key,
-                    current_date,
-                )
-                .await?;
-
-                Ok(MinecraftLoginFlow {
-                    verifier,
-                    challenge,
-                    session_id,
-                    redirect_uri: redirect_uri.value.msa_oauth_redirect,
-                })
-            } else {
-                Err(crate::ErrorKind::from(err).into())
-            }
+        Ok((session_id, redirect_uri)) => {
+            return Ok(MinecraftLoginFlow {
+                verifier,
+                challenge,
+                session_id,
+                auth_request_uri: redirect_uri.value.msa_oauth_redirect,
+            });
         }
+        Err(err) => return Err(crate::ErrorKind::from(err).into()),
     }
 }
 
@@ -159,9 +125,8 @@ pub async fn login_finish(
     flow: MinecraftLoginFlow,
     exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
 ) -> crate::Result<Credentials> {
-    let (pair, _, _) =
-        DeviceTokenPair::refresh_and_get_device_token(Utc::now(), false, exec)
-            .await?;
+    let (pair, _) =
+        DeviceTokenPair::refresh_and_get_device_token(Utc::now(), exec).await?;
 
     let oauth_token = oauth_token(code, &flow.verifier).await?;
     let sisu_authorize = sisu_authorize(
@@ -244,6 +209,34 @@ pub async fn offline_auth(
     Ok(credentials)
 }
 
+// [AR] Feature
+#[tracing::instrument]
+pub async fn elyby_auth(
+    uuid: Uuid,
+    username: &str,
+    access_token: &str,
+    exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
+) -> crate::Result<Credentials> {
+    let mut credentials = Credentials {
+        offline_profile: MinecraftProfile::default(),
+        access_token: access_token.to_string(),
+        refresh_token: "null".to_string(),
+        expires: Utc::now() + Duration::days(365 * 99),
+        active: true,
+        account_type: AccountType::ElyBy.as_lowercase_str(),
+    };
+
+    credentials.offline_profile = MinecraftProfile {
+        id: uuid,
+        name: username.to_string(),
+        ..credentials.offline_profile
+    };
+
+    credentials.upsert(exec).await?;
+
+    Ok(credentials)
+}
+
 /// [AR] • Feature
 #[derive(Deserialize, Debug)]
 pub enum AccountType {
@@ -323,10 +316,9 @@ impl Credentials {
         }
 
         let oauth_token = oauth_refresh(&self.refresh_token).await?;
-        let (pair, current_date, _) =
+        let (pair, current_date) =
             DeviceTokenPair::refresh_and_get_device_token(
                 oauth_token.date,
-                false,
                 exec,
             )
             .await?;
@@ -694,21 +686,20 @@ impl DeviceTokenPair {
     #[tracing::instrument(skip(exec))]
     async fn refresh_and_get_device_token(
         current_date: DateTime<Utc>,
-        force_generate: bool,
         exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite> + Copy,
-    ) -> crate::Result<(Self, DateTime<Utc>, bool)> {
+    ) -> crate::Result<(Self, DateTime<Utc>)> {
         let pair = Self::get(exec).await?;
 
         if let Some(mut pair) = pair {
-            if pair.token.not_after > Utc::now() && !force_generate {
-                Ok((pair, current_date, false))
+            if pair.token.not_after > current_date {
+                Ok((pair, current_date))
             } else {
                 let res = device_token(&pair.key, current_date).await?;
 
                 pair.token = res.value;
                 pair.upsert(exec).await?;
 
-                Ok((pair, res.date, true))
+                Ok((pair, res.date))
             }
         } else {
             let key = generate_key()?;
@@ -721,7 +712,7 @@ impl DeviceTokenPair {
 
             pair.upsert(exec).await?;
 
-            Ok((pair, res.date, true))
+            Ok((pair, res.date))
         }
     }
 
@@ -819,8 +810,8 @@ impl DeviceTokenPair {
 }
 
 const MICROSOFT_CLIENT_ID: &str = "00000000402b5328";
-const REDIRECT_URL: &str = "https://login.live.com/oauth20_desktop.srf";
-const REQUESTED_SCOPES: &str = "service::user.auth.xboxlive.com::MBI_SSL";
+const AUTH_REPLY_URL: &str = "https://login.live.com/oauth20_desktop.srf";
+const REQUESTED_SCOPE: &str = "service::user.auth.xboxlive.com::MBI_SSL";
 
 /* [AR] Fix
  * Weird visibility issue that didn't reproduce before
@@ -903,7 +894,7 @@ async fn sisu_authenticate(
           "AppId": MICROSOFT_CLIENT_ID,
           "DeviceToken": token,
           "Offers": [
-            REQUESTED_SCOPES
+            REQUESTED_SCOPE
           ],
           "Query": {
             "code_challenge": challenge,
@@ -911,7 +902,7 @@ async fn sisu_authenticate(
             "state": generate_oauth_challenge(),
             "prompt": "select_account"
           },
-          "RedirectUri": REDIRECT_URL,
+          "RedirectUri": AUTH_REPLY_URL,
           "Sandbox": "RETAIL",
           "TokenType": "code",
           "TitleId": "1794566092",
@@ -955,12 +946,12 @@ async fn oauth_token(
     verifier: &str,
 ) -> Result<RequestWithDate<OAuthToken>, MinecraftAuthenticationError> {
     let mut query = HashMap::new();
-    query.insert("client_id", "00000000402b5328");
+    query.insert("client_id", MICROSOFT_CLIENT_ID);
     query.insert("code", code);
     query.insert("code_verifier", verifier);
     query.insert("grant_type", "authorization_code");
-    query.insert("redirect_uri", "https://login.live.com/oauth20_desktop.srf");
-    query.insert("scope", "service::user.auth.xboxlive.com::MBI_SSL");
+    query.insert("redirect_uri", AUTH_REPLY_URL);
+    query.insert("scope", REQUESTED_SCOPE);
 
     let res = auth_retry(|| {
         REQWEST_CLIENT
@@ -1004,11 +995,11 @@ async fn oauth_refresh(
     refresh_token: &str,
 ) -> Result<RequestWithDate<OAuthToken>, MinecraftAuthenticationError> {
     let mut query = HashMap::new();
-    query.insert("client_id", "00000000402b5328");
+    query.insert("client_id", MICROSOFT_CLIENT_ID);
     query.insert("refresh_token", refresh_token);
     query.insert("grant_type", "refresh_token");
-    query.insert("redirect_uri", "https://login.live.com/oauth20_desktop.srf");
-    query.insert("scope", "service::user.auth.xboxlive.com::MBI_SSL");
+    query.insert("redirect_uri", AUTH_REPLY_URL);
+    query.insert("scope", REQUESTED_SCOPE);
 
     let res = auth_retry(|| {
         REQWEST_CLIENT
@@ -1072,7 +1063,7 @@ async fn sisu_authorize(
         "/authorize",
         json!({
             "AccessToken": format!("t={access_token}"),
-            "AppId": "00000000402b5328",
+            "AppId": MICROSOFT_CLIENT_ID,
             "DeviceToken": device_token,
             "ProofKey": {
                 "kty": "EC",

packages/app-lib/src/state/mr_auth.rs

@@ -1,4 +1,3 @@
-use crate::config::{MODRINTH_API_URL, MODRINTH_URL};
 use crate::state::{CacheBehaviour, CachedEntry};
 use crate::util::fetch::{FetchSemaphore, fetch_advanced};
 use chrono::{DateTime, Duration, TimeZone, Utc};
@@ -31,7 +30,7 @@ impl ModrinthCredentials {
 
                 let resp = fetch_advanced(
                     Method::POST,
-                    &format!("{MODRINTH_API_URL}session/refresh"),
+                    concat!(env!("MODRINTH_API_URL"), "session/refresh"),
                     None,
                     None,
                     Some(("Authorization", &*creds.session)),
@@ -190,8 +189,8 @@ impl ModrinthCredentials {
     }
 }
 
-pub fn get_login_url() -> String {
-    format!("{MODRINTH_URL}auth/sign-in?launcher=true")
+pub const fn get_login_url() -> &'static str {
+    concat!(env!("MODRINTH_URL"), "auth/sign-in")
 }
 
 pub async fn finish_login_flow(
@@ -199,6 +198,12 @@ pub async fn finish_login_flow(
     semaphore: &FetchSemaphore,
     exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
 ) -> crate::Result<ModrinthCredentials> {
+    // The authorization code actually is the access token, since Labrinth doesn't
+    // issue separate authorization codes. Therefore, this is equivalent to an
+    // implicit OAuth grant flow, and no additional exchanging or finalization is
+    // needed. TODO not do this for the reasons outlined at
+    // https://oauth.net/2/grant-types/implicit/
+
     let info = fetch_info(code, semaphore, exec).await?;
 
     Ok(ModrinthCredentials {
@@ -216,7 +221,7 @@ async fn fetch_info(
 ) -> crate::Result<crate::state::cache::User> {
     let result = fetch_advanced(
         Method::GET,
-        &format!("{MODRINTH_API_URL}user"),
+        concat!(env!("MODRINTH_API_URL"), "user"),
         None,
         None,
         Some(("Authorization", token)),

packages/app-lib/src/util/fetch.rs

@@ -1,6 +1,5 @@
 //! Functions for fetching information from the Internet
 use super::io::{self, IOError};
-use crate::config::{MODRINTH_API_URL, MODRINTH_API_URL_V3};
 use crate::event::LoadingBarId;
 use crate::event::emit::emit_loading;
 use bytes::Bytes;
@@ -84,8 +83,8 @@ pub async fn fetch_advanced(
         .as_ref()
         .is_none_or(|x| &*x.0.to_lowercase() != "authorization")
         && (url.starts_with("https://cdn.modrinth.com")
-            || url.starts_with(MODRINTH_API_URL)
-            || url.starts_with(MODRINTH_API_URL_V3))
+            || url.starts_with(env!("MODRINTH_API_URL"))
+            || url.starts_with(env!("MODRINTH_API_URL_V3")))
     {
         crate::state::ModrinthCredentials::get_active(exec).await?
     } else {

packages/app-lib/src/util/utils.rs

@@ -2,11 +2,14 @@ use crate::api::update;
 use crate::state::db;
 ///
 /// [AR] Feature Utils
+/// 
+/// Version: 0.1.1
 ///
 use crate::{Result, State};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::process;
+use std::time::SystemTime;
 use tokio::{fs, io};
 
 const PACKAGE_JSON_CONTENT: &str =
@@ -47,30 +50,105 @@ pub fn read_package_json() -> io::Result<Launcher> {
     Ok(launcher)
 }
 
-/// ### AR • Ely By Injector
-/// Returns the path to the ely by injector
-/// If resource doesn't exist, it will be downloaded.
-pub async fn get_or_download_ely_by_injector() -> Result<PathBuf> {
-    tracing::info!("[AR] • Attempting to get or download AuthLib Injector");
-    let state= State::get().await?;
+/// ### AR • Ely.by Injector
+/// Returns the PathBuf to the Ely.by AuthLib Injector
+/// If resource doesn't exist or outdated, it will be downloaded from Git Astralium.
+pub async fn get_or_download_elyby_injector() -> Result<PathBuf> {
+    tracing::info!("[AR] • Initializing state for Ely.by AuthLib Injector...");
+    let state = State::get().await?;
     let libraries_dir = state.directories.libraries_dir();
 
-    ensure_astralrinth_library_dir_exists(&libraries_dir).await?;
+    // Stores the local authlib injectors from `libraries/astralrinth/authlib_injectors/` directory.
+    let mut local_authlib_injectors = Vec::new();
 
-    let (asset_name, download_url) = extract_ely_authlib_metadata("authlib-injector").await?;
-    let ely_by_injector = state.directories.libraries_dir().join(format!("astralrinth/{}", asset_name));
-    let path_in_libs = format!("astralrinth/{}", asset_name);
-    tracing::info!("[AR] • Path in libs: {}", path_in_libs);
+    validate_astralrinth_library_dir(&libraries_dir, "authlib_injector/").await?;
+    let astralrinth_dir = libraries_dir.join("astralrinth/");
+    let authlib_injector_dir = astralrinth_dir.join("authlib_injector/");
+    let mut authlib_injector_dir_data = fs::read_dir(&authlib_injector_dir).await?;
 
-    if !ely_by_injector.exists() {
-        tracing::info!("[AR] • Doesn't exist, attempting to download AuthLib Injector from URL: {}", download_url);
-        let bytes = fetch_bytes_from_url(download_url.as_str()).await?;
-        write_file_to_libraries(&path_in_libs, &bytes).await?;
+    // Get all local authlib injectors
+    while let Some(entry) = authlib_injector_dir_data.next_entry().await? {
+        let path = entry.path();
+        if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+            if file_name.starts_with("authlib-injector") {
+                let metadata = entry.metadata().await?;
+                let modified = metadata.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+                local_authlib_injectors.push((path.clone(), modified));
+            }
+        }
+    }
+
+    // Get information about latest authlib injector from remote repository
+    let (asset_name, download_url) = match extract_elyby_authlib_metadata("authlib-injector").await {
+        Ok(data) => data,
+        Err(err) => {
+            if let Some((local_path, _)) = local_authlib_injectors
+                .iter()
+                .max_by(|a, b| a.1.cmp(&b.1)) 
+            {
+                tracing::info!("[AR] • Found local AuthLib Injector(s):");
+                for (path, time) in &local_authlib_injectors {
+                    tracing::info!("• {:?} (modified: {:?})", path.file_name().unwrap(), time);
+                }
+                tracing::warn!("[AR] • Failed to get latest AuthLib Injector from remote, using latest local version: {}", local_path.display());
+                return Ok(local_path.clone());
+            } else {
+                tracing::error!("[AR] • Failed to get AuthLib Injector from remote and no local copy found.");
+                return Err(crate::ErrorKind::NetworkErrorOccurred { error: format!("Failed to fetch authlib-injector metadata and no local version available: {}", err) }.as_error());
+            }
+        }
+    };
+
+    if !local_authlib_injectors.is_empty() {
+        local_authlib_injectors.sort_by(|a, b| a.1.cmp(&b.1));
+        tracing::info!("[AR] • Found local AuthLib Injector(s):");
+        for (path, time) in &local_authlib_injectors {
+            tracing::info!("• {:?} (modified: {:?})", path.file_name().unwrap(), time);
+        }
+    }
+
+    let remote_authlib_injector = if !asset_name.is_empty() {
+        authlib_injector_dir.join(&asset_name)
+    } else {
+        return Err(crate::ErrorKind::ParseError { reason: "Asset name is empty from metadata".to_string() }.as_error());
+    };
+
+    let latest_local_authlib_injector = local_authlib_injectors
+        .first()
+        .map(|(p, _)| p.clone());
+
+    let latest_local_authlib_injector_full_path_buf = match latest_local_authlib_injector {
+        Some(path) => path,
+        None => {
+            tracing::info!("[AR] • No local version found, will download from remote: {}", remote_authlib_injector.display());
+            let bytes = fetch_bytes_from_url(download_url.as_str()).await?;
+            write_file_to_libraries(&remote_authlib_injector.to_string_lossy(), &bytes).await?;
+            tracing::info!("[AR] • Successfully saved AuthLib Injector to {}", remote_authlib_injector.display());
+            return Ok(remote_authlib_injector);
+        }
+    };
+
+    tracing::info!("[AR] • Remote Asset name: {}", asset_name);
+    tracing::info!("[AR] • Remote Download URL: {}", download_url);
+    tracing::info!("[AR] • Latest local AuthLib Injector: {}", latest_local_authlib_injector_full_path_buf.file_name().unwrap().to_string_lossy());
+    tracing::info!("[AR] • Comparing local version {} with parsed remote version {}", latest_local_authlib_injector_full_path_buf.display(), remote_authlib_injector.display());
+
+    if remote_authlib_injector == latest_local_authlib_injector_full_path_buf {
+        tracing::info!("[AR] • Remote version is the same as local version, using local copy.");
+        return Ok(latest_local_authlib_injector_full_path_buf);
+    } else {
+        tracing::info!(
+            "[AR] • Doesn't exist or outdated, attempting to download latest AuthLib Injector from URL: {}",
+            download_url
+        );
+        let bytes = fetch_bytes_from_url(download_url.as_str()).await?;
+        write_file_to_libraries(&remote_authlib_injector.to_string_lossy(), &bytes).await?;
+        tracing::info!("[AR] • Successfully saved AuthLib Injector to {}", remote_authlib_injector.display());
+        return Ok(remote_authlib_injector);
     }
-    Ok(ely_by_injector)
 }
 
-/// ### AR • Migration
+/// ### AR • Migration. Patch
 /// Applying migration fix for SQLite database.
 pub async fn apply_migration_fix(eol: &str) -> Result<bool> {
     tracing::info!("[AR] • Attempting to apply migration fix");
@@ -83,7 +161,7 @@ pub async fn apply_migration_fix(eol: &str) -> Result<bool> {
     Ok(patched)
 }
 
-/// ### AR • Updater
+/// ### AR • Feature. Updater
 /// Initialize the update launcher.
 pub async fn init_update_launcher(
     download_url: &str,
@@ -115,7 +193,7 @@ pub async fn init_update_launcher(
     Ok(())
 }
 
-/// ### AR • AuthLib (Ely By)
+/// ### AR • AuthLib (Ely.by)
 /// Initializes the AuthLib patching process.
 ///
 /// Returns `true` if the authlib patched successfully.
@@ -123,13 +201,18 @@ pub async fn init_authlib_patching(
     minecraft_version: &str,
     is_mojang: bool,
 ) -> Result<bool> {
-    let minecraft_library_metadata = get_minecraft_library_metadata(minecraft_version).await?;
+    let minecraft_library_metadata =
+        get_minecraft_library_metadata(minecraft_version).await?;
     // Parses the AuthLib version from string
     // Example output: "com.mojang:authlib:6.0.58" -> "6.0.58"
-    let authlib_version = minecraft_library_metadata.name.split(':').nth(2).unwrap_or("unknown");
+    let authlib_version = minecraft_library_metadata
+        .name
+        .split(':')
+        .nth(2)
+        .unwrap_or("unknown");
     let authlib_fullname_string = format!("authlib-{}.jar", authlib_version);
     let authlib_fullname_str = authlib_fullname_string.as_str();
-    
+
     tracing::info!(
         "[AR] • Attempting to download AuthLib -> {}.",
         authlib_fullname_string
@@ -144,18 +227,35 @@ pub async fn init_authlib_patching(
     .await
 }
 
-/// Ensures the `astralrinth/` directory exists inside the libraries directory.
-async fn ensure_astralrinth_library_dir_exists(libraries_dir: &PathBuf) -> Result<()> {
-    let astralrinth_path = libraries_dir.join("astralrinth");
+/// ### AR • Universal Write (IO) Function.
+/// Validating the `astralrinth/{target_directory}/` directory exists inside the libraries/astralrinth directory.
+async fn validate_astralrinth_library_dir(
+    libraries_dir: &PathBuf,
+    validation_directory: &str
+) -> Result<()> {
+    let astralrinth_path = libraries_dir.join(format!("astralrinth/{}", validation_directory));
     if !astralrinth_path.exists() {
-        tokio::fs::create_dir_all(&astralrinth_path).await.map_err(|e| {
-            tracing::error!("[AR] • Failed to create {} directory: {:?}", astralrinth_path.display(), e);
-            crate::ErrorKind::IOErrorOccurred {
-                error: format!("Failed to create {} directory: {}", astralrinth_path.display(), e),
-            }
-            .as_error()
-        })?;
-        tracing::info!("[AR] • Created missing {} directory", astralrinth_path.display());
+        tokio::fs::create_dir_all(&astralrinth_path)
+            .await
+            .map_err(|e| {
+                tracing::error!(
+                    "[AR] • Failed to create {} directory: {:?}",
+                    astralrinth_path.display(),
+                    e
+                );
+                crate::ErrorKind::IOErrorOccurred {
+                    error: format!(
+                        "Failed to create {} directory: {}",
+                        astralrinth_path.display(),
+                        e
+                    ),
+                }
+                .as_error()
+            })?;
+        tracing::info!(
+            "[AR] • Created missing {} directory",
+            astralrinth_path.display()
+        );
     }
     Ok(())
 }
@@ -178,7 +278,7 @@ async fn write_file_to_libraries(
     })
 }
 
-/// ### AR • AuthLib (Ely By)
+/// ### AR • AuthLib (Ely.by)
 /// Downloads the AuthLib file from Mojang libraries or Git Astralium services.
 async fn download_authlib(
     minecraft_library_metadata: &Library,
@@ -187,14 +287,17 @@ async fn download_authlib(
     is_mojang: bool,
 ) -> Result<bool> {
     let state = State::get().await?;
-    let (mut url, path) = extract_minecraft_local_download_info(minecraft_library_metadata, minecraft_version)?;
+    let (mut url, path) = extract_minecraft_local_download_info(
+        minecraft_library_metadata,
+        minecraft_version,
+    )?;
     let full_path = state.directories.libraries_dir().join(path);
 
     if !is_mojang {
         tracing::info!(
             "[AR] • Attempting to download AuthLib from Git Astralium"
         );
-        (_, url) = extract_ely_authlib_metadata(authlib_fullname).await?;
+        (_, url) = extract_elyby_authlib_metadata(authlib_fullname).await?;
     }
     tracing::info!("[AR] • Downloading AuthLib from URL: {}", url);
     let bytes = fetch_bytes_from_url(&url).await?;
@@ -204,9 +307,11 @@ async fn download_authlib(
     Ok(true)
 }
 
-/// ### AR • AuthLib (Ely By)
+/// ### AR • AuthLib (Ely.by)
 /// Parses the ElyIntegration release JSON and returns the download URL for the given AuthLib version.
-async fn extract_ely_authlib_metadata(authlib_fullname: &str) -> Result<(String, String)> {
+async fn extract_elyby_authlib_metadata(
+    authlib_fullname: &str,
+) -> Result<(String, String)> {
     const URL: &str = "https://git.astralium.su/api/v1/repos/didirus/ElyIntegration/releases/latest";
 
     let response = reqwest::get(URL).await.map_err(|e| {
@@ -215,7 +320,10 @@ async fn extract_ely_authlib_metadata(authlib_fullname: &str) -> Result<(String,
             e
         );
         crate::ErrorKind::NetworkErrorOccurred {
-            error: format!("Failed to fetch ElyIntegration release JSON: {}", e),
+            error: format!(
+                "Failed to fetch ElyIntegration release JSON: {}",
+                e
+            ),
         }
         .as_error()
     })?;
@@ -228,15 +336,15 @@ async fn extract_ely_authlib_metadata(authlib_fullname: &str) -> Result<(String,
         .as_error()
     })?;
 
-    let assets = json
-        .get("assets")
-        .and_then(|v| v.as_array())
-        .ok_or_else(|| {
-            crate::ErrorKind::ParseError {
-                reason: "Missing 'assets' array".into(),
-            }
-            .as_error()
-        })?;
+    let assets =
+        json.get("assets")
+            .and_then(|v| v.as_array())
+            .ok_or_else(|| {
+                crate::ErrorKind::ParseError {
+                    reason: "Missing 'assets' array".into(),
+                }
+                .as_error()
+            })?;
 
     let asset = assets
         .iter()
@@ -281,7 +389,7 @@ async fn extract_ely_authlib_metadata(authlib_fullname: &str) -> Result<(String,
     Ok((asset_name, download_url))
 }
 
-/// ### AR • AuthLib (Ely By)
+/// ### AR • AuthLib (Ely.by)
 /// Extracts the artifact URL and Path from the library structure.
 ///
 /// Returns a tuple of references to the URL and path strings,
@@ -331,9 +439,15 @@ async fn fetch_bytes_from_url(url: &str) -> Result<bytes::Bytes> {
     )
     .await
     .map_err(|_| {
-        tracing::error!("[AR] • Download timed out after {} seconds", TIMEOUT_SECONDS);
+        tracing::error!(
+            "[AR] • Download timed out after {} seconds",
+            TIMEOUT_SECONDS
+        );
         crate::ErrorKind::NetworkErrorOccurred {
-            error: format!("Download timed out after {TIMEOUT_SECONDS} seconds").to_string(),
+            error: format!(
+                "Download timed out after {TIMEOUT_SECONDS} seconds"
+            )
+            .to_string(),
         }
         .as_error()
     })?
@@ -363,9 +477,11 @@ async fn fetch_bytes_from_url(url: &str) -> Result<bytes::Bytes> {
     })
 }
 
-/// ### AR • AuthLib (Ely By)
+/// ### AR • AuthLib (Ely.by)
 /// Gets the Minecraft library metadata from the local libraries directory.
-async fn get_minecraft_library_metadata(minecraft_version: &str) -> Result<Library> {
+async fn get_minecraft_library_metadata(
+    minecraft_version: &str,
+) -> Result<Library> {
     let state = State::get().await?;
 
     let path = state
@@ -416,4 +532,4 @@ async fn get_minecraft_library_metadata(minecraft_version: &str) -> Result<Libra
         minecraft_version: minecraft_version.to_string(),
     }
     .as_error())
-}
+}

packages/moderation/README.md

@@ -1,8 +1,6 @@
-<!-- TODO: After checklist v1.5, move everything into src directory. -->
-
 # @modrinth/moderation
 
-This package contains both the moderation checklist system used by moderators for reviewing projects on Modrinth, and the publishing checklist (nag system) that provides automated feedback to project authors during the submission process.
+This package contains the moderation checklist system used for reviewing projects on Modrinth. It provides a structured and transparent way to define moderation stages, actions, and messages that are displayed to moderators during the review process.
 
 ## Structure
 
@@ -11,31 +9,22 @@ The package is organized as follows:
 ```
 /packages/moderation/
 ├── data/
-│   ├── checklist.ts        # Main moderation checklist definition - imports and exports all stages
-│   ├── messages/           # Markdown files containing message templates for moderation
+│   ├── checklist.ts        # Main checklist definition - imports and exports all stages
+│   ├── messages/           # Markdown files containing message templates
 │   │   ├── title/          # Messages for the title stage
 │   │   ├── description/    # Messages for the description stage
 │   │   └── ...             # One directory per stage
-│   ├── stages/             # Moderation stage definition files
-│   │   ├── title.ts        # Title stage definition
-│   │   ├── description.ts  # Description stage definition
-│   │   └── ...             # One file per stage
-│   └── nags/               # Publishing checklist (nag system) files
-│       ├── core.ts         # Core nags (required fields, basic validation)
-│       ├── core.i18n.ts    # Internationalization messages for core nags
-│       └── ...
+│   └── stages/             # Stage definition files
+│       ├── title.ts        # Title stage definition
+│       ├── description.ts  # Description stage definition
+│       └── ...             # One file per stage
 └── types/                  # Type definitions
-    ├── actions.ts          # Action-related types (moderation)
-    ├── messages.ts         # Message-related types (moderation)
-    ├── stage.ts            # Stage-related types (moderation)
-    └── nags.ts             # Nag-related types (publishing checklist)
+    ├── actions.ts          # Action-related types
+    ├── messages.ts         # Message-related types
+    └── stage.ts            # Stage-related types
 ```
 
-## Moderation Checklist System
-
-The moderation checklist provides a structured and transparent way to define moderation stages, actions, and messages that are displayed to moderators during the review process.
-
-### Stages
+## Stages
 
 A stage represents a discrete step in the moderation process, like checking a project's title, description, or links. Each stage has:
 
@@ -46,7 +35,7 @@ A stage represents a discrete step in the moderation process, like checking a pr
 
 Stages are defined in individual files in the `data/stages` directory and are assembled into the complete checklist in `data/checklist.ts`.
 
-### Actions
+## Actions
 
 Actions represent decisions moderators can make for each stage. They can be buttons, dropdowns, toggles, etc. Actions can have:
 
@@ -58,11 +47,11 @@ Actions represent decisions moderators can make for each stage. They can be butt
 
 Each action requires a unique `id` field that is used for conditional logic and action relationships. The `suggestedStatus` and `severity` fields help determine the overall moderation outcome.
 
-### Messages
+## Messages
 
 Messages are the actual text that will be included in communications to project authors. To promote maintainability and reuse, messages are stored as Markdown files in the `data/messages` directory, organized by stage.
 
-#### Variable replacement
+### Variable replacement
 
 You can use variables in your messages that will be replaced with user input:
 
@@ -92,11 +81,11 @@ More text after the variable.
 
 The `%MESSAGE%` placeholder will be replaced with the text entered by the moderator.
 
-### Conditional logic
+## Conditional logic
 
 The moderation system supports conditional behavior that changes based on the selection of other actions.
 
-#### Conditional messages
+### Conditional messages
 
 You can define different messages for an action based on other selected actions:
 
@@ -119,7 +108,7 @@ You can define different messages for an action based on other selected actions:
 }
 ```
 
-#### Enabling and disabling actions
+### Enabling and disabling actions
 
 Actions can enable or disable other actions when selected:
 
@@ -142,7 +131,7 @@ Actions can enable or disable other actions when selected:
 }
 ```
 
-#### Conditional text inputs
+### Conditional text inputs
 
 Text inputs can be conditionally shown based on selected actions:
 
@@ -158,101 +147,3 @@ relevantExtraInput: [
   },
 ]
 ```
-
-## Publishing Checklist (Nag System)
-
-The nag system provides automated feedback to project authors during the submission process, helping them improve their projects before they reach moderation. It analyzes project data and provides suggestions, warnings, and requirements.
-
-### Nags
-
-A nag represents a specific issue or suggestion for improvement. Each nag has:
-
-- A unique `id` for identification
-- A `title` and `description` displayed to the user
-- A `status` indicating severity: `'required'`, `'warning'`, or `'suggestion'`
-- A `shouldShow` function that determines when the nag should be displayed
-- An optional `link` to help users address the issue
-
-### Internationalization
-
-Each nag category has a corresponding `.i18n.ts` file containing message definitions:
-
-```typescript
-// Example from core.i18n.ts
-export default defineMessages({
-  addDescriptionTitle: {
-    id: 'nags.add-description.title',
-    defaultMessage: 'Add a description',
-  },
-  addDescriptionDescription: {
-    id: 'nags.add-description.description',
-    defaultMessage:
-      "A description that clearly describes the project's purpose and function is required.",
-  },
-})
-```
-
-If you want to use context in the messages, you can do so like this:
-
-```typescript
-description: (context: NagContext) => {
-  const { formatMessage } = useVIntl()
-
-  return formatMessage(messages.descriptionTooShortDescription, {
-    length: context.project.body?.length || 0,
-    minChars: MIN_DESCRIPTION_CHARS,
-  })
-}
-```
-
-### Nag Context
-
-The `NagContext` type provides access to:
-
-- `project`: Current project data
-- `versions`: Project versions
-- `tags`: Frontend "tags" (generated state)
-- `currentRoute`: Current page route
-- and other data...
-
-### Adding New Nags
-
-To add a new nag:
-
-1. Add the nag definition to the appropriate category file (or make a new category file and add it to `data/nags.ts`)
-2. Add corresponding i18n messages to the `.i18n.ts` file
-3. Implement the `shouldShow` logic based on project state
-4. Add appropriate links to help users resolve the issue
-5. Run `pnpm run fix` to fix lint issues & generate the root locale index.json file.
-
-Example:
-
-```typescript
-// In description.ts
-{
-  id: 'new-nag',
-  title: messages.newNagTitle,
-  description: messages.newNagDescription,
-  status: 'warning',
-  shouldShow: (context: NagContext) => {
-    // Your validation logic here
-    return someCondition
-  },
-  link: {
-    path: 'settings/description',
-    title: messages.editDescriptionTitle,
-    shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-description',
-  },
-}
-```
-
-```typescript
-// In description.i18n.ts
-newNagTitle: {
-  id: 'nags.new-nag.title',
-  defaultMessage: 'New Nag Title',
-},
-newNagDescription: {
-  id: 'nags.new-nag.description',
-  defaultMessage: 'Description of the new nag issue.',
-```

packages/moderation/data/nags.ts

@@ -1,7 +0,0 @@
-import type { Nag } from '../types/nags'
-import { coreNags } from './nags/core'
-import { descriptionNags } from './nags/description'
-import { linksNags } from './nags/links'
-import { tagsNags } from './nags/tags'
-
-export default [...coreNags, ...linksNags, ...descriptionNags, ...tagsNags] as Nag[]

packages/moderation/data/nags/core.i18n.ts

@@ -1,116 +0,0 @@
-import { defineMessages } from '@vintl/vintl'
-
-export default defineMessages({
-  moderatorFeedbackTitle: {
-    id: 'nags.moderator-feedback.title',
-    defaultMessage: 'Review moderator feedback',
-  },
-  moderatorFeedbackDescription: {
-    id: 'nags.moderator-feedback.description',
-    defaultMessage:
-      'Review any feedback from moderators regarding your project before resubmitting.',
-  },
-  moderationTitle: {
-    id: 'nags.moderation.title',
-    defaultMessage: 'Visit moderation thread',
-  },
-  uploadVersionTitle: {
-    id: 'nags.upload-version.title',
-    defaultMessage: 'Upload a version',
-  },
-  uploadVersionDescription: {
-    id: 'nags.upload-version.description',
-    defaultMessage: 'At least one version is required for a project to be submitted for review.',
-  },
-  versionsTitle: {
-    id: 'nags.versions.title',
-    defaultMessage: 'Visit versions page',
-  },
-  addDescriptionTitle: {
-    id: 'nags.add-description.title',
-    defaultMessage: 'Add a description',
-  },
-  addDescriptionDescription: {
-    id: 'nags.add-description.description',
-    defaultMessage:
-      "A description that clearly describes the project's purpose and function is required.",
-  },
-  settingsDescriptionTitle: {
-    id: 'nags.settings.description.title',
-    defaultMessage: 'Visit description settings',
-  },
-  addIconTitle: {
-    id: 'nags.add-icon.title',
-    defaultMessage: 'Add an icon',
-  },
-  addIconDescription: {
-    id: 'nags.add-icon.description',
-    defaultMessage:
-      'Your project should have a nice-looking icon to uniquely identify your project at a glance.',
-  },
-  settingsTitle: {
-    id: 'nags.settings.title',
-    defaultMessage: 'Visit general settings',
-  },
-  featureGalleryImageTitle: {
-    id: 'nags.feature-gallery-image.title',
-    defaultMessage: 'Feature a gallery image',
-  },
-  featureGalleryImageDescription: {
-    id: 'nags.feature-gallery-image.description',
-    defaultMessage: 'Featured gallery images may be the first impression of many users.',
-  },
-  galleryTitle: {
-    id: 'nags.gallery.title',
-    defaultMessage: 'Visit gallery page',
-  },
-  selectTagsTitle: {
-    id: 'nags.select-tags.title',
-    defaultMessage: 'Select tags',
-  },
-  selectTagsDescription: {
-    id: 'nags.select-tags.description',
-    defaultMessage: 'Select all tags that apply to your project.',
-  },
-  settingsTagsTitle: {
-    id: 'nags.settings.tags.title',
-    defaultMessage: 'Visit tag settings',
-  },
-  addLinksTitle: {
-    id: 'nags.add-links.title',
-    defaultMessage: 'Add external links',
-  },
-  addLinksDescription: {
-    id: 'nags.add-links.description',
-    defaultMessage:
-      'Add any relevant links targeted outside of Modrinth, such as sources, issues, or a Discord invite.',
-  },
-  settingsLinksTitle: {
-    id: 'nags.settings.links.title',
-    defaultMessage: 'Visit links settings',
-  },
-  selectEnvironmentsTitle: {
-    id: 'nags.select-environments.title',
-    defaultMessage: 'Select supported environments',
-  },
-  selectEnvironmentsDescription: {
-    id: 'nags.select-environments.description',
-    defaultMessage: `Select if the {projectType} functions on the client-side and/or server-side.`,
-  },
-  settingsEnvironmentsTitle: {
-    id: 'nags.settings.environments.title',
-    defaultMessage: 'Visit general settings',
-  },
-  selectLicenseTitle: {
-    id: 'nags.select-license.title',
-    defaultMessage: 'Select license',
-  },
-  selectLicenseDescription: {
-    id: 'nags.select-license.description',
-    defaultMessage: 'Select the license your {projectType} is distributed under.',
-  },
-  settingsLicenseTitle: {
-    id: 'nags.settings.license.title',
-    defaultMessage: 'Visit license settings',
-  },
-})

packages/moderation/data/nags/core.ts

@@ -1,151 +0,0 @@
-import type { Nag, NagContext } from '../../types/nags'
-import { formatProjectType } from '@modrinth/utils'
-import { useVIntl } from '@vintl/vintl'
-
-import messages from './core.i18n'
-
-export const coreNags: Nag[] = [
-  {
-    id: 'moderator-feedback',
-    title: messages.moderatorFeedbackTitle,
-    description: messages.moderatorFeedbackDescription,
-    status: 'suggestion',
-    shouldShow: (context: NagContext) =>
-      context.tags.rejectedStatuses.includes(context.project.status),
-    link: {
-      path: 'moderation',
-      title: messages.moderationTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-moderation',
-    },
-  },
-  {
-    id: 'upload-version',
-    title: messages.uploadVersionTitle,
-    description: messages.uploadVersionDescription,
-    status: 'required',
-    shouldShow: (context: NagContext) => context.versions.length < 1,
-    link: {
-      path: 'versions',
-      title: messages.versionsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-versions',
-    },
-  },
-  {
-    id: 'add-description',
-    title: messages.addDescriptionTitle,
-    description: messages.addDescriptionDescription,
-    status: 'required',
-    shouldShow: (context: NagContext) =>
-      context.project.body === '' || context.project.body.startsWith('# Placeholder description'),
-    link: {
-      path: 'settings/description',
-      title: messages.settingsDescriptionTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-description',
-    },
-  },
-  {
-    id: 'add-icon',
-    title: messages.addIconTitle,
-    description: messages.addIconDescription,
-    status: 'suggestion',
-    shouldShow: (context: NagContext) => !context.project.icon_url,
-    link: {
-      path: 'settings',
-      title: messages.settingsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'feature-gallery-image',
-    title: messages.featureGalleryImageTitle,
-    description: messages.featureGalleryImageDescription,
-    status: 'suggestion',
-    shouldShow: (context: NagContext) => {
-      const featuredGalleryImage = context.project.gallery?.find((img) => img.featured)
-      return context.project?.gallery?.length === 0 || !featuredGalleryImage
-    },
-    link: {
-      path: 'gallery',
-      title: messages.galleryTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-gallery',
-    },
-  },
-  {
-    id: 'select-tags',
-    title: messages.selectTagsTitle,
-    description: messages.selectTagsDescription,
-    status: 'suggestion',
-    shouldShow: (context: NagContext) =>
-      context.project.versions.length > 0 && context.project.categories.length < 1,
-    link: {
-      path: 'settings/tags',
-      title: messages.settingsTagsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-tags',
-    },
-  },
-  {
-    id: 'add-links',
-    title: messages.addLinksTitle,
-    description: messages.addLinksDescription,
-    status: 'suggestion',
-    shouldShow: (context: NagContext) =>
-      !(
-        context.project.issues_url ||
-        context.project.source_url ||
-        context.project.wiki_url ||
-        context.project.discord_url ||
-        context.project.donation_urls.length > 0
-      ),
-    link: {
-      path: 'settings/links',
-      title: messages.settingsLinksTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-links',
-    },
-  },
-  {
-    id: 'select-environments',
-    title: messages.selectEnvironmentsTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-
-      return formatMessage(messages.selectEnvironmentsDescription, {
-        projectType: formatProjectType(context.project.project_type).toLowerCase(),
-      })
-    },
-    status: 'required',
-    shouldShow: (context: NagContext) => {
-      const excludedTypes = ['resourcepack', 'plugin', 'shader', 'datapack']
-      return (
-        context.project.versions.length > 0 &&
-        !excludedTypes.includes(context.project.project_type) &&
-        (context.project.client_side === 'unknown' ||
-          context.project.server_side === 'unknown' ||
-          (context.project.client_side === 'unsupported' &&
-            context.project.server_side === 'unsupported'))
-      )
-    },
-    link: {
-      path: 'settings',
-      title: messages.settingsEnvironmentsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'select-license',
-    title: messages.selectLicenseTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-
-      return formatMessage(messages.selectLicenseDescription, {
-        projectType: formatProjectType(context.project.project_type).toLowerCase(),
-      })
-    },
-    status: 'required',
-    shouldShow: (context: NagContext) => context.project.license.id === 'LicenseRef-Unknown',
-    link: {
-      path: 'settings/license',
-      title: messages.settingsLicenseTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-license',
-    },
-  },
-]

packages/moderation/data/nags/description.i18n.ts

@@ -1,88 +0,0 @@
-import { defineMessages } from '@vintl/vintl'
-
-export default defineMessages({
-  descriptionTooShortTitle: {
-    id: 'nags.description-too-short.title',
-    defaultMessage: 'Description may be insufficient',
-  },
-  descriptionTooShortDescription: {
-    id: 'nags.description-too-short.description',
-    defaultMessage:
-      "Your description is {length} characters. It's recommended to have at least {minChars} characters to provide users with enough information about your project.",
-  },
-  longHeadersTitle: {
-    id: 'nags.long-headers.title',
-    defaultMessage: 'Headers are too long',
-  },
-  longHeadersDescription: {
-    id: 'nags.long-headers.description',
-    defaultMessage:
-      '{count, plural, one {# header} other {# headers}} in your description {count, plural, one {is} other {are}} too long. Headers should be concise and act as section titles, not full sentences.',
-  },
-  summaryTooShortTitle: {
-    id: 'nags.summary-too-short.title',
-    defaultMessage: 'Summary may be insufficient',
-  },
-  summaryTooShortDescription: {
-    id: 'nags.summary-too-short.description',
-    defaultMessage:
-      "Your summary is {length} characters. It's recommended to have at least {minChars} characters to provide users with enough information about your project.",
-  },
-  minecraftTitleClauseTitle: {
-    id: 'nags.minecraft-title-clause.title',
-    defaultMessage: 'Title contains "Minecraft"',
-  },
-  minecraftTitleClauseDescription: {
-    id: 'nags.minecraft-title-clause.description',
-    defaultMessage:
-      'Please remove "Minecraft" from your title. You cannot use "Minecraft" in your title for legal reasons.',
-  },
-  titleContainsTechnicalInfoTitle: {
-    id: 'nags.title-contains-technical-info.title',
-    defaultMessage: 'Title contains loader or version info',
-  },
-  titleContainsTechnicalInfoDescription: {
-    id: 'nags.title-contains-technical-info.description',
-    defaultMessage:
-      'Removing these helps keep titles clean and makes your project easier to find. Version and loader information is automatically displayed alongside your project.',
-  },
-  summarySameAsTitleTitle: {
-    id: 'nags.summary-same-as-title.title',
-    defaultMessage: 'Summary is project name',
-  },
-  summarySameAsTitleDescription: {
-    id: 'nags.summary-same-as-title.description',
-    defaultMessage:
-      "Your summary is the same as your project name. Please change it. It's recommended to have a unique summary to provide more context about your project.",
-  },
-  imageHeavyDescriptionTitle: {
-    id: 'nags.image-heavy-description.title',
-    defaultMessage: 'Description is mostly images',
-  },
-  imageHeavyDescriptionDescription: {
-    id: 'nags.image-heavy-description.description',
-    defaultMessage:
-      'Please add more descriptive text to help users understand your project, especially those using screen readers or with slow internet connections.',
-  },
-  missingAltTextTitle: {
-    id: 'nags.missing-alt-text.title',
-    defaultMessage: 'Images missing alt text',
-  },
-  missingAltTextDescription: {
-    id: 'nags.missing-alt-text.description',
-    defaultMessage:
-      'Some of your images are missing alt text, which is important for accessibility, especially for visually impaired users.',
-  },
-  editDescriptionTitle: {
-    id: 'nags.edit-description.title',
-    defaultMessage: 'Edit description',
-  },
-  editSummaryTitle: {
-    id: 'nags.edit-summary.title',
-    defaultMessage: 'Edit summary',
-  },
-  editTitleTitle: {
-    id: 'nags.edit-title.title',
-    defaultMessage: 'Edit title',
-  },
-})

packages/moderation/data/nags/description.ts

@@ -1,226 +0,0 @@
-import type { Nag, NagContext } from '../../types/nags'
-import { useVIntl } from '@vintl/vintl'
-
-import messages from './description.i18n'
-
-export const MIN_DESCRIPTION_CHARS = 500
-export const MAX_HEADER_LENGTH = 100
-export const MIN_SUMMARY_CHARS = 125
-
-function analyzeHeaderLength(markdown: string): { hasLongHeaders: boolean; longHeaders: string[] } {
-  if (!markdown) return { hasLongHeaders: false, longHeaders: [] }
-
-  const withoutCodeBlocks = markdown.replace(/```[\s\S]*?```/g, '').replace(/`[^`]*`/g, '')
-
-  const headerRegex = /^(#{1,3})\s+(.+)$/gm
-  const headers = [...withoutCodeBlocks.matchAll(headerRegex)]
-
-  const longHeaders: string[] = []
-
-  headers.forEach((match) => {
-    const headerText = match[2].trim()
-    const sentenceEnders = /[.!?]+/g
-    const sentences = headerText.split(sentenceEnders).filter((s) => s.trim().length > 0)
-
-    const hasSentenceEnders = sentenceEnders.test(headerText)
-    const isVeryLong = headerText.length > MAX_HEADER_LENGTH
-    const hasMultipleSentences = sentences.length > 1
-
-    if (hasSentenceEnders || isVeryLong || hasMultipleSentences) {
-      longHeaders.push(headerText)
-    }
-  })
-
-  return {
-    hasLongHeaders: longHeaders.length > 0,
-    longHeaders,
-  }
-}
-
-function analyzeImageContent(markdown: string): { imageHeavy: boolean; hasEmptyAltText: boolean } {
-  if (!markdown) return { imageHeavy: false, hasEmptyAltText: false }
-
-  const withoutCodeBlocks = markdown.replace(/```[\s\S]*?```/g, '').replace(/`[^`]*`/g, '')
-
-  const imageRegex = /!\[([^\]]*)\]\([^)]+\)/g
-  const images = [...withoutCodeBlocks.matchAll(imageRegex)]
-
-  const htmlImageRegex = /<img[^>]*>/gi
-  const htmlImages = [...withoutCodeBlocks.matchAll(htmlImageRegex)]
-
-  const totalImages = images.length + htmlImages.length
-  if (totalImages === 0) return { imageHeavy: false, hasEmptyAltText: false }
-
-  const textWithoutImages = withoutCodeBlocks
-    .replace(/!\[([^\]]*)\]\([^)]+\)/g, '')
-    .replace(/<img[^>]*>/gi, '')
-    .replace(/\s+/g, ' ')
-    .trim()
-
-  const textLength = textWithoutImages.length
-  const imageHeavy = textLength < 100 || (totalImages >= 3 && textLength < 200)
-
-  const hasEmptyAltText =
-    images.some((match) => !match[1]?.trim()) ||
-    htmlImages.some((match) => {
-      const altMatch = match[0].match(/alt\s*=\s*["']([^"']*)["']/i)
-      return !altMatch || !altMatch[1]?.trim()
-    })
-
-  return { imageHeavy, hasEmptyAltText }
-}
-
-export const descriptionNags: Nag[] = [
-  {
-    id: 'description-too-short',
-    title: messages.descriptionTooShortTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-
-      return formatMessage(messages.descriptionTooShortDescription, {
-        length: context.project.body?.length || 0,
-        minChars: MIN_DESCRIPTION_CHARS,
-      })
-    },
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const bodyLength = context.project.body?.trim()?.length || 0
-      return bodyLength < MIN_DESCRIPTION_CHARS && bodyLength !== 0
-    },
-    link: {
-      path: 'settings/description',
-      title: messages.editDescriptionTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-description',
-    },
-  },
-  {
-    id: 'long-headers',
-    title: messages.longHeadersTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-      const { longHeaders } = analyzeHeaderLength(context.project.body || '')
-      const count = longHeaders.length
-
-      return formatMessage(messages.longHeadersDescription, {
-        count,
-      })
-    },
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const { hasLongHeaders } = analyzeHeaderLength(context.project.body || '')
-      return hasLongHeaders
-    },
-    link: {
-      path: 'settings/description',
-      title: messages.editDescriptionTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-description',
-    },
-  },
-  {
-    id: 'summary-too-short',
-    title: messages.summaryTooShortTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-
-      return formatMessage(messages.summaryTooShortDescription, {
-        length: context.project.description?.length || 0,
-        minChars: MIN_SUMMARY_CHARS,
-      })
-    },
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const summaryLength = context.project.description?.trim()?.length || 0
-      return summaryLength < MIN_SUMMARY_CHARS && summaryLength !== 0
-    },
-    link: {
-      path: 'settings',
-      title: messages.editSummaryTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'minecraft-title-clause',
-    title: messages.minecraftTitleClauseTitle,
-    description: messages.minecraftTitleClauseDescription,
-    status: 'required',
-    shouldShow: (context: NagContext) => {
-      const title = context.project.title?.toLowerCase() || ''
-      const wordsInTitle = title.split(' ').filter((word) => word.length > 0)
-      return title.includes('minecraft') && title.length > 0 && wordsInTitle.length <= 3
-    },
-    link: {
-      path: 'settings',
-      title: messages.editTitleTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'title-contains-technical-info',
-    title: messages.titleContainsTechnicalInfoTitle,
-    description: messages.titleContainsTechnicalInfoDescription,
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const title = context.project.title?.toLowerCase() || ''
-      if (!title) return false
-
-      const loaderNames =
-        context.tags.loaders?.map((loader: { name: string }) => loader.name?.toLowerCase()) || []
-      const hasLoader = loaderNames.some((loader) => loader && title.includes(loader.toLowerCase()))
-      const versionPatterns = [/\b1\.\d+(\.\d+)?\b/]
-      const hasVersionPattern = versionPatterns.some((pattern) => pattern.test(title))
-
-      return hasLoader || hasVersionPattern
-    },
-    link: {
-      path: 'settings',
-      title: messages.editTitleTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'summary-same-as-title',
-    title: messages.summarySameAsTitleTitle,
-    description: messages.summarySameAsTitleDescription,
-    status: 'required',
-    shouldShow: (context: NagContext) => {
-      const title = context.project.title?.trim() || ''
-      const summary = context.project.description?.trim() || ''
-      return title === summary && title.length > 0 && summary.length > 0
-    },
-    link: {
-      path: 'settings',
-      title: messages.editSummaryTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'image-heavy-description',
-    title: messages.imageHeavyDescriptionTitle,
-    description: messages.imageHeavyDescriptionDescription,
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const { imageHeavy } = analyzeImageContent(context.project.body || '')
-      return imageHeavy
-    },
-    link: {
-      path: 'settings/description',
-      title: messages.editDescriptionTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-description',
-    },
-  },
-  {
-    id: 'missing-alt-text',
-    title: messages.missingAltTextTitle,
-    description: messages.missingAltTextDescription,
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const { hasEmptyAltText } = analyzeImageContent(context.project.body || '')
-      return hasEmptyAltText
-    },
-    link: {
-      path: 'settings/description',
-      title: messages.editDescriptionTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-description',
-    },
-  },
-]

packages/moderation/data/nags/index.ts

@@ -1,4 +0,0 @@
-export * from './core'
-export * from './links'
-export * from './description'
-export * from './tags'

packages/moderation/data/nags/links.i18n.ts

@@ -1,48 +0,0 @@
-import { defineMessages } from '@vintl/vintl'
-
-export default defineMessages({
-  verifyExternalLinksTitle: {
-    id: 'nags.verify-external-links.title',
-    defaultMessage: 'Verify external links',
-  },
-  verifyExternalLinksDescription: {
-    id: 'nags.verify-external-links.description',
-    defaultMessage:
-      "Some of your external links may be using domains that aren't recognized as common for their link type.",
-  },
-  invalidLicenseUrlTitle: {
-    id: 'nags.invalid-license-url.title',
-    defaultMessage: 'Invalid license URL',
-  },
-  invalidLicenseUrlDescriptionDefault: {
-    id: 'nags.invalid-license-url.description.default',
-    defaultMessage: 'License URL is invalid.',
-  },
-  invalidLicenseUrlDescriptionDomain: {
-    id: 'nags.invalid-license-url.description.domain',
-    defaultMessage:
-      'Your license URL points to {domain}, which is not appropriate for license information. License URLs should link to the actual license text or legal documentation, not social media, gaming platforms etc.',
-  },
-  invalidLicenseUrlDescriptionMalformed: {
-    id: 'nags.invalid-license-url.description.malformed',
-    defaultMessage:
-      'Your license URL appears to be malformed. Please provide a valid URL to your license text.',
-  },
-  gplLicenseSourceRequiredTitle: {
-    id: 'nags.gpl-license-source-required.title',
-    defaultMessage: 'GPL license requires source',
-  },
-  gplLicenseSourceRequiredDescription: {
-    id: 'nags.gpl-license-source-required.description',
-    defaultMessage:
-      'Your {projectType} uses a GPL license which requires source code to be available. Please provide a source code link or consider using a different license.',
-  },
-  visitLinksSettingsTitle: {
-    id: 'nags.visit-links-settings.title',
-    defaultMessage: 'Visit links settings',
-  },
-  editLicenseTitle: {
-    id: 'nags.edit-license.title',
-    defaultMessage: 'Edit license',
-  },
-})

packages/moderation/data/nags/links.ts

@@ -1,155 +0,0 @@
-import type { Nag, NagContext } from '../../types/nags'
-import { formatProjectType } from '@modrinth/utils'
-import { useVIntl } from '@vintl/vintl'
-
-import messages from './links.i18n'
-
-export const commonLinkDomains = {
-  source: ['github.com', 'gitlab.com', 'bitbucket.org', 'codeberg.org', 'git.sr.ht'],
-  issues: ['github.com', 'gitlab.com', 'bitbucket.org', 'codeberg.org'],
-  discord: ['discord.gg', 'discord.com'],
-  licenseBlocklist: [
-    'youtube.com',
-    'youtu.be',
-    'modrinth.com',
-    'curseforge.com',
-    'twitter.com',
-    'x.com',
-    'discord.gg',
-    'discord.com',
-    'instagram.com',
-    'facebook.com',
-    'tiktok.com',
-    'reddit.com',
-    'twitch.tv',
-    'patreon.com',
-    'ko-fi.com',
-    'paypal.com',
-    'buymeacoffee.com',
-  ],
-}
-
-export function isCommonUrl(url: string | undefined, commonDomains: string[]): boolean {
-  if (!url) return false
-  try {
-    const domain = new URL(url).hostname.toLowerCase()
-    return commonDomains.some((allowed) => domain.includes(allowed))
-  } catch {
-    return false
-  }
-}
-
-export function isUncommonLicenseUrl(url: string | undefined, domains: string[]): boolean {
-  if (!url) return false
-  try {
-    const domain = new URL(url).hostname.toLowerCase()
-    return domains.some((uncommonDomain) => domain.includes(uncommonDomain))
-  } catch {
-    return false
-  }
-}
-
-export const linksNags: Nag[] = [
-  {
-    id: 'verify-external-links',
-    title: messages.verifyExternalLinksTitle,
-    description: messages.verifyExternalLinksDescription,
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      return (
-        !isCommonUrl(context.project.source_url, commonLinkDomains.source) ||
-        !isCommonUrl(context.project.issues_url, commonLinkDomains.issues) ||
-        !isCommonUrl(context.project.discord_url, commonLinkDomains.discord)
-      )
-    },
-    link: {
-      path: 'settings/links',
-      title: messages.visitLinksSettingsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-links',
-    },
-  },
-  {
-    id: 'invalid-license-url',
-    title: messages.invalidLicenseUrlTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-      const licenseUrl = context.project.license.url
-
-      if (!licenseUrl) {
-        return formatMessage(messages.invalidLicenseUrlDescriptionDefault)
-      }
-
-      try {
-        const domain = new URL(licenseUrl).hostname.toLowerCase()
-        return formatMessage(messages.invalidLicenseUrlDescriptionDomain, { domain })
-      } catch {
-        return formatMessage(messages.invalidLicenseUrlDescriptionMalformed)
-      }
-    },
-    status: 'required',
-    shouldShow: (context: NagContext) => {
-      const licenseUrl = context.project.license.url
-      if (!licenseUrl) return false
-
-      const isBlocklisted = isUncommonLicenseUrl(licenseUrl, commonLinkDomains.licenseBlocklist)
-
-      try {
-        new URL(licenseUrl)
-        return isBlocklisted
-      } catch {
-        return true
-      }
-    },
-    link: {
-      path: 'settings',
-      title: messages.editLicenseTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings',
-    },
-  },
-  {
-    id: 'gpl-license-source-required',
-    title: messages.gplLicenseSourceRequiredTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-
-      return formatMessage(messages.gplLicenseSourceRequiredDescription, {
-        projectType: formatProjectType(context.project.project_type).toLowerCase(),
-      })
-    },
-    status: 'required',
-    shouldShow: (context: NagContext) => {
-      const gplLicenses = [
-        'GPL-2.0',
-        'GPL-2.0+',
-        'GPL-2.0-only',
-        'GPL-2.0-or-later',
-        'GPL-3.0',
-        'GPL-3.0+',
-        'GPL-3.0-only',
-        'GPL-3.0-or-later',
-        'LGPL-2.1',
-        'LGPL-2.1+',
-        'LGPL-2.1-only',
-        'LGPL-2.1-or-later',
-        'LGPL-3.0',
-        'LGPL-3.0+',
-        'LGPL-3.0-only',
-        'LGPL-3.0-or-later',
-        'AGPL-3.0',
-        'AGPL-3.0+',
-        'AGPL-3.0-only',
-        'AGPL-3.0-or-later',
-      ]
-
-      const isGplLicense = gplLicenses.includes(context.project.license.id)
-      const hasSourceUrl = !!context.project.source_url
-
-      return isGplLicense && !hasSourceUrl
-    },
-    link: {
-      path: 'settings/links',
-      title: messages.visitLinksSettingsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-links',
-    },
-  },
-]

packages/moderation/data/nags/tags.i18n.ts

@@ -1,35 +0,0 @@
-import { defineMessages } from '@vintl/vintl'
-
-export default defineMessages({
-  tooManyTagsTitle: {
-    id: 'nags.too-many-tags.title',
-    defaultMessage: 'Too many tags selected',
-  },
-  tooManyTagsDescription: {
-    id: 'nags.too-many-tags.description',
-    defaultMessage:
-      "You've selected {tagCount} tags. Consider reducing to 5 or fewer to keep your project focused and easier to discover.",
-  },
-  multipleResolutionTagsTitle: {
-    id: 'nags.multiple-resolution-tags.title',
-    defaultMessage: 'Multiple resolution tags selected',
-  },
-  multipleResolutionTagsDescription: {
-    id: 'nags.multiple-resolution-tags.description',
-    defaultMessage:
-      "You've selected {count} resolution tags ({tags}). Resource packs should typically only have one resolution tag that matches their primary resolution.",
-  },
-  allTagsSelectedTitle: {
-    id: 'nags.all-tags-selected.title',
-    defaultMessage: 'All tags selected',
-  },
-  allTagsSelectedDescription: {
-    id: 'nags.all-tags-selected.description',
-    defaultMessage:
-      "You've selected all {totalAvailableTags} available tags. This defeats the purpose of tags, which are meant to help users find relevant projects. Please select only the tags that truly apply to your project.",
-  },
-  editTagsTitle: {
-    id: 'nags.edit-tags.title',
-    defaultMessage: 'Edit tags',
-  },
-})

packages/moderation/data/nags/tags.ts

@@ -1,107 +0,0 @@
-import type { Project } from '@modrinth/utils'
-import type { Nag, NagContext } from '../../types/nags'
-import { useVIntl } from '@vintl/vintl'
-
-import messages from './tags.i18n'
-
-function getCategories(
-  project: Project & { actualProjectType: string },
-  tags: {
-    categories?: {
-      project_type: string
-    }[]
-  },
-) {
-  return (
-    tags.categories?.filter(
-      (category: { project_type: string }) => category.project_type === project.actualProjectType,
-    ) ?? []
-  )
-}
-
-export const tagsNags: Nag[] = [
-  {
-    id: 'too-many-tags',
-    title: messages.tooManyTagsTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-      const tagCount =
-        context.project.categories.length + (context.project.additional_categories?.length || 0)
-
-      return formatMessage(messages.tooManyTagsDescription, {
-        tagCount,
-      })
-    },
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      const tagCount =
-        context.project.categories.length + (context.project.additional_categories?.length || 0)
-      return tagCount > 5
-    },
-    link: {
-      path: 'settings/tags',
-      title: messages.editTagsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-tags',
-    },
-  },
-  {
-    id: 'multiple-resolution-tags',
-    title: messages.multipleResolutionTagsTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-      const resolutionTags = context.project.categories.filter((tag: string) =>
-        ['16x', '32x', '48x', '64x', '128x', '256x', '512x', '1024x'].includes(tag),
-      )
-
-      return formatMessage(messages.multipleResolutionTagsDescription, {
-        count: resolutionTags.length,
-        tags: resolutionTags.join(', '),
-      })
-    },
-    status: 'warning',
-    shouldShow: (context: NagContext) => {
-      if (context.project.project_type !== 'resourcepack') return false
-
-      const resolutionTags = context.project.categories.filter((tag: string) =>
-        ['16x', '32x', '48x', '64x', '128x', '256x', '512x', '1024x'].includes(tag),
-      )
-      return resolutionTags.length > 1
-    },
-    link: {
-      path: 'settings/tags',
-      title: messages.editTagsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-tags',
-    },
-  },
-  {
-    id: 'all-tags-selected',
-    title: messages.allTagsSelectedTitle,
-    description: (context: NagContext) => {
-      const { formatMessage } = useVIntl()
-      const categoriesForProjectType = getCategories(
-        context.project as Project & { actualProjectType: string },
-        context.tags,
-      )
-      const totalAvailableTags = categoriesForProjectType.length
-
-      return formatMessage(messages.allTagsSelectedDescription, {
-        totalAvailableTags,
-      })
-    },
-    status: 'required',
-    shouldShow: (context: NagContext) => {
-      const categoriesForProjectType = getCategories(
-        context.project as Project & { actualProjectType: string },
-        context.tags,
-      )
-      const totalSelectedTags =
-        context.project.categories.length + (context.project.additional_categories?.length || 0)
-      return totalSelectedTags === categoriesForProjectType.length
-    },
-    link: {
-      path: 'settings/tags',
-      title: messages.editTagsTitle,
-      shouldShow: (context: NagContext) => context.currentRoute !== 'type-id-settings-tags',
-    },
-  },
-]

packages/moderation/index.ts

@@ -2,10 +2,8 @@ export * from './types/actions'
 export * from './types/messages'
 export * from './types/stage'
 export * from './types/keybinds'
-export * from './types/nags'
 export * from './utils'
+export { finalPermissionMessages } from './data/modpack-permissions-stage'
 
-export * from './data/nags/index'
 export { default as checklist } from './data/checklist'
 export { default as keybinds } from './data/keybinds'
-export { default as nags } from './data/nags'

packages/moderation/locales/en-US/index.json

@@ -1,191 +0,0 @@
-{
-  "nags.add-description.description": {
-    "defaultMessage": "A description that clearly describes the project's purpose and function is required."
-  },
-  "nags.add-description.title": {
-    "defaultMessage": "Add a description"
-  },
-  "nags.add-icon.description": {
-    "defaultMessage": "Your project should have a nice-looking icon to uniquely identify your project at a glance."
-  },
-  "nags.add-icon.title": {
-    "defaultMessage": "Add an icon"
-  },
-  "nags.add-links.description": {
-    "defaultMessage": "Add any relevant links targeted outside of Modrinth, such as sources, issues, or a Discord invite."
-  },
-  "nags.add-links.title": {
-    "defaultMessage": "Add external links"
-  },
-  "nags.all-tags-selected.description": {
-    "defaultMessage": "You've selected all {totalAvailableTags} available tags. This defeats the purpose of tags, which are meant to help users find relevant projects. Please select only the tags that truly apply to your project."
-  },
-  "nags.all-tags-selected.title": {
-    "defaultMessage": "All tags selected"
-  },
-  "nags.description-too-short.description": {
-    "defaultMessage": "Your description is {length} characters. It's recommended to have at least {minChars} characters to provide users with enough information about your project."
-  },
-  "nags.description-too-short.title": {
-    "defaultMessage": "Description may be insufficient"
-  },
-  "nags.edit-description.title": {
-    "defaultMessage": "Edit description"
-  },
-  "nags.edit-license.title": {
-    "defaultMessage": "Edit license"
-  },
-  "nags.edit-summary.title": {
-    "defaultMessage": "Edit summary"
-  },
-  "nags.edit-tags.title": {
-    "defaultMessage": "Edit tags"
-  },
-  "nags.edit-title.title": {
-    "defaultMessage": "Edit title"
-  },
-  "nags.feature-gallery-image.description": {
-    "defaultMessage": "Featured gallery images may be the first impression of many users."
-  },
-  "nags.feature-gallery-image.title": {
-    "defaultMessage": "Feature a gallery image"
-  },
-  "nags.gallery.title": {
-    "defaultMessage": "Visit gallery page"
-  },
-  "nags.gpl-license-source-required.description": {
-    "defaultMessage": "Your {projectType} uses a GPL license which requires source code to be available. Please provide a source code link or consider using a different license."
-  },
-  "nags.gpl-license-source-required.title": {
-    "defaultMessage": "GPL license requires source"
-  },
-  "nags.image-heavy-description.description": {
-    "defaultMessage": "Please add more descriptive text to help users understand your project, especially those using screen readers or with slow internet connections."
-  },
-  "nags.image-heavy-description.title": {
-    "defaultMessage": "Description is mostly images"
-  },
-  "nags.invalid-license-url.description.default": {
-    "defaultMessage": "License URL is invalid."
-  },
-  "nags.invalid-license-url.description.domain": {
-    "defaultMessage": "Your license URL points to {domain}, which is not appropriate for license information. License URLs should link to the actual license text or legal documentation, not social media, gaming platforms etc."
-  },
-  "nags.invalid-license-url.description.malformed": {
-    "defaultMessage": "Your license URL appears to be malformed. Please provide a valid URL to your license text."
-  },
-  "nags.invalid-license-url.title": {
-    "defaultMessage": "Invalid license URL"
-  },
-  "nags.long-headers.description": {
-    "defaultMessage": "{count, plural, one {# header} other {# headers}} in your description {count, plural, one {is} other {are}} too long. Headers should be concise and act as section titles, not full sentences."
-  },
-  "nags.long-headers.title": {
-    "defaultMessage": "Headers are too long"
-  },
-  "nags.minecraft-title-clause.description": {
-    "defaultMessage": "Please remove \"Minecraft\" from your title. You cannot use \"Minecraft\" in your title for legal reasons."
-  },
-  "nags.minecraft-title-clause.title": {
-    "defaultMessage": "Title contains \"Minecraft\""
-  },
-  "nags.missing-alt-text.description": {
-    "defaultMessage": "Some of your images are missing alt text, which is important for accessibility, especially for visually impaired users."
-  },
-  "nags.missing-alt-text.title": {
-    "defaultMessage": "Images missing alt text"
-  },
-  "nags.moderation.title": {
-    "defaultMessage": "Visit moderation thread"
-  },
-  "nags.moderator-feedback.description": {
-    "defaultMessage": "Review any feedback from moderators regarding your project before resubmitting."
-  },
-  "nags.moderator-feedback.title": {
-    "defaultMessage": "Review moderator feedback"
-  },
-  "nags.multiple-resolution-tags.description": {
-    "defaultMessage": "You've selected {count} resolution tags ({tags}). Resource packs should typically only have one resolution tag that matches their primary resolution."
-  },
-  "nags.multiple-resolution-tags.title": {
-    "defaultMessage": "Multiple resolution tags selected"
-  },
-  "nags.select-environments.description": {
-    "defaultMessage": "Select if the {projectType} functions on the client-side and/or server-side."
-  },
-  "nags.select-environments.title": {
-    "defaultMessage": "Select supported environments"
-  },
-  "nags.select-license.description": {
-    "defaultMessage": "Select the license your {projectType} is distributed under."
-  },
-  "nags.select-license.title": {
-    "defaultMessage": "Select license"
-  },
-  "nags.select-tags.description": {
-    "defaultMessage": "Select all tags that apply to your project."
-  },
-  "nags.select-tags.title": {
-    "defaultMessage": "Select tags"
-  },
-  "nags.settings.description.title": {
-    "defaultMessage": "Visit description settings"
-  },
-  "nags.settings.environments.title": {
-    "defaultMessage": "Visit general settings"
-  },
-  "nags.settings.license.title": {
-    "defaultMessage": "Visit license settings"
-  },
-  "nags.settings.links.title": {
-    "defaultMessage": "Visit links settings"
-  },
-  "nags.settings.tags.title": {
-    "defaultMessage": "Visit tag settings"
-  },
-  "nags.settings.title": {
-    "defaultMessage": "Visit general settings"
-  },
-  "nags.summary-same-as-title.description": {
-    "defaultMessage": "Your summary is the same as your project name. Please change it. It's recommended to have a unique summary to provide more context about your project."
-  },
-  "nags.summary-same-as-title.title": {
-    "defaultMessage": "Summary is project name"
-  },
-  "nags.summary-too-short.description": {
-    "defaultMessage": "Your summary is {length} characters. It's recommended to have at least {minChars} characters to provide users with enough information about your project."
-  },
-  "nags.summary-too-short.title": {
-    "defaultMessage": "Summary may be insufficient"
-  },
-  "nags.title-contains-technical-info.description": {
-    "defaultMessage": "Removing these helps keep titles clean and makes your project easier to find. Version and loader information is automatically displayed alongside your project."
-  },
-  "nags.title-contains-technical-info.title": {
-    "defaultMessage": "Title contains loader or version info"
-  },
-  "nags.too-many-tags.description": {
-    "defaultMessage": "You've selected {tagCount} tags. Consider reducing to 5 or fewer to keep your project focused and easier to discover."
-  },
-  "nags.too-many-tags.title": {
-    "defaultMessage": "Too many tags selected"
-  },
-  "nags.upload-version.description": {
-    "defaultMessage": "At least one version is required for a project to be submitted for review."
-  },
-  "nags.upload-version.title": {
-    "defaultMessage": "Upload a version"
-  },
-  "nags.verify-external-links.description": {
-    "defaultMessage": "Some of your external links may be using domains that aren't recognized as common for their link type."
-  },
-  "nags.verify-external-links.title": {
-    "defaultMessage": "Verify external links"
-  },
-  "nags.versions.title": {
-    "defaultMessage": "Visit versions page"
-  },
-  "nags.visit-links-settings.title": {
-    "defaultMessage": "Visit links settings"
-  }
-}

packages/moderation/package.json

@@ -6,17 +6,14 @@
   "types": "./index.d.ts",
   "scripts": {
     "lint": "eslint . && prettier --check .",
-    "fix": "eslint . --fix && prettier --write . && pnpm run intl:extract",
-    "intl:extract": "formatjs extract \"**/*.{vue,ts,tsx,js,jsx,mts,cts,mjs,cjs}\" --ignore \"**/*.d.ts\" --ignore \"node_modules/**/*\" --out-file locales/en-US/index.json --preserve-whitespace"
+    "fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@modrinth/assets": "workspace:*",
     "@modrinth/utils": "workspace:*",
+    "@modrinth/assets": "workspace:*",
     "vue": "^3.5.13"
   },
   "devDependencies": {
-    "@formatjs/cli": "^6.2.12",
-    "@vintl/vintl": "^4.4.1",
     "eslint": "^8.57.0",
     "eslint-config-custom": "workspace:*",
     "tsconfig": "workspace:*"

packages/moderation/types/nags.ts

@@ -1,96 +0,0 @@
-import type { Project, User, Version } from '@modrinth/utils'
-import type { MessageDescriptor } from '@vintl/vintl'
-import type { FunctionalComponent, SVGAttributes } from 'vue'
-
-/**
- * Type which represents the status type of a nag.
- *
- * - `required` indicates that the nag must be addressed.
- * - `warning` indicates that the nag is important but not critical, and can be ignored. It is often used for issues that should be resolved but do not block project submission.
- * - `suggestion` indicates that the nag is a recommendation and can be ignored.
- */
-export type NagStatus = 'required' | 'warning' | 'suggestion' | 'special-submit-action'
-
-/**
- * Interface representing the context in which a nag is displayed.
- * It includes the project, versions, current member, all members, and the current route.
- * This context is used to determine whether a nag or it's link should be shown and how it should be presented.
- */
-export interface NagContext {
-  /**
-   * The project associated with the nag.
-   */
-  project: Project
-  /**
-   * The versions associated with the project.
-   */
-  versions: Version[]
-  /**
-   * The current project member viewing the nag.
-   */
-  currentMember: User
-  /**
-   * The current route in the application.
-   */
-  currentRoute: string
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  tags: any
-  submitProject: (...any: any) => any
-  /* eslint-enable @typescript-eslint/no-explicit-any */
-}
-
-/**
- * Interface representing a nag's link.
- */
-export interface NagLink {
-  /**
-   * A relative path to the nag's link, e.g. '/settings'.
-   */
-  path: string
-  /**
-   * The text to display for the nag's link.
-   */
-  title: MessageDescriptor | string
-  /**
-   * The status of the nag, which can be 'required', 'warning', or 'suggestion'.
-   */
-  shouldShow?: (context: NagContext) => boolean
-}
-
-/**
- * Interface representing a nag.
- */
-export interface Nag {
-  /**
-   * A unique identifier for the nag.
-   */
-  id: string
-  /**
-   * The title of the nag.
-   */
-  title: MessageDescriptor | string
-  /**
-   * A function that returns the description of the nag.
-   * It can accept a context to provide dynamic descriptions.
-   */
-  description: MessageDescriptor | ((context: NagContext) => string)
-  /**
-   * The status of the nag, which can be 'required', 'warning', or 'suggestion'.
-   */
-  status: NagStatus
-  /**
-   * An optional icon for the nag, usually from `@modrinth/assets`.
-   * If not specified it will use the default icon associated with the nag status.
-   */
-  icon?: FunctionalComponent<SVGAttributes>
-
-  /**
-   * A function that determines whether the nag should be shown based on the context.
-   */
-  shouldShow: (context: NagContext) => boolean
-  /**
-   * An optional link associated with the nag.
-   * If provided, it should be displayed alongside the nag.
-   */
-  link?: NagLink
-}

packages/utils/changelog.ts

@@ -10,6 +10,13 @@ export type VersionEntry = {
 }
 
 const VERSIONS: VersionEntry[] = [
+  {
+    date: `2025-07-19T15:20:00-07:00`,
+    product: 'web',
+    body: `### Improvements
+- Removed Tumblr icon from footer as we no longer use it.
+- Reverted changes to publishing checklist since they need more work.`,
+  },
   {
     date: `2025-07-16T12:40:00-07:00`,
     product: 'web',

packages/utils/types.ts

@@ -315,7 +315,7 @@ export interface ModerationPermissionType {
 export interface ModerationBaseModpackItem {
   sha1: string
   file_name: string
-  type: 'unknown' | 'flame'
+  type: 'unknown' | 'flame' | 'identified'
   status: ModerationModpackPermissionApprovalType['id'] | null
   approved: ModerationPermissionType['id'] | null
 }
@@ -334,9 +334,26 @@ export interface ModerationFlameModpackItem extends ModerationBaseModpackItem {
   url: string
 }
 
-export type ModerationModpackItem = ModerationUnknownModpackItem | ModerationFlameModpackItem
+export interface ModerationIdentifiedModpackItem extends ModerationBaseModpackItem {
+  type: 'identified'
+  proof?: string
+  url?: string
+  title?: string
+}
+
+export type ModerationModpackItem =
+  | ModerationUnknownModpackItem
+  | ModerationFlameModpackItem
+  | ModerationIdentifiedModpackItem
 
 export interface ModerationModpackResponse {
+  identified?: Record<
+    string,
+    {
+      file_name: string
+      status: ModerationModpackPermissionApprovalType['id']
+    }
+  >
   unknown_files?: Record<string, string>
   flame_files?: Record<
     string,
@@ -350,8 +367,8 @@ export interface ModerationModpackResponse {
 }
 
 export interface ModerationJudgement {
-  type: 'flame' | 'unknown'
-  status: string
+  type: 'flame' | 'unknown' | 'identified'
+  status: string | null
   id?: string
   link?: string
   title?: string

pnpm-lock.yaml

@@ -473,12 +473,6 @@ importers:
         specifier: ^3.5.13
         version: 3.5.13(typescript@5.8.2)
     devDependencies:
-      '@formatjs/cli':
-        specifier: ^6.2.12
-        version: 6.2.12(@vue/compiler-core@3.5.13)(vue@3.5.13(typescript@5.8.2))
-      '@vintl/vintl':
-        specifier: ^4.4.1
-        version: 4.4.1(typescript@5.8.2)(vue@3.5.13(typescript@5.8.2))
       eslint:
         specifier: ^8.57.0
         version: 8.57.0
@@ -8751,10 +8745,6 @@ snapshots:
     dependencies:
       vue: 3.5.13(typescript@5.5.4)
 
-  '@braw/async-computed@5.0.2(vue@3.5.13(typescript@5.8.2))':
-    dependencies:
-      vue: 3.5.13(typescript@5.8.2)
-
   '@cloudflare/kv-asset-handler@0.3.4':
     dependencies:
       mime: 3.0.0
@@ -9282,11 +9272,6 @@ snapshots:
       '@vue/compiler-core': 3.5.13
       vue: 3.5.13(typescript@5.5.4)
 
-  '@formatjs/cli@6.2.12(@vue/compiler-core@3.5.13)(vue@3.5.13(typescript@5.8.2))':
-    optionalDependencies:
-      '@vue/compiler-core': 3.5.13
-      vue: 3.5.13(typescript@5.8.2)
-
   '@formatjs/ecma402-abstract@1.18.3':
     dependencies:
       '@formatjs/intl-localematcher': 0.5.4
@@ -9344,18 +9329,6 @@ snapshots:
     optionalDependencies:
       typescript: 5.5.4
 
-  '@formatjs/intl@2.10.4(typescript@5.8.2)':
-    dependencies:
-      '@formatjs/ecma402-abstract': 2.0.0
-      '@formatjs/fast-memoize': 2.2.0
-      '@formatjs/icu-messageformat-parser': 2.7.8
-      '@formatjs/intl-displaynames': 6.6.8
-      '@formatjs/intl-listformat': 7.5.7
-      intl-messageformat: 10.5.14
-      tslib: 2.6.3
-    optionalDependencies:
-      typescript: 5.8.2
-
   '@formatjs/ts-transformer@3.13.14':
     dependencies:
       '@formatjs/icu-messageformat-parser': 2.7.8
@@ -11089,17 +11062,6 @@ snapshots:
     transitivePeerDependencies:
       - typescript
 
-  '@vintl/vintl@4.4.1(typescript@5.8.2)(vue@3.5.13(typescript@5.8.2))':
-    dependencies:
-      '@braw/async-computed': 5.0.2(vue@3.5.13(typescript@5.8.2))
-      '@formatjs/icu-messageformat-parser': 2.7.8
-      '@formatjs/intl': 2.10.4(typescript@5.8.2)
-      '@formatjs/intl-localematcher': 0.4.2
-      intl-messageformat: 10.5.14
-      vue: 3.5.13(typescript@5.8.2)
-    transitivePeerDependencies:
-      - typescript
-
   '@vitejs/plugin-vue-jsx@4.1.1(vite@5.4.11(@types/node@20.14.11)(sass@1.77.6)(terser@5.38.1))(vue@3.5.13(typescript@5.5.4))':
     dependencies:
       '@babel/core': 7.26.0