Add launcher catalog workflow and smoke tests

app/assets/js/authmanager.js

@@ -0,0 +1,425 @@
+/**
+ * AuthManager
+ * 
+ * This module aims to abstract login procedures. Results from Mojang's REST api
+ * are retrieved through our Mojang module. These results are processed and stored,
+ * if applicable, in the config using the ConfigManager. All login procedures should
+ * be made through this module.
+ * 
+ * @module authmanager
+ */
+// Requirements
+const ConfigManager          = require('./configmanager')
+const { LoggerUtil }         = require('helios-core')
+const { RestResponseStatus } = require('helios-core/common')
+const { MojangRestAPI, MojangErrorCode } = require('helios-core/mojang')
+const { MicrosoftAuth, MicrosoftErrorCode } = require('helios-core/microsoft')
+const { AZURE_CLIENT_ID }    = require('./ipcconstants')
+const Lang = require('./langloader')
+
+const log = LoggerUtil.getLogger('AuthManager')
+
+// Error messages
+
+function microsoftErrorDisplayable(errorCode) {
+    switch (errorCode) {
+        case MicrosoftErrorCode.NO_PROFILE:
+            return {
+                title: Lang.queryJS('auth.microsoft.error.noProfileTitle'),
+                desc: Lang.queryJS('auth.microsoft.error.noProfileDesc')
+            }
+        case MicrosoftErrorCode.NO_XBOX_ACCOUNT:
+            return {
+                title: Lang.queryJS('auth.microsoft.error.noXboxAccountTitle'),
+                desc: Lang.queryJS('auth.microsoft.error.noXboxAccountDesc')
+            }
+        case MicrosoftErrorCode.XBL_BANNED:
+            return {
+                title: Lang.queryJS('auth.microsoft.error.xblBannedTitle'),
+                desc: Lang.queryJS('auth.microsoft.error.xblBannedDesc')
+            }
+        case MicrosoftErrorCode.UNDER_18:
+            return {
+                title: Lang.queryJS('auth.microsoft.error.under18Title'),
+                desc: Lang.queryJS('auth.microsoft.error.under18Desc')
+            }
+        case MicrosoftErrorCode.UNKNOWN:
+            return {
+                title: Lang.queryJS('auth.microsoft.error.unknownTitle'),
+                desc: Lang.queryJS('auth.microsoft.error.unknownDesc')
+            }
+    }
+}
+
+function mojangErrorDisplayable(errorCode) {
+    switch(errorCode) {
+        case MojangErrorCode.ERROR_METHOD_NOT_ALLOWED:
+            return {
+                title: Lang.queryJS('auth.mojang.error.methodNotAllowedTitle'),
+                desc: Lang.queryJS('auth.mojang.error.methodNotAllowedDesc')
+            }
+        case MojangErrorCode.ERROR_NOT_FOUND:
+            return {
+                title: Lang.queryJS('auth.mojang.error.notFoundTitle'),
+                desc: Lang.queryJS('auth.mojang.error.notFoundDesc')
+            }
+        case MojangErrorCode.ERROR_USER_MIGRATED:
+            return {
+                title: Lang.queryJS('auth.mojang.error.accountMigratedTitle'),
+                desc: Lang.queryJS('auth.mojang.error.accountMigratedDesc')
+            }
+        case MojangErrorCode.ERROR_INVALID_CREDENTIALS:
+            return {
+                title: Lang.queryJS('auth.mojang.error.invalidCredentialsTitle'),
+                desc: Lang.queryJS('auth.mojang.error.invalidCredentialsDesc')
+            }
+        case MojangErrorCode.ERROR_RATELIMIT:
+            return {
+                title: Lang.queryJS('auth.mojang.error.tooManyAttemptsTitle'),
+                desc: Lang.queryJS('auth.mojang.error.tooManyAttemptsDesc')
+            }
+        case MojangErrorCode.ERROR_INVALID_TOKEN:
+            return {
+                title: Lang.queryJS('auth.mojang.error.invalidTokenTitle'),
+                desc: Lang.queryJS('auth.mojang.error.invalidTokenDesc')
+            }
+        case MojangErrorCode.ERROR_ACCESS_TOKEN_HAS_PROFILE:
+            return {
+                title: Lang.queryJS('auth.mojang.error.tokenHasProfileTitle'),
+                desc: Lang.queryJS('auth.mojang.error.tokenHasProfileDesc')
+            }
+        case MojangErrorCode.ERROR_CREDENTIALS_MISSING:
+            return {
+                title: Lang.queryJS('auth.mojang.error.credentialsMissingTitle'),
+                desc: Lang.queryJS('auth.mojang.error.credentialsMissingDesc')
+            }
+        case MojangErrorCode.ERROR_INVALID_SALT_VERSION:
+            return {
+                title: Lang.queryJS('auth.mojang.error.invalidSaltVersionTitle'),
+                desc: Lang.queryJS('auth.mojang.error.invalidSaltVersionDesc')
+            }
+        case MojangErrorCode.ERROR_UNSUPPORTED_MEDIA_TYPE:
+            return {
+                title: Lang.queryJS('auth.mojang.error.unsupportedMediaTypeTitle'),
+                desc: Lang.queryJS('auth.mojang.error.unsupportedMediaTypeDesc')
+            }
+        case MojangErrorCode.ERROR_GONE:
+            return {
+                title: Lang.queryJS('auth.mojang.error.accountGoneTitle'),
+                desc: Lang.queryJS('auth.mojang.error.accountGoneDesc')
+            }
+        case MojangErrorCode.ERROR_UNREACHABLE:
+            return {
+                title: Lang.queryJS('auth.mojang.error.unreachableTitle'),
+                desc: Lang.queryJS('auth.mojang.error.unreachableDesc')
+            }
+        case MojangErrorCode.ERROR_NOT_PAID:
+            return {
+                title: Lang.queryJS('auth.mojang.error.gameNotPurchasedTitle'),
+                desc: Lang.queryJS('auth.mojang.error.gameNotPurchasedDesc')
+            }
+        case MojangErrorCode.UNKNOWN:
+            return {
+                title: Lang.queryJS('auth.mojang.error.unknownErrorTitle'),
+                desc: Lang.queryJS('auth.mojang.error.unknownErrorDesc')
+            }
+        default:
+            throw new Error(`Unknown error code: ${errorCode}`)
+    }
+}
+
+// Functions
+
+/**
+ * Add a Mojang account. This will authenticate the given credentials with Mojang's
+ * authserver. The resultant data will be stored as an auth account in the
+ * configuration database.
+ * 
+ * @param {string} username The account username (email if migrated).
+ * @param {string} password The account password.
+ * @returns {Promise.<Object>} Promise which resolves the resolved authenticated account object.
+ */
+exports.addMojangAccount = async function(username, password) {
+    try {
+        const response = await MojangRestAPI.authenticate(username, password, ConfigManager.getClientToken())
+        console.log(response)
+        if(response.responseStatus === RestResponseStatus.SUCCESS) {
+
+            const session = response.data
+            if(session.selectedProfile != null){
+                const ret = ConfigManager.addMojangAuthAccount(session.selectedProfile.id, session.accessToken, username, session.selectedProfile.name)
+                if(ConfigManager.getClientToken() == null){
+                    ConfigManager.setClientToken(session.clientToken)
+                }
+                ConfigManager.save()
+                return ret
+            } else {
+                return Promise.reject(mojangErrorDisplayable(MojangErrorCode.ERROR_NOT_PAID))
+            }
+
+        } else {
+            return Promise.reject(mojangErrorDisplayable(response.mojangErrorCode))
+        }
+        
+    } catch (err){
+        log.error(err)
+        return Promise.reject(mojangErrorDisplayable(MojangErrorCode.UNKNOWN))
+    }
+}
+
+const AUTH_MODE = { FULL: 0, MS_REFRESH: 1, MC_REFRESH: 2 }
+
+/**
+ * Perform the full MS Auth flow in a given mode.
+ * 
+ * AUTH_MODE.FULL = Full authorization for a new account.
+ * AUTH_MODE.MS_REFRESH = Full refresh authorization.
+ * AUTH_MODE.MC_REFRESH = Refresh of the MC token, reusing the MS token.
+ * 
+ * @param {string} entryCode FULL-AuthCode. MS_REFRESH=refreshToken, MC_REFRESH=accessToken
+ * @param {*} authMode The auth mode.
+ * @returns An object with all auth data. AccessToken object will be null when mode is MC_REFRESH.
+ */
+async function fullMicrosoftAuthFlow(entryCode, authMode) {
+    try {
+
+        let accessTokenRaw
+        let accessToken
+        if(authMode !== AUTH_MODE.MC_REFRESH) {
+            const accessTokenResponse = await MicrosoftAuth.getAccessToken(entryCode, authMode === AUTH_MODE.MS_REFRESH, AZURE_CLIENT_ID)
+            if(accessTokenResponse.responseStatus === RestResponseStatus.ERROR) {
+                return Promise.reject(microsoftErrorDisplayable(accessTokenResponse.microsoftErrorCode))
+            }
+            accessToken = accessTokenResponse.data
+            accessTokenRaw = accessToken.access_token
+        } else {
+            accessTokenRaw = entryCode
+        }
+        
+        const xblResponse = await MicrosoftAuth.getXBLToken(accessTokenRaw)
+        if(xblResponse.responseStatus === RestResponseStatus.ERROR) {
+            return Promise.reject(microsoftErrorDisplayable(xblResponse.microsoftErrorCode))
+        }
+        const xstsResonse = await MicrosoftAuth.getXSTSToken(xblResponse.data)
+        if(xstsResonse.responseStatus === RestResponseStatus.ERROR) {
+            return Promise.reject(microsoftErrorDisplayable(xstsResonse.microsoftErrorCode))
+        }
+        const mcTokenResponse = await MicrosoftAuth.getMCAccessToken(xstsResonse.data)
+        if(mcTokenResponse.responseStatus === RestResponseStatus.ERROR) {
+            return Promise.reject(microsoftErrorDisplayable(mcTokenResponse.microsoftErrorCode))
+        }
+        const mcProfileResponse = await MicrosoftAuth.getMCProfile(mcTokenResponse.data.access_token)
+        if(mcProfileResponse.responseStatus === RestResponseStatus.ERROR) {
+            return Promise.reject(microsoftErrorDisplayable(mcProfileResponse.microsoftErrorCode))
+        }
+        return {
+            accessToken,
+            accessTokenRaw,
+            xbl: xblResponse.data,
+            xsts: xstsResonse.data,
+            mcToken: mcTokenResponse.data,
+            mcProfile: mcProfileResponse.data
+        }
+    } catch(err) {
+        log.error(err)
+        return Promise.reject(microsoftErrorDisplayable(MicrosoftErrorCode.UNKNOWN))
+    }
+}
+
+/**
+ * Calculate the expiry date. Advance the expiry time by 10 seconds
+ * to reduce the liklihood of working with an expired token.
+ * 
+ * @param {number} nowMs Current time milliseconds.
+ * @param {number} epiresInS Expires in (seconds)
+ * @returns 
+ */
+function calculateExpiryDate(nowMs, epiresInS) {
+    return nowMs + ((epiresInS-10)*1000)
+}
+
+/**
+ * Add a Microsoft account. This will pass the provided auth code to Mojang's OAuth2.0 flow.
+ * The resultant data will be stored as an auth account in the configuration database.
+ * 
+ * @param {string} authCode The authCode obtained from microsoft.
+ * @returns {Promise.<Object>} Promise which resolves the resolved authenticated account object.
+ */
+exports.addMicrosoftAccount = async function(authCode) {
+
+    const fullAuth = await fullMicrosoftAuthFlow(authCode, AUTH_MODE.FULL)
+
+    // Advance expiry by 10 seconds to avoid close calls.
+    const now = new Date().getTime()
+
+    const ret = ConfigManager.addMicrosoftAuthAccount(
+        fullAuth.mcProfile.id,
+        fullAuth.mcToken.access_token,
+        fullAuth.mcProfile.name,
+        calculateExpiryDate(now, fullAuth.mcToken.expires_in),
+        fullAuth.accessToken.access_token,
+        fullAuth.accessToken.refresh_token,
+        calculateExpiryDate(now, fullAuth.accessToken.expires_in)
+    )
+    ConfigManager.save()
+
+    return ret
+}
+
+/**
+ * Remove a Mojang account. This will invalidate the access token associated
+ * with the account and then remove it from the database.
+ * 
+ * @param {string} uuid The UUID of the account to be removed.
+ * @returns {Promise.<void>} Promise which resolves to void when the action is complete.
+ */
+exports.removeMojangAccount = async function(uuid){
+    try {
+        const authAcc = ConfigManager.getAuthAccount(uuid)
+        const response = await MojangRestAPI.invalidate(authAcc.accessToken, ConfigManager.getClientToken())
+        if(response.responseStatus === RestResponseStatus.SUCCESS) {
+            ConfigManager.removeAuthAccount(uuid)
+            ConfigManager.save()
+            return Promise.resolve()
+        } else {
+            log.error('Error while removing account', response.error)
+            return Promise.reject(response.error)
+        }
+    } catch (err){
+        log.error('Error while removing account', err)
+        return Promise.reject(err)
+    }
+}
+
+/**
+ * Remove a Microsoft account. It is expected that the caller will invoke the OAuth logout
+ * through the ipc renderer.
+ * 
+ * @param {string} uuid The UUID of the account to be removed.
+ * @returns {Promise.<void>} Promise which resolves to void when the action is complete.
+ */
+exports.removeMicrosoftAccount = async function(uuid){
+    try {
+        ConfigManager.removeAuthAccount(uuid)
+        ConfigManager.save()
+        return Promise.resolve()
+    } catch (err){
+        log.error('Error while removing account', err)
+        return Promise.reject(err)
+    }
+}
+
+/**
+ * Validate the selected account with Mojang's authserver. If the account is not valid,
+ * we will attempt to refresh the access token and update that value. If that fails, a
+ * new login will be required.
+ * 
+ * @returns {Promise.<boolean>} Promise which resolves to true if the access token is valid,
+ * otherwise false.
+ */
+async function validateSelectedMojangAccount(){
+    const current = ConfigManager.getSelectedAccount()
+    const response = await MojangRestAPI.validate(current.accessToken, ConfigManager.getClientToken())
+
+    if(response.responseStatus === RestResponseStatus.SUCCESS) {
+        const isValid = response.data
+        if(!isValid){
+            const refreshResponse = await MojangRestAPI.refresh(current.accessToken, ConfigManager.getClientToken())
+            if(refreshResponse.responseStatus === RestResponseStatus.SUCCESS) {
+                const session = refreshResponse.data
+                ConfigManager.updateMojangAuthAccount(current.uuid, session.accessToken)
+                ConfigManager.save()
+            } else {
+                log.error('Error while validating selected profile:', refreshResponse.error)
+                log.info('Account access token is invalid.')
+                return false
+            }
+            log.info('Account access token validated.')
+            return true
+        } else {
+            log.info('Account access token validated.')
+            return true
+        }
+    }
+    
+}
+
+/**
+ * Validate the selected account with Microsoft's authserver. If the account is not valid,
+ * we will attempt to refresh the access token and update that value. If that fails, a
+ * new login will be required.
+ * 
+ * @returns {Promise.<boolean>} Promise which resolves to true if the access token is valid,
+ * otherwise false.
+ */
+async function validateSelectedMicrosoftAccount(){
+    const current = ConfigManager.getSelectedAccount()
+    const now = new Date().getTime()
+    const mcExpiresAt = current.expiresAt
+    const mcExpired = now >= mcExpiresAt
+
+    if(!mcExpired) {
+        return true
+    }
+
+    // MC token expired. Check MS token.
+
+    const msExpiresAt = current.microsoft.expires_at
+    const msExpired = now >= msExpiresAt
+
+    if(msExpired) {
+        // MS expired, do full refresh.
+        try {
+            const res = await fullMicrosoftAuthFlow(current.microsoft.refresh_token, AUTH_MODE.MS_REFRESH)
+
+            ConfigManager.updateMicrosoftAuthAccount(
+                current.uuid,
+                res.mcToken.access_token,
+                res.accessToken.access_token,
+                res.accessToken.refresh_token,
+                calculateExpiryDate(now, res.accessToken.expires_in),
+                calculateExpiryDate(now, res.mcToken.expires_in)
+            )
+            ConfigManager.save()
+            return true
+        } catch(_err) {
+            return false
+        }
+    } else {
+        // Only MC expired, use existing MS token.
+        try {
+            const res = await fullMicrosoftAuthFlow(current.microsoft.access_token, AUTH_MODE.MC_REFRESH)
+
+            ConfigManager.updateMicrosoftAuthAccount(
+                current.uuid,
+                res.mcToken.access_token,
+                current.microsoft.access_token,
+                current.microsoft.refresh_token,
+                current.microsoft.expires_at,
+                calculateExpiryDate(now, res.mcToken.expires_in)
+            )
+            ConfigManager.save()
+            return true
+        }
+        catch(_err) {
+            return false
+        }
+    }
+}
+
+/**
+ * Validate the selected auth account.
+ * 
+ * @returns {Promise.<boolean>} Promise which resolves to true if the access token is valid,
+ * otherwise false.
+ */
+exports.validateSelected = async function(){
+    const current = ConfigManager.getSelectedAccount()
+
+    if(current.type === 'microsoft') {
+        return await validateSelectedMicrosoftAccount()
+    } else {
+        return await validateSelectedMojangAccount()
+    }
+    
+}

app/assets/js/catalogmanager.js

