Altarik/Launcher
4
0
Fork 0
mirror of https://github.com/AltarikMC/Launcher synced 2024-11-21 06:09:51 +01:00
Code

Made a lot of server fixes thank to eslint

Browse Source
This commit is contained in:
Quentin Legot 2023-11-28 00:18:41 +01:00
parent 9e20458ff6
commit 5721b96601
8 changed files with 1712 additions and 590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
.eslintrc.cjs Normal file
View File

@ -0,0 +1,32 @@
module.exports = {
env: {
browser: true,
es2021: true
},
extends: [
'standard',
'plugin:vue/vue3-essential'
],
overrides: [
{
env: {
node: true
},
files: [
'.eslintrc.{js,cjs}'
],
parserOptions: {
sourceType: 'script'
}
}
],
parserOptions: {
ecmaVersion: 'latest',
sourceType: 'module'
},
plugins: [
'vue'
],
rules: {
}
}

8
package.json
View File

@ -35,7 +35,13 @@
"@electron-forge/maker-zip": "^7.1.0", "@electron-forge/maker-zip": "^7.1.0",
"@electron-forge/plugin-auto-unpack-natives": "^7.1.0", "@electron-forge/plugin-auto-unpack-natives": "^7.1.0",
"@electron-forge/publisher-github": "^7.1.0", "@electron-forge/publisher-github": "^7.1.0",
"electron": "beta" "electron": "beta",
"eslint": "^8.0.1",
"eslint-config-standard": "^17.1.0",
"eslint-plugin-import": "^2.25.2",
"eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
"eslint-plugin-promise": "^6.0.0",
"eslint-plugin-vue": "^9.18.1"
}, },
"dependencies": { "dependencies": {
"decompress": "^4.2.1", "decompress": "^4.2.1",

92
src/server/install.js
View File

@ -1,47 +1,47 @@
export default function handleSquirrelEvent(app) { export default function handleSquirrelEvent (app) {
if (process.argv.length === 1) { if (process.argv.length === 1) {
return false; return false
}
const ChildProcess = require('child_process');
const path = require('path');
const appFolder = path.resolve(process.execPath, '..');
const rootAtomFolder = path.resolve(appFolder, '..');
const updateDotExe = path.resolve(path.join(rootAtomFolder, 'Update.exe'));
const exeName = path.basename(process.execPath);
const spawn = function(command, args) {
let spawnedProcess;
try {
spawnedProcess = ChildProcess.spawn(command, args, {detached: true});
} catch (error) {}
return spawnedProcess;
};
const spawnUpdate = function(args) {
return spawn(updateDotExe, args);
};
const squirrelEvent = process.argv[1];
switch (squirrelEvent) {
case '--squirrel-install':
case '--squirrel-updated':
spawnUpdate(['--createShortcut', exeName]);
setTimeout(app.quit, 1000);
return true;
case '--squirrel-uninstall':
spawnUpdate(['--removeShortcut', exeName]);
setTimeout(app.quit, 1000);
return true;
case '--squirrel-obsolete':
app.quit();
return true;
}
} }
const ChildProcess = require('child_process')
const path = require('path')
const appFolder = path.resolve(process.execPath, '..')
const rootAtomFolder = path.resolve(appFolder, '..')
const updateDotExe = path.resolve(path.join(rootAtomFolder, 'Update.exe'))
const exeName = path.basename(process.execPath)
const spawn = function (command, args) {
let spawnedProcess
try {
spawnedProcess = ChildProcess.spawn(command, args, { detached: true })
} catch (error) {}
return spawnedProcess
}
const spawnUpdate = function (args) {
return spawn(updateDotExe, args)
}
const squirrelEvent = process.argv[1]
switch (squirrelEvent) {
case '--squirrel-install':
case '--squirrel-updated':
spawnUpdate(['--createShortcut', exeName])
setTimeout(app.quit, 1000)
return true
case '--squirrel-uninstall':
spawnUpdate(['--removeShortcut', exeName])
setTimeout(app.quit, 1000)
return true
case '--squirrel-obsolete':
app.quit()
return true
}
}

168
src/server/main.js
View File

@ -1,114 +1,112 @@
import { app, BrowserWindow, Menu, ipcMain, autoUpdater, dialog } from 'electron' import { app, BrowserWindow, Menu, ipcMain, autoUpdater, dialog } from 'electron'
import logger from 'electron-log' import isDev from 'electron-is-dev'
import { join } from 'path' import logger from 'electron-log'
import updater from './updater.js' import { join, dirname } from 'path'
import Updater from './updater.js'
import electronStartup from 'electron-squirrel-startup' import electronStartup from 'electron-squirrel-startup'
import install from "./install.js" import install from './install.js'
import mc from './minecraft.js' import Mc from './minecraft.js'
import { minimizeWindow, closeWindow } from "./menubar.js"; import { minimizeWindow, closeWindow } from './menubar.js'
import { fileURLToPath } from 'url' import { fileURLToPath } from 'url'
import { dirname } from 'path'
const updaterInstance = new Updater(app, autoUpdater, dialog, logger, showNotification)
let updaterInstance = new updater(app, autoUpdater, dialog, logger, showNotification)
updaterInstance.configUpdater() updaterInstance.configUpdater()
let minecraft = new mc() const minecraft = new Mc()
minecraft.showNotification = showNotification minecraft.showNotification = showNotification
const __filename = fileURLToPath(import.meta.url) const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename) const __dirname = dirname(__filename)
const iconPath = join(__dirname, "icon.ico") const iconPath = join(__dirname, 'icon.ico')
let win = null let win = null
function createWindow () { function createWindow () {
win = new BrowserWindow({ win = new BrowserWindow({
width: 1000, width: 1000,
height: 600, height: 600,
resizable: false, resizable: false,
icon: iconPath, icon: iconPath,
webPreferences: { webPreferences: {
nodeIntegration: true, nodeIntegration: true,
contextIsolation: false contextIsolation: false
}, },
frame: false frame: false
}) })
//Menu.setApplicationMenu(null) if (!isDev) {
win.loadFile('src/client/checkingUpdate.html') Menu.setApplicationMenu(null)
win.on("close", () => { }
app.quit()
}) win.loadFile('src/client/checkingUpdate.html')
win.on('close', () => {
app.quit()
})
} }
function showNotification(title, body="", clazz="info") { function showNotification (title, body = '', clazz = 'info') {
win.webContents.send('notification', {title: title, body: body, class: clazz}) win.webContents.send('notification', { title, body, class: clazz })
} }
ipcMain.on("disconnect", () => { ipcMain.on('disconnect', () => {
minecraft.auth = null minecraft.auth = null
win.loadFile('src/client/login.html').then(() => showNotification("Déconnecté", "Vous avez été déconnecté de votre compte", "success")) win.loadFile('src/client/login.html').then(() => showNotification('Déconnecté', 'Vous avez été déconnecté de votre compte', 'success'))
}) })
ipcMain.on("pageReady", (event) => { ipcMain.on('pageReady', (event) => {
event.sender.send("nick", { name: minecraft.auth.name }) event.sender.send('nick', { name: minecraft.auth.name })
minecraft.getModsInformations(event) minecraft.getModsInformations(event)
}) })
ipcMain.on("checking-update", () => { ipcMain.on('checking-update', () => {
updaterInstance.checkForUpdates(win, showNotification) updaterInstance.checkForUpdates(win, showNotification)
}) })
function main() { function main () {
if (electronStartup) { if (electronStartup) {
install.handleSquirrelEvent(app) install.handleSquirrelEvent(app)
app.quit() app.quit()
return return
}
app.whenReady().then(() => {
createWindow()
})
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') {
app.quit()
} }
})
app.whenReady().then(() => { ipcMain.on('minimizeWindow', () => {
createWindow() minimizeWindow(win)
}) })
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') {
app.quit()
}
})
ipcMain.on('minimizeWindow', () => {
minimizeWindow(win)
})
ipcMain.on('closeWindow', () => {
closeWindow(win)
})
app.on('activate', () => {
if (win === null){
createWindow()
}
})
ipcMain.on("login", (event, args) => {
minecraft.login(event, win, args.user, args.pass)
})
ipcMain.on("microsoft-login", (event) => {
minecraft.microsoftLogin(event, win)
})
ipcMain.on("invalidateData", event => {
minecraft.invalidateData(event)
})
ipcMain.on("launch", (event, args) => {
minecraft.launch(event, args)
})
ipcMain.on('closeWindow', () => {
closeWindow(win)
})
app.on('activate', () => {
if (win === null) {
createWindow()
}
})
ipcMain.on('login', (event, args) => {
minecraft.login(event, win, args.user, args.pass)
})
ipcMain.on('microsoft-login', (event) => {
minecraft.microsoftLogin(event, win)
})
ipcMain.on('invalidateData', event => {
minecraft.invalidateData(event)
})
ipcMain.on('launch', (event, args) => {
minecraft.launch(event, args)
})
} }
main() main()

