fix some bugs & chmod

package.json

@@ -1,9 +1,5 @@
 {
   "name": "@ragestudio/relic-core",
-  "private": true,
-  "workspaces": [
-    "packages/*"
-  ],
   "repository": "https://github.com/srgooglo/rs_bundler",
   "author": "SrGooglo <srgooglo@ragestudio.net>",
   "license": "MIT",

packages/core/package.json

@@ -1,43 +1,45 @@
 {
-  "name": "@ragestudio/relic-core",
+	"name": "@ragestudio/relic-core",
-  "version": "0.18.0",
+	"version": "0.20.3",
-  "license": "MIT",
+	"license": "MIT",
-  "author": "RageStudio",
+	"author": "RageStudio",
-  "description": "RageStudio Relic, yet another package manager.",
+	"description": "RageStudio Relic, yet another package manager.",
-  "main": "./dist/index.js",
+	"main": "./dist/index.js",
-  "files": [
+	"files": [
-    "dist",
+		"dist",
-    "src"
+		"src"
-  ],
+	],
-  "scripts": {
+	"scripts": {
-    "build": "hermes build",
+		"build": "hermes build",
-    "build:swc": "npx swc ./src --out-dir ./dist --strip-leading-paths"
+		"build:swc": "npx swc ./src --out-dir ./dist --strip-leading-paths"
-  },
+	},
-  "dependencies": {
+	"dependencies": {
-    "@foxify/events": "^2.1.0",
+		"@foxify/events": "^2.1.0",
-    "adm-zip": "^0.5.12",
+		"adm-zip": "^0.5.12",
-    "axios": "^1.6.8",
+		"aria2": "^4.1.2",
-    "checksum": "^1.0.0",
+		"axios": "^1.6.8",
-    "cli-color": "^2.0.4",
+		"checksum": "^1.0.0",
-    "cli-progress": "^3.12.0",
+		"cli-color": "^2.0.4",
-    "deep-object-diff": "^1.1.9",
+		"cli-progress": "^3.12.0",
-    "extends-classes": "^1.0.5",
+		"deep-object-diff": "^1.1.9",
-    "googleapis": "^134.0.0",
+		"extends-classes": "^1.0.5",
-    "human-format": "^1.2.0",
+		"googleapis": "^134.0.0",
-    "merge-stream": "^2.0.0",
+		"human-format": "^1.2.0",
-    "module-alias": "^2.2.3",
+		"merge-stream": "^2.0.0",
-    "node-7z": "^3.0.0",
+		"module-alias": "^2.2.3",
-    "open": "8.4.2",
+		"node-7z": "^3.0.0",
-    "request": "^2.88.2",
+		"open": "8.4.2",
-    "rimraf": "^5.0.5",
+		"request": "^2.88.2",
-    "signal-exit": "^4.1.0",
+		"rimraf": "^5.0.5",
-    "unzipper": "^0.10.14",
+		"signal-exit": "^4.1.0",
-    "upath": "^2.0.1",
+		"unzipper": "^0.10.14",
-    "uuid": "^9.0.1",
+		"upath": "^2.0.1",
-    "winston": "^3.13.0"
+		"uuid": "^9.0.1",
-  },
+		"webtorrent": "^2.4.1",
-  "devDependencies": {
+		"winston": "^3.13.0"
-    "@swc/cli": "^0.3.12",
+	},
-    "@swc/core": "^1.4.11"
+	"devDependencies": {
-  }
+		"@swc/cli": "^0.3.12",
+		"@swc/core": "^1.4.11"
+	}
 }

packages/core/src/classes/Settings.js

@@ -0,0 +1,57 @@
+import fs from "node:fs"
+import path from "node:path"
+import Vars from "../vars"
+
+const settingsPath = path.resolve(Vars.runtime_path, "settings.json")
+
+export default class Settings {
+    static filePath = settingsPath
+
+    static async initialize() {
+        if (!fs.existsSync(settingsPath)) {
+            await fs.promises.writeFile(settingsPath, "{}")
+        }
+    }
+
+    static async read() {
+        return JSON.parse(await fs.promises.readFile(settingsPath, "utf8"))
+    }
+
+    static async write(data) {
+        await fs.promises.writeFile(settingsPath, JSON.stringify(data, null, 2))
+    }
+
+    static async get(key) {
+        const data = await this.read()
+
+        if (key) {
+            return data[key]
+        }
+
+        return data
+    }
+
+    static async has(key) {
+        const data = await this.read()
+
+        return key in data
+    }
+
+    static async set(key, value) {
+        const data = await this.read()
+
+        data[key] = value
+
+        await this.write(data)
+    }
+
+    static async delete(key) {
+        const data = await this.read()
+
+        delete data[key]
+
+        await this.write(data)
+
+        return data
+    }
+}

packages/core/src/generic_steps/index.js

@@ -4,18 +4,21 @@ import ISM_GIT_CLONE from "./git_clone"
 import ISM_GIT_PULL from "./git_pull"
 import ISM_GIT_RESET from "./git_reset"
 import ISM_HTTP from "./http"
+import ISM_TORRENT from "./torrent"
 
 const InstallationStepsMethods = {
     git_clone: ISM_GIT_CLONE,
     git_pull: ISM_GIT_PULL,
     git_reset: ISM_GIT_RESET,
     http_file: ISM_HTTP,
+    torrent: ISM_TORRENT,
 }
 
 const StepsOrders = [
     "git_clones",
     "git_pull",
     "git_reset",
+    "torrent",
     "http_file",
 ]
 
@@ -37,7 +40,7 @@ export default async function processGenericSteps(pkg, steps, logger = Logger, a
     for await (let step of steps) {
         step.type = step.type.toLowerCase()
 
-        if (abortController.signal.aborted) {
+        if (abortController?.signal?.aborted) {
             return false
         }
 

packages/core/src/generic_steps/torrent.js

@@ -0,0 +1,48 @@
+import path from "node:path"
+import fs from "node:fs"
+
+import parseStringVars from "../utils/parseStringVars"
+import downloadTorrent from "../helpers/downloadTorrent"
+
+export default async (pkg, step, logger, abortController) => {
+    if (!step.magnet) {
+        throw new Error(`Magnet is required for torrent step`)
+    }
+
+    if (typeof step.path === "undefined") {
+        step.path = `.`
+    }
+
+    step.path = await parseStringVars(step.path, pkg)
+
+    let _path = path.resolve(pkg.install_path, step.path)
+
+    global._relic_eventBus.emit(`pkg:update:state`, {
+        id: pkg.id,
+        status_text: `Preparing torrent...`,
+    })
+
+    logger.info(`Preparing torrent with magnet => [${step.magnet}]`)
+
+    if (step.tmp) {
+        _path = path.resolve(os.tmpdir(), String(new Date().getTime()))
+    }
+
+    const parentDir = path.resolve(_path, "..")
+
+    if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true })
+    }
+
+    await downloadTorrent(step.magnet, _path, {
+        onProgress: (progress) => {
+            global._relic_eventBus.emit(`pkg:update:state`, {
+                id: pkg.id,
+                use_id_only: true,
+                status_text: `Downloaded ${progress.transferredString} / ${progress.totalString} | ${progress.speedString}/s`,
+            })
+        },
+        taskId: pkg.id
+    })
+
+}

packages/core/src/handlers/cancelInstall.js

@@ -15,6 +15,10 @@ export default async function reinstall(pkg_id) {
             return null
         }
 
+        global._relic_eventBus.emit(`pkg:install:cancel`, pkg_id)
+        global._relic_eventBus.emit(`pkg:install:cancel:${pkg_id}`, pkg_id)
+        global._relic_eventBus.emit(`task:cancel:${pkg_id}`, pkg_id)
+
         const task = globalThis.relic_core.tasks.find((task) => task.id === pkg_id)
 
         if (task) {

packages/core/src/handlers/install.js

@@ -10,7 +10,7 @@ import Apply from "../handlers/apply"
 
 const BaseLog = Logger.child({ service: "INSTALLER" })
 
-export default async function install(manifest) {
+export default async function install(manifest, options = {}) {
     let id = null
     let abortController = new AbortController()
 
@@ -112,7 +112,7 @@ export default async function install(manifest) {
             return false
         }
 
-        if (Array.isArray(manifest.installSteps)) {
+        if (Array.isArray(manifest.installSteps) && !options.noInstallSteps) {
             Log.info(`Executing generic install steps...`)
 
             global._relic_eventBus.emit(`pkg:update:state`, {

packages/core/src/helpers/downloadTorrent.js

@@ -0,0 +1,140 @@
+import humanFormat from "human-format"
+import aria2 from "aria2"
+
+function convertSize(size) {
+    return `${humanFormat(size, {
+        decimals: 2,
+    })}B`
+}
+
+export default async function downloadTorrent(
+    magnet,
+    destination,
+    {
+        onStart,
+        onProgress,
+        onDone,
+        onError,
+        taskId,
+    } = {}
+) {
+    let progressInterval = null
+    let tickProgress = {
+        total: 0,
+        transferred: 0,
+        speed: 0,
+
+        totalString: "0B",
+        transferredString: "0B",
+        speedString: "0B/s",
+    }
+
+    const client = new aria2({
+        host: "localhost",
+        port: 6800,
+        secure: false,
+        secret: "",
+        path: "/jsonrpc"
+    })
+
+    await client.open()
+
+    let downloadId = await client.call(
+        "addUri",
+        [magnet],
+        {
+            dir: destination,
+        },
+    )
+
+    async function stopDownload() {
+        await client.call("remove", downloadId)
+        clearInterval(progressInterval)
+    }
+
+    await new Promise(async (resolve, reject) => {
+        if (typeof onStart === "function") {
+            onStart()
+        }
+
+        if (taskId) {
+            global._relic_eventBus.once(`task:cancel:${taskId}`, stopDownload)
+        }
+
+        progressInterval = setInterval(async () => {
+            const data = await client.call("tellStatus", downloadId)
+
+            console.log(data)
+
+            if (data.status === "complete") {
+                if (Array.isArray(data.followedBy) && data.followedBy[0]) {
+                    // replace downloadId
+                    downloadId = data.followedBy[0]
+                }
+            }
+
+            tickProgress.total = parseInt(data.totalLength)
+            tickProgress.speed = parseInt(data.downloadSpeed)
+            tickProgress.transferred = parseInt(data.completedLength)
+            tickProgress.connections = data.connections
+
+            tickProgress.transferredString = convertSize(tickProgress.transferred)
+            tickProgress.totalString = convertSize(tickProgress.total)
+            tickProgress.speedString = convertSize(tickProgress.speed)
+
+            if (typeof onProgress === "function") {
+                onProgress(tickProgress)
+            }
+        }, 1000)
+
+        client.on("onDownloadStart", async ([{ gid }]) => {
+            const data = await client.call("tellStatus", gid)
+
+            console.log(data)
+
+            if (typeof data.following !== "undefined") {
+                if (data.following === downloadId) {
+                    downloadId = data.gid
+                }
+            }
+        })
+
+        client.on("onBtDownloadComplete", ([{ gid }]) => {
+            if (gid !== downloadId) {
+                return false
+            }
+
+            if (typeof onDone === "function") {
+                onDone()
+            }
+
+            stopDownload()
+
+            return resolve({
+                downloadId,
+            })
+        })
+
+        client.on("onDownloadError", ([{ gid }]) => {
+            if (gid !== downloadId) {
+                return false
+            }
+
+            stopDownload()
+
+            if (typeof onError === "function") {
+                onError()
+            }
+
+            return reject()
+        })
+    })
+
+    await client.call("remove", downloadId)
+
+    if (taskId) {
+        global._relic_eventBus.off(`task:cancel:${taskId}`, stopDownload)
+    }
+
+    return downloadId
+}

packages/core/src/helpers/setup.js

@@ -69,7 +69,7 @@ export default async () => {
                 await fs.promises.mkdir(path.resolve(Vars.binaries_path, prerequisite.id), { recursive: true })
 
                 if (typeof prerequisite.url === "function") {
-                    prerequisite.url = await prerequisite.url(resolveOs(), os.arch())
+                    prerequisite.url = await prerequisite.url(os.platform(), os.arch())
                     Log.info(`Resolved url: ${prerequisite.url}`)
                 }
 

packages/core/src/index.js

@@ -4,8 +4,10 @@ import { onExit } from "signal-exit"
 import open from "open"
 
 import SetupHelper from "./helpers/setup"
+import { execa } from "./libraries/execa"
 import Logger from "./logger"
 
+import Settings from "./classes/Settings"
 import Vars from "./vars"
 import DB from "./db"
 
@@ -24,58 +26,91 @@ import PackageCheckUpdate from "./handlers/checkUpdate"
 import PackageLastOperationRetry from "./handlers/lastOperationRetry"
 
 export default class RelicCore {
-    constructor(params) {
+	constructor(params) {
-        this.params = params
+		this.params = params
-    }
+	}
 
-    eventBus = global._relic_eventBus = new EventEmitter()
+	eventBus = (global._relic_eventBus = new EventEmitter())
 
-    logger = Logger
+	logger = Logger
 
-    db = DB
+	db = DB
 
-    async initialize() {
+	async initialize() {
-        globalThis.relic_core = {
+		globalThis.relic_core = {
-            tasks: [],
+			tasks: [],
-        }
+			vars: Vars,
+		}
 
-        await DB.initialize()
+		console.log(`Checking runtime_path >`, Vars.runtime_path)
 
+		if (!fs.existsSync(Vars.runtime_path)) {
+			fs.mkdirSync(Vars.runtime_path, { recursive: true })
+		}
 
-        onExit(this.onExit)
+		await DB.initialize()
-    }
 
-    onExit = () => {
+		await Settings.initialize()
-        if (fs.existsSync(Vars.cache_path)) {
-            fs.rmSync(Vars.cache_path, { recursive: true, force: true })
-        }
-    }
 
-    async setup() {
+		if (!(await Settings.get("packages_path"))) {
-        return await SetupHelper()
+			await Settings.set("packages_path", Vars.packages_path)
-    }
+		}
 
-    package = {
+		this.aria2c_instance = execa(
-        install: PackageInstall,
+			Vars.aria2_bin,
-        execute: PackageExecute,
+			[
-        uninstall: PackageUninstall,
+				"--enable-rpc",
-        reinstall: PackageReinstall,
+				"--rpc-listen-all=true",
-        cancelInstall: PackageCancelInstall,
+				"--rpc-allow-origin-all",
-        update: PackageUpdate,
+				"--file-allocation=none",
-        apply: PackageApply,
+			],
-        list: PackageList,
+			{
-        read: PackageRead,
+				stdout: "inherit",
-        authorize: PackageAuthorize,
+				stderr: "inherit",
-        deauthorize: PackageDeauthorize,
+			},
-        checkUpdate: PackageCheckUpdate,
+		)
-        lastOperationRetry: PackageLastOperationRetry,
-    }
 
-    openPath(pkg_id) {
+		onExit(this.onExit)
-        if (!pkg_id) {
+	}
-            return open(Vars.runtime_path)
-        }
 
-        return open(Vars.packages_path + "/" + pkg_id)
+	onExit = () => {
-    }
+		if (fs.existsSync(Vars.cache_path)) {
+			fs.rmSync(Vars.cache_path, { recursive: true, force: true })
+		}
+
+		if (this.aria2c_instance) {
+			this.aria2c_instance.kill("SIGINT")
+		}
+	}
+
+	async setup() {
+		return await SetupHelper()
+	}
+
+	package = {
+		install: PackageInstall,
+		execute: PackageExecute,
+		uninstall: PackageUninstall,
+		reinstall: PackageReinstall,
+		cancelInstall: PackageCancelInstall,
+		update: PackageUpdate,
+		apply: PackageApply,
+		list: PackageList,
+		read: PackageRead,
+		authorize: PackageAuthorize,
+		deauthorize: PackageDeauthorize,
+		checkUpdate: PackageCheckUpdate,
+		lastOperationRetry: PackageLastOperationRetry,
+	}
+
+	async openPath(pkg_id) {
+		if (!pkg_id) {
+			return open(Vars.runtime_path)
+		}
+
+		const packagesPath =
+			(await Settings.get("packages_path")) ?? Vars.packages_path
+
+		return open(packagesPath + "/" + pkg_id)
+	}
 }

packages/core/src/manifest/libs/extract/index.js

@@ -0,0 +1,34 @@
+import extractFile from "../../../utils/extractFile"
+import { execa } from "../../../libraries/execa"
+import Vars from "../../../vars"
+
+export default class Extract {
+    async extractFull(file, dest, { password } = {}) {
+        const args = [
+            "x",
+            "-y",
+        ]
+
+        if (password) {
+            args.push(`-p"${password}"`)
+        }
+
+        args.push(`-o"${dest}"`)
+
+        args.push(`"${file}"`)
+
+        const cmd = `${Vars.sevenzip_bin} ${args.join(" ")}`
+
+        console.log(cmd)
+
+        await execa(cmd, {
+            shell: true,
+            stdout: "inherit",
+            stderr: "inherit",
+        })
+    }
+
+    async autoExtract(file, dest) {
+        return await extractFile(file, dest)
+    }
+}

packages/core/src/manifest/libs/fs/index.js

@@ -36,4 +36,36 @@ export default class SecureFileSystem {
     existsSync(...args) {
         return fs.existsSync(...args)
     }
+
+    async rename(from, to) {
+        this.checkOutsideJail(from)
+        this.checkOutsideJail(to)
+
+        return await fs.promises.rename(from, to)
+    }
+
+    async writeFile(path, data, options) {
+        this.checkOutsideJail(path)
+        return await fs.promises.writeFile(path, data, options)
+    }
+
+    async readDir(path) {
+        this.checkOutsideJail(path)
+        return await fs.promises.readdir(path)
+    }
+
+    async rm(path, options) {
+        this.checkOutsideJail(path)
+        return await fs.promises.rm(path, options)
+    }
+
+    async mkdir(path, options) {
+        this.checkOutsideJail(path)
+        return await fs.promises.mkdir(path, options)
+    }
+
+    async stat(path) {
+        this.checkOutsideJail(path)
+        return await fs.promises.stat(path)
+    }
 }

packages/core/src/manifest/libs/index.js

@@ -2,6 +2,7 @@ import Open from "./open"
 import Path from "./path"
 import Fs from "./fs"
 import Auth from "./auth"
+import Extract from "./extract"
 
 // Third party libraries
 import Mcl from "./mcl"
@@ -11,5 +12,6 @@ export default {
     path: Path,
     open: Open,
     auth: Auth,
-    mcl: Mcl
+    extract: Extract,
+    mcl: Mcl,
 }

packages/core/src/manifest/libs/mcl/authenticator.js

@@ -1,5 +1,5 @@
-const request = require('request')
+import request from "request"
-const { v3 } = require('uuid')
+import {v3} from "uuid"
 
 let uuid
 let api_url = 'https://authserver.mojang.com'

packages/core/src/manifest/libs/mcl/handler.js

@@ -1,9 +1,9 @@
-const fs = require('fs')
+import fs from "node:fs"
-const path = require('path')
+import path from "node:path"
-const request = require('request')
+import child from "node:child_process"
-const checksum = require('checksum')
+import request from "request"
-const Zip = require('adm-zip')
+import checksum from "checksum"
-const child = require('child_process')
+import Zip from "adm-zip"
 let counter = 0
 
 export default class Handler {

packages/core/src/manifest/vm.js

@@ -3,16 +3,32 @@ import Logger from "../logger"
 import os from "node:os"
 import vm from "node:vm"
 import path from "node:path"
+
+import DB from "../db"
 import ManifestConfigManager from "../classes/ManifestConfig"
 
 import resolveOs from "../utils/resolveOs"
 import FetchLibraries from "./libraries"
 
+import Settings from "../classes/Settings"
+
 import Vars from "../vars"
 
 async function BuildManifest(baseClass, context, { soft = false } = {}) {
-    // inject install_path
+    // try to find install_path on db
-    context.install_path = path.resolve(Vars.packages_path, baseClass.id)
+    const pkg = await DB.getPackages(baseClass.id)
+
+    if (pkg) {
+        if (pkg.install_path) {
+            context.install_path = pkg.install_path
+        }
+    } else {
+        const packagesPath = await Settings.get("packages_path") ?? Vars.packages_path
+
+        // inject install_path
+        context.install_path = path.resolve(packagesPath, baseClass.id)
+    }
+
     baseClass.install_path = context.install_path
 
     if (soft === true) {

packages/core/src/prerequisites.js

@@ -9,9 +9,11 @@ export default [
     {
         id: "7z-bin",
         finalBin: Vars.sevenzip_bin,
-        url: resolveRemoteBinPath(`${baseURL}/7zip-bin`, process.platform === "win32" ? "7za.exe" : "7za"),
+        url: resolveRemoteBinPath(`${baseURL}/7z-full`, "7z.zip"),
-        destination: Vars.sevenzip_bin,
+        destination: path.resolve(Vars.binaries_path, "7z.zip"),
+        extract: path.resolve(Vars.binaries_path, "7z-bin"),
         rewriteExecutionPermission: true,
+        deleteBeforeExtract: true,
     },
     {
         id: "git-bin",
@@ -24,14 +26,13 @@ export default [
         deleteBeforeExtract: true,
     },
     {
-        id: "rclone-bin",
+        id: "aria2",
-        finalBin: Vars.rclone_bin,
+        finalBin: Vars.aria2_bin,
-        url: resolveRemoteBinPath(`${baseURL}/rclone`, "rclone-bin.zip"),
+        url: async (os, arch) => {
-        destination: path.resolve(Vars.binaries_path, "rclone-bin.zip"),
+            return `https://storage.ragestudio.net/rstudio/binaries/aria2/${os}/${arch}/${os === "win32" ? "aria2c.exe" : "aria2c"}`
-        extract: path.resolve(Vars.binaries_path, "rclone-bin"),
+        },
-        requireOs: ["win32"],
+        destination: Vars.aria2_bin,
-        rewriteExecutionPermission: true,
+        rewriteExecutionPermission: Vars.aria2_bin,
-        deleteBeforeExtract: true,
     },
     {
         id: "java22_jre_bin",
@@ -43,7 +44,7 @@ export default [
                 params: {
                     arch: arch,
                     java_version: "22",
-                    os: os,
+                    os: os === "win32" ? "windows" : os,
                     archive_type: "zip",
                     javafx_bundled: "false",
                     java_package_type: "jre",
@@ -77,7 +78,7 @@ export default [
                 params: {
                     arch: arch,
                     java_version: "17",
-                    os: os,
+                    os: os === "win32" ? "windows" : os,
                     archive_type: "zip",
                     javafx_bundled: "false",
                     java_package_type: "jre",

packages/core/src/utils/resolveRemoteBinPath.js

@@ -2,10 +2,10 @@ export default (pre, post) => {
     let url = null
 
     if (process.platform === "darwin") {
-        url = `${pre}/mac/${process.arch}/${post}`
+        url = `${pre}/darwin/${process.arch}/${post}`
     }
     else if (process.platform === "win32") {
-        url = `${pre}/win/${process.arch}/${post}`
+        url = `${pre}/win32/${process.arch}/${post}`
     }
     else {
         url = `${pre}/linux/${process.arch}/${post}`

packages/core/src/utils/resolveUserDataPath.js

@@ -0,0 +1,9 @@
+import path from "node:path"
+import upath from "upath"
+
+export default () => {
+    return upath.normalizeSafe(path.resolve(
+        process.env.APPDATA ||
+        (process.platform == "darwin" ? process.env.HOME + "/Library/Preferences" : process.env.HOME + "/.local/share"),
+    ))
+}

packages/core/src/vars.js

@@ -1,36 +1,67 @@
 import path from "node:path"
 import upath from "upath"
+import resolveUserDataPath from "./utils/resolveUserDataPath"
 
-const isWin = process.platform.includes("win")
+const isWin = process.platform.includes("win32")
 const isMac = process.platform.includes("darwin")
 
 const runtimeName = "rs-relic"
 
-const userdata_path = upath.normalizeSafe(path.resolve(
+const userdata_path = resolveUserDataPath()
-    process.env.APPDATA ||
-    (process.platform == "darwin" ? process.env.HOME + "/Library/Preferences" : process.env.HOME + "/.local/share"),
-))
 const runtime_path = upath.normalizeSafe(path.join(userdata_path, runtimeName))
 const cache_path = upath.normalizeSafe(path.join(runtime_path, "cache"))
 const packages_path = upath.normalizeSafe(path.join(runtime_path, "packages"))
-const binaries_path = upath.normalizeSafe(path.resolve(runtime_path, "binaries"))
+const binaries_path = upath.normalizeSafe(
+	path.resolve(runtime_path, "binaries"),
+)
 const db_path = upath.normalizeSafe(path.resolve(runtime_path, "db.json"))
 
 const binaries = {
-    sevenzip_bin: upath.normalizeSafe(path.resolve(binaries_path, "7z-bin", isWin ? "7za.exe" : "7za")),
+	sevenzip_bin: upath.normalizeSafe(
-    git_bin: upath.normalizeSafe(path.resolve(binaries_path, "git-bin", "bin", isWin ? "git.exe" : "git")),
+		path.resolve(binaries_path, "7z-bin", isWin ? "7za.exe" : "7z"),
-    rclone_bin: upath.normalizeSafe(path.resolve(binaries_path, "rclone-bin", isWin ? "rclone.exe" : "rclone")),
+	),
-    java22_jre_bin: upath.normalizeSafe(path.resolve(binaries_path, "java22_jre_bin", (isMac ? "Contents/Home/bin/java" : (isWin ? "bin/java.exe" : "bin/java")))),
+	git_bin: upath.normalizeSafe(
-    java17_jre_bin: upath.normalizeSafe(path.resolve(binaries_path, "java17_jre_bin", (isMac ? "Contents/Home/bin/java" : (isWin ? "bin/java.exe" : "bin/java")))),
+		path.resolve(
+			binaries_path,
+			"git-bin",
+			"bin",
+			isWin ? "git.exe" : "git",
+		),
+	),
+	aria2_bin: upath.normalizeSafe(
+		path.resolve(binaries_path, "aria2", isWin ? "aria2c.exe" : "aria2c"),
+	),
+	java22_jre_bin: upath.normalizeSafe(
+		path.resolve(
+			binaries_path,
+			"java22_jre_bin",
+			isMac
+				? "Contents/Home/bin/java"
+				: isWin
+					? "bin/java.exe"
+					: "bin/java",
+		),
+	),
+	java17_jre_bin: upath.normalizeSafe(
+		path.resolve(
+			binaries_path,
+			"java17_jre_bin",
+			isMac
+				? "Contents/Home/bin/java"
+				: isWin
+					? "bin/java.exe"
+					: "bin/java",
+		),
+	),
 }
 
 export default {
-    runtimeName,
+	runtimeName,
-    db_path,
+	db_path,
-    userdata_path,
+	userdata_path,
-    runtime_path,
+	runtime_path,
-    cache_path,
+	cache_path,
-    packages_path,
+	packages_path,
-    binaries_path,
+	binaries_path,
-    ...binaries,
+	...binaries,
 }

packages/gui/electron-builder.yml

@@ -26,10 +26,10 @@ dmg:
 linux:
   target:
     - AppImage
-    - snap
     - deb
-  maintainer: electronjs.org
+  maintainer: ragestudio.net
   category: Utility
+  icon: resources/icon.png
 appImage:
   artifactName: ${productName}-${version}.${ext}
 npmRebuild: false

packages/gui/package.json

@@ -1,55 +1,56 @@
 {
-  "name": "@ragestudio/relic-gui",
+	"name": "relic-gui",
-  "version": "0.18.0",
+	"version": "0.20.3",
-  "description": "RageStudio Relic, yet another package manager.",
+	"description": "RageStudio Relic, yet another package manager.",
-  "main": "./out/main/index.js",
+	"homepage": "https://relic.ragestudio.net",
-  "author": "RageStudio",
+	"main": "./out/main/index.js",
-  "license": "MIT",
+	"author": "RageStudio",
-  "scripts": {
+	"license": "MIT",
-    "start": "electron-vite preview",
+	"scripts": {
-    "dev": "npm run build:core && electron-vite dev",
+		"start": "electron-vite preview",
-    "build": "npm run build:core && electron-vite build",
+		"dev": "npm run build:core && electron-vite dev",
-    "postinstall": "electron-builder install-app-deps",
+		"build": "npm run build:core && electron-vite build",
-    "pack:win": "electron-builder --win --config",
+		"postinstall": "electron-builder install-app-deps",
-    "pack:mac": "electron-builder --mac --config",
+		"pack:win": "electron-builder --win --config",
-    "pack:linux": "electron-builder --linux --config",
+		"pack:mac": "electron-builder --mac --config",
-    "build:win": "npm run build && npm run pack:win",
+		"pack:linux": "electron-builder --linux --config",
-    "build:mac": "npm run build && npm run pack:mac",
+		"build:win": "npm run build && npm run pack:win",
-    "build:linux": "npm run build && npm run pack:linux",
+		"build:mac": "npm run build && npm run pack:mac",
-    "build:core": "cd ../core && npm run build:swc"
+		"build:linux": "npm run build && npm run pack:linux",
-  },
+		"build:core": "cd ../core && npm run build:swc"
-  "dependencies": {
+	},
-    "@electron-toolkit/preload": "^2.0.0",
+	"dependencies": {
-    "@electron-toolkit/utils": "^2.0.0",
+		"@electron-toolkit/preload": "^2.0.0",
-    "@getstation/electron-google-oauth2": "^14.0.0",
+		"@electron-toolkit/utils": "^2.0.0",
-    "@imjs/electron-differential-updater": "^5.1.7",
+		"@getstation/electron-google-oauth2": "^14.0.0",
-    "@loadable/component": "^5.16.3",
+		"@imjs/electron-differential-updater": "^5.1.7",
-    "@ragestudio/relic-core": "^0.18.8",
+		"@loadable/component": "^5.16.3",
-    "antd": "^5.13.2",
+		"@ragestudio/relic-core": "^0.20.3",
-    "classnames": "^2.3.2",
+		"antd": "^5.13.2",
-    "electron-differential-updater": "^4.3.2",
+		"classnames": "^2.3.2",
-    "electron-is-dev": "^2.0.0",
+		"electron-differential-updater": "^4.3.2",
-    "electron-store": "^8.1.0",
+		"electron-is-dev": "^2.0.0",
-    "electron-updater": "^6.1.1",
+		"electron-store": "^8.1.0",
-    "got": "11.8.3",
+		"electron-updater": "^6.1.1",
-    "human-format": "^1.2.0",
+		"got": "11.8.3",
-    "protocol-registry": "^1.4.1",
+		"human-format": "^1.2.0",
-    "less": "^4.2.0",
+		"protocol-registry": "^1.4.1",
-    "lodash": "^4.17.21",
+		"less": "^4.2.0",
-    "react-icons": "^4.11.0",
+		"lodash": "^4.17.21",
-    "react-motion": "0.5.2",
+		"react-icons": "^4.11.0",
-    "react-router-dom": "6.6.2",
+		"react-motion": "0.5.2",
-    "react-spinners": "^0.13.8",
+		"react-router-dom": "6.6.2",
-    "react-spring": "^9.7.3"
+		"react-spinners": "^0.13.8",
-  },
+		"react-spring": "^9.7.3"
-  "devDependencies": {
+	},
-    "@ragestudio/hermes": "^0.1.1",
+	"devDependencies": {
-    "@vitejs/plugin-react": "^4.0.4",
+		"@ragestudio/hermes": "^0.1.1",
-    "electron": "25.6.0",
+		"@vitejs/plugin-react": "^4.0.4",
-    "electron-builder": "24.6.3",
+		"electron": "25.6.0",
-    "electron-vite": "^2.1.0",
+		"electron-builder": "24.6.3",
-    "react": "^18.2.0",
+		"electron-vite": "^2.1.0",
-    "react-dom": "^18.2.0",
+		"react": "^18.2.0",
-    "vite": "^4.4.9"
+		"react-dom": "^18.2.0",
-  }
+		"vite": "^4.4.9"
+	}
 }

packages/gui/src/main/classes/CoreAdapter.js

@@ -1,5 +1,6 @@
 import sendToRender from "../utils/sendToRender"
-import { ipcMain } from "electron"
+import { ipcMain, dialog } from "electron"
+import path from "node:path"
 
 export default class CoreAdapter {
     constructor(electronApp, RelicCore) {
@@ -77,6 +78,28 @@ export default class CoreAdapter {
         "core:open-path": async (event, pkg_id) => {
             return await this.core.openPath(pkg_id)
         },
+        "core:change-packages-path": async (event) => {
+            const { canceled, filePaths } = await dialog.showOpenDialog(undefined, {
+                properties: ["openDirectory"]
+            })
+
+            if (canceled) {
+                return false
+            }
+
+            const targetPath = path.resolve(filePaths[0], "RelicPackages")
+
+            await global.Settings.set("packages_path", targetPath)
+
+            return targetPath
+        },
+        "core:set-default-packages-path": async (event) => {
+            const { packages_path } = globalThis.relic_core.vars
+
+            await global.Settings.set("packages_path", packages_path)
+
+            return packages_path
+        },
     }
 
     coreEvents = {

packages/gui/src/main/index.js

@@ -1,20 +1,18 @@
-global.SettingsStore = new Store({
-	name: "settings",
-	watch: true,
-})
 import path from "node:path"
 
 import { app, shell, BrowserWindow, ipcMain } from "electron"
 import { electronApp, optimizer, is } from "@electron-toolkit/utils"
 import isDev from "electron-is-dev"
-import Store from "electron-store"
 
 let RelicCore = null
+let Settings = null
 
 if (isDev) {
-	RelicCore = require("../../../core").default
+	RelicCore = require("../../../core/dist").default
+	Settings = global.Settings = require("../../../core/dist/classes/Settings").default
 } else {
 	RelicCore = require("@ragestudio/relic-core").default
+	Settings = global.Settings = require("@ragestudio/relic-core/dist/classes/Settings").default
 }
 
 import CoreAdapter from "./classes/CoreAdapter"
@@ -84,17 +82,17 @@ class ElectronApp {
 				autoUpdater.quitAndInstall()
 			}, 3000)
 		},
-		"settings:get": (event, key) => {
+		"settings:get": async (event, key) => {
-			return global.SettingsStore.get(key)
+			return await Settings.get(key)
 		},
-		"settings:set": (event, key, value) => {
+		"settings:set": async (event, key, value) => {
-			return global.SettingsStore.set(key, value)
+			return await Settings.set(key, value)
 		},
-		"settings:delete": (event, key) => {
+		"settings:delete": async (event, key) => {
-			return global.SettingsStore.delete(key)
+			return await Settings.delete(key)
 		},
-		"settings:has": (event, key) => {
+		"settings:has": async (event, key) => {
-			return global.SettingsStore.has(key)
+			return await Settings.has(key)
 		},
 		"app:open-logs": async (event) => {
 			const loggerWindow = await this.logsViewer.createWindow()