@@ -0,0 +1,234 @@
+const fs = require('fs-extra')
+const got = require('got')
+const path = require('path')
+
+const ConfigManager = require('./configmanager')
+const { DEFAULT_REMOTE_DISTRO_URL, setRemoteDistributionUrl } = require('./distromanager')
+
+const LOCAL_CATALOG_PATH = path.join(__dirname, '..', 'launcher', 'catalog.json')
+
+function normalizeText(value){
+    return typeof value === 'string' ? value.trim() : ''
+}
+
+function normalizeNullableText(value){
+    const nextValue = normalizeText(value)
+    return nextValue.length > 0 ? nextValue : null
+}
+
+function toStoredProfile(rawProfile){
+    const kind = normalizeText(rawProfile.kind) || 'modpack'
+    const storedProfile = {
+        id: normalizeText(rawProfile.id),
+        name: normalizeText(rawProfile.name),
+        kind,
+        description: normalizeText(rawProfile.description),
+        details: normalizeText(rawProfile.details),
+        distributionUrl: normalizeNullableText(rawProfile.distributionUrl),
+        defaultServerAddress: normalizeText(rawProfile.defaultServerAddress),
+        allowCustomServerAddress: rawProfile.allowCustomServerAddress === true,
+        worldArchiveUrl: normalizeNullableText(rawProfile.worldArchiveUrl),
+        worldDirectoryName: normalizeNullableText(rawProfile.worldDirectoryName),
+        serverBundleUrl: normalizeNullableText(rawProfile.serverBundleUrl),
+        serverDirectoryName: normalizeText(rawProfile.serverDirectoryName) || 'server',
+        serverLaunchCommand: normalizeNullableText(rawProfile.serverLaunchCommand),
+        serverWorkingDirectory: normalizeNullableText(rawProfile.serverWorkingDirectory),
+        serverPort: Number.isFinite(Number(rawProfile.serverPort)) ? Number(rawProfile.serverPort) : 25565,
+        tunnelCommand: normalizeNullableText(rawProfile.tunnelCommand),
+        tunnelAddressRegex: normalizeNullableText(rawProfile.tunnelAddressRegex),
+        artwork: normalizeText(rawProfile.artwork)
+    }
+
+    if(kind !== 'map'){
+        storedProfile.worldArchiveUrl = null
+        storedProfile.worldDirectoryName = null
+    }
+
+    if(kind !== 'server-pack'){
+        storedProfile.serverBundleUrl = null
+        storedProfile.serverDirectoryName = 'server'
+        storedProfile.serverLaunchCommand = null
+        storedProfile.serverWorkingDirectory = null
+        storedProfile.serverPort = 25565
+        storedProfile.tunnelCommand = null
+        storedProfile.tunnelAddressRegex = null
+    }
+
+    return storedProfile
+}
+
+function normalizeProfile(rawProfile, sourceType = 'catalog'){
+    const storedProfile = toStoredProfile(rawProfile)
+    const launchIssues = []
+    const hostIssues = []
+
+    if(storedProfile.distributionUrl == null){
+        launchIssues.push('distribution URL이 필요합니다.')
+    }
+
+    if(storedProfile.kind === 'map'){
+        if(storedProfile.worldArchiveUrl == null){
+            launchIssues.push('맵 ZIP 또는 로컬 월드 경로가 필요합니다.')
+        }
+        if(storedProfile.worldDirectoryName == null){
+            launchIssues.push('월드 폴더 이름이 필요합니다.')
+        }
+    }
+
+    if(storedProfile.kind === 'server-pack' && storedProfile.serverBundleUrl == null){
+        hostIssues.push('로컬 호스팅을 하려면 서버 번들 ZIP 또는 디렉터리 경로가 필요합니다.')
+    }
+
+    const launchReady = launchIssues.length === 0
+    const hostReady = storedProfile.kind === 'server-pack' ? hostIssues.length === 0 : false
+
+    return {
+        ...storedProfile,
+        sourceType,
+        isCustom: sourceType === 'custom',
+        configured: launchReady,
+        launchReady,
+        launchIssues,
+        hostReady,
+        hostIssues
+    }
+}
+
+function resolveCatalogFileSource(source){
+    if(source.startsWith('file://')){
+        return decodeURIComponent(source.substring('file://'.length))
+    }
+    return path.resolve(source)
+}
+
+async function readCatalogSource(source){
+    if(/^https?:\/\//i.test(source)){
+        return got(source, {
+            responseType: 'json'
+        }).json()
+    }
+
+    return fs.readJson(resolveCatalogFileSource(source))
+}
+
+exports.getLocalCatalogPath = function(){
+    return LOCAL_CATALOG_PATH
+}
+
+exports.loadCatalog = async function(){
+    const configuredSource = ConfigManager.getLibraryCatalogSource()
+    const source = configuredSource != null && configuredSource.trim().length > 0 ? configuredSource.trim() : LOCAL_CATALOG_PATH
+    let rawCatalog = {
+        version: 1,
+        profiles: []
+    }
+    let sourceError = null
+
+    try {
+        rawCatalog = await readCatalogSource(source)
+    } catch (error) {
+        sourceError = error
+    }
+
+    const rawProfiles = Array.isArray(rawCatalog.profiles) ? rawCatalog.profiles : []
+
+    return {
+        version: rawCatalog.version ?? 1,
+        source,
+        sourceError,
+        profiles: rawProfiles
+            .filter((profile) => profile != null && typeof profile.id === 'string' && typeof profile.name === 'string')
+            .map((profile) => normalizeProfile(profile, 'catalog'))
+            .sort((left, right) => left.name.localeCompare(right.name, 'ko'))
+    }
+}
+
+exports.getInstalledProfiles = async function(){
+    const catalog = await exports.loadCatalog()
+    const installedProfiles = ConfigManager.getInstalledLibraryProfiles()
+
+    return installedProfiles.map((installedProfile) => {
+        const latestProfile = catalog.profiles.find((profile) => profile.id === installedProfile.id)
+        return latestProfile != null
+            ? {
+                ...installedProfile,
+                ...latestProfile,
+                installedAt: installedProfile.installedAt
+            }
+            : installedProfile
+    })
+}
+
+exports.installProfile = async function(profileId){
+    const catalog = await exports.loadCatalog()
+    const profile = catalog.profiles.find((entry) => entry.id === profileId)
+
+    if(profile == null){
+        throw new Error(`Unknown profile: ${profileId}`)
+    }
+
+    const installedProfile = {
+        ...profile,
+        installedAt: new Date().toISOString()
+    }
+
+    ConfigManager.upsertInstalledLibraryProfile(installedProfile)
+
+    if(ConfigManager.getSelectedLibraryProfile() == null){
+        ConfigManager.setSelectedLibraryProfile(profile.id)
+    }
+
+    ConfigManager.save()
+    return installedProfile
+}
+
+exports.removeProfile = function(profileId){
+    ConfigManager.removeInstalledLibraryProfile(profileId)
+    ConfigManager.save()
+}
+
+exports.selectProfile = function(profileId){
+    ConfigManager.setSelectedLibraryProfile(profileId)
+    ConfigManager.save()
+}
+
+exports.getSelectedProfileId = function(){
+    return ConfigManager.getSelectedLibraryProfile()
+}
+
+exports.getSelectedProfileSync = function(){
+    const selectedProfileId = ConfigManager.getSelectedLibraryProfile()
+    if(selectedProfileId == null){
+        return null
+    }
+    return ConfigManager.getInstalledLibraryProfile(selectedProfileId)
+}
+
+exports.resolveServerAddress = function(profile){
+    if(profile == null){
+        return null
+    }
+
+    const manualAddress = ConfigManager.getLibraryServerAddressOverride(profile.id)
+    if(manualAddress != null && manualAddress.length > 0){
+        return manualAddress
+    }
+
+    if(typeof profile.defaultServerAddress === 'string' && profile.defaultServerAddress.length > 0){
+        return profile.defaultServerAddress
+    }
+
+    return null
+}
+
+exports.setServerAddressOverride = function(profileId, address){
+    ConfigManager.setLibraryServerAddressOverride(profileId, address)
+    ConfigManager.save()
+}
+
+exports.applyConfiguredProfile = function(){
+    const selectedProfile = exports.getSelectedProfileSync()
+    const distributionUrl = selectedProfile?.distributionUrl ?? DEFAULT_REMOTE_DISTRO_URL
+    setRemoteDistributionUrl(distributionUrl)
+    return selectedProfile
+}

app/assets/js/discordwrapper.js

@@ -0,0 +1,52 @@
+// Work in progress
+const { LoggerUtil } = require('helios-core')
+
+const logger = LoggerUtil.getLogger('DiscordWrapper')
+
+const { Client } = require('discord-rpc-patch')
+
+const Lang = require('./langloader')
+
+let client
+let activity
+
+exports.initRPC = function(genSettings, servSettings, initialDetails = Lang.queryJS('discord.waiting')){
+    client = new Client({ transport: 'ipc' })
+
+    activity = {
+        details: initialDetails,
+        state: Lang.queryJS('discord.state', {shortId: servSettings.shortId}),
+        largeImageKey: servSettings.largeImageKey,
+        largeImageText: servSettings.largeImageText,
+        smallImageKey: genSettings.smallImageKey,
+        smallImageText: genSettings.smallImageText,
+        startTimestamp: new Date().getTime(),
+        instance: false
+    }
+
+    client.on('ready', () => {
+        logger.info('Discord RPC Connected')
+        client.setActivity(activity)
+    })
+    
+    client.login({clientId: genSettings.clientId}).catch(error => {
+        if(error.message.includes('ENOENT')) {
+            logger.info('Unable to initialize Discord Rich Presence, no client detected.')
+        } else {
+            logger.info('Unable to initialize Discord Rich Presence: ' + error.message, error)
+        }
+    })
+}
+
+exports.updateDetails = function(details){
+    activity.details = details
+    client.setActivity(activity)
+}
+
+exports.shutdownRPC = function(){
+    if(!client) return
+    client.clearActivity()
+    client.destroy()
+    client = null
+    activity = null
+}

app/assets/js/distromanager.js

@@ -0,0 +1,74 @@
+const { DistributionAPI } = require('helios-core/common')
+
+const ConfigManager = require('./configmanager')
+
+const DEFAULT_REMOTE_DISTRO_URL = 'https://cdn.mysticred.space/launcher/distribution.json'
+
+let remoteDistroUrl = DEFAULT_REMOTE_DISTRO_URL
+let activeApi = createApi(remoteDistroUrl)
+
+function createApi(url) {
+    const api = new DistributionAPI(
+        ConfigManager.getLauncherDirectory(),
+        null,
+        null,
+        url,
+        false
+    )
+
+    return api
+}
+
+function replaceApi(url) {
+    const nextApi = createApi(url)
+
+    if(activeApi != null){
+        if(typeof activeApi.commonDir !== 'undefined'){
+            nextApi.commonDir = activeApi.commonDir
+        }
+        if(typeof activeApi.instanceDir !== 'undefined'){
+            nextApi.instanceDir = activeApi.instanceDir
+        }
+        if(typeof activeApi.isDevMode === 'function' && activeApi.isDevMode()){
+            nextApi.toggleDevMode(true)
+        }
+    }
+
+    activeApi = nextApi
+    remoteDistroUrl = url
+}
+
+exports.DEFAULT_REMOTE_DISTRO_URL = DEFAULT_REMOTE_DISTRO_URL
+
+exports.getRemoteDistributionUrl = function() {
+    return remoteDistroUrl
+}
+
+exports.setRemoteDistributionUrl = function(url) {
+    if(url != null && url.trim().length > 0 && url !== remoteDistroUrl){
+        replaceApi(url)
+    }
+    return remoteDistroUrl
+}
+
+exports.resetRemoteDistributionUrl = function() {
+    replaceApi(DEFAULT_REMOTE_DISTRO_URL)
+    return remoteDistroUrl
+}
+
+exports.DistroAPI = new Proxy({}, {
+    get(_target, prop) {
+        const value = activeApi[prop]
+        if(typeof value === 'function'){
+            return value.bind(activeApi)
+        }
+        return value
+    },
+    set(_target, prop, value) {
+        activeApi[prop] = value
+        return true
+    },
+    has(_target, prop) {
+        return prop in activeApi
+    }
+})

app/assets/js/dropinmodutil.js

@@ -0,0 +1,238 @@
+const fs        = require('fs-extra')
+const path      = require('path')
+const { ipcRenderer, shell } = require('electron')
+const { SHELL_OPCODE } = require('./ipcconstants')
+
+// Group #1: File Name (without .disabled, if any)
+// Group #2: File Extension (jar, zip, or litemod)
+// Group #3: If it is disabled (if string 'disabled' is present)
+const MOD_REGEX = /^(.+(jar|zip|litemod))(?:\.(disabled))?$/
+const DISABLED_EXT = '.disabled'
+
+const SHADER_REGEX = /^(.+)\.zip$/
+const SHADER_OPTION = /shaderPack=(.+)/
+const SHADER_DIR = 'shaderpacks'
+const SHADER_CONFIG = 'optionsshaders.txt'
+
+/**
+ * Validate that the given directory exists. If not, it is
+ * created.
+ * 
+ * @param {string} modsDir The path to the mods directory.
+ */
+exports.validateDir = function(dir) {
+    fs.ensureDirSync(dir)
+}
+
+/**
+ * Scan for drop-in mods in both the mods folder and version
+ * safe mods folder.
+ * 
+ * @param {string} modsDir The path to the mods directory.
+ * @param {string} version The minecraft version of the server configuration.
+ * 
+ * @returns {{fullName: string, name: string, ext: string, disabled: boolean}[]}
+ * An array of objects storing metadata about each discovered mod.
+ */
+exports.scanForDropinMods = function(modsDir, version) {
+    const modsDiscovered = []
+    if(fs.existsSync(modsDir)){
+        let modCandidates = fs.readdirSync(modsDir)
+        let verCandidates = []
+        const versionDir = path.join(modsDir, version)
+        if(fs.existsSync(versionDir)){
+            verCandidates = fs.readdirSync(versionDir)
+        }
+        for(let file of modCandidates){
+            const match = MOD_REGEX.exec(file)
+            if(match != null){
+                modsDiscovered.push({
+                    fullName: match[0],
+                    name: match[1],
+                    ext: match[2],
+                    disabled: match[3] != null
+                })
+            }
+        }
+        for(let file of verCandidates){
+            const match = MOD_REGEX.exec(file)
+            if(match != null){
+                modsDiscovered.push({
+                    fullName: path.join(version, match[0]),
+                    name: match[1],
+                    ext: match[2],
+                    disabled: match[3] != null
+                })
+            }
+        }
+    }
+    return modsDiscovered
+}
+
+/**
+ * Add dropin mods.
+ * 
+ * @param {FileList} files The files to add.
+ * @param {string} modsDir The path to the mods directory.
+ */
+exports.addDropinMods = function(files, modsdir) {
+
+    exports.validateDir(modsdir)
+
+    for(let f of files) {
+        if(MOD_REGEX.exec(f.name) != null) {
+            fs.moveSync(f.path, path.join(modsdir, f.name))
+        }
+    }
+
+}
+
+/**
+ * Delete a drop-in mod from the file system.
+ * 
+ * @param {string} modsDir The path to the mods directory.
+ * @param {string} fullName The fullName of the discovered mod to delete.
+ * 
+ * @returns {Promise.<boolean>} True if the mod was deleted, otherwise false.
+ */
+exports.deleteDropinMod = async function(modsDir, fullName){
+
+    const res = await ipcRenderer.invoke(SHELL_OPCODE.TRASH_ITEM, path.join(modsDir, fullName))
+
+    if(!res.result) {
+        shell.beep()
+        console.error('Error deleting drop-in mod.', res.error)
+        return false
+    }
+
+    return true
+}
+
+/**
+ * Toggle a discovered mod on or off. This is achieved by either 
+ * adding or disabling the .disabled extension to the local file.
+ * 
+ * @param {string} modsDir The path to the mods directory.
+ * @param {string} fullName The fullName of the discovered mod to toggle.
+ * @param {boolean} enable Whether to toggle on or off the mod.
+ * 
+ * @returns {Promise.<void>} A promise which resolves when the mod has
+ * been toggled. If an IO error occurs the promise will be rejected.
+ */
+exports.toggleDropinMod = function(modsDir, fullName, enable){
+    return new Promise((resolve, reject) => {
+        const oldPath = path.join(modsDir, fullName)
+        const newPath = path.join(modsDir, enable ? fullName.substring(0, fullName.indexOf(DISABLED_EXT)) : fullName + DISABLED_EXT)
+
+        fs.rename(oldPath, newPath, (err) => {
+            if(err){
+                reject(err)
+            } else {
+                resolve()
+            }
+        })
+    })
+}
+
+/**
+ * Check if a drop-in mod is enabled.
+ * 
+ * @param {string} fullName The fullName of the discovered mod to toggle.
+ * @returns {boolean} True if the mod is enabled, otherwise false.
+ */
+exports.isDropinModEnabled = function(fullName){
+    return !fullName.endsWith(DISABLED_EXT)
+}
+
+/**
+ * Scan for shaderpacks inside the shaderpacks folder.
+ * 
+ * @param {string} instanceDir The path to the server instance directory.
+ * 
+ * @returns {{fullName: string, name: string}[]}
+ * An array of objects storing metadata about each discovered shaderpack.
+ */
+exports.scanForShaderpacks = function(instanceDir){
+    const shaderDir = path.join(instanceDir, SHADER_DIR)
+    const packsDiscovered = [{
+        fullName: 'OFF',
+        name: 'Off (Default)'
+    }]
+    if(fs.existsSync(shaderDir)){
+        let modCandidates = fs.readdirSync(shaderDir)
+        for(let file of modCandidates){
+            const match = SHADER_REGEX.exec(file)
+            if(match != null){
+                packsDiscovered.push({
+                    fullName: match[0],
+                    name: match[1]
+                })
+            }
+        }
+    }
+    return packsDiscovered
+}
+
+/**
+ * Read the optionsshaders.txt file to locate the current
+ * enabled pack. If the file does not exist, OFF is returned.
+ * 
+ * @param {string} instanceDir The path to the server instance directory.
+ * 
+ * @returns {string} The file name of the enabled shaderpack.
+ */
+exports.getEnabledShaderpack = function(instanceDir){
+    exports.validateDir(instanceDir)
+
+    const optionsShaders = path.join(instanceDir, SHADER_CONFIG)
+    if(fs.existsSync(optionsShaders)){
+        const buf = fs.readFileSync(optionsShaders, {encoding: 'utf-8'})
+        const match = SHADER_OPTION.exec(buf)
+        if(match != null){
+            return match[1]
+        } else {
+            console.warn('WARNING: Shaderpack regex failed.')
+        }
+    }
+    return 'OFF'
+}
+
+/**
+ * Set the enabled shaderpack.
+ * 
+ * @param {string} instanceDir The path to the server instance directory.
+ * @param {string} pack the file name of the shaderpack.
+ */
+exports.setEnabledShaderpack = function(instanceDir, pack){
+    exports.validateDir(instanceDir)
+
+    const optionsShaders = path.join(instanceDir, SHADER_CONFIG)
+    let buf
+    if(fs.existsSync(optionsShaders)){
+        buf = fs.readFileSync(optionsShaders, {encoding: 'utf-8'})
+        buf = buf.replace(SHADER_OPTION, `shaderPack=${pack}`)
+    } else {
+        buf = `shaderPack=${pack}`
+    }
+    fs.writeFileSync(optionsShaders, buf, {encoding: 'utf-8'})
+}
+
+/**
+ * Add shaderpacks.
+ * 
+ * @param {FileList} files The files to add.
+ * @param {string} instanceDir The path to the server instance directory.
+ */
+exports.addShaderpacks = function(files, instanceDir) {
+
+    const p = path.join(instanceDir, SHADER_DIR)
+
+    exports.validateDir(p)
+
+    for(let f of files) {
+        if(SHADER_REGEX.exec(f.name) != null) {
+            fs.moveSync(f.path, path.join(p, f.name))
+        }
+    }
+
+}

app/assets/js/ipcconstants.js

@@ -0,0 +1,28 @@
+// NOTE FOR THIRD-PARTY
+// REPLACE THIS CLIENT ID WITH YOUR APPLICATION ID.
+// SEE https://github.com/dscalzi/HeliosLauncher/blob/master/docs/MicrosoftAuth.md
+exports.AZURE_CLIENT_ID = '8f387cc5-3138-4699-89a9-f97948e3927e'
+// SEE NOTE ABOVE.
+
+
+// Opcodes
+exports.MSFT_OPCODE = {
+    OPEN_LOGIN: 'MSFT_AUTH_OPEN_LOGIN',
+    OPEN_LOGOUT: 'MSFT_AUTH_OPEN_LOGOUT',
+    REPLY_LOGIN: 'MSFT_AUTH_REPLY_LOGIN',
+    REPLY_LOGOUT: 'MSFT_AUTH_REPLY_LOGOUT'
+}
+// Reply types for REPLY opcode.
+exports.MSFT_REPLY_TYPE = {
+    SUCCESS: 'MSFT_AUTH_REPLY_SUCCESS',
+    ERROR: 'MSFT_AUTH_REPLY_ERROR'
+}
+// Error types for ERROR reply.
+exports.MSFT_ERROR = {
+    ALREADY_OPEN: 'MSFT_AUTH_ERR_ALREADY_OPEN',
+    NOT_FINISHED: 'MSFT_AUTH_ERR_NOT_FINISHED'
+}
+
+exports.SHELL_OPCODE = {
+    TRASH_ITEM: 'TRASH_ITEM'
+}

app/assets/js/isdev.js

@@ -0,0 +1,5 @@
+'use strict'
+const getFromEnv = parseInt(process.env.ELECTRON_IS_DEV, 10) === 1
+const isEnvSet = 'ELECTRON_IS_DEV' in process.env
+
+module.exports = isEnvSet ? getFromEnv : (process.defaultApp || /node_modules[\\/]electron[\\/]/.test(process.execPath))

app/assets/js/langloader.js

@@ -0,0 +1,43 @@
+const fs = require('fs-extra')
+const path = require('path')
+const toml = require('toml')
+const merge = require('lodash.merge')
+
+let lang
+
+exports.loadLanguage = function(id){
+    lang = merge(lang || {}, toml.parse(fs.readFileSync(path.join(__dirname, '..', 'lang', `${id}.toml`))) || {})
+}
+
+exports.query = function(id, placeHolders){
+    let query = id.split('.')
+    let res = lang
+    for(let q of query){
+        res = res[q]
+    }
+    let text = res === lang ? '' : res
+    if (placeHolders) {
+        Object.entries(placeHolders).forEach(([key, value]) => {
+            text = text.replace(`{${key}}`, value)
+        })
+    }
+    return text
+}
+
+exports.queryJS = function(id, placeHolders){
+    return exports.query(`js.${id}`, placeHolders)
+}
+
+exports.queryEJS = function(id, placeHolders){
+    return exports.query(`ejs.${id}`, placeHolders)
+}
+
+exports.setupLanguage = function(){
+    // Load Language Files
+    exports.loadLanguage('en_US')
+    // Uncomment this when translations are ready
+    exports.loadLanguage('ko_KR')
+
+    // Load Custom Language File for Launcher Customizer
+    exports.loadLanguage('_custom')
+}

app/assets/js/preloader.js