14
src/server/menubar.js
View File

@ -1,9 +1,9 @@
export function minimizeWindow(browserWindow) { export function minimizeWindow (browserWindow) {
if(browserWindow.minimizable) { if (browserWindow.minimizable) {
browserWindow.minimize() browserWindow.minimize()
} }
} }
export function closeWindow(browserWindow) { export function closeWindow (browserWindow) {
browserWindow.close() browserWindow.close()
} }

702
src/server/minecraft.js
View File

@ -1,385 +1,375 @@
import isDev from "electron-is-dev" import isDev from 'electron-is-dev'
import mlc from "minecraft-launcher-core" import mlc from 'minecraft-launcher-core'
import fetch from "node-fetch" import fetch from 'node-fetch'
import { hashFile } from "hasha" import { hashFile } from 'hasha'
import fs from "fs" import fs from 'fs'
import { join } from "path" import { join } from 'path'
import constants from "constants" import zip from 'extract-zip'
import zip from "extract-zip" import logger from 'electron-log'
import logger from "electron-log" import { Auth, lst } from 'msmc'
import { Auth, lst } from "msmc" import decompress from 'decompress'
import decompress from "decompress" import decompressTar from 'decompress-targz'
import decompressTar from "decompress-targz"
const { Authenticator, Client } = mlc const { Authenticator, Client } = mlc
export default class Minecraft { export default class Minecraft {
appdata = process.env.APPDATA || (process.platform === 'darwin' ? process.env.HOME + '/Library/Preferences' : process.env.HOME + '/.local/share')
localappdata = process.env.LOCALAPPDATA || (process.platform === 'darwin' ? process.env.HOME + '/Library/Application Support/' : process.env.HOME + '/.config')
minecraftpath = join(this.appdata, '.altarik')
launcher = new Client()
auth = null
modsList = undefined
showNotification = undefined
modsInformationsEndpoint = 'https://launcher.altarik.fr'
appdata = process.env.APPDATA || (process.platform === "darwin" ? process.env.HOME + "/Library/Preferences" : process.env.HOME + "/.local/share") setShowNotification (showNotification) {
localappdata = process.env.LOCALAPPDATA || (process.platform === "darwin" ? process.env.HOME + "/Library/Application Support/" : process.env.HOME + "/.config") this.showNotification = showNotification
minecraftpath = join(this.appdata, ".altarik") }
launcher = new Client()
auth = null
modsList = undefined
showNotification = undefined
modsInformationsEndpoint = "https://launcher.altarik.fr"
setShowNotification(showNotification) { /**
this.showNotification = showNotification
}
/**
* @deprecated Mojang removed this method of authentification * @deprecated Mojang removed this method of authentification
* Used to login through Mojang account * Used to login through Mojang account
*/ */
login(event, win, username, password) { login (event, win, username, password) {
this.auth = null this.auth = null
if(isDev || password.trim() !== "") { if (isDev || password.trim() !== '') {
this.auth = Authenticator.getAuth(username, password) this.auth = Authenticator.getAuth(username, password)
this.auth.then(v => { this.auth.then(v => {
win.loadFile("src/client/index.html") win.loadFile('src/client/index.html')
}).catch(() => { }).catch(() => {
event.sender.send("loginError") event.sender.send('loginError')
logger.error("[MJ login] User haven't purchase the game") logger.error("[MJ login] User haven't purchase the game")
this.showNotification("Erreur de connexion", "Vous ne possèdez pas de licence Minecraft sur ce compte", "error") this.showNotification('Erreur de connexion', 'Vous ne possèdez pas de licence Minecraft sur ce compte', 'error')
}) })
} else { } else {
this.showNotification("Erreur de connexion", "Veuillez renseignez un mot de passe", "warning") this.showNotification('Erreur de connexion', 'Veuillez renseignez un mot de passe', 'warning')
}
} }
}
/** /**
* Used to login through a Microsoft account * Used to login through a Microsoft account
*/ */
microsoftLogin(event, win) { microsoftLogin (event, win) {
const authManager = new Auth("select_account") const authManager = new Auth('select_account')
authManager.launch("electron").then(async xboxManager => { authManager.launch('electron').then(async xboxManager => {
xboxManager.getMinecraft().then(async token => { xboxManager.getMinecraft().then(async token => {
if(!token.isDemo()) { if (!token.isDemo()) {
this.auth = token.mclc() this.auth = token.mclc()
logger.info("[MS login] User has been connected successfully to them account") logger.info('[MS login] User has been connected successfully to them account')
win.loadFile("src/client/index.html") win.loadFile('src/client/index.html')
} else {
event.sender.send("loginError")
logger.error("[MS login] User haven't purchase the game")
this.showNotification("Erreur de connexion", "Vous ne possèdez pas de licence Minecraft sur ce compte", "error")
}
}).catch(err => {
event.sender.send("loginError")
logger.error("[MS login] " + lst(err))
this.showNotification("Erreur de connexion à Mojang", lst(err), "error")
})
}).catch(err => {
event.sender.send("loginError")
if(err != "error.gui.closed") {
logger.error("[MS login] " + lst(err))
this.showNotification("Une erreur de connexion à Xbox est survenue", lst(err), "error")
}
})
}
launch(event, args) {
this.extractJava(Number(args.chapter), event).then((javaPath) => {
this.extractMods(Number(args.chapter), event).then((chapter) => {
this.launcher.launch({
authorization: this.auth,
root: this.minecraftpath,
javaPath: javaPath,
version: {
number: chapter.minecraftVersion,
type: chapter.type | "release",
custom: chapter.customVersion
},
memory: {
max: args.maxMem,
min: args.minMem
}
}).then(v => {
if(v === null) {
this.close(event, -1)
}
})
this.launcher.on("debug", (e) => logger.info(`debug: ${e}`));
this.launcher.on("data", (e) => logger.info(`data: ${e}`));
this.launcher.on("progress", (e) => {
event.sender.send("progress", e)
logger.info(`progress ${e.type} :${e.task} / ${e.total}`)
})
this.launcher.on("arguments", (e) => {
event.sender.send("launch", e)
logger.info("launching the game")
logger.info(e)
})
this.launcher.on("close", (e) => {
this.close(event, e)
})
}).catch((err) => {
this.showNotification("Impossible de lancer le jeu", "Erreur inconnue", "error")
event.sender.send("close", 1)
logger.error("Unable to launch the game")
logger.error(err)
})
}).catch(err => {
this.showNotification("Impossible de lancer le jeu", "Impossible d'installer Java pour votre configuration", "error")
event.sender.send("close", 1)
logger.warn("Unable to install java")
logger.warn(err)
})
}
close(event, code) {
event.sender.send("close", code)
if(code !== 0) {
logger.warn("Minecraft didn't close properly")
logger.warn(code)
this.showNotification("Une erreur est survenue", "Minecraft ne s'est pas fermé correctement", "error")
}
}
getModsInformations(event) {
fetch(this.modsInformationsEndpoint).then(response => {
if(response.ok) {
response.json().then(data => {
let folder = join(this.localappdata, "altarik-launcher", "data")
if(!fs.existsSync(folder))
fs.mkdirSync(folder, {recursive: true})
let file = join(folder, "launcher.json")
if(fs.existsSync(file))
fs.rmSync(file)
fs.writeFileSync(file, JSON.stringify(data))
event.sender.send("modsInformations", this.extractModsInformations(data))
}).catch(err => {
event.sender.send("modsInformations", this.extractModsFromFileSystem())
logger.warn(err)
logger.warn("An error occured while trying to connect to server")
})
} else {
logger.warn("Unable to connect to server")
logger.warn(err)
event.sender.send("modsInformations", this.extractModsFromFileSystem())
}
}).catch(err => {
logger.warn("Unable to connect to server")
logger.warn(err)
event.sender.send("modsInformations", this.extractModsFromFileSystem())
})
}
extractModsFromFileSystem() {
let filepath = join(this.localappdata, "altarik-launcher/data/launcher.json")
if(fs.existsSync(filepath)) {
let content = fs.readFileSync(filepath)
if(content !== null) {
this.showNotification("Impossible de récupérer certaines informations en ligne", "utilisation des dernières données récupérées", "warning")
return this.extractModsInformations(JSON.parse(content))
} else {
this.showNotification("Impossible de récupérer certaines informations en ligne", "Veuillez réessayez en cliquant sur le bouton", "warning")
logger.error("Unable to get chapters informations from server or filesystem")
return null
}
} else { } else {
return null; event.sender.send('loginError')
logger.error("[MS login] User haven't purchase the game")
this.showNotification('Erreur de connexion', 'Vous ne possèdez pas de licence Minecraft sur ce compte', 'error')
} }
} }).catch(err => {
event.sender.send('loginError')
logger.error('[MS login] ' + lst(err))
this.showNotification('Erreur de connexion à Mojang', lst(err), 'error')
})
}).catch(err => {
event.sender.send('loginError')
if (err !== 'error.gui.closed') {
logger.error('[MS login] ' + lst(err))
this.showNotification('Une erreur de connexion à Xbox est survenue', lst(err), 'error')
}
})
}
extractModsInformations(json) { launch (event, args) {
this.modsList = json.chapters this.extractJava(Number(args.chapter), event).then((javaPath) => {
return this.modsList this.extractMods(Number(args.chapter), event).then((chapter) => {
} this.launcher.launch({
authorization: this.auth,
async extractMods(chapterId, event) { root: this.minecraftpath,
return new Promise(async (resolve, reject) => { javaPath,
const modsFolder = join(this.minecraftpath, "mods") version: {
const shaderFolder = join(this.minecraftpath, "shaderpacks") number: chapter.minecraftVersion,
if(fs.existsSync(modsFolder)) type: chapter.type | 'release',
fs.rmSync(modsFolder, { recursive: true }) custom: chapter.customVersion
if(fs.existsSync(shaderFolder)) },
fs.rmSync(shaderFolder, { recursive: true }) memory: {
for(const i in this.modsList) { max: args.maxMem,
if(Number(i) === chapterId) { min: args.minMem
const chapter = this.modsList[i] }
for(let j in chapter.modspack.mods) { }).then(v => {
event.sender.send("progress", {type: "mods", task: 0, total: chapter.modspack.mods.length }) if (v === null) {
let modpackFolder = join(this.minecraftpath, "modpack", chapter.title) this.close(event, -1)
if(!fs.existsSync(modpackFolder)) }
fs.mkdirSync(modpackFolder, { recursive: true })
const path = join(modpackFolder, `modpack${j}.zip`)
try {
fs.accessSync(path, constants.W_OK)
let sha1 = await hashFile(path, {algorithm: "sha1"})
if(sha1 === chapter.modspack.sha1sum[j]) {
await this.unzipMods(path).catch(err => {
reject(err)
})
} else {
logger.warn(`sha1sum ${sha1} don't correspond to ${chapter.modspack.sha1sum[j]} of mods ${path}`)
await this.downloadAndExtractMods(chapter.modspack.mods[j], path).catch(err => {
reject(err)
})
}
event.sender.send("progress", {type: "mods", task: Number(j)+1, total: chapter.modspack.mods.length })
} catch (err) {
try {
await this.downloadAndExtractMods(chapter.modspack.mods[j], path)
} catch(e) {
reject({ err, e })
return
}
}
}
resolve(chapter)
return
}
}
reject("didn't found the correct chapter" + chapter)
}) })
} this.launcher.on('debug', (e) => logger.info(`debug: ${e}`))
downloadMods(link, path) { this.launcher.on('data', (e) => logger.info(`data: ${e}`))
return new Promise((resolve, reject) => { this.launcher.on('progress', (e) => {
fetch(link).then(response => { event.sender.send('progress', e)
if(response.ok) { logger.info(`progress ${e.type} :${e.task} / ${e.total}`)
if(fs.existsSync(path))
fs.rmSync(path)
const dest = fs.createWriteStream(path)
response.body.pipe(dest)
response.body.on("end", () => {
logger.log("download completed");
resolve("download completed")
})
dest.on("error", () => {
reject("An error appenned when using stream")
});
} else {
reject(response.status)
}
}).catch(err => {
reject(err)
})
}) })
} this.launcher.on('arguments', (e) => {
event.sender.send('launch', e)
async unzipMods(zipLocation, outLocation=this.minecraftpath) { logger.info('launching the game')
return new Promise(async (resolve, reject) => { logger.info(e)
logger.info(`unzipping ${zipLocation} file to ${outLocation}`)
zip(zipLocation, { dir: outLocation }).then(() => {
resolve()
}).catch(err => {
logger.error(`failed to unzip file`)
reject(err)
})
}) })
this.launcher.on('close', (e) => {
} this.close(event, e)
async extractTar(tarLocation, outLocation=this.microsoftpath) {
return new Promise(async (resolve, reject) => {
logger.info(`Extracting targz ${tarLocation} file to ${outLocation}`)
decompress(tarLocation, outLocation, {
plugins: [
decompressTar()
]
}).then(() => {
resolve()
}).catch((e) => {
logger.error(`Failed to extract targz file`)
reject(e)
})
}) })
} }).catch((err) => {
this.showNotification('Impossible de lancer le jeu', 'Erreur inconnue', 'error')
event.sender.send('close', 1)
logger.error('Unable to launch the game')
logger.error(err)
})
}).catch(err => {
this.showNotification('Impossible de lancer le jeu', "Impossible d'installer Java pour votre configuration", 'error')
event.sender.send('close', 1)
logger.warn('Unable to install java')
logger.warn(err)
})
}
async downloadAndExtractMods(link, path) { close (event, code) {
return new Promise(async (resolve, reject) => { event.sender.send('close', code)
this.downloadMods(link, path).then(() => { if (code !== 0) {
this.unzipMods(path).then(() => { logger.warn("Minecraft didn't close properly")
resolve() logger.warn(code)
}).catch(err => { this.showNotification('Une erreur est survenue', "Minecraft ne s'est pas fermé correctement", 'error')
reject(err) }
}
getModsInformations (event) {
fetch(this.modsInformationsEndpoint).then(response => {
if (response.ok) {
response.json().then(data => {
const folder = join(this.localappdata, 'altarik-launcher', 'data')
if (!fs.existsSync(folder)) { fs.mkdirSync(folder, { recursive: true }) }
const file = join(folder, 'launcher.json')
if (fs.existsSync(file)) { fs.rmSync(file) }
fs.writeFileSync(file, JSON.stringify(data))
event.sender.send('modsInformations', this.extractModsInformations(data))
}).catch(err => {
event.sender.send('modsInformations', this.extractModsFromFileSystem())
logger.warn(err)
logger.warn('An error occured while trying to connect to server')
})
} else {
logger.warn('Unable to connect to server')
logger.warn(response.status)
event.sender.send('modsInformations', this.extractModsFromFileSystem())
}
}).catch(err => {
logger.warn('Unable to connect to server')
logger.warn(err)
event.sender.send('modsInformations', this.extractModsFromFileSystem())
})
}
extractModsFromFileSystem () {
const filepath = join(this.localappdata, 'altarik-launcher/data/launcher.json')
if (fs.existsSync(filepath)) {
const content = fs.readFileSync(filepath)
if (content !== null) {
this.showNotification('Impossible de récupérer certaines informations en ligne', 'utilisation des dernières données récupérées', 'warning')
return this.extractModsInformations(JSON.parse(content))
} else {
this.showNotification('Impossible de récupérer certaines informations en ligne', 'Veuillez réessayez en cliquant sur le bouton', 'warning')
logger.error('Unable to get chapters informations from server or filesystem')
return null
}
} else {
return null
}
}
extractModsInformations (json) {
this.modsList = json.chapters
return this.modsList
}
async extractMods (chapterId, event) {
return new Promise(async (resolve, reject) => {
const modsFolder = join(this.minecraftpath, 'mods')
const shaderFolder = join(this.minecraftpath, 'shaderpacks')
if (fs.existsSync(modsFolder)) { fs.rmSync(modsFolder, { recursive: true }) }
if (fs.existsSync(shaderFolder)) { fs.rmSync(shaderFolder, { recursive: true }) }
for (const i in this.modsList) {
if (Number(i) === chapterId) {
const chapter = this.modsList[i]
for (const j in chapter.modspack.mods) {
event.sender.send('progress', { type: 'mods', task: 0, total: chapter.modspack.mods.length })
const modpackFolder = join(this.minecraftpath, 'modpack', chapter.title)
if (!fs.existsSync(modpackFolder)) { fs.mkdirSync(modpackFolder, { recursive: true }) }
const path = join(modpackFolder, `modpack${j}.zip`)
try {
fs.accessSync(path, fs.W_OK)
const sha1 = await hashFile(path, { algorithm: 'sha1' })
if (sha1 === chapter.modspack.sha1sum[j]) {
await this.unzipMods(path).catch(err => {
reject(err)
}) })
}).catch(err => { } else {
reject(err) logger.warn(`sha1sum ${sha1} don't correspond to ${chapter.modspack.sha1sum[j]} of mods ${path}`)
}) await this.downloadAndExtractMods(chapter.modspack.mods[j], path).catch(err => {
}) reject(err)
}
async extractJava(chapterId, event) {
return new Promise(async (resolve, reject) => {
const runtime = join(this.minecraftpath, "runtime")
if(this.modsList[chapterId].java.platform[process.platform] !== undefined
&& this.modsList[chapterId].java.platform[process.platform][process.arch] !== undefined) {
event.sender.send("progress", {type: "java", task: 0, total: 1 })
const infos = this.modsList[chapterId].java.platform[process.platform][process.arch]
const jre = join(runtime, infos.name)
const downloadFolder = join(runtime, "download")
const downloadFile = join(downloadFolder, `${infos.name}.zip`)
if(fs.existsSync(jre))
fs.rmSync(jre, { recursive: true })
if(!fs.existsSync(downloadFolder))
fs.mkdirSync(downloadFolder, { recursive: true })
if(fs.existsSync(downloadFile)) {
let sha1 = await hashFile(downloadFile, {algorithm: "sha256"})
if(sha1 === infos.sha256sum) {
await this.extractJavaArchive(downloadFile, runtime)
let filename = process.platform == "win32" ? "java.exe" : "java"
resolve(join(jre, "bin", filename))
} else {
logger.warn(`java sha256sum ${sha1} don't correspond to ${infos.sha256sum}`)
await this.downloadAndExtractJava(infos, downloadFolder, runtime).then(() => resolve(join(jre, "bin", process.platform === "win32" ? "java.exe" : "java"))).catch(err => reject(err))
}
} else {
await this.downloadAndExtractJava(infos, downloadFolder, runtime).then(() => resolve(join(jre, "bin", process.platform === "win32" ? "java.exe" : "java"))).catch(err => reject(err))
}
event.sender.send("progress", {type: "java", task: 1, total: 1 })
} else {
reject("There is not available version for this system")
}
})
}
async downloadAndExtractJava(infos, downloadFolder, runtimeFolder) {
return new Promise((resolve, reject) => {
logger.info(`Downloading ${infos.name}`)
this.downloadMods(infos.link, join(downloadFolder, `${infos.name}.zip`)).then(() => {
logger.info(`download completed`)
this.extractJavaArchive(join(downloadFolder, `${infos.name}.zip`), runtimeFolder).then(() => {
logger.info(`File unzipped`)
resolve()
}).catch(err => {
let join_s = join(downloadFolder, `${infos.name}.zip`)
logger.info(`Failed to unzip ${join_s}`)
reject(err)
}) })
}).catch(err => { }
logger.err(`Failed to download ${infos.link} to ${infos.name}.zip`) event.sender.send('progress', { type: 'mods', task: Number(j) + 1, total: chapter.modspack.mods.length })
reject(err) } catch (err) {
}) try {
}) await this.downloadAndExtractMods(chapter.modspack.mods[j], path)
} } catch (e) {
reject(new Error({ err, e }))
return
}
}
}
resolve(chapter)
return
}
}
reject(new Error("didn't found the correct chapter" + chapterId))
})
}
async extractJavaArchive(zipLocation, outLocation) { downloadMods (link, path) {
if(process.platform === "win32") { return new Promise((resolve, reject) => {
await this.unzipMods(zipLocation, outLocation) fetch(link).then(response => {
if (response.ok) {
if (fs.existsSync(path)) { fs.rmSync(path) }
const dest = fs.createWriteStream(path)
response.body.pipe(dest)
response.body.on('end', () => {
logger.log('download completed')
resolve('download completed')
})
dest.on('error', () => {
reject(new Error('An error appenned when using stream'))
})
} else { } else {
await this.extractTar(zipLocation, outLocation) reject(response.status)
} }
} }).catch(err => {
reject(err)
})
})
}
invalidateData(event) { async unzipMods (zipLocation, outLocation = this.minecraftpath) {
logger.info("invalidate game data...") return new Promise((resolve, reject) => {
const assets = join(this.minecraftpath, "assets") logger.info(`unzipping ${zipLocation} file to ${outLocation}`)
const librairies = join(this.minecraftpath,"libraries") zip(zipLocation, { dir: outLocation }).then(() => {
const natives = join(this.minecraftpath, "natives") resolve()
const versions = join(this.minecraftpath, "versions") }).catch(err => {
if(fs.existsSync(assets)) logger.error('failed to unzip file')
fs.rmSync(assets, { recursive: true }) reject(err)
if(fs.existsSync(librairies)) })
fs.rmSync(librairies, { recursive: true }) })
if(fs.existsSync(natives)) }
fs.rmSync(natives, { recursive: true })
if(fs.existsSync(versions)) async extractTar (tarLocation, outLocation = this.microsoftpath) {
fs.rmSync(versions, { recursive: true }) return new Promise((resolve, reject) => {
logger.info("Game data invalidated") logger.info(`Extracting targz ${tarLocation} file to ${outLocation}`)
event.sender.send("invalidated") decompress(tarLocation, outLocation, {
plugins: [
decompressTar()
]
}).then(() => {
resolve()
}).catch((e) => {
logger.error('Failed to extract targz file')
reject(e)
})
})
}
async downloadAndExtractMods (link, path) {
return new Promise((resolve, reject) => {
this.downloadMods(link, path).then(() => {
this.unzipMods(path).then(() => {
resolve()
}).catch(err => {
reject(err)
})
}).catch(err => {
reject(err)
})
})
}
async extractJava (chapterId, event) {
return new Promise((resolve, reject) => {
const runtime = join(this.minecraftpath, 'runtime')
if (this.modsList[chapterId].java.platform[process.platform] !== undefined &&
this.modsList[chapterId].java.platform[process.platform][process.arch] !== undefined) {
event.sender.send('progress', { type: 'java', task: 0, total: 1 })
const infos = this.modsList[chapterId].java.platform[process.platform][process.arch]
const jre = join(runtime, infos.name)
const downloadFolder = join(runtime, 'download')
const downloadFile = join(downloadFolder, `${infos.name}.zip`)
if (fs.existsSync(jre)) { fs.rmSync(jre, { recursive: true }) }
if (!fs.existsSync(downloadFolder)) { fs.mkdirSync(downloadFolder, { recursive: true }) }
if (fs.existsSync(downloadFile)) {
hashFile(downloadFile, { algorithm: 'sha256' }).then(sha1 => {
if (sha1 === infos.sha256sum) {
this.extractJavaArchive(downloadFile, runtime).then(() => {
const filename = process.platform === 'win32' ? 'java.exe' : 'java'
resolve(join(jre, 'bin', filename))
}).catch(err => {
reject(err)
})
} else {
logger.warn(`java sha256sum ${sha1} don't correspond to ${infos.sha256sum}`)
this.downloadAndExtractJava(infos, downloadFolder, runtime).then(() => resolve(join(jre, 'bin', process.platform === 'win32' ? 'java.exe' : 'java'))).catch(err => reject(err))
}
}).catch(err => {
reject(err)
})
} else {
this.downloadAndExtractJava(infos, downloadFolder, runtime).then(() => resolve(join(jre, 'bin', process.platform === 'win32' ? 'java.exe' : 'java'))).catch(err => reject(err))
}
event.sender.send('progress', { type: 'java', task: 1, total: 1 })
} else {
reject(new Error('There is not available version for this system'))
}
})
}
async downloadAndExtractJava (infos, downloadFolder, runtimeFolder) {
return new Promise((resolve, reject) => {
logger.info(`Downloading ${infos.name}`)
this.downloadMods(infos.link, join(downloadFolder, `${infos.name}.zip`)).then(() => {
logger.info('download completed')
this.extractJavaArchive(join(downloadFolder, `${infos.name}.zip`), runtimeFolder).then(() => {
logger.info('File unzipped')
resolve()
}).catch(err => {
const joinS = join(downloadFolder, `${infos.name}.zip`)
logger.info(`Failed to unzip ${joinS}`)
reject(err)
})
}).catch(err => {
logger.err(`Failed to download ${infos.link} to ${infos.name}.zip`)
reject(err)
})
})
}
async extractJavaArchive (zipLocation, outLocation) {
if (process.platform === 'win32') {
await this.unzipMods(zipLocation, outLocation)
} else {
await this.extractTar(zipLocation, outLocation)
} }
}
invalidateData (event) {
logger.info('invalidate game data...')
const assets = join(this.minecraftpath, 'assets')
const librairies = join(this.minecraftpath, 'libraries')
const natives = join(this.minecraftpath, 'natives')
const versions = join(this.minecraftpath, 'versions')
if (fs.existsSync(assets)) { fs.rmSync(assets, { recursive: true }) }
if (fs.existsSync(librairies)) { fs.rmSync(librairies, { recursive: true }) }
if (fs.existsSync(natives)) { fs.rmSync(natives, { recursive: true }) }
if (fs.existsSync(versions)) { fs.rmSync(versions, { recursive: true }) }
logger.info('Game data invalidated')
event.sender.send('invalidated')
}
} }

158
src/server/updater.js
View File

@ -1,98 +1,94 @@
import isDev from 'electron-is-dev' import isDev from 'electron-is-dev'
import fetch from 'node-fetch' import fetch from 'node-fetch'
import pkg from "../../package.json" assert { type: "json" } import pkg from '../../package.json' assert {type: 'json'}
const server = 'https://update.electronjs.org' const server = 'https://update.electronjs.org'
export default class Updater { export default class Updater {
constructor (app, autoUpdater, dialog, logger, ipcMain) {
this.app = app
this.autoUpdater = autoUpdater
this.dialog = dialog
this.logger = logger
this.ipcMain = ipcMain
}
constructor(app, autoUpdater, dialog, logger, ipcMain) { configUpdater () {
this.app = app this.logger.info(`electron version: ${process.versions.electron}`)
this.autoUpdater = autoUpdater this.logger.info(`chrome version: ${process.versions.chrome}`)
this.dialog = dialog this.logger.info(`Node version: ${process.versions.node}`)
this.logger = logger this.logger.info(`platform: ${process.platform}`)
this.ipcMain = ipcMain this.logger.info(`arch: ${process.arch}`)
if (isDev) {
this.logger.info(`developpement version ${this.app.getVersion()}`)
return
} }
this.logger.info(`production version ${this.app.getVersion()}`)
// TODO : replace dialog by automatic restart
this.autoUpdater.on('update-downloaded', (_event, releaseNotes, releaseName) => {
this.logger.info(`update downloaded ${releaseName}`)
this.logger.info('Leaving application to install update...')
this.autoUpdater.quitAndInstall()
})
}
configUpdater() { checkForUpdates (win, showNotification) {
this.logger.info(`electron version: ${process.versions['electron']}`) if (isDev) {
this.logger.info(`chrome version: ${process.versions['chrome']}`) win.loadFile('src/client/login.html')
this.logger.info(`Node version: ${process.versions['node']}`) return
this.logger.info(`platform: ${process.platform}`)
this.logger.info(`arch: ${process.arch}`)
if(isDev) {
this.logger.info(`developpement version ${this.app.getVersion()}`)
return
}
this.logger.info(`production version ${this.app.getVersion()}`)
// TODO : replace dialog by automatic restart
this.autoUpdater.on('update-downloaded', (_event, releaseNotes, releaseName) => {
this.logger.info(`update downloaded ${releaseName}`)
this.logger.info("Leaving application to install update...")
this.autoUpdater.quitAndInstall()
})
} }
this.logger.info('Checking for update...')
const feed = `${server}/${pkg.repository}/${process.platform}-${process.arch}/${this.app.getVersion()}`
if (process.platform !== 'linux') {
this.autoUpdater.setFeedURL(feed)
this.autoUpdater.on('error', message => {
this.displayError(win, showNotification, message)
})
checkForUpdates(win, showNotification) { this.autoUpdater.on('update-available', () => {
if(isDev) { this.logger.info('update available, downloading...')
win.loadFile('src/client/login.html') win.webContents.send('update-available')
return; })
} this.autoUpdater.on('update-not-available', () => {
this.logger.info("Checking for update...") this.logger.info('update not available')
const feed = `${server}/${pkg.repository}/${process.platform}-${process.arch}/${this.app.getVersion()}` win.loadFile('src/client/login.html')
if(process.platform != 'linux') { })
this.autoUpdater.setFeedURL(feed) this.autoUpdater.checkForUpdates()
this.autoUpdater.on('error', message => { } else {
this.displayError(win, showNotification, message) this.searchUpdateLinux(win, showNotification)
})
this.autoUpdater.on('update-available', () => {
this.logger.info("update available, downloading...")
win.webContents.send("update-available")
})
this.autoUpdater.on("update-not-available", () => {
this.logger.info("update not available")
win.loadFile('src/client/login.html')
})
this.autoUpdater.checkForUpdates()
} else {
this.searchUpdateLinux(win, showNotification)
}
} }
}
searchUpdateLinux(win, showNotification) { searchUpdateLinux (win, showNotification) {
const url = 'https://api.github.com/repos/AltarikMc/Launcher/releases/latest' const url = 'https://api.github.com/repos/AltarikMc/Launcher/releases/latest'
fetch(url).then(response => { fetch(url).then(response => {
if(response.status === 200) { if (response.status === 200) {
response.json().then(json => { response.json().then(json => {
if(json.tag_name !== pkg.version) { if (json.tag_name !== pkg.version) {
let asset = json.assets.filter(el => el.browser_download_url.includes(".zip")) const asset = json.assets.filter(el => el.browser_download_url.includes('.zip'))
if(asset.length === 1) { if (asset.length === 1) {
let downloadUrl = asset[0].browser_download_url const downloadUrl = asset[0].browser_download_url
win.webContents.send("please-download-update", { url: downloadUrl} ) win.webContents.send('please-download-update', { url: downloadUrl })
this.logger.info("update available, please download") this.logger.info('update available, please download')
} else {
this.displayError(win, showNotification, "Can't find right asset in last update")
}
} else {
this.logger.info("update not available")
win.loadFile('src/client/login.html')
}
}).catch(err => this.displayError(win, showNotification, err))
} else { } else {
this.displayError(win, showNotification, "Server unavailable") this.displayError(win, showNotification, "Can't find right asset in last update")
} }
}).catch(err => this.displayError(win, showNotification, err)) } else {
} this.logger.info('update not available')
win.loadFile('src/client/login.html')
displayError(win, showNotification, errorMessage) { }
this.logger.error('There was a problem updating the application') }).catch(err => this.displayError(win, showNotification, err))
this.logger.error(errorMessage) } else {
win.loadFile('src/client/login.html').then(() => { this.displayError(win, showNotification, 'Server unavailable')
showNotification("Une erreur est survenue lors de la vérification de la mise à jour", "Veuillez vérifier votre connexion internet et réessayer", "error") }
}) }).catch(err => this.displayError(win, showNotification, err))
} }
displayError (win, showNotification, errorMessage) {
this.logger.error('There was a problem updating the application')
this.logger.error(errorMessage)
win.loadFile('src/client/login.html').then(() => {
showNotification('Une erreur est survenue lors de la vérification de la mise à jour', 'Veuillez vérifier votre connexion internet et réessayer', 'error')
})
}
} }

1128
yarn.lock
View File

File diff suppressed because it is too large Load Diff