@@ -0,0 +1,69 @@
+const {ipcRenderer}  = require('electron')
+const fs             = require('fs-extra')
+const os             = require('os')
+const path           = require('path')
+
+const ConfigManager  = require('./configmanager')
+const CatalogManager = require('./catalogmanager')
+const { DistroAPI }  = require('./distromanager')
+const LangLoader     = require('./langloader')
+const { LoggerUtil } = require('helios-core')
+// eslint-disable-next-line no-unused-vars
+const { HeliosDistribution } = require('helios-core/common')
+
+const logger = LoggerUtil.getLogger('Preloader')
+
+logger.info('Loading..')
+
+// Load ConfigManager
+ConfigManager.load()
+CatalogManager.applyConfiguredProfile()
+
+// Yuck!
+// TODO Fix this
+DistroAPI['commonDir'] = ConfigManager.getCommonDirectory()
+DistroAPI['instanceDir'] = ConfigManager.getInstanceDirectory()
+
+// Load Strings
+LangLoader.setupLanguage()
+
+/**
+ * 
+ * @param {HeliosDistribution} data 
+ */
+function onDistroLoad(data){
+    if(data != null){
+        
+        // Resolve the selected server if its value has yet to be set.
+        if(ConfigManager.getSelectedServer() == null || data.getServerById(ConfigManager.getSelectedServer()) == null){
+            logger.info('Determining default selected server..')
+            ConfigManager.setSelectedServer(data.getMainServer().rawServer.id)
+            ConfigManager.save()
+        }
+    }
+    ipcRenderer.send('distributionIndexDone', data != null)
+}
+
+// Ensure Distribution is downloaded and cached.
+DistroAPI.getDistribution()
+    .then(heliosDistro => {
+        logger.info('Loaded distribution index.')
+
+        onDistroLoad(heliosDistro)
+    })
+    .catch(err => {
+        logger.info('Failed to load an older version of the distribution index.')
+        logger.info('Application cannot run.')
+        logger.error(err)
+
+        onDistroLoad(null)
+    })
+
+// Clean up temp dir incase previous launches ended unexpectedly. 
+fs.remove(path.join(os.tmpdir(), ConfigManager.getTempNativeFolder()), (err) => {
+    if(err){
+        logger.warn('Error while cleaning natives directory', err)
+    } else {
+        logger.info('Cleaned natives directory.')
+    }
+})

app/assets/js/processbuilder.js

@@ -0,0 +1,952 @@
+const AdmZip                = require('adm-zip')
+const child_process         = require('child_process')
+const crypto                = require('crypto')
+const fs                    = require('fs-extra')
+const { LoggerUtil }        = require('helios-core')
+const { getMojangOS, isLibraryCompatible, mcVersionAtLeast }  = require('helios-core/common')
+const { Type }              = require('helios-distribution-types')
+const os                    = require('os')
+const path                  = require('path')
+
+const ConfigManager            = require('./configmanager')
+
+const logger = LoggerUtil.getLogger('ProcessBuilder')
+
+function resolveServerAddressOverride(address, fallbackPort) {
+    if(address == null || address.trim().length === 0){
+        return null
+    }
+
+    const trimmed = address.trim()
+
+    if(trimmed.startsWith('[')){
+        const closingIndex = trimmed.indexOf(']')
+        if(closingIndex !== -1){
+            const host = trimmed.substring(1, closingIndex)
+            const remainder = trimmed.substring(closingIndex + 1)
+            if(remainder.startsWith(':')){
+                return {
+                    hostname: host,
+                    port: remainder.substring(1) || fallbackPort
+                }
+            }
+            return {
+                hostname: host,
+                port: fallbackPort
+            }
+        }
+    }
+
+    const splitIndex = trimmed.lastIndexOf(':')
+    if(splitIndex > -1 && trimmed.indexOf(':') === splitIndex){
+        return {
+            hostname: trimmed.substring(0, splitIndex),
+            port: trimmed.substring(splitIndex + 1) || fallbackPort
+        }
+    }
+
+    return {
+        hostname: trimmed,
+        port: fallbackPort
+    }
+}
+
+
+/**
+ * Only forge and fabric are top level mod loaders.
+ * 
+ * Forge 1.13+ launch logic is similar to fabrics, for now using usingFabricLoader flag to
+ * change minor details when needed.
+ * 
+ * Rewrite of this module may be needed in the future.
+ */
+class ProcessBuilder {
+
+    constructor(distroServer, vanillaManifest, modManifest, authUser, launcherVersion){
+        this.gameDir = path.join(ConfigManager.getInstanceDirectory(), distroServer.rawServer.id)
+        this.commonDir = ConfigManager.getCommonDirectory()
+        this.server = distroServer
+        this.vanillaManifest = vanillaManifest
+        this.modManifest = modManifest
+        this.authUser = authUser
+        this.launcherVersion = launcherVersion
+        this.forgeModListFile = path.join(this.gameDir, 'forgeMods.list') // 1.13+
+        this.fmlDir = path.join(this.gameDir, 'forgeModList.json')
+        this.llDir = path.join(this.gameDir, 'liteloaderModList.json')
+        this.libPath = path.join(this.commonDir, 'libraries')
+
+        this.usingLiteLoader = false
+        this.usingFabricLoader = false
+        this.llPath = null
+    }
+    
+    /**
+     * Convienence method to run the functions typically used to build a process.
+     */
+    build(){
+        fs.ensureDirSync(this.gameDir)
+        const tempNativePath = path.join(os.tmpdir(), ConfigManager.getTempNativeFolder(), crypto.pseudoRandomBytes(16).toString('hex'))
+        process.throwDeprecation = true
+        this.setupLiteLoader()
+        logger.info('Using liteloader:', this.usingLiteLoader)
+        this.usingFabricLoader = this.server.modules.some(mdl => mdl.rawModule.type === Type.Fabric)
+        logger.info('Using fabric loader:', this.usingFabricLoader)
+        const modObj = this.resolveModConfiguration(ConfigManager.getModConfiguration(this.server.rawServer.id).mods, this.server.modules)
+        
+        // Mod list below 1.13
+        // Fabric only supports 1.14+
+        if(!mcVersionAtLeast('1.13', this.server.rawServer.minecraftVersion)){
+            this.constructJSONModList('forge', modObj.fMods, true)
+            if(this.usingLiteLoader){
+                this.constructJSONModList('liteloader', modObj.lMods, true)
+            }
+        }
+        
+        const uberModArr = modObj.fMods.concat(modObj.lMods)
+        let args = this.constructJVMArguments(uberModArr, tempNativePath)
+
+        if(mcVersionAtLeast('1.13', this.server.rawServer.minecraftVersion)){
+            //args = args.concat(this.constructModArguments(modObj.fMods))
+            args = args.concat(this.constructModList(modObj.fMods))
+        }
+
+        // Hide access token
+        const loggableArgs = [...args]
+        loggableArgs[loggableArgs.findIndex(x => x === this.authUser.accessToken)] = '**********'
+
+        logger.info('Launch Arguments:', loggableArgs)
+
+        const child = child_process.spawn(ConfigManager.getJavaExecutable(this.server.rawServer.id), args, {
+            cwd: this.gameDir,
+            detached: ConfigManager.getLaunchDetached()
+        })
+
+        if(ConfigManager.getLaunchDetached()){
+            child.unref()
+        }
+
+        child.stdout.setEncoding('utf8')
+        child.stderr.setEncoding('utf8')
+
+        child.stdout.on('data', (data) => {
+            data.trim().split('\n').forEach(x => console.log(`\x1b[32m[Minecraft]\x1b[0m ${x}`))
+            
+        })
+        child.stderr.on('data', (data) => {
+            data.trim().split('\n').forEach(x => console.log(`\x1b[31m[Minecraft]\x1b[0m ${x}`))
+        })
+        child.on('close', (code) => {
+            logger.info('Exited with code', code)
+            fs.remove(tempNativePath, (err) => {
+                if(err){
+                    logger.warn('Error while deleting temp dir', err)
+                } else {
+                    logger.info('Temp dir deleted successfully.')
+                }
+            })
+        })
+
+        return child
+    }
+
+    /**
+     * Get the platform specific classpath separator. On windows, this is a semicolon.
+     * On Unix, this is a colon.
+     * 
+     * @returns {string} The classpath separator for the current operating system.
+     */
+    static getClasspathSeparator() {
+        return process.platform === 'win32' ? ';' : ':'
+    }
+
+    /**
+     * Determine if an optional mod is enabled from its configuration value. If the
+     * configuration value is null, the required object will be used to
+     * determine if it is enabled.
+     * 
+     * A mod is enabled if:
+     *   * The configuration is not null and one of the following:
+     *     * The configuration is a boolean and true.
+     *     * The configuration is an object and its 'value' property is true.
+     *   * The configuration is null and one of the following:
+     *     * The required object is null.
+     *     * The required object's 'def' property is null or true.
+     * 
+     * @param {Object | boolean} modCfg The mod configuration object.
+     * @param {Object} required Optional. The required object from the mod's distro declaration.
+     * @returns {boolean} True if the mod is enabled, false otherwise.
+     */
+    static isModEnabled(modCfg, required = null){
+        return modCfg != null ? ((typeof modCfg === 'boolean' && modCfg) || (typeof modCfg === 'object' && (typeof modCfg.value !== 'undefined' ? modCfg.value : true))) : required != null ? required.def : true
+    }
+
+    /**
+     * Function which performs a preliminary scan of the top level
+     * mods. If liteloader is present here, we setup the special liteloader
+     * launch options. Note that liteloader is only allowed as a top level
+     * mod. It must not be declared as a submodule.
+     */
+    setupLiteLoader(){
+        for(let ll of this.server.modules){
+            if(ll.rawModule.type === Type.LiteLoader){
+                if(!ll.getRequired().value){
+                    const modCfg = ConfigManager.getModConfiguration(this.server.rawServer.id).mods
+                    if(ProcessBuilder.isModEnabled(modCfg[ll.getVersionlessMavenIdentifier()], ll.getRequired())){
+                        if(fs.existsSync(ll.getPath())){
+                            this.usingLiteLoader = true
+                            this.llPath = ll.getPath()
+                        }
+                    }
+                } else {
+                    if(fs.existsSync(ll.getPath())){
+                        this.usingLiteLoader = true
+                        this.llPath = ll.getPath()
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Resolve an array of all enabled mods. These mods will be constructed into
+     * a mod list format and enabled at launch.
+     * 
+     * @param {Object} modCfg The mod configuration object.
+     * @param {Array.<Object>} mdls An array of modules to parse.
+     * @returns {{fMods: Array.<Object>, lMods: Array.<Object>}} An object which contains
+     * a list of enabled forge mods and litemods.
+     */
+    resolveModConfiguration(modCfg, mdls){
+        let fMods = []
+        let lMods = []
+
+        for(let mdl of mdls){
+            const type = mdl.rawModule.type
+            if(type === Type.ForgeMod || type === Type.LiteMod || type === Type.LiteLoader || type === Type.FabricMod){
+                const o = !mdl.getRequired().value
+                const e = ProcessBuilder.isModEnabled(modCfg[mdl.getVersionlessMavenIdentifier()], mdl.getRequired())
+                if(!o || (o && e)){
+                    if(mdl.subModules.length > 0){
+                        const v = this.resolveModConfiguration(modCfg[mdl.getVersionlessMavenIdentifier()].mods, mdl.subModules)
+                        fMods = fMods.concat(v.fMods)
+                        lMods = lMods.concat(v.lMods)
+                        if(type === Type.LiteLoader){
+                            continue
+                        }
+                    }
+                    if(type === Type.ForgeMod || type === Type.FabricMod){
+                        fMods.push(mdl)
+                    } else {
+                        lMods.push(mdl)
+                    }
+                }
+            }
+        }
+
+        return {
+            fMods,
+            lMods
+        }
+    }
+
+    _lteMinorVersion(version) {
+        return Number(this.modManifest.id.split('-')[0].split('.')[1]) <= Number(version)
+    }
+
+    /**
+     * Test to see if this version of forge requires the absolute: prefix
+     * on the modListFile repository field.
+     */
+    _requiresAbsolute(){
+        try {
+            if(this._lteMinorVersion(9)) {
+                return false
+            }
+            const ver = this.modManifest.id.split('-')[2]
+            const pts = ver.split('.')
+            const min = [14, 23, 3, 2655]
+            for(let i=0; i<pts.length; i++){
+                const parsed = Number.parseInt(pts[i])
+                if(parsed < min[i]){
+                    return false
+                } else if(parsed > min[i]){
+                    return true
+                }
+            }
+        } catch (_err) {
+            // We know old forge versions follow this format.
+            // Error must be caused by newer version.
+        }
+        
+        // Equal or errored
+        return true
+    }
+
+    /**
+     * Construct a mod list json object.
+     * 
+     * @param {'forge' | 'liteloader'} type The mod list type to construct.
+     * @param {Array.<Object>} mods An array of mods to add to the mod list.
+     * @param {boolean} save Optional. Whether or not we should save the mod list file.
+     */
+    constructJSONModList(type, mods, save = false){
+        const modList = {
+            repositoryRoot: ((type === 'forge' && this._requiresAbsolute()) ? 'absolute:' : '') + path.join(this.commonDir, 'modstore')
+        }
+
+        const ids = []
+        if(type === 'forge'){
+            for(let mod of mods){
+                ids.push(mod.getExtensionlessMavenIdentifier())
+            }
+        } else {
+            for(let mod of mods){
+                ids.push(mod.getMavenIdentifier())
+            }
+        }
+        modList.modRef = ids
+        
+        if(save){
+            const json = JSON.stringify(modList, null, 4)
+            fs.writeFileSync(type === 'forge' ? this.fmlDir : this.llDir, json, 'UTF-8')
+        }
+
+        return modList
+    }
+
+    // /**
+    //  * Construct the mod argument list for forge 1.13
+    //  * 
+    //  * @param {Array.<Object>} mods An array of mods to add to the mod list.
+    //  */
+    // constructModArguments(mods){
+    //     const argStr = mods.map(mod => {
+    //         return mod.getExtensionlessMavenIdentifier()
+    //     }).join(',')
+
+    //     if(argStr){
+    //         return [
+    //             '--fml.mavenRoots',
+    //             path.join('..', '..', 'common', 'modstore'),
+    //             '--fml.mods',
+    //             argStr
+    //         ]
+    //     } else {
+    //         return []
+    //     }
+        
+    // }
+
+    /**
+     * Construct the mod argument list for forge 1.13 and Fabric
+     * 
+     * @param {Array.<Object>} mods An array of mods to add to the mod list.
+     */
+    constructModList(mods) {
+        const writeBuffer = mods.map(mod => {
+            return this.usingFabricLoader ? mod.getPath() : mod.getExtensionlessMavenIdentifier()
+        }).join('\n')
+
+        if(writeBuffer) {
+            fs.writeFileSync(this.forgeModListFile, writeBuffer, 'UTF-8')
+            return this.usingFabricLoader ? [
+                '--fabric.addMods',
+                `@${this.forgeModListFile}`
+            ] : [
+                '--fml.mavenRoots',
+                path.join('..', '..', 'common', 'modstore'),
+                '--fml.modLists',
+                this.forgeModListFile
+            ]
+        } else {
+            return []
+        }
+
+    }
+
+    _processAutoConnectArg(args){
+        const selectedProfileId = ConfigManager.getSelectedLibraryProfile()
+        const quickPlayWorld = selectedProfileId != null
+            ? ConfigManager.getLibraryQuickPlayWorld(selectedProfileId)
+            : null
+
+        if(quickPlayWorld){
+            if(mcVersionAtLeast('1.20', this.server.rawServer.minecraftVersion)){
+                args.push('--quickPlaySingleplayer')
+                args.push(quickPlayWorld)
+            }
+            return
+        }
+
+        if(ConfigManager.getAutoConnect() && this.server.rawServer.autoconnect){
+            const serverAddressOverride = selectedProfileId != null
+                ? resolveServerAddressOverride(
+                    ConfigManager.getLibraryServerAddressOverride(selectedProfileId),
+                    this.server.port
+                )
+                : null
+            const hostname = serverAddressOverride?.hostname ?? this.server.hostname
+            const port = serverAddressOverride?.port ?? this.server.port
+            if(mcVersionAtLeast('1.20', this.server.rawServer.minecraftVersion)){
+                args.push('--quickPlayMultiplayer')
+                args.push(`${hostname}:${port}`)
+            } else {
+                args.push('--server')
+                args.push(hostname)
+                args.push('--port')
+                args.push(port)
+            }
+        }
+    }
+
+    /**
+     * Construct the argument array that will be passed to the JVM process.
+     * 
+     * @param {Array.<Object>} mods An array of enabled mods which will be launched with this process.
+     * @param {string} tempNativePath The path to store the native libraries.
+     * @returns {Array.<string>} An array containing the full JVM arguments for this process.
+     */
+    constructJVMArguments(mods, tempNativePath){
+        if(mcVersionAtLeast('1.13', this.server.rawServer.minecraftVersion)){
+            return this._constructJVMArguments113(mods, tempNativePath)
+        } else {
+            return this._constructJVMArguments112(mods, tempNativePath)
+        }
+    }
+
+    /**
+     * Construct the argument array that will be passed to the JVM process.
+     * This function is for 1.12 and below.
+     * 
+     * @param {Array.<Object>} mods An array of enabled mods which will be launched with this process.
+     * @param {string} tempNativePath The path to store the native libraries.
+     * @returns {Array.<string>} An array containing the full JVM arguments for this process.
+     */
+    _constructJVMArguments112(mods, tempNativePath){
+
+        let args = []
+
+        // Classpath Argument
+        args.push('-cp')
+        args.push(this.classpathArg(mods, tempNativePath).join(ProcessBuilder.getClasspathSeparator()))
+
+        // Java Arguments
+        if(process.platform === 'darwin'){
+            args.push('-Xdock:name=MRSLauncher')
+            args.push('-Xdock:icon=' + path.join(__dirname, '..', 'images', 'minecraft.icns'))
+        }
+        args.push('-Xmx' + ConfigManager.getMaxRAM(this.server.rawServer.id))
+        args.push('-Xms' + ConfigManager.getMinRAM(this.server.rawServer.id))
+        args = args.concat(ConfigManager.getJVMOptions(this.server.rawServer.id))
+        args.push('-Djava.library.path=' + tempNativePath)
+
+        // Main Java Class
+        args.push(this.modManifest.mainClass)
+
+        // Forge Arguments
+        args = args.concat(this._resolveForgeArgs())
+
+        return args
+    }
+
+    /**
+     * Construct the argument array that will be passed to the JVM process.
+     * This function is for 1.13+
+     * 
+     * Note: Required Libs https://github.com/MinecraftForge/MinecraftForge/blob/af98088d04186452cb364280340124dfd4766a5c/src/fmllauncher/java/net/minecraftforge/fml/loading/LibraryFinder.java#L82
+     * 
+     * @param {Array.<Object>} mods An array of enabled mods which will be launched with this process.
+     * @param {string} tempNativePath The path to store the native libraries.
+     * @returns {Array.<string>} An array containing the full JVM arguments for this process.
+     */
+    _constructJVMArguments113(mods, tempNativePath){
+
+        const argDiscovery = /\${*(.*)}/
+
+        // JVM Arguments First
+        let args = this.vanillaManifest.arguments.jvm
+
+        // Debug securejarhandler
+        // args.push('-Dbsl.debug=true')
+
+        if(this.modManifest.arguments.jvm != null) {
+            for(const argStr of this.modManifest.arguments.jvm) {
+                args.push(argStr
+                    .replaceAll('${library_directory}', this.libPath)
+                    .replaceAll('${classpath_separator}', ProcessBuilder.getClasspathSeparator())
+                    .replaceAll('${version_name}', this.modManifest.id)
+                )
+            }
+        }
+
+        //args.push('-Dlog4j.configurationFile=D:\\WesterosCraft\\game\\common\\assets\\log_configs\\client-1.12.xml')
+
+        // Java Arguments
+        if(process.platform === 'darwin'){
+            args.push('-Xdock:name=MRSLauncher')
+            args.push('-Xdock:icon=' + path.join(__dirname, '..', 'images', 'minecraft.icns'))
+        }
+        args.push('-Xmx' + ConfigManager.getMaxRAM(this.server.rawServer.id))
+        args.push('-Xms' + ConfigManager.getMinRAM(this.server.rawServer.id))
+        args = args.concat(ConfigManager.getJVMOptions(this.server.rawServer.id))
+
+        // Main Java Class
+        args.push(this.modManifest.mainClass)
+
+        // Vanilla Arguments
+        args = args.concat(this.vanillaManifest.arguments.game)
+
+        for(let i=0; i<args.length; i++){
+            if(typeof args[i] === 'object' && args[i].rules != null){
+                
+                let checksum = 0
+                for(let rule of args[i].rules){
+                    if(rule.os != null){
+                        if(rule.os.name === getMojangOS()
+                            && (rule.os.version == null || new RegExp(rule.os.version).test(os.release))){
+                            if(rule.action === 'allow'){
+                                checksum++
+                            }
+                        } else {
+                            if(rule.action === 'disallow'){
+                                checksum++
+                            }
+                        }
+                    } else if(rule.features != null){
+                        // We don't have many 'features' in the index at the moment.
+                        // This should be fine for a while.
+                        if(rule.features.has_custom_resolution != null && rule.features.has_custom_resolution === true){
+                            if(ConfigManager.getFullscreen()){
+                                args[i].value = [
+                                    '--fullscreen',
+                                    'true'
+                                ]
+                            }
+                            checksum++
+                        }
+                    }
+                }
+
+                // TODO splice not push
+                if(checksum === args[i].rules.length){
+                    if(typeof args[i].value === 'string'){
+                        args[i] = args[i].value
+                    } else if(typeof args[i].value === 'object'){
+                        //args = args.concat(args[i].value)
+                        args.splice(i, 1, ...args[i].value)
+                    }
+
+                    // Decrement i to reprocess the resolved value
+                    i--
+                } else {
+                    args[i] = null
+                }
+
+            } else if(typeof args[i] === 'string'){
+                if(argDiscovery.test(args[i])){
+                    const identifier = args[i].match(argDiscovery)[1]
+                    let val = null
+                    switch(identifier){
+                        case 'auth_player_name':
+                            val = this.authUser.displayName.trim()
+                            break
+                        case 'version_name':
+                            //val = vanillaManifest.id
+                            val = this.server.rawServer.id
+                            break
+                        case 'game_directory':
+                            val = this.gameDir
+                            break
+                        case 'assets_root':
+                            val = path.join(this.commonDir, 'assets')
+                            break
+                        case 'assets_index_name':
+                            val = this.vanillaManifest.assets
+                            break
+                        case 'auth_uuid':
+                            val = this.authUser.uuid.trim()
+                            break
+                        case 'auth_access_token':
+                            val = this.authUser.accessToken
+                            break
+                        case 'user_type':
+                            val = this.authUser.type === 'microsoft' ? 'msa' : 'mojang'
+                            break
+                        case 'version_type':
+                            val = this.vanillaManifest.type
+                            break
+                        case 'resolution_width':
+                            val = ConfigManager.getGameWidth()
+                            break
+                        case 'resolution_height':
+                            val = ConfigManager.getGameHeight()
+                            break
+                        case 'natives_directory':
+                            val = args[i].replace(argDiscovery, tempNativePath)
+                            break
+                        case 'launcher_name':
+                            val = args[i].replace(argDiscovery, 'MRS-Launcher')
+                            break
+                        case 'launcher_version':
+                            val = args[i].replace(argDiscovery, this.launcherVersion)
+                            break
+                        case 'classpath':
+                            val = this.classpathArg(mods, tempNativePath).join(ProcessBuilder.getClasspathSeparator())
+                            break
+                    }
+                    if(val != null){
+                        args[i] = val
+                    }
+                }
+            }
+        }
+
+        // Autoconnect
+        this._processAutoConnectArg(args)
+        
+
+        // Forge Specific Arguments
+        args = args.concat(this.modManifest.arguments.game)
+
+        // Filter null values
+        args = args.filter(arg => {
+            return arg != null
+        })
+
+        return args
+    }
+
+    /**
+     * Resolve the arguments required by forge.
+     * 
+     * @returns {Array.<string>} An array containing the arguments required by forge.
+     */
+    _resolveForgeArgs(){
+        const mcArgs = this.modManifest.minecraftArguments.split(' ')
+        const argDiscovery = /\${*(.*)}/
+
+        // Replace the declared variables with their proper values.
+        for(let i=0; i<mcArgs.length; ++i){
+            if(argDiscovery.test(mcArgs[i])){
+                const identifier = mcArgs[i].match(argDiscovery)[1]
+                let val = null
+                switch(identifier){
+                    case 'auth_player_name':
+                        val = this.authUser.displayName.trim()
+                        break
+                    case 'version_name':
+                        //val = vanillaManifest.id
+                        val = this.server.rawServer.id
+                        break
+                    case 'game_directory':
+                        val = this.gameDir
+                        break
+                    case 'assets_root':
+                        val = path.join(this.commonDir, 'assets')
+                        break
+                    case 'assets_index_name':
+                        val = this.vanillaManifest.assets
+                        break
+                    case 'auth_uuid':
+                        val = this.authUser.uuid.trim()
+                        break
+                    case 'auth_access_token':
+                        val = this.authUser.accessToken
+                        break
+                    case 'user_type':
+                        val = this.authUser.type === 'microsoft' ? 'msa' : 'mojang'
+                        break
+                    case 'user_properties': // 1.8.9 and below.
+                        val = '{}'
+                        break
+                    case 'version_type':
+                        val = this.vanillaManifest.type
+                        break
+                }
+                if(val != null){
+                    mcArgs[i] = val
+                }
+            }
+        }
+
+        // Autoconnect to the selected server.
+        this._processAutoConnectArg(mcArgs)
+
+        // Prepare game resolution
+        if(ConfigManager.getFullscreen()){
+            mcArgs.push('--fullscreen')
+            mcArgs.push(true)
+        } else {
+            mcArgs.push('--width')
+            mcArgs.push(ConfigManager.getGameWidth())
+            mcArgs.push('--height')
+            mcArgs.push(ConfigManager.getGameHeight())
+        }
+        
+        // Mod List File Argument
+        mcArgs.push('--modListFile')
+        if(this._lteMinorVersion(9)) {
+            mcArgs.push(path.basename(this.fmlDir))
+        } else {
+            mcArgs.push('absolute:' + this.fmlDir)
+        }
+        
+
+        // LiteLoader
+        if(this.usingLiteLoader){
+            mcArgs.push('--modRepo')
+            mcArgs.push(this.llDir)
+
+            // Set first arg to liteloader tweak class
+            mcArgs.unshift('com.mumfrey.liteloader.launch.LiteLoaderTweaker')
+            mcArgs.unshift('--tweakClass')
+        }
+
+        return mcArgs
+    }
+
+    /**
+     * Ensure that the classpath entries all point to jar files.
+     * 
+     * @param {Array.<String>} list Array of classpath entries.
+     */
+    _processClassPathList(list) {
+
+        const ext = '.jar'
+        const extLen = ext.length
+        for(let i=0; i<list.length; i++) {
+            const extIndex = list[i].indexOf(ext)
+            if(extIndex > -1 && extIndex  !== list[i].length - extLen) {
+                list[i] = list[i].substring(0, extIndex + extLen)
+            }
+        }
+
+    }
+
+    /**
+     * Resolve the full classpath argument list for this process. This method will resolve all Mojang-declared
+     * libraries as well as the libraries declared by the server. Since mods are permitted to declare libraries,
+     * this method requires all enabled mods as an input
+     * 
+     * @param {Array.<Object>} mods An array of enabled mods which will be launched with this process.
+     * @param {string} tempNativePath The path to store the native libraries.
+     * @returns {Array.<string>} An array containing the paths of each library required by this process.
+     */
+    classpathArg(mods, tempNativePath){
+        let cpArgs = []
+
+        if(!mcVersionAtLeast('1.17', this.server.rawServer.minecraftVersion) || this.usingFabricLoader) {
+            // Add the version.jar to the classpath.
+            // Must not be added to the classpath for Forge 1.17+.
+            const version = this.vanillaManifest.id
+            cpArgs.push(path.join(this.commonDir, 'versions', version, version + '.jar'))
+        }
+        
+
+        if(this.usingLiteLoader){
+            cpArgs.push(this.llPath)
+        }
+
+        // Resolve the Mojang declared libraries.
+        const mojangLibs = this._resolveMojangLibraries(tempNativePath)
+
+        // Resolve the server declared libraries.
+        const servLibs = this._resolveServerLibraries(mods)
+
+        // Merge libraries, server libs with the same
+        // maven identifier will override the mojang ones.
+        // Ex. 1.7.10 forge overrides mojang's guava with newer version.
+        const finalLibs = {...mojangLibs, ...servLibs}
+        cpArgs = cpArgs.concat(Object.values(finalLibs))
+
+        this._processClassPathList(cpArgs)
+
+        return cpArgs
+    }
+
+    /**
+     * Resolve the libraries defined by Mojang's version data. This method will also extract
+     * native libraries and point to the correct location for its classpath.
+     * 
+     * TODO - clean up function
+     * 
+     * @param {string} tempNativePath The path to store the native libraries.
+     * @returns {{[id: string]: string}} An object containing the paths of each library mojang declares.
+     */
+    _resolveMojangLibraries(tempNativePath){
+        const nativesRegex = /.+:natives-([^-]+)(?:-(.+))?/
+        const libs = {}
+
+        const libArr = this.vanillaManifest.libraries
+        fs.ensureDirSync(tempNativePath)
+        for(let i=0; i<libArr.length; i++){
+            const lib = libArr[i]
+            if(isLibraryCompatible(lib.rules, lib.natives)){
+
+                // Pre-1.19 has a natives object.
+                if(lib.natives != null) {
+                    // Extract the native library.
+                    const exclusionArr = lib.extract != null ? lib.extract.exclude : ['META-INF/']
+                    const artifact = lib.downloads.classifiers[lib.natives[getMojangOS()].replace('${arch}', process.arch.replace('x', ''))]
+
+                    // Location of native zip.
+                    const to = path.join(this.libPath, artifact.path)
+
+                    let zip = new AdmZip(to)
+                    let zipEntries = zip.getEntries()
+
+                    // Unzip the native zip.
+                    for(let i=0; i<zipEntries.length; i++){
+                        const fileName = zipEntries[i].entryName
+
+                        let shouldExclude = false
+
+                        // Exclude noted files.
+                        exclusionArr.forEach(function(exclusion){
+                            if(fileName.indexOf(exclusion) > -1){
+                                shouldExclude = true
+                            }
+                        })
+
+                        // Extract the file.
+                        if(!shouldExclude){
+                            fs.writeFile(path.join(tempNativePath, fileName), zipEntries[i].getData(), (err) => {
+                                if(err){
+                                    logger.error('Error while extracting native library:', err)
+                                }
+                            })
+                        }
+
+                    }
+                }
+                // 1.19+ logic
+                else if(lib.name.includes('natives-')) {
+
+                    const regexTest = nativesRegex.exec(lib.name)
+                    // const os = regexTest[1]
+                    const arch = regexTest[2] ?? 'x64'
+
+                    if(arch != process.arch) {
+                        continue
+                    }
+
+                    // Extract the native library.
+                    const exclusionArr = lib.extract != null ? lib.extract.exclude : ['META-INF/', '.git', '.sha1']
+                    const artifact = lib.downloads.artifact
+
+                    // Location of native zip.
+                    const to = path.join(this.libPath, artifact.path)
+
+                    let zip = new AdmZip(to)
+                    let zipEntries = zip.getEntries()
+
+                    // Unzip the native zip.
+                    for(let i=0; i<zipEntries.length; i++){
+                        if(zipEntries[i].isDirectory) {
+                            continue
+                        }
+
+                        const fileName = zipEntries[i].entryName
+
+                        let shouldExclude = false
+
+                        // Exclude noted files.
+                        exclusionArr.forEach(function(exclusion){
+                            if(fileName.indexOf(exclusion) > -1){
+                                shouldExclude = true
+                            }
+                        })
+
+                        const extractName = fileName.includes('/') ? fileName.substring(fileName.lastIndexOf('/')) : fileName
+
+                        // Extract the file.
+                        if(!shouldExclude){
+                            fs.writeFile(path.join(tempNativePath, extractName), zipEntries[i].getData(), (err) => {
+                                if(err){
+                                    logger.error('Error while extracting native library:', err)
+                                }
+                            })
+                        }
+
+                    }
+                }
+                // No natives
+                else {
+                    const dlInfo = lib.downloads
+                    const artifact = dlInfo.artifact
+                    const to = path.join(this.libPath, artifact.path)
+                    const versionIndependentId = lib.name.substring(0, lib.name.lastIndexOf(':'))
+                    libs[versionIndependentId] = to
+                }
+            }
+        }
+
+        return libs
+    }
+
+    /**
+     * Resolve the libraries declared by this server in order to add them to the classpath.
+     * This method will also check each enabled mod for libraries, as mods are permitted to
+     * declare libraries.
+     * 
+     * @param {Array.<Object>} mods An array of enabled mods which will be launched with this process.
+     * @returns {{[id: string]: string}} An object containing the paths of each library this server requires.
+     */
+    _resolveServerLibraries(mods){
+        const mdls = this.server.modules
+        let libs = {}
+
+        // Locate Forge/Fabric/Libraries
+        for(let mdl of mdls){
+            const type = mdl.rawModule.type
+            if(type === Type.ForgeHosted || type === Type.Fabric || type === Type.Library){
+                libs[mdl.getVersionlessMavenIdentifier()] = mdl.getPath()
+                if(mdl.subModules.length > 0){
+                    const res = this._resolveModuleLibraries(mdl)
+                    libs = {...libs, ...res}
+                }
+            }
+        }
+
+        //Check for any libraries in our mod list.
+        for(let i=0; i<mods.length; i++){
+            if(mods.sub_modules != null){
+                const res = this._resolveModuleLibraries(mods[i])
+                libs = {...libs, ...res}
+            }
+        }
+
+        return libs
+    }
+
+    /**
+     * Recursively resolve the path of each library required by this module.
+     * 
+     * @param {Object} mdl A module object from the server distro index.
+     * @returns {{[id: string]: string}} An object containing the paths of each library this module requires.
+     */
+    _resolveModuleLibraries(mdl){
+        if(!mdl.subModules.length > 0){
+            return {}
+        }
+        let libs = {}
+        for(let sm of mdl.subModules){
+            if(sm.rawModule.type === Type.Library){
+
+                if(sm.rawModule.classpath ?? true) {
+                    libs[sm.getVersionlessMavenIdentifier()] = sm.getPath()
+                }
+            }
+            // If this module has submodules, we need to resolve the libraries for those.
+            // To avoid unnecessary recursive calls, base case is checked here.
+            if(mdl.subModules.length > 0){
+                const res = this._resolveModuleLibraries(sm)
+                libs = {...libs, ...res}
+            }
+        }
+        return libs
+    }
+
+}
+
+module.exports = ProcessBuilder

app/assets/js/profileassetmanager.js

@@ -0,0 +1,168 @@
+const AdmZip = require('adm-zip')
+const fs = require('fs-extra')
+const got = require('got')
+const os = require('os')
+const path = require('path')
+const { pipeline } = require('stream/promises')
+
+const ConfigManager = require('./configmanager')
+
+function getProfileBaseDirectory(profileId){
+    return path.join(ConfigManager.getDataDirectory(), 'profiles', profileId)
+}
+
+function getProfileDownloadDirectory(profileId){
+    return path.join(getProfileBaseDirectory(profileId), 'downloads')
+}
+
+function getProfileCacheFile(profileId, fileName){
+    return path.join(getProfileDownloadDirectory(profileId), fileName)
+}
+
+function getServerBundleDirectory(profile){
+    return path.join(getProfileBaseDirectory(profile.id), profile.serverDirectoryName || 'server')
+}
+
+function isRemoteSource(source){
+    return /^https?:\/\//i.test(source)
+}
+
+function resolveLocalSource(source){
+    if(source == null){
+        return null
+    }
+
+    if(source.startsWith('file://')){
+        return decodeURIComponent(source.substring('file://'.length))
+    }
+
+    return path.resolve(source)
+}
+
+async function downloadSourceToFile(source, destination){
+    await fs.ensureDir(path.dirname(destination))
+
+    if(isRemoteSource(source)){
+        await pipeline(
+            got.stream(source),
+            fs.createWriteStream(destination)
+        )
+        return destination
+    }
+
+    const localSource = resolveLocalSource(source)
+    const localStat = await fs.stat(localSource)
+    if(localStat.isDirectory()){
+        throw new Error(`Directory source is not supported for archive cache: ${localSource}`)
+    }
+    await fs.copy(localSource, destination, { overwrite: true })
+    return destination
+}
+
+async function extractZipToDirectory(zipPath, destination){
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'launcher-assets-'))
+    try {
+        await fs.ensureDir(tempDir)
+        new AdmZip(zipPath).extractAllTo(tempDir, true)
+
+        const rootEntries = (await fs.readdir(tempDir)).filter((entry) => entry !== '__MACOSX')
+        await fs.remove(destination)
+
+        if(rootEntries.length === 1){
+            const onlyEntry = path.join(tempDir, rootEntries[0])
+            const entryStat = await fs.stat(onlyEntry)
+            if(entryStat.isDirectory()){
+                await fs.copy(onlyEntry, destination, { overwrite: true })
+                return
+            }
+        }
+
+        await fs.copy(tempDir, destination, { overwrite: true })
+    } finally {
+        await fs.remove(tempDir)
+    }
+}
+
+async function ensureCachedArchive(profileId, source, fileName){
+    const cachePath = getProfileCacheFile(profileId, fileName)
+    await downloadSourceToFile(source, cachePath)
+    return cachePath
+}
+
+exports.getProfileBaseDirectory = getProfileBaseDirectory
+exports.getServerBundleDirectory = getServerBundleDirectory
+
+exports.prefetchProfileAssets = async function(profile){
+    if(profile.worldArchiveUrl){
+        await ensureCachedArchive(profile.id, profile.worldArchiveUrl, 'world.zip')
+    }
+    if(profile.serverBundleUrl){
+        await ensureCachedArchive(profile.id, profile.serverBundleUrl, 'server.zip')
+    }
+
+    const currentState = ConfigManager.getLibraryProfileAssetState(profile.id)
+    ConfigManager.setLibraryProfileAssetState(profile.id, {
+        ...currentState,
+        prefetchedAt: new Date().toISOString()
+    })
+    ConfigManager.save()
+}
+
+exports.ensureWorldInstalled = async function(profile, serverId){
+    if(!profile.worldArchiveUrl || !profile.worldDirectoryName){
+        return null
+    }
+
+    const savesDirectory = path.join(ConfigManager.getInstanceDirectory(), serverId, 'saves')
+    const targetWorldDirectory = path.join(savesDirectory, profile.worldDirectoryName)
+
+    await fs.ensureDir(savesDirectory)
+    if(isRemoteSource(profile.worldArchiveUrl) || profile.worldArchiveUrl.endsWith('.zip') || profile.worldArchiveUrl.startsWith('file://')){
+        const cachePath = await ensureCachedArchive(profile.id, profile.worldArchiveUrl, 'world.zip')
+        await extractZipToDirectory(cachePath, targetWorldDirectory)
+    } else {
+        await fs.remove(targetWorldDirectory)
+        await fs.copy(resolveLocalSource(profile.worldArchiveUrl), targetWorldDirectory, { overwrite: true })
+    }
+
+    ConfigManager.setLibraryQuickPlayWorld(profile.id, profile.worldDirectoryName)
+    ConfigManager.setLibraryProfileAssetState(profile.id, {
+        worldInstalledAt: new Date().toISOString(),
+        worldInstalledServerId: serverId,
+        worldDirectoryName: profile.worldDirectoryName
+    })
+    ConfigManager.save()
+
+    return targetWorldDirectory
+}
+
+exports.ensureServerBundleInstalled = async function(profile){
+    if(!profile.serverBundleUrl){
+        return null
+    }
+
+    const targetDirectory = getServerBundleDirectory(profile)
+    if(isRemoteSource(profile.serverBundleUrl) || profile.serverBundleUrl.endsWith('.zip') || profile.serverBundleUrl.startsWith('file://')){
+        const cachePath = await ensureCachedArchive(profile.id, profile.serverBundleUrl, 'server.zip')
+        await extractZipToDirectory(cachePath, targetDirectory)
+    } else {
+        await fs.remove(targetDirectory)
+        await fs.copy(resolveLocalSource(profile.serverBundleUrl), targetDirectory, { overwrite: true })
+    }
+
+    ConfigManager.setLibraryProfileAssetState(profile.id, {
+        serverBundleInstalledAt: new Date().toISOString(),
+        serverBundleDirectory: targetDirectory
+    })
+    ConfigManager.save()
+
+    return targetDirectory
+}
+
+exports.prepareProfileForLaunch = async function(profile, serverId){
+    if(profile.kind === 'map'){
+        return exports.ensureWorldInstalled(profile, serverId)
+    }
+
+    return null
+}

app/assets/js/scripts/install.js

@@ -0,0 +1,307 @@
+const CatalogManager = require('./assets/js/catalogmanager')
+const ConfigManager = require('./assets/js/configmanager')
+const ProfileAssetManager = require('./assets/js/profileassetmanager')
+
+const installCatalogList = document.getElementById('installCatalogList')
+const installDetailTitle = document.getElementById('installDetailTitle')
+const installDetailSummary = document.getElementById('installDetailSummary')
+const installDetailMeta = document.getElementById('installDetailMeta')
+const installDetailInfo = document.getElementById('installDetailInfo')
+const installDetailBody = document.getElementById('installDetailBody')
+const installDetailAddButton = document.getElementById('installDetailAddButton')
+
+let selectedProfileId = null
+let latestCatalog = null
+
+function describeProfileKind(kind){
+    switch(kind){
+        case 'map':
+            return '오리지널 맵'
+        case 'server-pack':
+            return '플러그인 맵 + 서버팩'
+        case 'modpack':
+        default:
+            return '모드팩'
+    }
+}
+
+function createInstallBadge(text){
+    const badge = document.createElement('span')
+    badge.className = 'launcherBadge'
+    badge.textContent = text
+    return badge
+}
+
+function createInfoLine(label, value){
+    const line = document.createElement('div')
+    line.className = 'launcherInfoLine'
+
+    const labelElement = document.createElement('span')
+    labelElement.className = 'launcherInfoLabel'
+    labelElement.textContent = label
+
+    const valueElement = document.createElement('span')
+    valueElement.className = 'launcherInfoValue'
+    valueElement.textContent = value
+
+    line.appendChild(labelElement)
+    line.appendChild(valueElement)
+    return line
+}
+
+function showInstallMessage(title, message){
+    if(typeof setOverlayContent === 'function'){
+        setOverlayContent(title, message, '확인')
+        setOverlayHandler(() => toggleOverlay(false))
+        toggleOverlay(true)
+    }
+}
+
+function buildDetailText(profile){
+    if(typeof profile.details === 'string' && profile.details.trim().length > 0){
+        return profile.details.trim()
+    }
+
+    switch(profile.kind){
+        case 'map':
+            return '이 프로필은 싱글플레이 월드를 바로 실행하기 위한 항목입니다. 필요한 클라이언트 배포 파일과 월드 자료는 관리자가 미리 등록해둡니다.'
+        case 'server-pack':
+            return '이 프로필은 서버 실행/접속 흐름을 함께 다루는 항목입니다. 클라이언트 파일과 서버 번들은 관리자가 미리 등록하며, 사용자는 라이브러리에서 실행과 접속만 진행합니다.'
+        case 'modpack':
+        default:
+            return '이 프로필은 일반 모드팩 클라이언트입니다. 필요한 배포 파일은 관리자가 미리 등록하며, 사용자는 라이브러리에 추가한 뒤 실행만 하면 됩니다.'
+    }
+}
+
+function renderDetailPanel(profile){
+    const installedIds = new Set(
+        ConfigManager.getInstalledLibraryProfiles().map((installedProfile) => installedProfile.id)
+    )
+    const installed = installedIds.has(profile.id)
+
+    installDetailTitle.textContent = profile.name
+    installDetailSummary.textContent = profile.description || '설명이 없습니다.'
+    installDetailMeta.innerHTML = ''
+    installDetailMeta.appendChild(createInstallBadge(describeProfileKind(profile.kind)))
+    if(installed){
+        installDetailMeta.appendChild(createInstallBadge('라이브러리 보유'))
+    }
+    if(!profile.launchReady){
+        installDetailMeta.appendChild(createInstallBadge('실행 준비 필요'))
+    }
+    if(profile.kind === 'server-pack' && profile.hostReady){
+        installDetailMeta.appendChild(createInstallBadge('로컬 호스팅 가능'))
+    }
+
+    installDetailInfo.innerHTML = ''
+    installDetailInfo.appendChild(createInfoLine('프로필 ID', profile.id))
+    installDetailInfo.appendChild(createInfoLine('종류', describeProfileKind(profile.kind)))
+    installDetailInfo.appendChild(createInfoLine('실행 준비', profile.launchReady ? '완료' : '추가 설정 필요'))
+
+    if(profile.defaultServerAddress){
+        installDetailInfo.appendChild(createInfoLine('기본 주소', profile.defaultServerAddress))
+    }
+    if(profile.kind === 'map' && profile.worldDirectoryName){
+        installDetailInfo.appendChild(createInfoLine('월드 폴더', profile.worldDirectoryName))
+    }
+    if(profile.kind === 'server-pack'){
+        installDetailInfo.appendChild(createInfoLine('로컬 호스팅', profile.hostReady ? '가능' : '관리자 설정 필요'))
+    }
+    if(profile.launchIssues.length > 0){
+        installDetailInfo.appendChild(createInfoLine('확인 필요', profile.launchIssues.join(' / ')))
+    } else if(profile.hostIssues.length > 0){
+        installDetailInfo.appendChild(createInfoLine('호스팅 참고', profile.hostIssues.join(' / ')))
+    }
+
+    installDetailBody.textContent = buildDetailText(profile)
+    installDetailAddButton.disabled = installed || !profile.launchReady
+    installDetailAddButton.textContent = installed ? '이미 라이브러리에 있음' : '라이브러리에 추가'
+    installDetailAddButton.onclick = async () => {
+        try {
+            const installedProfile = await CatalogManager.installProfile(profile.id)
+            await ProfileAssetManager.prefetchProfileAssets(installedProfile)
+            if(installedProfile.kind === 'server-pack' && installedProfile.hostReady){
+                await ProfileAssetManager.ensureServerBundleInstalled(installedProfile)
+            }
+            renderDetailPanel(profile)
+            await renderInstallView()
+            if(typeof refreshLibraryView === 'function'){
+                await refreshLibraryView()
+            }
+            showInstallMessage('추가 완료', `${profile.name} 프로필을 라이브러리에 추가했습니다.`)
+        } catch (error) {
+            console.error(error)
+            const message = error instanceof Error ? error.message : '프로필 설치 중 오류가 발생했습니다.'
+            showInstallMessage('설치 실패', message)
+        }
+    }
+}
+
+function renderEmptyDetailPanel(){
+    installDetailTitle.textContent = '프로필을 선택하세요'
+    installDetailSummary.textContent = '왼쪽 목록에서 모드팩, 맵, 서버팩을 고르면 자세한 설명과 설치 조건을 볼 수 있습니다.'
+    installDetailMeta.innerHTML = ''
+    installDetailInfo.innerHTML = ''
+    installDetailBody.textContent = '관리자가 등록한 프로필 상세 설명이 여기에 표시됩니다.'
+    installDetailAddButton.disabled = true
+    installDetailAddButton.textContent = '라이브러리에 추가'
+    installDetailAddButton.onclick = null
+}
+
+function selectProfile(profileId){
+    selectedProfileId = profileId
+    if(latestCatalog == null){
+        renderEmptyDetailPanel()
+        return
+    }
+
+    const profile = latestCatalog.profiles.find((entry) => entry.id === profileId)
+    if(profile == null){
+        renderEmptyDetailPanel()
+        return
+    }
+
+    renderDetailPanel(profile)
+}
+
+async function renderInstallView(){
+    installCatalogList.innerHTML = ''
+
+    try {
+        const catalog = await CatalogManager.loadCatalog()
+        latestCatalog = catalog
+        const installedIds = new Set(
+            ConfigManager.getInstalledLibraryProfiles().map((profile) => profile.id)
+        )
+
+        if(catalog.sourceError != null){
+            const warningCard = document.createElement('article')
+            warningCard.className = 'launcherCard'
+            warningCard.innerHTML = '<h3 class="launcherCardTitle">카탈로그 로드 경고</h3><p class="launcherCardDescription">관리자가 등록한 카탈로그를 읽지 못했습니다. 현재 보이는 목록이 없다면 배포 주소 또는 로컬 카탈로그 파일을 관리자 측에서 확인해야 합니다.</p>'
+            installCatalogList.appendChild(warningCard)
+        }
+
+        for(const profile of catalog.profiles){
+            const card = document.createElement('article')
+            card.className = 'launcherCard'
+            if(profile.id === selectedProfileId){
+                card.setAttribute('selected', 'true')
+            }
+
+            const header = document.createElement('div')
+            header.className = 'launcherCardHeader'
+
+            const titleGroup = document.createElement('div')
+            titleGroup.className = 'launcherCardTitleGroup'
+
+            const title = document.createElement('h3')
+            title.className = 'launcherCardTitle'
+            title.textContent = profile.name
+
+            const meta = document.createElement('div')
+            meta.className = 'launcherCardMeta'
+            meta.appendChild(createInstallBadge(describeProfileKind(profile.kind)))
+            if(installedIds.has(profile.id)){
+                meta.appendChild(createInstallBadge('설치됨'))
+            }
+            if(profile.kind === 'server-pack' && profile.hostReady){
+                meta.appendChild(createInstallBadge('호스팅 가능'))
+            }
+
+            titleGroup.appendChild(title)
+            titleGroup.appendChild(meta)
+            header.appendChild(titleGroup)
+
+            const description = document.createElement('p')
+            description.className = 'launcherCardDescription'
+            description.textContent = profile.description || '설명이 없습니다.'
+
+            const actions = document.createElement('div')
+            actions.className = 'launcherCardActions'
+
+            const detailButton = document.createElement('button')
+            detailButton.className = 'launcherSecondaryButton'
+            detailButton.textContent = '자세히 보기'
+            detailButton.addEventListener('click', () => {
+                selectProfile(profile.id)
+                renderInstallView()
+            })
+
+            const installButton = document.createElement('button')
+            installButton.className = 'launcherPrimaryButton'
+            installButton.textContent = installedIds.has(profile.id) ? '설치됨' : '라이브러리에 추가'
+            installButton.disabled = installedIds.has(profile.id) || !profile.launchReady
+            installButton.addEventListener('click', async () => {
+                try {
+                    const installedProfile = await CatalogManager.installProfile(profile.id)
+                    await ProfileAssetManager.prefetchProfileAssets(installedProfile)
+                    if(installedProfile.kind === 'server-pack' && installedProfile.hostReady){
+                        await ProfileAssetManager.ensureServerBundleInstalled(installedProfile)
+                    }
+                    selectProfile(profile.id)
+                    await renderInstallView()
+                    if(typeof refreshLibraryView === 'function'){
+                        await refreshLibraryView()
+                    }
+                    showInstallMessage('추가 완료', `${profile.name} 프로필을 라이브러리에 추가했습니다.`)
+                } catch (error) {
+                    console.error(error)
+                    const message = error instanceof Error ? error.message : '프로필 설치 중 오류가 발생했습니다.'
+                    showInstallMessage('설치 실패', message)
+                }
+            })
+
+            actions.appendChild(detailButton)
+            actions.appendChild(installButton)
+
+            card.appendChild(header)
+            card.appendChild(description)
+            card.appendChild(actions)
+            installCatalogList.appendChild(card)
+        }
+
+        if(catalog.profiles.length === 0){
+            renderEmptyDetailPanel()
+            return
+        }
+
+        const selectedProfileStillExists = catalog.profiles.some((profile) => profile.id === selectedProfileId)
+        if(!selectedProfileStillExists){
+            selectedProfileId = catalog.profiles[0].id
+        }
+
+        selectProfile(selectedProfileId)
+    } catch (error) {
+        console.error(error)
+        latestCatalog = null
+        renderEmptyDetailPanel()
+
+        const errorCard = document.createElement('article')
+        errorCard.className = 'launcherCard'
+        errorCard.innerHTML = '<h3 class="launcherCardTitle">카탈로그 로드 실패</h3><p class="launcherCardDescription">관리자가 등록한 카탈로그를 읽지 못했습니다.</p>'
+        installCatalogList.appendChild(errorCard)
+    }
+}
+
+document.getElementById('installOpenSettingsButton').addEventListener('click', async () => {
+    await prepareSettings()
+    switchView(getCurrentView(), VIEWS.settings)
+})
+
+document.getElementById('installBackToLibraryButton').addEventListener('click', async () => {
+    if(typeof refreshLibraryView === 'function'){
+        await refreshLibraryView()
+    }
+    switchView(getCurrentView(), VIEWS.library)
+})
+
+document.getElementById('installDetailOpenLibraryButton').addEventListener('click', async () => {
+    if(typeof refreshLibraryView === 'function'){
+        await refreshLibraryView()
+    }
+    switchView(getCurrentView(), VIEWS.library)
+})
+
+window.refreshInstallView = renderInstallView
+renderEmptyDetailPanel()
+renderInstallView()

app/assets/js/scripts/library.js

@@ -0,0 +1,417 @@
+const { clipboard } = require('electron')
+
+const CatalogManager = require('./assets/js/catalogmanager')
+const ConfigManager = require('./assets/js/configmanager')
+const ProfileAssetManager = require('./assets/js/profileassetmanager')
+const ServerRuntime = require('./assets/js/serverruntime')
+const { DistroAPI } = require('./assets/js/distromanager')
+
+const libraryList = document.getElementById('libraryList')
+const libraryEmptyState = document.getElementById('libraryEmptyState')
+
+function renderLibraryEmptyState(isEmpty){
+    libraryEmptyState.style.display = isEmpty ? 'flex' : 'none'
+}
+
+function createBadge(text){
+    const badge = document.createElement('span')
+    badge.className = 'launcherBadge'
+    badge.textContent = text
+    return badge
+}
+
+function describeProfileKind(kind){
+    switch(kind){
+        case 'map':
+            return '맵'
+        case 'server-pack':
+            return '서버팩'
+        case 'modpack':
+        default:
+            return '모드팩'
+    }
+}
+
+function createParagraph(className, text){
+    const element = document.createElement('p')
+    element.className = className
+    element.textContent = text
+    return element
+}
+
+function createInfoLine(label, value){
+    const line = document.createElement('div')
+    line.className = 'launcherInfoLine'
+
+    const labelElement = document.createElement('span')
+    labelElement.className = 'launcherInfoLabel'
+    labelElement.textContent = label
+
+    const valueElement = document.createElement('span')
+    valueElement.className = 'launcherInfoValue'
+    valueElement.textContent = value
+
+    line.appendChild(labelElement)
+    line.appendChild(valueElement)
+    return line
+}
+
+function showLibraryMessage(title, message){
+    if(typeof setOverlayContent === 'function'){
+        setOverlayContent(title, message, '확인')
+        setOverlayHandler(() => toggleOverlay(false))
+        toggleOverlay(true)
+    }
+}
+
+function describeAssetState(profile){
+    const state = ConfigManager.getLibraryProfileAssetState(profile.id)
+
+    if(profile.kind === 'map'){
+        if(state.worldInstalledAt){
+            return `맵 설치 완료 · ${profile.worldDirectoryName}`
+        }
+        if(profile.worldArchiveUrl){
+            return '맵 아카이브 준비 필요'
+        }
+    }
+
+    if(profile.kind === 'server-pack'){
+        if(state.serverBundleInstalledAt){
+            return '서버 번들 설치 완료'
+        }
+        if(profile.serverBundleUrl){
+            return '서버 번들 준비 필요'
+        }
+    }
+
+    return '추가 자산 없음'
+}
+
+async function prepareProfileAssets(profile){
+    try {
+        await ProfileAssetManager.prefetchProfileAssets(profile)
+        if(profile.kind === 'server-pack' && profile.hostReady){
+            await ProfileAssetManager.ensureServerBundleInstalled(profile)
+        }
+        await renderLibraryView()
+        showLibraryMessage('자료 준비 완료', `${profile.name} 자료를 준비했습니다.`)
+    } catch (error) {
+        console.error(error)
+        showLibraryMessage('자료 준비 실패', '프로필 자료를 내려받거나 해제하는 중 오류가 발생했습니다.')
+    }
+}
+
+async function activateProfile(profile, launchNow = false){
+    if(!profile.configured){
+        const firstIssue = profile.launchIssues?.[0] ?? '이 프로필은 아직 실행 조건이 충족되지 않았습니다.'
+        showLibraryMessage('프로필 설정 필요', firstIssue)
+        return
+    }
+
+    CatalogManager.selectProfile(profile.id)
+    CatalogManager.applyConfiguredProfile()
+
+    try {
+        const distro = await DistroAPI.refreshDistributionOrFallback()
+        if(distro == null){
+            throw new Error('Distribution refresh returned null.')
+        }
+
+        const currentServer = distro.getServerById(ConfigManager.getSelectedServer())
+        if(currentServer == null && typeof distro.getMainServer === 'function'){
+            const mainServer = distro.getMainServer()
+            if(mainServer != null){
+                ConfigManager.setSelectedServer(mainServer.rawServer.id)
+                ConfigManager.save()
+            }
+        }
+
+        const selectedServerId = ConfigManager.getSelectedServer()
+        if(selectedServerId != null){
+            await ProfileAssetManager.prepareProfileForLaunch(profile, selectedServerId)
+        }
+
+        onDistroRefresh(distro)
+
+        if(getCurrentView() === VIEWS.landing){
+            if(launchNow){
+                document.getElementById('launch_button').click()
+            }
+            return
+        }
+
+        switchView(getCurrentView(), VIEWS.landing, 250, 250, () => {}, () => {
+            if(launchNow){
+                document.getElementById('launch_button').click()
+            }
+        })
+    } catch (error) {
+        console.error(error)
+        showLibraryMessage('프로필 로드 실패', '선택한 프로필의 distribution.json 또는 부가 자산을 불러오지 못했습니다.')
+    }
+}
+
+function appendAddressOverrideField(profile, fieldGroup){
+    if(!profile.allowCustomServerAddress){
+        return
+    }
+
+    const label = document.createElement('label')
+    label.className = 'launcherFieldLabel'
+    label.textContent = '접속 주소'
+
+    const input = document.createElement('input')
+    input.className = 'launcherFieldInput'
+    input.type = 'text'
+    input.placeholder = profile.defaultServerAddress || 'example.com:25565'
+    input.value = ConfigManager.getLibraryServerAddressOverride(profile.id) ?? ''
+    input.addEventListener('change', () => {
+        CatalogManager.setServerAddressOverride(profile.id, input.value)
+    })
+
+    fieldGroup.appendChild(label)
+    fieldGroup.appendChild(input)
+}
+
+function appendPublishedAddressField(profile, hostState, fieldGroup){
+    if(!hostState.publishedAddress){
+        return
+    }
+
+    const label = document.createElement('label')
+    label.className = 'launcherFieldLabel'
+    label.textContent = '호스트 공개 주소'
+
+    const row = document.createElement('div')
+    row.className = 'launcherInlineField'
+
+    const input = document.createElement('input')
+    input.className = 'launcherFieldInput'
+    input.type = 'text'
+    input.readOnly = true
+    input.value = hostState.publishedAddress
+
+    const copyButton = document.createElement('button')
+    copyButton.className = 'launcherSecondaryButton'
+    copyButton.textContent = '주소 복사'
+    copyButton.addEventListener('click', () => {
+        clipboard.writeText(hostState.publishedAddress)
+    })
+
+    row.appendChild(input)
+    row.appendChild(copyButton)
+    fieldGroup.appendChild(label)
+    fieldGroup.appendChild(row)
+}
+
+async function renderLibraryView(){
+    libraryList.innerHTML = ''
+
+    try {
+        const installedProfiles = await CatalogManager.getInstalledProfiles()
+        const selectedProfileId = CatalogManager.getSelectedProfileId()
+
+        renderLibraryEmptyState(installedProfiles.length === 0)
+
+        for(const profile of installedProfiles){
+            const hostState = ServerRuntime.getHostedProfileState(profile.id)
+            const card = document.createElement('article')
+            card.className = 'launcherCard'
+            if(profile.id === selectedProfileId){
+                card.setAttribute('selected', 'true')
+            }
+
+            const header = document.createElement('div')
+            header.className = 'launcherCardHeader'
+
+            const titleGroup = document.createElement('div')
+            titleGroup.className = 'launcherCardTitleGroup'
+
+            const title = document.createElement('h3')
+            title.className = 'launcherCardTitle'
+            title.textContent = profile.name
+
+            const meta = document.createElement('div')
+            meta.className = 'launcherCardMeta'
+            meta.appendChild(createBadge(describeProfileKind(profile.kind)))
+            if(profile.isCustom){
+                meta.appendChild(createBadge('커스텀'))
+            }
+            if(profile.id === selectedProfileId){
+                meta.appendChild(createBadge('선택됨'))
+            }
+            if(profile.kind === 'map' && profile.worldDirectoryName){
+                meta.appendChild(createBadge(profile.worldDirectoryName))
+            }
+            if(profile.kind === 'map' && !profile.launchReady){
+                meta.appendChild(createBadge('맵 설정 필요'))
+            }
+            if(profile.kind === 'server-pack' && !profile.hostReady){
+                meta.appendChild(createBadge('호스팅 설정 필요'))
+            }
+            if(hostState.running){
+                meta.appendChild(createBadge(hostState.tunneling ? '서버+터널' : '서버 실행 중'))
+            }
+
+            titleGroup.appendChild(title)
+            titleGroup.appendChild(meta)
+            header.appendChild(titleGroup)
+
+            const description = createParagraph('launcherCardDescription', profile.description || '설명이 없습니다.')
+
+            const infoBlock = document.createElement('div')
+            infoBlock.className = 'launcherInfoBlock'
+            infoBlock.appendChild(createInfoLine('자료 상태', describeAssetState(profile)))
+            infoBlock.appendChild(createInfoLine('실행 준비', profile.launchReady ? '완료' : '추가 설정 필요'))
+            if(profile.defaultServerAddress){
+                infoBlock.appendChild(createInfoLine('기본 주소', profile.defaultServerAddress))
+            }
+            if(profile.kind === 'server-pack'){
+                infoBlock.appendChild(createInfoLine('로컬 호스팅', profile.hostReady ? '가능' : '서버 번들 필요'))
+            }
+            if(hostState.running){
+                infoBlock.appendChild(createInfoLine('호스트 상태', hostState.tunneling ? '터널 연결 중' : '로컬 서버 실행 중'))
+            }
+            if(profile.launchIssues?.length > 0){
+                infoBlock.appendChild(createInfoLine('확인 필요', profile.launchIssues[0]))
+            } else if(profile.hostIssues?.length > 0){
+                infoBlock.appendChild(createInfoLine('호스팅 확인', profile.hostIssues[0]))
+            }
+
+            const fieldGroup = document.createElement('div')
+            fieldGroup.className = 'launcherFieldGroup'
+            appendAddressOverrideField(profile, fieldGroup)
+            appendPublishedAddressField(profile, hostState, fieldGroup)
+
+            const actions = document.createElement('div')
+            actions.className = 'launcherCardActions'
+
+            const prepareButton = document.createElement('button')
+            prepareButton.className = 'launcherSecondaryButton'
+            prepareButton.textContent = '자료 준비'
+            prepareButton.addEventListener('click', async () => {
+                await prepareProfileAssets(profile)
+            })
+
+            const selectButton = document.createElement('button')
+            selectButton.className = 'launcherSecondaryButton'
+            selectButton.textContent = '프로필 선택'
+            selectButton.disabled = !profile.configured
+            selectButton.addEventListener('click', async () => {
+                CatalogManager.selectProfile(profile.id)
+                CatalogManager.applyConfiguredProfile()
+                await renderLibraryView()
+            })
+
+            const openButton = document.createElement('button')
+            openButton.className = 'launcherSecondaryButton'
+            openButton.textContent = '실행 화면'
+            openButton.disabled = !profile.configured
+            openButton.addEventListener('click', async () => {
+                await activateProfile(profile, false)
+            })
+
+            const launchButton = document.createElement('button')
+            launchButton.className = 'launcherPrimaryButton'
+            launchButton.textContent = profile.kind === 'map' ? '맵 실행' : '바로 실행'
+            launchButton.disabled = !profile.configured
+            launchButton.addEventListener('click', async () => {
+                await activateProfile(profile, true)
+            })
+
+            actions.appendChild(prepareButton)
+            actions.appendChild(selectButton)
+            actions.appendChild(openButton)
+            actions.appendChild(launchButton)
+
+            if(profile.kind === 'server-pack'){
+                const startHostButton = document.createElement('button')
+                startHostButton.className = 'launcherSecondaryButton'
+                startHostButton.textContent = '서버 실행'
+                startHostButton.disabled = hostState.running || !profile.hostReady
+                startHostButton.addEventListener('click', async () => {
+                    try {
+                        await ServerRuntime.startHostedProfile(profile)
+                        await renderLibraryView()
+                    } catch (error) {
+                        console.error(error)
+                        showLibraryMessage('서버 실행 실패', '서버 번들이 준비되지 않았거나 시작 명령을 찾지 못했습니다.')
+                    }
+                })
+
+                const stopHostButton = document.createElement('button')
+                stopHostButton.className = 'launcherGhostButton'
+                stopHostButton.textContent = '서버 중지'
+                stopHostButton.disabled = !hostState.running
+                stopHostButton.addEventListener('click', async () => {
+                    ServerRuntime.stopHostedProfile(profile.id)
+                    await renderLibraryView()
+                })
+
+                actions.appendChild(startHostButton)
+                actions.appendChild(stopHostButton)
+            }
+
+            const removeButton = document.createElement('button')
+            removeButton.className = 'launcherGhostButton'
+            removeButton.textContent = '제거'
+            removeButton.addEventListener('click', async () => {
+                ServerRuntime.stopHostedProfile(profile.id)
+                CatalogManager.removeProfile(profile.id)
+                await renderLibraryView()
+                if(typeof refreshInstallView === 'function'){
+                    await refreshInstallView()
+                }
+            })
+
+            actions.appendChild(removeButton)
+
+            card.appendChild(header)
+            card.appendChild(description)
+            card.appendChild(infoBlock)
+            if(fieldGroup.childNodes.length > 0){
+                card.appendChild(fieldGroup)
+            }
+            card.appendChild(actions)
+            libraryList.appendChild(card)
+        }
+    } catch (error) {
+        console.error(error)
+        renderLibraryEmptyState(false)
+        const errorCard = document.createElement('article')
+        errorCard.className = 'launcherCard'
+        errorCard.innerHTML = '<h3 class="launcherCardTitle">라이브러리 로드 실패</h3><p class="launcherCardDescription">선택한 카탈로그를 읽지 못했습니다. 설치 페이지에서 카탈로그 경로를 다시 확인하세요.</p>'
+        libraryList.appendChild(errorCard)
+    }
+}
+
+document.getElementById('libraryOpenInstallButton').addEventListener('click', async () => {
+    if(typeof refreshInstallView === 'function'){
+        await refreshInstallView()
+    }
+    switchView(getCurrentView(), VIEWS.install)
+})
+
+document.getElementById('libraryOpenSettingsButton').addEventListener('click', async () => {
+    await prepareSettings()
+    switchView(getCurrentView(), VIEWS.settings)
+})
+
+document.getElementById('libraryOpenLaunchButton').addEventListener('click', async () => {
+    const selectedProfile = CatalogManager.getSelectedProfileSync()
+    if(selectedProfile == null){
+        switchView(getCurrentView(), VIEWS.install)
+        return
+    }
+    await activateProfile(selectedProfile, false)
+})
+
+setInterval(() => {
+    if(getCurrentView() === VIEWS.library && ServerRuntime.hasRunningProfiles()){
+        renderLibraryView()
+    }
+}, 3000)
+
+window.refreshLibraryView = renderLibraryView
+renderLibraryView()

app/assets/js/scripts/login.js

@@ -0,0 +1,234 @@
+/**
+ * Script for login.ejs
+ */
+// Validation Regexes.
+const validUsername         = /^[a-zA-Z0-9_]{1,16}$/
+const basicEmail            = /^\S+@\S+\.\S+$/
+//const validEmail          = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i
+
+// Login Elements
+const loginCancelContainer  = document.getElementById('loginCancelContainer')
+const loginCancelButton     = document.getElementById('loginCancelButton')
+const loginEmailError       = document.getElementById('loginEmailError')
+const loginUsername         = document.getElementById('loginUsername')
+const loginPasswordError    = document.getElementById('loginPasswordError')
+const loginPassword         = document.getElementById('loginPassword')
+const checkmarkContainer    = document.getElementById('checkmarkContainer')
+const loginRememberOption   = document.getElementById('loginRememberOption')
+const loginButton           = document.getElementById('loginButton')
+const loginForm             = document.getElementById('loginForm')
+
+// Control variables.
+let lu = false, lp = false
+
+
+/**
+ * Show a login error.
+ * 
+ * @param {HTMLElement} element The element on which to display the error.
+ * @param {string} value The error text.
+ */
+function showError(element, value){
+    element.innerHTML = value
+    element.style.opacity = 1
+}
+
+/**
+ * Shake a login error to add emphasis.
+ * 
+ * @param {HTMLElement} element The element to shake.
+ */
+function shakeError(element){
+    if(element.style.opacity == 1){
+        element.classList.remove('shake')
+        void element.offsetWidth
+        element.classList.add('shake')
+    }
+}
+
+/**
+ * Validate that an email field is neither empty nor invalid.
+ * 
+ * @param {string} value The email value.
+ */
+function validateEmail(value){
+    if(value){
+        if(!basicEmail.test(value) && !validUsername.test(value)){
+            showError(loginEmailError, Lang.queryJS('login.error.invalidValue'))
+            loginDisabled(true)
+            lu = false
+        } else {
+            loginEmailError.style.opacity = 0
+            lu = true
+            if(lp){
+                loginDisabled(false)
+            }
+        }
+    } else {
+        lu = false
+        showError(loginEmailError, Lang.queryJS('login.error.requiredValue'))
+        loginDisabled(true)
+    }
+}
+
+/**
+ * Validate that the password field is not empty.
+ * 
+ * @param {string} value The password value.
+ */
+function validatePassword(value){
+    if(value){
+        loginPasswordError.style.opacity = 0
+        lp = true
+        if(lu){
+            loginDisabled(false)
+        }
+    } else {
+        lp = false
+        showError(loginPasswordError, Lang.queryJS('login.error.invalidValue'))
+        loginDisabled(true)
+    }
+}
+
+// Emphasize errors with shake when focus is lost.
+loginUsername.addEventListener('focusout', (e) => {
+    validateEmail(e.target.value)
+    shakeError(loginEmailError)
+})
+loginPassword.addEventListener('focusout', (e) => {
+    validatePassword(e.target.value)
+    shakeError(loginPasswordError)
+})
+
+// Validate input for each field.
+loginUsername.addEventListener('input', (e) => {
+    validateEmail(e.target.value)
+})
+loginPassword.addEventListener('input', (e) => {
+    validatePassword(e.target.value)
+})
+
+/**
+ * Enable or disable the login button.
+ * 
+ * @param {boolean} v True to enable, false to disable.
+ */
+function loginDisabled(v){
+    if(loginButton.disabled !== v){
+        loginButton.disabled = v
+    }
+}
+
+/**
+ * Enable or disable loading elements.
+ * 
+ * @param {boolean} v True to enable, false to disable.
+ */
+function loginLoading(v){
+    if(v){
+        loginButton.setAttribute('loading', v)
+        loginButton.innerHTML = loginButton.innerHTML.replace(Lang.queryJS('login.login'), Lang.queryJS('login.loggingIn'))
+    } else {
+        loginButton.removeAttribute('loading')
+        loginButton.innerHTML = loginButton.innerHTML.replace(Lang.queryJS('login.loggingIn'), Lang.queryJS('login.login'))
+    }
+}
+
+/**
+ * Enable or disable login form.
+ * 
+ * @param {boolean} v True to enable, false to disable.
+ */
+function formDisabled(v){
+    loginDisabled(v)
+    loginCancelButton.disabled = v
+    loginUsername.disabled = v
+    loginPassword.disabled = v
+    if(v){
+        checkmarkContainer.setAttribute('disabled', v)
+    } else {
+        checkmarkContainer.removeAttribute('disabled')
+    }
+    loginRememberOption.disabled = v
+}
+
+let loginViewOnSuccess = VIEWS.library
+let loginViewOnCancel = VIEWS.settings
+let loginViewCancelHandler
+
+function loginCancelEnabled(val){
+    if(val){
+        $(loginCancelContainer).show()
+    } else {
+        $(loginCancelContainer).hide()
+    }
+}
+
+loginCancelButton.onclick = (e) => {
+    switchView(getCurrentView(), loginViewOnCancel, 500, 500, () => {
+        loginUsername.value = ''
+        loginPassword.value = ''
+        loginCancelEnabled(false)
+        if(loginViewCancelHandler != null){
+            loginViewCancelHandler()
+            loginViewCancelHandler = null
+        }
+    })
+}
+
+// Disable default form behavior.
+loginForm.onsubmit = () => { return false }
+
+// Bind login button behavior.
+loginButton.addEventListener('click', () => {
+    // Disable form.
+    formDisabled(true)
+
+    // Show loading stuff.
+    loginLoading(true)
+
+    AuthManager.addMojangAccount(loginUsername.value, loginPassword.value).then((value) => {
+        updateSelectedAccount(value)
+        loginButton.innerHTML = loginButton.innerHTML.replace(Lang.queryJS('login.loggingIn'), Lang.queryJS('login.success'))
+        $('.circle-loader').toggleClass('load-complete')
+        $('.checkmark').toggle()
+        setTimeout(() => {
+            switchView(VIEWS.login, loginViewOnSuccess, 500, 500, async () => {
+                // Temporary workaround
+                if(loginViewOnSuccess === VIEWS.settings){
+                    await prepareSettings()
+                }
+                loginViewOnSuccess = VIEWS.library // Reset this for good measure.
+                loginCancelEnabled(false) // Reset this for good measure.
+                loginViewCancelHandler = null // Reset this for good measure.
+                loginUsername.value = ''
+                loginPassword.value = ''
+                $('.circle-loader').toggleClass('load-complete')
+                $('.checkmark').toggle()
+                loginLoading(false)
+                loginButton.innerHTML = loginButton.innerHTML.replace(Lang.queryJS('login.success'), Lang.queryJS('login.login'))
+                formDisabled(false)
+            })
+        }, 1000)
+    }).catch((displayableError) => {
+        loginLoading(false)
+
+        let actualDisplayableError
+        if(isDisplayableError(displayableError)) {
+            msftLoginLogger.error('Error while logging in.', displayableError)
+            actualDisplayableError = displayableError
+        } else {
+            // Uh oh.
+            msftLoginLogger.error('Unhandled error during login.', displayableError)
+            actualDisplayableError = Lang.queryJS('login.error.unknown')
+        }
+
+        setOverlayContent(actualDisplayableError.title, actualDisplayableError.desc, Lang.queryJS('login.tryAgain'))
+        setOverlayHandler(() => {
+            formDisabled(false)
+            toggleOverlay(false)
+        })
+        toggleOverlay(true)
+    })
+
+})

app/assets/js/scripts/loginOptions.js

@@ -0,0 +1,50 @@
+const loginOptionsCancelContainer = document.getElementById('loginOptionCancelContainer')
+const loginOptionMicrosoft = document.getElementById('loginOptionMicrosoft')
+const loginOptionMojang = document.getElementById('loginOptionMojang')
+const loginOptionsCancelButton = document.getElementById('loginOptionCancelButton')
+
+let loginOptionsCancellable = false
+
+let loginOptionsViewOnLoginSuccess
+let loginOptionsViewOnLoginCancel
+let loginOptionsViewOnCancel
+let loginOptionsViewCancelHandler
+
+function loginOptionsCancelEnabled(val){
+    if(val){
+        $(loginOptionsCancelContainer).show()
+    } else {
+        $(loginOptionsCancelContainer).hide()
+    }
+}
+
+loginOptionMicrosoft.onclick = (e) => {
+    switchView(getCurrentView(), VIEWS.waiting, 500, 500, () => {
+        ipcRenderer.send(
+            MSFT_OPCODE.OPEN_LOGIN,
+            loginOptionsViewOnLoginSuccess,
+            loginOptionsViewOnLoginCancel
+        )
+    })
+}
+
+loginOptionMojang.onclick = (e) => {
+    switchView(getCurrentView(), VIEWS.login, 500, 500, () => {
+        loginViewOnSuccess = loginOptionsViewOnLoginSuccess
+        loginViewOnCancel = loginOptionsViewOnLoginCancel
+        loginCancelEnabled(true)
+    })
+}
+
+loginOptionsCancelButton.onclick = (e) => {
+    switchView(getCurrentView(), loginOptionsViewOnCancel, 500, 500, () => {
+        // Clear login values (Mojang login)
+        // No cleanup needed for Microsoft.
+        loginUsername.value = ''
+        loginPassword.value = ''
+        if(loginOptionsViewCancelHandler != null){
+            loginOptionsViewCancelHandler()
+            loginOptionsViewCancelHandler = null
+        }
+    })
+}

app/assets/js/scripts/overlay.js

@@ -0,0 +1,324 @@
+/**
+ * Script for overlay.ejs
+ */
+
+/* Overlay Wrapper Functions */
+
+/**
+ * Check to see if the overlay is visible.
+ * 
+ * @returns {boolean} Whether or not the overlay is visible.
+ */
+function isOverlayVisible(){
+    return document.getElementById('main').hasAttribute('overlay')
+}
+
+let overlayHandlerContent
+
+/**
+ * Overlay keydown handler for a non-dismissable overlay.
+ * 
+ * @param {KeyboardEvent} e The keydown event.
+ */
+function overlayKeyHandler (e){
+    if(e.key === 'Enter' || e.key === 'Escape'){
+        document.getElementById(overlayHandlerContent).getElementsByClassName('overlayKeybindEnter')[0].click()
+    }
+}
+/**
+ * Overlay keydown handler for a dismissable overlay.
+ * 
+ * @param {KeyboardEvent} e The keydown event.
+ */
+function overlayKeyDismissableHandler (e){
+    if(e.key === 'Enter'){
+        document.getElementById(overlayHandlerContent).getElementsByClassName('overlayKeybindEnter')[0].click()
+    } else if(e.key === 'Escape'){
+        document.getElementById(overlayHandlerContent).getElementsByClassName('overlayKeybindEsc')[0].click()
+    }
+}
+
+/**
+ * Bind overlay keydown listeners for escape and exit.
+ * 
+ * @param {boolean} state Whether or not to add new event listeners.
+ * @param {string} content The overlay content which will be shown.
+ * @param {boolean} dismissable Whether or not the overlay is dismissable 
+ */
+function bindOverlayKeys(state, content, dismissable){
+    overlayHandlerContent = content
+    document.removeEventListener('keydown', overlayKeyHandler)
+    document.removeEventListener('keydown', overlayKeyDismissableHandler)
+    if(state){
+        if(dismissable){
+            document.addEventListener('keydown', overlayKeyDismissableHandler)
+        } else {
+            document.addEventListener('keydown', overlayKeyHandler)
+        }
+    }
+}
+
+/**
+ * Toggle the visibility of the overlay.
+ * 
+ * @param {boolean} toggleState True to display, false to hide.
+ * @param {boolean} dismissable Optional. True to show the dismiss option, otherwise false.
+ * @param {string} content Optional. The content div to be shown.
+ */
+function toggleOverlay(toggleState, dismissable = false, content = 'overlayContent'){
+    if(toggleState == null){
+        toggleState = !document.getElementById('main').hasAttribute('overlay')
+    }
+    if(typeof dismissable === 'string'){
+        content = dismissable
+        dismissable = false
+    }
+    bindOverlayKeys(toggleState, content, dismissable)
+    if(toggleState){
+        document.getElementById('main').setAttribute('overlay', true)
+        // Make things untabbable.
+        $('#main *').attr('tabindex', '-1')
+        $('#' + content).parent().children().hide()
+        $('#' + content).show()
+        if(dismissable){
+            $('#overlayDismiss').show()
+        } else {
+            $('#overlayDismiss').hide()
+        }
+        $('#overlayContainer').fadeIn({
+            duration: 250,
+            start: () => {
+                if(getCurrentView() === VIEWS.settings){
+                    document.getElementById('settingsContainer').style.backgroundColor = 'transparent'
+                }
+            }
+        })
+    } else {
+        document.getElementById('main').removeAttribute('overlay')
+        // Make things tabbable.
+        $('#main *').removeAttr('tabindex')
+        $('#overlayContainer').fadeOut({
+            duration: 250,
+            start: () => {
+                if(getCurrentView() === VIEWS.settings){
+                    document.getElementById('settingsContainer').style.backgroundColor = 'rgba(0, 0, 0, 0.50)'
+                }
+            },
+            complete: () => {
+                $('#' + content).parent().children().hide()
+                $('#' + content).show()
+                if(dismissable){
+                    $('#overlayDismiss').show()
+                } else {
+                    $('#overlayDismiss').hide()
+                }
+            }
+        })
+    }
+}
+
+async function toggleServerSelection(toggleState){
+    await prepareServerSelectionList()
+    toggleOverlay(toggleState, true, 'serverSelectContent')
+}
+
+/**
+ * Set the content of the overlay.
+ * 
+ * @param {string} title Overlay title text.
+ * @param {string} description Overlay description text.
+ * @param {string} acknowledge Acknowledge button text.
+ * @param {string} dismiss Dismiss button text.
+ */
+function setOverlayContent(title, description, acknowledge, dismiss = Lang.queryJS('overlay.dismiss')){
+    document.getElementById('overlayTitle').innerHTML = title
+    document.getElementById('overlayDesc').innerHTML = description
+    document.getElementById('overlayAcknowledge').innerHTML = acknowledge
+    document.getElementById('overlayDismiss').innerHTML = dismiss
+}
+
+/**
+ * Set the onclick handler of the overlay acknowledge button.
+ * If the handler is null, a default handler will be added.
+ * 
+ * @param {function} handler 
+ */
+function setOverlayHandler(handler){
+    if(handler == null){
+        document.getElementById('overlayAcknowledge').onclick = () => {
+            toggleOverlay(false)
+        }
+    } else {
+        document.getElementById('overlayAcknowledge').onclick = handler
+    }
+}
+
+/**
+ * Set the onclick handler of the overlay dismiss button.
+ * If the handler is null, a default handler will be added.
+ * 
+ * @param {function} handler 
+ */
+function setDismissHandler(handler){
+    if(handler == null){
+        document.getElementById('overlayDismiss').onclick = () => {
+            toggleOverlay(false)
+        }
+    } else {
+        document.getElementById('overlayDismiss').onclick = handler
+    }
+}
+
+/* Server Select View */
+
+document.getElementById('serverSelectConfirm').addEventListener('click', async () => {
+    const listings = document.getElementsByClassName('serverListing')
+    for(let i=0; i<listings.length; i++){
+        if(listings[i].hasAttribute('selected')){
+            const serv = (await DistroAPI.getDistribution()).getServerById(listings[i].getAttribute('servid'))
+            updateSelectedServer(serv)
+            refreshServerStatus(true)
+            toggleOverlay(false)
+            return
+        }
+    }
+    // None are selected? Not possible right? Meh, handle it.
+    if(listings.length > 0){
+        const serv = (await DistroAPI.getDistribution()).getServerById(listings[i].getAttribute('servid'))
+        updateSelectedServer(serv)
+        toggleOverlay(false)
+    }
+})
+
+document.getElementById('accountSelectConfirm').addEventListener('click', async () => {
+    const listings = document.getElementsByClassName('accountListing')
+    for(let i=0; i<listings.length; i++){
+        if(listings[i].hasAttribute('selected')){
+            const authAcc = ConfigManager.setSelectedAccount(listings[i].getAttribute('uuid'))
+            ConfigManager.save()
+            updateSelectedAccount(authAcc)
+            if(getCurrentView() === VIEWS.settings) {
+                await prepareSettings()
+            }
+            toggleOverlay(false)
+            validateSelectedAccount()
+            return
+        }
+    }
+    // None are selected? Not possible right? Meh, handle it.
+    if(listings.length > 0){
+        const authAcc = ConfigManager.setSelectedAccount(listings[0].getAttribute('uuid'))
+        ConfigManager.save()
+        updateSelectedAccount(authAcc)
+        if(getCurrentView() === VIEWS.settings) {
+            await prepareSettings()
+        }
+        toggleOverlay(false)
+        validateSelectedAccount()
+    }
+})
+
+// Bind server select cancel button.
+document.getElementById('serverSelectCancel').addEventListener('click', () => {
+    toggleOverlay(false)
+})
+
+document.getElementById('accountSelectCancel').addEventListener('click', () => {
+    $('#accountSelectContent').fadeOut(250, () => {
+        $('#overlayContent').fadeIn(250)
+    })
+})
+
+function setServerListingHandlers(){
+    const listings = Array.from(document.getElementsByClassName('serverListing'))
+    listings.map((val) => {
+        val.onclick = e => {
+            if(val.hasAttribute('selected')){
+                return
+            }
+            const cListings = document.getElementsByClassName('serverListing')
+            for(let i=0; i<cListings.length; i++){
+                if(cListings[i].hasAttribute('selected')){
+                    cListings[i].removeAttribute('selected')
+                }
+            }
+            val.setAttribute('selected', '')
+            document.activeElement.blur()
+        }
+    })
+}
+
+function setAccountListingHandlers(){
+    const listings = Array.from(document.getElementsByClassName('accountListing'))
+    listings.map((val) => {
+        val.onclick = e => {
+            if(val.hasAttribute('selected')){
+                return
+            }
+            const cListings = document.getElementsByClassName('accountListing')
+            for(let i=0; i<cListings.length; i++){
+                if(cListings[i].hasAttribute('selected')){
+                    cListings[i].removeAttribute('selected')
+                }
+            }
+            val.setAttribute('selected', '')
+            document.activeElement.blur()
+        }
+    })
+}
+
+async function populateServerListings(){
+    const distro = await DistroAPI.getDistribution()
+    const giaSel = ConfigManager.getSelectedServer()
+    const servers = distro.servers
+    let htmlString = ''
+    for(const serv of servers){
+        htmlString += `<button class="serverListing" servid="${serv.rawServer.id}" ${serv.rawServer.id === giaSel ? 'selected' : ''}>
+            <img class="serverListingImg" src="${serv.rawServer.icon}"/>
+            <div class="serverListingDetails">
+                <span class="serverListingName">${serv.rawServer.name}</span>
+                <span class="serverListingDescription">${serv.rawServer.description}</span>
+                <div class="serverListingInfo">
+                    <div class="serverListingVersion">${serv.rawServer.minecraftVersion}</div>
+                    <div class="serverListingRevision">${serv.rawServer.version}</div>
+                    ${serv.rawServer.mainServer ? `<div class="serverListingStarWrapper">
+                        <svg id="Layer_1" viewBox="0 0 107.45 104.74" width="20px" height="20px">
+                            <defs>
+                                <style>.cls-1{fill:#fff;}.cls-2{fill:none;stroke:#fff;stroke-miterlimit:10;}</style>
+                            </defs>
+                            <path class="cls-1" d="M100.93,65.54C89,62,68.18,55.65,63.54,52.13c2.7-5.23,18.8-19.2,28-27.55C81.36,31.74,63.74,43.87,58.09,45.3c-2.41-5.37-3.61-26.52-4.37-39-.77,12.46-2,33.64-4.36,39-5.7-1.46-23.3-13.57-33.49-20.72,9.26,8.37,25.39,22.36,28,27.55C39.21,55.68,18.47,62,6.52,65.55c12.32-2,33.63-6.06,39.34-4.9-.16,5.87-8.41,26.16-13.11,37.69,6.1-10.89,16.52-30.16,21-33.9,4.5,3.79,14.93,23.09,21,34C70,86.84,61.73,66.48,61.59,60.65,67.36,59.49,88.64,63.52,100.93,65.54Z"/>
+                            <circle class="cls-2" cx="53.73" cy="53.9" r="38"/>
+                        </svg>
+                        <span class="serverListingStarTooltip">${Lang.queryJS('settings.serverListing.mainServer')}</span>
+                    </div>` : ''}
+                </div>
+            </div>
+        </button>`
+    }
+    document.getElementById('serverSelectListScrollable').innerHTML = htmlString
+
+}
+
+function populateAccountListings(){
+    const accountsObj = ConfigManager.getAuthAccounts()
+    const accounts = Array.from(Object.keys(accountsObj), v=>accountsObj[v])
+    let htmlString = ''
+    for(let i=0; i<accounts.length; i++){
+        htmlString += `<button class="accountListing" uuid="${accounts[i].uuid}" ${i===0 ? 'selected' : ''}>
+            <img src="https://mc-heads.net/head/${accounts[i].uuid}/40">
+            <div class="accountListingName">${accounts[i].displayName}</div>
+        </button>`
+    }
+    document.getElementById('accountSelectListScrollable').innerHTML = htmlString
+
+}
+
+async function prepareServerSelectionList(){
+    await populateServerListings()
+    setServerListingHandlers()
+}
+
+function prepareAccountSelectionList(){
+    populateAccountListings()
+    setAccountListingHandlers()
+}

app/assets/js/scripts/uibinder.js

@@ -0,0 +1,468 @@
+/**
+ * Initialize UI functions which depend on internal modules.
+ * Loaded after core UI functions are initialized in uicore.js.
+ */
+// Requirements
+const path          = require('path')
+const { Type }      = require('helios-distribution-types')
+
+const AuthManager   = require('./assets/js/authmanager')
+const ConfigManager = require('./assets/js/configmanager')
+const { DistroAPI } = require('./assets/js/distromanager')
+
+let rscShouldLoad = false
+let fatalStartupError = false
+
+// Mapping of each view to their container IDs.
+const VIEWS = {
+    landing: '#landingContainer',
+    library: '#libraryContainer',
+    install: '#installContainer',
+    loginOptions: '#loginOptionsContainer',
+    login: '#loginContainer',
+    settings: '#settingsContainer',
+    welcome: '#welcomeContainer',
+    waiting: '#waitingContainer'
+}
+
+// The currently shown view container.
+let currentView
+
+/**
+ * Switch launcher views.
+ * 
+ * @param {string} current The ID of the current view container. 
+ * @param {*} next The ID of the next view container.
+ * @param {*} currentFadeTime Optional. The fade out time for the current view.
+ * @param {*} nextFadeTime Optional. The fade in time for the next view.
+ * @param {*} onCurrentFade Optional. Callback function to execute when the current
+ * view fades out.
+ * @param {*} onNextFade Optional. Callback function to execute when the next view
+ * fades in.
+ */
+function switchView(current, next, currentFadeTime = 500, nextFadeTime = 500, onCurrentFade = () => {}, onNextFade = () => {}){
+    currentView = next
+    $(`${current}`).fadeOut(currentFadeTime, async () => {
+        await onCurrentFade()
+        $(`${next}`).fadeIn(nextFadeTime, async () => {
+            await onNextFade()
+        })
+    })
+}
+
+/**
+ * Get the currently shown view container.
+ * 
+ * @returns {string} The currently shown view container.
+ */
+function getCurrentView(){
+    return currentView
+}
+
+async function showMainUI(data){
+
+    if(!isDev){
+        loggerAutoUpdater.info('Initializing..')
+        ipcRenderer.send('autoUpdateAction', 'initAutoUpdater', ConfigManager.getAllowPrerelease())
+    }
+
+    await prepareSettings(true)
+    updateSelectedServer(data.getServerById(ConfigManager.getSelectedServer()))
+    refreshServerStatus()
+    setTimeout(() => {
+        document.getElementById('frameBar').style.backgroundColor = 'rgba(0, 0, 0, 0.5)'
+        document.body.style.backgroundImage = `url('assets/images/backgrounds/${document.body.getAttribute('bkid')}.png')`
+        $('#main').show()
+
+        const isLoggedIn = Object.keys(ConfigManager.getAuthAccounts()).length > 0
+
+        // If this is enabled in a development environment we'll get ratelimited.
+        // The relaunch frequency is usually far too high.
+        if(!isDev && isLoggedIn){
+            validateSelectedAccount()
+        }
+
+        if(ConfigManager.isFirstLaunch()){
+            currentView = VIEWS.welcome
+            $(VIEWS.welcome).fadeIn(1000)
+        } else {
+            if(isLoggedIn){
+                currentView = VIEWS.library
+                $(VIEWS.library).fadeIn(1000)
+            } else {
+                loginOptionsCancelEnabled(false)
+                loginOptionsViewOnLoginSuccess = VIEWS.library
+                loginOptionsViewOnLoginCancel = VIEWS.loginOptions
+                currentView = VIEWS.loginOptions
+                $(VIEWS.loginOptions).fadeIn(1000)
+            }
+        }
+
+        setTimeout(() => {
+            $('#loadingContainer').fadeOut(500, () => {
+                $('#loadSpinnerImage').removeClass('rotating')
+            })
+        }, 250)
+        
+    }, 750)
+    // Disable tabbing to the news container.
+    initNews().then(() => {
+        $('#newsContainer *').attr('tabindex', '-1')
+    })
+}
+
+function showFatalStartupError(){
+    setTimeout(() => {
+        $('#loadingContainer').fadeOut(250, () => {
+            document.getElementById('overlayContainer').style.background = 'none'
+            setOverlayContent(
+                Lang.queryJS('uibinder.startup.fatalErrorTitle'),
+                Lang.queryJS('uibinder.startup.fatalErrorMessage'),
+                Lang.queryJS('uibinder.startup.closeButton')
+            )
+            setOverlayHandler(() => {
+                const window = remote.getCurrentWindow()
+                window.close()
+            })
+            toggleOverlay(true)
+        })
+    }, 750)
+}
+
+/**
+ * Common functions to perform after refreshing the distro index.
+ * 
+ * @param {Object} data The distro index object.
+ */
+function onDistroRefresh(data){
+    updateSelectedServer(data.getServerById(ConfigManager.getSelectedServer()))
+    refreshServerStatus()
+    initNews()
+    syncModConfigurations(data)
+    ensureJavaSettings(data)
+}
+
+/**
+ * Sync the mod configurations with the distro index.
+ * 
+ * @param {Object} data The distro index object.
+ */
+function syncModConfigurations(data){
+
+    const syncedCfgs = []
+
+    for(let serv of data.servers){
+
+        const id = serv.rawServer.id
+        const mdls = serv.modules
+        const cfg = ConfigManager.getModConfiguration(id)
+
+        if(cfg != null){
+
+            const modsOld = cfg.mods
+            const mods = {}
+
+            for(let mdl of mdls){
+                const type = mdl.rawModule.type
+
+                if(type === Type.ForgeMod || type === Type.LiteMod || type === Type.LiteLoader || type === Type.FabricMod){
+                    if(!mdl.getRequired().value){
+                        const mdlID = mdl.getVersionlessMavenIdentifier()
+                        if(modsOld[mdlID] == null){
+                            mods[mdlID] = scanOptionalSubModules(mdl.subModules, mdl)
+                        } else {
+                            mods[mdlID] = mergeModConfiguration(modsOld[mdlID], scanOptionalSubModules(mdl.subModules, mdl), false)
+                        }
+                    } else {
+                        if(mdl.subModules.length > 0){
+                            const mdlID = mdl.getVersionlessMavenIdentifier()
+                            const v = scanOptionalSubModules(mdl.subModules, mdl)
+                            if(typeof v === 'object'){
+                                if(modsOld[mdlID] == null){
+                                    mods[mdlID] = v
+                                } else {
+                                    mods[mdlID] = mergeModConfiguration(modsOld[mdlID], v, true)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            syncedCfgs.push({
+                id,
+                mods
+            })
+
+        } else {
+
+            const mods = {}
+
+            for(let mdl of mdls){
+                const type = mdl.rawModule.type
+                if(type === Type.ForgeMod || type === Type.LiteMod || type === Type.LiteLoader || type === Type.FabricMod){
+                    if(!mdl.getRequired().value){
+                        mods[mdl.getVersionlessMavenIdentifier()] = scanOptionalSubModules(mdl.subModules, mdl)
+                    } else {
+                        if(mdl.subModules.length > 0){
+                            const v = scanOptionalSubModules(mdl.subModules, mdl)
+                            if(typeof v === 'object'){
+                                mods[mdl.getVersionlessMavenIdentifier()] = v
+                            }
+                        }
+                    }
+                }
+            }
+
+            syncedCfgs.push({
+                id,
+                mods
+            })
+
+        }
+    }
+
+    ConfigManager.setModConfigurations(syncedCfgs)
+    ConfigManager.save()
+}
+
+/**
+ * Ensure java configurations are present for the available servers.
+ * 
+ * @param {Object} data The distro index object.
+ */
+function ensureJavaSettings(data) {
+
+    // Nothing too fancy for now.
+    for(const serv of data.servers){
+        ConfigManager.ensureJavaConfig(serv.rawServer.id, serv.effectiveJavaOptions, serv.rawServer.javaOptions?.ram)
+    }
+
+    ConfigManager.save()
+}
+
+/**
+ * Recursively scan for optional sub modules. If none are found,
+ * this function returns a boolean. If optional sub modules do exist,
+ * a recursive configuration object is returned.
+ * 
+ * @returns {boolean | Object} The resolved mod configuration.
+ */
+function scanOptionalSubModules(mdls, origin){
+    if(mdls != null){
+        const mods = {}
+
+        for(let mdl of mdls){
+            const type = mdl.rawModule.type
+            // Optional types.
+            if(type === Type.ForgeMod || type === Type.LiteMod || type === Type.LiteLoader || type === Type.FabricMod){
+                // It is optional.
+                if(!mdl.getRequired().value){
+                    mods[mdl.getVersionlessMavenIdentifier()] = scanOptionalSubModules(mdl.subModules, mdl)
+                } else {
+                    if(mdl.hasSubModules()){
+                        const v = scanOptionalSubModules(mdl.subModules, mdl)
+                        if(typeof v === 'object'){
+                            mods[mdl.getVersionlessMavenIdentifier()] = v
+                        }
+                    }
+                }
+            }
+        }
+
+        if(Object.keys(mods).length > 0){
+            const ret = {
+                mods
+            }
+            if(!origin.getRequired().value){
+                ret.value = origin.getRequired().def
+            }
+            return ret
+        }
+    }
+    return origin.getRequired().def
+}
+
+/**
+ * Recursively merge an old configuration into a new configuration.
+ * 
+ * @param {boolean | Object} o The old configuration value.
+ * @param {boolean | Object} n The new configuration value.
+ * @param {boolean} nReq If the new value is a required mod.
+ * 
+ * @returns {boolean | Object} The merged configuration.
+ */
+function mergeModConfiguration(o, n, nReq = false){
+    if(typeof o === 'boolean'){
+        if(typeof n === 'boolean') return o
+        else if(typeof n === 'object'){
+            if(!nReq){
+                n.value = o
+            }
+            return n
+        }
+    } else if(typeof o === 'object'){
+        if(typeof n === 'boolean') return typeof o.value !== 'undefined' ? o.value : true
+        else if(typeof n === 'object'){
+            if(!nReq){
+                n.value = typeof o.value !== 'undefined' ? o.value : true
+            }
+
+            const newMods = Object.keys(n.mods)
+            for(let i=0; i<newMods.length; i++){
+
+                const mod = newMods[i]
+                if(o.mods[mod] != null){
+                    n.mods[mod] = mergeModConfiguration(o.mods[mod], n.mods[mod])
+                }
+            }
+
+            return n
+        }
+    }
+    // If for some reason we haven't been able to merge,
+    // wipe the old value and use the new one. Just to be safe
+    return n
+}
+
+async function validateSelectedAccount(){
+    const selectedAcc = ConfigManager.getSelectedAccount()
+    if(selectedAcc != null){
+        const val = await AuthManager.validateSelected()
+        if(!val){
+            ConfigManager.removeAuthAccount(selectedAcc.uuid)
+            ConfigManager.save()
+            const accLen = Object.keys(ConfigManager.getAuthAccounts()).length
+            setOverlayContent(
+                Lang.queryJS('uibinder.validateAccount.failedMessageTitle'),
+                accLen > 0
+                    ? Lang.queryJS('uibinder.validateAccount.failedMessage', { 'account': selectedAcc.displayName })
+                    : Lang.queryJS('uibinder.validateAccount.failedMessageSelectAnotherAccount', { 'account': selectedAcc.displayName }),
+                Lang.queryJS('uibinder.validateAccount.loginButton'),
+                Lang.queryJS('uibinder.validateAccount.selectAnotherAccountButton')
+            )
+            setOverlayHandler(() => {
+
+                const isMicrosoft = selectedAcc.type === 'microsoft'
+
+                if(isMicrosoft) {
+                    // Empty for now
+                } else {
+                    // Mojang
+                    // For convenience, pre-populate the username of the account.
+                    document.getElementById('loginUsername').value = selectedAcc.username
+                    validateEmail(selectedAcc.username)
+                }
+                
+                loginOptionsViewOnLoginSuccess = getCurrentView()
+                loginOptionsViewOnLoginCancel = VIEWS.loginOptions
+
+                if(accLen > 0) {
+                    loginOptionsViewOnCancel = getCurrentView()
+                    loginOptionsViewCancelHandler = () => {
+                        if(isMicrosoft) {
+                            ConfigManager.addMicrosoftAuthAccount(
+                                selectedAcc.uuid,
+                                selectedAcc.accessToken,
+                                selectedAcc.username,
+                                selectedAcc.expiresAt,
+                                selectedAcc.microsoft.access_token,
+                                selectedAcc.microsoft.refresh_token,
+                                selectedAcc.microsoft.expires_at
+                            )
+                        } else {
+                            ConfigManager.addMojangAuthAccount(selectedAcc.uuid, selectedAcc.accessToken, selectedAcc.username, selectedAcc.displayName)
+                        }
+                        ConfigManager.save()
+                        validateSelectedAccount()
+                    }
+                    loginOptionsCancelEnabled(true)
+                } else {
+                    loginOptionsCancelEnabled(false)
+                }
+                toggleOverlay(false)
+                switchView(getCurrentView(), VIEWS.loginOptions)
+            })
+            setDismissHandler(() => {
+                if(accLen > 1){
+                    prepareAccountSelectionList()
+                    $('#overlayContent').fadeOut(250, () => {
+                        bindOverlayKeys(true, 'accountSelectContent', true)
+                        $('#accountSelectContent').fadeIn(250)
+                    })
+                } else {
+                    const accountsObj = ConfigManager.getAuthAccounts()
+                    const accounts = Array.from(Object.keys(accountsObj), v => accountsObj[v])
+                    // This function validates the account switch.
+                    setSelectedAccount(accounts[0].uuid)
+                    toggleOverlay(false)
+                }
+            })
+            toggleOverlay(true, accLen > 0)
+        } else {
+            return true
+        }
+    } else {
+        return true
+    }
+}
+
+/**
+ * Temporary function to update the selected account along
+ * with the relevent UI elements.
+ * 
+ * @param {string} uuid The UUID of the account.
+ */
+function setSelectedAccount(uuid){
+    const authAcc = ConfigManager.setSelectedAccount(uuid)
+    ConfigManager.save()
+    updateSelectedAccount(authAcc)
+    validateSelectedAccount()
+}
+
+// Synchronous Listener
+document.addEventListener('readystatechange', async () => {
+
+    if (document.readyState === 'interactive' || document.readyState === 'complete'){
+        if(rscShouldLoad){
+            rscShouldLoad = false
+            if(!fatalStartupError){
+                const data = await DistroAPI.getDistribution()
+                await showMainUI(data)
+            } else {
+                showFatalStartupError()
+            }
+        } 
+    }
+
+}, false)
+
+// Actions that must be performed after the distribution index is downloaded.
+ipcRenderer.on('distributionIndexDone', async (event, res) => {
+    if(res) {
+        const data = await DistroAPI.getDistribution()
+        syncModConfigurations(data)
+        ensureJavaSettings(data)
+        if(document.readyState === 'interactive' || document.readyState === 'complete'){
+            await showMainUI(data)
+        } else {
+            rscShouldLoad = true
+        }
+    } else {
+        fatalStartupError = true
+        if(document.readyState === 'interactive' || document.readyState === 'complete'){
+            showFatalStartupError()
+        } else {
+            rscShouldLoad = true
+        }
+    }
+})
+
+// Util for development
+async function devModeToggle() {
+    DistroAPI.toggleDevMode(true)
+    const data = await DistroAPI.refreshDistributionOrFallback()
+    ensureJavaSettings(data)
+    updateSelectedServer(data.servers[0])
+    syncModConfigurations(data)
+}

app/assets/js/scripts/uicore.js

@@ -0,0 +1,213 @@
+/**
+ * Core UI functions are initialized in this file. This prevents
+ * unexpected errors from breaking the core features. Specifically,
+ * actions in this file should not require the usage of any internal
+ * modules, excluding dependencies.
+ */
+// Requirements
+const $                              = require('jquery')
+const {ipcRenderer, shell, webFrame} = require('electron')
+const remote                         = require('@electron/remote')
+const isDev                          = require('./assets/js/isdev')
+const { LoggerUtil }                 = require('helios-core')
+const Lang                           = require('./assets/js/langloader')
+
+const loggerUICore             = LoggerUtil.getLogger('UICore')
+const loggerAutoUpdater        = LoggerUtil.getLogger('AutoUpdater')
+
+// Log deprecation and process warnings.
+process.traceProcessWarnings = true
+process.traceDeprecation = true
+
+// Disable eval function.
+window.eval = global.eval = function () {
+    throw new Error('Sorry, this app does not support window.eval().')
+}
+
+// Display warning when devtools window is opened.
+remote.getCurrentWebContents().on('devtools-opened', () => {
+    console.log('%cThe console is dark and full of terrors.', 'color: white; -webkit-text-stroke: 4px #a02d2a; font-size: 60px; font-weight: bold')
+    console.log('%cIf you\'ve been told to paste something here, you\'re being scammed.', 'font-size: 16px')
+    console.log('%cUnless you know exactly what you\'re doing, close this window.', 'font-size: 16px')
+})
+
+// Disable zoom, needed for darwin.
+webFrame.setZoomLevel(0)
+webFrame.setVisualZoomLevelLimits(1, 1)
+
+// Initialize auto updates in production environments.
+let updateCheckListener
+if(!isDev){
+    ipcRenderer.on('autoUpdateNotification', (event, arg, info) => {
+        switch(arg){
+            case 'checking-for-update':
+                loggerAutoUpdater.info('Checking for update..')
+                settingsUpdateButtonStatus(Lang.queryJS('uicore.autoUpdate.checkingForUpdateButton'), true)
+                break
+            case 'update-available':
+                loggerAutoUpdater.info('New update available', info.version)
+                
+                if(process.platform === 'darwin'){
+                    info.darwindownload = `https://github.com/peunsu/MRSLauncher/releases/download/v${info.version}/MRS-Launcher-setup-${info.version}${process.arch === 'arm64' ? '-arm64' : '-x64'}.dmg`
+                    showUpdateUI(info)
+                }
+                
+                populateSettingsUpdateInformation(info)
+                break
+            case 'update-downloaded':
+                loggerAutoUpdater.info('Update ' + info.version + ' ready to be installed.')
+                settingsUpdateButtonStatus(Lang.queryJS('uicore.autoUpdate.installNowButton'), false, () => {
+                    if(!isDev){
+                        ipcRenderer.send('autoUpdateAction', 'installUpdateNow')
+                    }
+                })
+                showUpdateUI(info)
+                break
+            case 'update-not-available':
+                loggerAutoUpdater.info('No new update found.')
+                settingsUpdateButtonStatus(Lang.queryJS('uicore.autoUpdate.checkForUpdatesButton'))
+                break
+            case 'ready':
+                updateCheckListener = setInterval(() => {
+                    ipcRenderer.send('autoUpdateAction', 'checkForUpdate')
+                }, 1800000)
+                ipcRenderer.send('autoUpdateAction', 'checkForUpdate')
+                break
+            case 'realerror':
+                if(info != null && info.code != null){
+                    if(info.code === 'ERR_UPDATER_INVALID_RELEASE_FEED'){
+                        loggerAutoUpdater.info('No suitable releases found.')
+                    } else if(info.code === 'ERR_XML_MISSED_ELEMENT'){
+                        loggerAutoUpdater.info('No releases found.')
+                    } else {
+                        loggerAutoUpdater.error('Error during update check..', info)
+                        loggerAutoUpdater.debug('Error Code:', info.code)
+                    }
+                }
+                break
+            default:
+                loggerAutoUpdater.info('Unknown argument', arg)
+                break
+        }
+    })
+}
+
+/**
+ * Send a notification to the main process changing the value of
+ * allowPrerelease. If we are running a prerelease version, then
+ * this will always be set to true, regardless of the current value
+ * of val.
+ * 
+ * @param {boolean} val The new allow prerelease value.
+ */
+function changeAllowPrerelease(val){
+    ipcRenderer.send('autoUpdateAction', 'allowPrereleaseChange', val)
+}
+
+function showUpdateUI(info){
+    //TODO Make this message a bit more informative `${info.version}`
+    document.getElementById('image_seal_container').setAttribute('update', true)
+    document.getElementById('image_seal_container').onclick = () => {
+        /*setOverlayContent('Update Available', 'A new update for the launcher is available. Would you like to install now?', 'Install', 'Later')
+        setOverlayHandler(() => {
+            if(!isDev){
+                ipcRenderer.send('autoUpdateAction', 'installUpdateNow')
+            } else {
+                console.error('Cannot install updates in development environment.')
+                toggleOverlay(false)
+            }
+        })
+        setDismissHandler(() => {
+            toggleOverlay(false)
+        })
+        toggleOverlay(true, true)*/
+        switchView(getCurrentView(), VIEWS.settings, 500, 500, () => {
+            settingsNavItemListener(document.getElementById('settingsNavUpdate'), false)
+        })
+    }
+}
+
+/* jQuery Example
+$(function(){
+    loggerUICore.info('UICore Initialized');
+})*/
+
+document.addEventListener('readystatechange', function () {
+    if (document.readyState === 'interactive'){
+        loggerUICore.info('UICore Initializing..')
+
+        // Bind close button.
+        Array.from(document.getElementsByClassName('fCb')).map((val) => {
+            val.addEventListener('click', e => {
+                const window = remote.getCurrentWindow()
+                window.close()
+            })
+        })
+
+        // Bind restore down button.
+        Array.from(document.getElementsByClassName('fRb')).map((val) => {
+            val.addEventListener('click', e => {
+                const window = remote.getCurrentWindow()
+                if(window.isMaximized()){
+                    window.unmaximize()
+                } else {
+                    window.maximize()
+                }
+                document.activeElement.blur()
+            })
+        })
+
+        // Bind minimize button.
+        Array.from(document.getElementsByClassName('fMb')).map((val) => {
+            val.addEventListener('click', e => {
+                const window = remote.getCurrentWindow()
+                window.minimize()
+                document.activeElement.blur()
+            })
+        })
+
+        // Remove focus from social media buttons once they're clicked.
+        Array.from(document.getElementsByClassName('mediaURL')).map(val => {
+            val.addEventListener('click', e => {
+                document.activeElement.blur()
+            })
+        })
+
+    } else if(document.readyState === 'complete'){
+
+        //266.01
+        //170.8
+        //53.21
+        // Bind progress bar length to length of bot wrapper
+        //const targetWidth = document.getElementById("launch_content").getBoundingClientRect().width
+        //const targetWidth2 = document.getElementById("server_selection").getBoundingClientRect().width
+        //const targetWidth3 = document.getElementById("launch_button").getBoundingClientRect().width
+
+        document.getElementById('launch_details').style.maxWidth = 266.01
+        document.getElementById('launch_progress').style.width = 170.8
+        document.getElementById('launch_details_right').style.maxWidth = 170.8
+        document.getElementById('launch_progress_label').style.width = 53.21
+        
+    }
+
+}, false)
+
+/**
+ * Open web links in the user's default browser.
+ */
+$(document).on('click', 'a[href^="http"]', function(event) {
+    event.preventDefault()
+    shell.openExternal(this.href)
+})
+
+/**
+ * Opens DevTools window if you hold (ctrl + shift + i).
+ * This will crash the program if you are using multiple
+ * DevTools, for example the chrome debugger in VS Code. 
+ */
+document.addEventListener('keydown', function (e) {
+    if((e.key === 'I' || e.key === 'i') && e.ctrlKey && e.shiftKey){
+        let window = remote.getCurrentWindow()
+        window.toggleDevTools()
+    }
+})

app/assets/js/scripts/welcome.js

@@ -0,0 +1,9 @@
+/**
+ * Script for welcome.ejs
+ */
+document.getElementById('welcomeButton').addEventListener('click', e => {
+    loginOptionsCancelEnabled(false) // False by default, be explicit.
+    loginOptionsViewOnLoginSuccess = VIEWS.library
+    loginOptionsViewOnLoginCancel = VIEWS.loginOptions
+    switchView(VIEWS.welcome, VIEWS.loginOptions)
+})

app/assets/js/serverruntime.js

@@ -0,0 +1,211 @@
+const childProcess = require('child_process')
+const fs = require('fs-extra')
+const path = require('path')
+
+const ConfigManager = require('./configmanager')
+const ProfileAssetManager = require('./profileassetmanager')
+
+const runtimes = new Map()
+
+function getRuntime(profileId){
+    if(!runtimes.has(profileId)){
+        runtimes.set(profileId, {
+            serverProcess: null,
+            tunnelProcess: null,
+            logs: [],
+            status: 'stopped',
+            publishedAddress: ConfigManager.getPublishedLibraryServerAddress(profileId)
+        })
+    }
+
+    return runtimes.get(profileId)
+}
+
+function appendLog(runtime, line){
+    runtime.logs.push(line)
+    if(runtime.logs.length > 200){
+        runtime.logs.shift()
+    }
+}
+
+function interpolateCommand(template, variables){
+    return Object.entries(variables).reduce((command, [key, value]) => {
+        return command.replaceAll(`\${${key}}`, String(value))
+    }, template)
+}
+
+function extractPublishedAddress(line, profile){
+    if(profile.tunnelAddressRegex){
+        const customRegex = new RegExp(profile.tunnelAddressRegex)
+        const customMatch = line.match(customRegex)
+        if(customMatch){
+            return customMatch[1] ?? customMatch[0]
+        }
+    }
+
+    const genericMatch = line.match(/([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}:\d+|[a-zA-Z0-9.-]+:\d{2,5})/)
+    return genericMatch ? genericMatch[1] : null
+}
+
+async function resolveServerLaunchCommand(profile, serverDirectory){
+    if(profile.serverLaunchCommand){
+        return profile.serverLaunchCommand
+    }
+
+    const startScript = process.platform === 'win32' ? 'start.bat' : 'start.sh'
+    const startScriptPath = path.join(serverDirectory, startScript)
+    if(await fs.pathExists(startScriptPath)){
+        return process.platform === 'win32' ? startScript : `./${startScript}`
+    }
+
+    const jarPath = path.join(serverDirectory, 'server.jar')
+    if(await fs.pathExists(jarPath)){
+        return 'java -jar server.jar nogui'
+    }
+
+    throw new Error('서버 시작 명령을 결정할 수 없습니다. serverLaunchCommand 또는 server.jar/start 스크립트를 준비하세요.')
+}
+
+function resolveWorkingDirectory(profile, serverDirectory){
+    if(profile.serverWorkingDirectory){
+        return path.join(serverDirectory, profile.serverWorkingDirectory)
+    }
+    return serverDirectory
+}
+
+async function startTunnelProcess(profile, runtime, serverDirectory){
+    if(!profile.tunnelCommand){
+        return null
+    }
+
+    const command = interpolateCommand(profile.tunnelCommand, {
+        port: profile.serverPort ?? 25565,
+        serverDir: serverDirectory
+    })
+
+    const tunnelProcess = childProcess.spawn(command, {
+        cwd: serverDirectory,
+        shell: true,
+        detached: false
+    })
+
+    runtime.tunnelProcess = tunnelProcess
+
+    tunnelProcess.stdout?.on('data', (chunk) => {
+        const text = chunk.toString()
+        text.split(/\r?\n/).filter(Boolean).forEach((line) => {
+            appendLog(runtime, `[tunnel] ${line}`)
+            const address = extractPublishedAddress(line, profile)
+            if(address){
+                runtime.publishedAddress = address
+                ConfigManager.setPublishedLibraryServerAddress(profile.id, address)
+                ConfigManager.save()
+            }
+        })
+    })
+
+    tunnelProcess.stderr?.on('data', (chunk) => {
+        chunk.toString().split(/\r?\n/).filter(Boolean).forEach((line) => {
+            appendLog(runtime, `[tunnel:err] ${line}`)
+        })
+    })
+
+    tunnelProcess.on('close', () => {
+        runtime.tunnelProcess = null
+    })
+
+    return tunnelProcess
+}
+
+exports.startHostedProfile = async function(profile){
+    const runtime = getRuntime(profile.id)
+    if(runtime.serverProcess != null){
+        return runtime
+    }
+
+    const serverDirectory = await ProfileAssetManager.ensureServerBundleInstalled(profile)
+    const workingDirectory = resolveWorkingDirectory(profile, serverDirectory)
+    const command = await resolveServerLaunchCommand(profile, workingDirectory)
+
+    runtime.status = 'starting'
+    runtime.publishedAddress = null
+    ConfigManager.setPublishedLibraryServerAddress(profile.id, null)
+    ConfigManager.save()
+    appendLog(runtime, `[launcher] starting server: ${command}`)
+
+    const serverProcess = childProcess.spawn(command, {
+        cwd: workingDirectory,
+        shell: true,
+        detached: false
+    })
+
+    runtime.serverProcess = serverProcess
+
+    serverProcess.stdout?.on('data', (chunk) => {
+        chunk.toString().split(/\r?\n/).filter(Boolean).forEach((line) => {
+            appendLog(runtime, `[server] ${line}`)
+            if(runtime.status !== 'running'){
+                runtime.status = 'running'
+            }
+        })
+    })
+
+    serverProcess.stderr?.on('data', (chunk) => {
+        chunk.toString().split(/\r?\n/).filter(Boolean).forEach((line) => {
+            appendLog(runtime, `[server:err] ${line}`)
+        })
+    })
+
+    serverProcess.on('close', () => {
+        runtime.serverProcess = null
+        runtime.status = 'stopped'
+        runtime.publishedAddress = null
+        ConfigManager.setPublishedLibraryServerAddress(profile.id, null)
+        ConfigManager.save()
+    })
+
+    if(profile.tunnelCommand){
+        await startTunnelProcess(profile, runtime, workingDirectory)
+    }
+
+    return runtime
+}
+
+exports.stopHostedProfile = function(profileId){
+    const runtime = getRuntime(profileId)
+
+    if(runtime.tunnelProcess != null){
+        runtime.tunnelProcess.kill()
+        runtime.tunnelProcess = null
+    }
+
+    if(runtime.serverProcess != null){
+        runtime.serverProcess.kill()
+        runtime.serverProcess = null
+    }
+
+    runtime.status = 'stopped'
+    runtime.publishedAddress = null
+    ConfigManager.setPublishedLibraryServerAddress(profileId, null)
+    ConfigManager.save()
+}
+
+exports.getHostedProfileState = function(profileId){
+    const runtime = getRuntime(profileId)
+    return {
+        status: runtime.status,
+        running: runtime.serverProcess != null,
+        tunneling: runtime.tunnelProcess != null,
+        publishedAddress: runtime.publishedAddress ?? ConfigManager.getPublishedLibraryServerAddress(profileId),
+        logs: [...runtime.logs]
+    }
+}
+
+exports.hasRunningProfiles = function(){
+    for(const runtime of runtimes.values()){
+        if(runtime.serverProcess != null || runtime.tunnelProcess != null){
+            return true
+        }
+    }
+    return false
+}

app/assets/js/serverstatus.js

@@ -0,0 +1,65 @@
+const net = require('net')
+
+/**
+ * Retrieves the status of a minecraft server.
+ * 
+ * @param {string} address The server address.
+ * @param {number} port Optional. The port of the server. Defaults to 25565.
+ * @returns {Promise.<Object>} A promise which resolves to an object containing
+ * status information.
+ */
+exports.getStatus = function(address, port = 25565){
+
+    if(port == null || port == ''){
+        port = 25565
+    }
+    if(typeof port === 'string'){
+        port = parseInt(port)
+    }
+
+    return new Promise((resolve, reject) => {
+        const socket = net.connect(port, address, () => {
+            let buff = Buffer.from([0xFE, 0x01])
+            socket.write(buff)
+        })
+
+        socket.setTimeout(2500, () => {
+            socket.end()
+            reject({
+                code: 'ETIMEDOUT',
+                errno: 'ETIMEDOUT',
+                address,
+                port
+            })
+        })
+
+        socket.on('data', (data) => {
+            if(data != null && data != ''){
+                let server_info = data.toString().split('\x00\x00\x00')
+                const NUM_FIELDS = 6
+                if(server_info != null && server_info.length >= NUM_FIELDS){
+                    resolve({
+                        online: true,
+                        version: server_info[2].replace(/\u0000/g, ''),
+                        motd: server_info[3].replace(/\u0000/g, ''),
+                        onlinePlayers: server_info[4].replace(/\u0000/g, ''),
+                        maxPlayers: server_info[5].replace(/\u0000/g,'')
+                    })
+                } else {
+                    resolve({
+                        online: false
+                    })
+                }
+            }
+            socket.end()
+        })
+
+        socket.on('error', (err) => {
+            socket.destroy()
+            reject(err)
+            // ENOTFOUND = Unable to resolve.
+            // ECONNREFUSED = Unable to connect to port.
+        })
+    })
+
+}