Migrate to Turborepo (#1251)

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

@@ -0,0 +1,345 @@
+//! Functions for fetching infromation from the Internet
+use crate::event::emit::emit_loading;
+use crate::event::LoadingBarId;
+use crate::state::CredentialsStore;
+use bytes::Bytes;
+use lazy_static::lazy_static;
+use reqwest::Method;
+use serde::de::DeserializeOwned;
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::time::{self, Duration};
+use tokio::sync::{RwLock, Semaphore};
+use tokio::{fs::File, io::AsyncWriteExt};
+
+use super::io::{self, IOError};
+
+#[derive(Debug)]
+pub struct IoSemaphore(pub RwLock<Semaphore>);
+#[derive(Debug)]
+pub struct FetchSemaphore(pub RwLock<Semaphore>);
+
+lazy_static! {
+    pub static ref REQWEST_CLIENT: reqwest::Client = {
+        let mut headers = reqwest::header::HeaderMap::new();
+        let header = reqwest::header::HeaderValue::from_str(&format!(
+            "modrinth/theseus/{} (support@modrinth.com)",
+            env!("CARGO_PKG_VERSION")
+        ))
+        .unwrap();
+        headers.insert(reqwest::header::USER_AGENT, header);
+        reqwest::Client::builder()
+            .tcp_keepalive(Some(time::Duration::from_secs(10)))
+            .default_headers(headers)
+            .build()
+            .expect("Reqwest Client Building Failed")
+    };
+}
+const FETCH_ATTEMPTS: usize = 3;
+
+#[tracing::instrument(skip(semaphore))]
+pub async fn fetch(
+    url: &str,
+    sha1: Option<&str>,
+    semaphore: &FetchSemaphore,
+    credentials: &CredentialsStore,
+) -> crate::Result<Bytes> {
+    fetch_advanced(
+        Method::GET,
+        url,
+        sha1,
+        None,
+        None,
+        None,
+        semaphore,
+        credentials,
+    )
+    .await
+}
+
+#[tracing::instrument(skip(json_body, semaphore))]
+pub async fn fetch_json<T>(
+    method: Method,
+    url: &str,
+    sha1: Option<&str>,
+    json_body: Option<serde_json::Value>,
+    semaphore: &FetchSemaphore,
+    credentials: &CredentialsStore,
+) -> crate::Result<T>
+where
+    T: DeserializeOwned,
+{
+    let result = fetch_advanced(
+        method,
+        url,
+        sha1,
+        json_body,
+        None,
+        None,
+        semaphore,
+        credentials,
+    )
+    .await?;
+    let value = serde_json::from_slice(&result)?;
+    Ok(value)
+}
+
+/// Downloads a file with retry and checksum functionality
+#[tracing::instrument(skip(json_body, semaphore))]
+#[theseus_macros::debug_pin]
+#[allow(clippy::too_many_arguments)]
+pub async fn fetch_advanced(
+    method: Method,
+    url: &str,
+    sha1: Option<&str>,
+    json_body: Option<serde_json::Value>,
+    header: Option<(&str, &str)>,
+    loading_bar: Option<(&LoadingBarId, f64)>,
+    semaphore: &FetchSemaphore,
+    credentials: &CredentialsStore,
+) -> crate::Result<Bytes> {
+    let io_semaphore = semaphore.0.read().await;
+    let _permit = io_semaphore.acquire().await?;
+
+    for attempt in 1..=(FETCH_ATTEMPTS + 1) {
+        let mut req = REQWEST_CLIENT.request(method.clone(), url);
+
+        if let Some(body) = json_body.clone() {
+            req = req.json(&body);
+        }
+
+        if let Some(header) = header {
+            req = req.header(header.0, header.1);
+        }
+
+        if url.starts_with("https://cdn.modrinth.com") {
+            if let Some(creds) = &credentials.0 {
+                req = req.header("Authorization", &creds.session);
+            }
+        }
+
+        let result = req.send().await;
+        match result {
+            Ok(x) => {
+                let bytes = if let Some((bar, total)) = &loading_bar {
+                    let length = x.content_length();
+                    if let Some(total_size) = length {
+                        use futures::StreamExt;
+                        let mut stream = x.bytes_stream();
+                        let mut bytes = Vec::new();
+                        while let Some(item) = stream.next().await {
+                            let chunk = item.or(Err(
+                                crate::error::ErrorKind::NoValueFor(
+                                    "fetch bytes".to_string(),
+                                ),
+                            ))?;
+                            bytes.append(&mut chunk.to_vec());
+                            emit_loading(
+                                bar,
+                                (chunk.len() as f64 / total_size as f64)
+                                    * total,
+                                None,
+                            )
+                            .await?;
+                        }
+
+                        Ok(bytes::Bytes::from(bytes))
+                    } else {
+                        x.bytes().await
+                    }
+                } else {
+                    x.bytes().await
+                };
+
+                if let Ok(bytes) = bytes {
+                    if let Some(sha1) = sha1 {
+                        let hash = sha1_async(bytes.clone()).await?;
+                        if &*hash != sha1 {
+                            if attempt <= 3 {
+                                continue;
+                            } else {
+                                return Err(crate::ErrorKind::HashError(
+                                    sha1.to_string(),
+                                    hash,
+                                )
+                                .into());
+                            }
+                        }
+                    }
+
+                    tracing::trace!("Done downloading URL {url}");
+                    return Ok(bytes);
+                } else if attempt <= 3 {
+                    continue;
+                } else if let Err(err) = bytes {
+                    return Err(err.into());
+                }
+            }
+            Err(_) if attempt <= 3 => continue,
+            Err(err) => {
+                return Err(err.into());
+            }
+        }
+    }
+
+    unreachable!()
+}
+
+/// Downloads a file from specified mirrors
+#[tracing::instrument(skip(semaphore))]
+#[theseus_macros::debug_pin]
+pub async fn fetch_mirrors(
+    mirrors: &[&str],
+    sha1: Option<&str>,
+    semaphore: &FetchSemaphore,
+    credentials: &CredentialsStore,
+) -> crate::Result<Bytes> {
+    if mirrors.is_empty() {
+        return Err(crate::ErrorKind::InputError(
+            "No mirrors provided!".to_string(),
+        )
+        .into());
+    }
+
+    for (index, mirror) in mirrors.iter().enumerate() {
+        let result = fetch(mirror, sha1, semaphore, credentials).await;
+
+        if result.is_ok() || (result.is_err() && index == (mirrors.len() - 1)) {
+            return result;
+        }
+    }
+
+    unreachable!()
+}
+
+/// Using labrinth API, checks if an internet response can be found, with a timeout in seconds
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+pub async fn check_internet(timeout: u64) -> bool {
+    REQWEST_CLIENT
+        .get("https://launcher-files.modrinth.com/detect.txt")
+        .timeout(Duration::from_secs(timeout))
+        .send()
+        .await
+        .is_ok()
+}
+
+/// Posts a JSON to a URL
+#[tracing::instrument(skip(json_body, semaphore))]
+#[theseus_macros::debug_pin]
+pub async fn post_json<T>(
+    url: &str,
+    json_body: serde_json::Value,
+    semaphore: &FetchSemaphore,
+    credentials: &CredentialsStore,
+) -> crate::Result<T>
+where
+    T: DeserializeOwned,
+{
+    let io_semaphore = semaphore.0.read().await;
+    let _permit = io_semaphore.acquire().await?;
+
+    let mut req = REQWEST_CLIENT.post(url).json(&json_body);
+    if let Some(creds) = &credentials.0 {
+        req = req.header("Authorization", &creds.session);
+    }
+
+    let result = req.send().await?.error_for_status()?;
+
+    let value = result.json().await?;
+    Ok(value)
+}
+
+pub async fn read_json<T>(
+    path: &Path,
+    semaphore: &IoSemaphore,
+) -> crate::Result<T>
+where
+    T: DeserializeOwned,
+{
+    let io_semaphore = semaphore.0.read().await;
+    let _permit = io_semaphore.acquire().await?;
+
+    let json = io::read(path).await?;
+    let json = serde_json::from_slice::<T>(&json)?;
+
+    Ok(json)
+}
+
+#[tracing::instrument(skip(bytes, semaphore))]
+pub async fn write<'a>(
+    path: &Path,
+    bytes: &[u8],
+    semaphore: &IoSemaphore,
+) -> crate::Result<()> {
+    let io_semaphore = semaphore.0.read().await;
+    let _permit = io_semaphore.acquire().await?;
+
+    if let Some(parent) = path.parent() {
+        io::create_dir_all(parent).await?;
+    }
+
+    let mut file = File::create(path)
+        .await
+        .map_err(|e| IOError::with_path(e, path))?;
+    file.write_all(bytes)
+        .await
+        .map_err(|e| IOError::with_path(e, path))?;
+    tracing::trace!("Done writing file {}", path.display());
+    Ok(())
+}
+
+pub async fn copy(
+    src: impl AsRef<std::path::Path>,
+    dest: impl AsRef<std::path::Path>,
+    semaphore: &IoSemaphore,
+) -> crate::Result<()> {
+    let src: &Path = src.as_ref();
+    let dest = dest.as_ref();
+
+    let io_semaphore = semaphore.0.read().await;
+    let _permit = io_semaphore.acquire().await?;
+
+    if let Some(parent) = dest.parent() {
+        io::create_dir_all(parent).await?;
+    }
+
+    io::copy(src, dest).await?;
+    tracing::trace!(
+        "Done copying file {} to {}",
+        src.display(),
+        dest.display()
+    );
+    Ok(())
+}
+
+// Writes a icon to the cache and returns the absolute path of the icon within the cache directory
+#[tracing::instrument(skip(bytes, semaphore))]
+pub async fn write_cached_icon(
+    icon_path: &str,
+    cache_dir: &Path,
+    bytes: Bytes,
+    semaphore: &IoSemaphore,
+) -> crate::Result<PathBuf> {
+    let extension = Path::new(&icon_path).extension().and_then(OsStr::to_str);
+    let hash = sha1_async(bytes.clone()).await?;
+    let path = cache_dir.join("icons").join(if let Some(ext) = extension {
+        format!("{hash}.{ext}")
+    } else {
+        hash
+    });
+
+    write(&path, &bytes, semaphore).await?;
+
+    let path = io::canonicalize(path)?;
+    Ok(path)
+}
+
+async fn sha1_async(bytes: Bytes) -> crate::Result<String> {
+    let hash = tokio::task::spawn_blocking(move || {
+        sha1_smol::Sha1::from(bytes).hexdigest()
+    })
+    .await?;
+
+    Ok(hash)
+}

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

@@ -0,0 +1,194 @@
+// IO error
+// A wrapper around the tokio IO functions that adds the path to the error message, instead of the uninformative std::io::Error.
+
+use std::{io::Write, path::Path};
+
+use tempfile::NamedTempFile;
+use tokio::task::spawn_blocking;
+
+#[derive(Debug, thiserror::Error)]
+pub enum IOError {
+    #[error("{source}, path: {path}")]
+    IOPathError {
+        #[source]
+        source: std::io::Error,
+        path: String,
+    },
+    #[error(transparent)]
+    IOError(#[from] std::io::Error),
+}
+
+impl IOError {
+    pub fn from(source: std::io::Error) -> Self {
+        Self::IOError(source)
+    }
+    pub fn with_path(
+        source: std::io::Error,
+        path: impl AsRef<std::path::Path>,
+    ) -> Self {
+        let path = path.as_ref();
+
+        Self::IOPathError {
+            source,
+            path: path.to_string_lossy().to_string(),
+        }
+    }
+}
+
+// dunce canonicalize
+pub fn canonicalize(
+    path: impl AsRef<std::path::Path>,
+) -> Result<std::path::PathBuf, IOError> {
+    let path = path.as_ref();
+    dunce::canonicalize(path).map_err(|e| IOError::IOPathError {
+        source: e,
+        path: path.to_string_lossy().to_string(),
+    })
+}
+
+// read_dir
+pub async fn read_dir(
+    path: impl AsRef<std::path::Path>,
+) -> Result<tokio::fs::ReadDir, IOError> {
+    let path = path.as_ref();
+    tokio::fs::read_dir(path)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: path.to_string_lossy().to_string(),
+        })
+}
+
+// create_dir_all
+pub async fn create_dir_all(
+    path: impl AsRef<std::path::Path>,
+) -> Result<(), IOError> {
+    let path = path.as_ref();
+    tokio::fs::create_dir_all(path)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: path.to_string_lossy().to_string(),
+        })
+}
+
+// remove_dir_all
+pub async fn remove_dir_all(
+    path: impl AsRef<std::path::Path>,
+) -> Result<(), IOError> {
+    let path = path.as_ref();
+    tokio::fs::remove_dir_all(path)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: path.to_string_lossy().to_string(),
+        })
+}
+
+// read_to_string
+pub async fn read_to_string(
+    path: impl AsRef<std::path::Path>,
+) -> Result<String, IOError> {
+    let path = path.as_ref();
+    tokio::fs::read_to_string(path)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: path.to_string_lossy().to_string(),
+        })
+}
+
+// read
+pub async fn read(
+    path: impl AsRef<std::path::Path>,
+) -> Result<Vec<u8>, IOError> {
+    let path = path.as_ref();
+    tokio::fs::read(path)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: path.to_string_lossy().to_string(),
+        })
+}
+
+// write
+pub async fn write(
+    path: impl AsRef<std::path::Path>,
+    data: impl AsRef<[u8]>,
+) -> Result<(), IOError> {
+    let path = path.as_ref().to_owned();
+    let data = data.as_ref().to_owned();
+    spawn_blocking(move || {
+        let cloned_path = path.clone();
+        sync_write(data, path).map_err(|e| IOError::IOPathError {
+            source: e,
+            path: cloned_path.to_string_lossy().to_string(),
+        })
+    })
+    .await
+    .map_err(|_| {
+        std::io::Error::new(std::io::ErrorKind::Other, "background task failed")
+    })??;
+
+    Ok(())
+}
+
+fn sync_write(
+    data: impl AsRef<[u8]>,
+    path: impl AsRef<Path>,
+) -> Result<(), std::io::Error> {
+    let mut tempfile =
+        NamedTempFile::new_in(path.as_ref().parent().ok_or_else(|| {
+            std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "could not get parent directory for temporary file",
+            )
+        })?)?;
+    tempfile.write_all(data.as_ref())?;
+    let tmp_path = tempfile.into_temp_path();
+    let path = path.as_ref();
+    tmp_path.persist(path)?;
+    std::io::Result::Ok(())
+}
+// rename
+pub async fn rename(
+    from: impl AsRef<std::path::Path>,
+    to: impl AsRef<std::path::Path>,
+) -> Result<(), IOError> {
+    let from = from.as_ref();
+    let to = to.as_ref();
+    tokio::fs::rename(from, to)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: from.to_string_lossy().to_string(),
+        })
+}
+
+// copy
+pub async fn copy(
+    from: impl AsRef<std::path::Path>,
+    to: impl AsRef<std::path::Path>,
+) -> Result<u64, IOError> {
+    let from: &Path = from.as_ref();
+    let to = to.as_ref();
+    tokio::fs::copy(from, to)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: from.to_string_lossy().to_string(),
+        })
+}
+
+// remove file
+pub async fn remove_file(
+    path: impl AsRef<std::path::Path>,
+) -> Result<(), IOError> {
+    let path = path.as_ref();
+    tokio::fs::remove_file(path)
+        .await
+        .map_err(|e| IOError::IOPathError {
+            source: e,
+            path: path.to_string_lossy().to_string(),
+        })
+}

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

@@ -0,0 +1,388 @@
+use super::io;
+use futures::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+use std::{collections::HashSet, path::Path};
+use tokio::task::JoinError;
+
+use crate::State;
+#[cfg(target_os = "windows")]
+use winreg::{
+    enums::{HKEY_LOCAL_MACHINE, KEY_READ, KEY_WOW64_32KEY, KEY_WOW64_64KEY},
+    RegKey,
+};
+
+#[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+pub struct JavaVersion {
+    pub path: String,
+    pub version: String,
+    pub architecture: String,
+}
+
+// Entrypoint function (Windows)
+// Returns a Vec of unique JavaVersions from the PATH, Windows Registry Keys and common Java locations
+#[cfg(target_os = "windows")]
+#[tracing::instrument]
+pub async fn get_all_jre() -> Result<Vec<JavaVersion>, JREError> {
+    let mut jre_paths = HashSet::new();
+
+    // Add JRES directly on PATH
+    jre_paths.extend(get_all_jre_path().await);
+    jre_paths.extend(get_all_autoinstalled_jre_path().await?);
+    if let Ok(java_home) = env::var("JAVA_HOME") {
+        jre_paths.insert(PathBuf::from(java_home));
+    }
+
+    // Hard paths for locations for commonly installed .exes
+    let java_paths = [
+        r"C:/Program Files/Java",
+        r"C:/Program Files (x86)/Java",
+        r"C:\Program Files\Eclipse Adoptium",
+        r"C:\Program Files (x86)\Eclipse Adoptium",
+    ];
+    for java_path in java_paths {
+        let Ok(java_subpaths) = std::fs::read_dir(java_path) else {
+            continue;
+        };
+        for java_subpath in java_subpaths.flatten() {
+            let path = java_subpath.path();
+            jre_paths.insert(path.join("bin"));
+        }
+    }
+
+    // Windows Registry Keys
+    let key_paths = [
+        r"SOFTWARE\JavaSoft\Java Runtime Environment", // Oracle
+        r"SOFTWARE\JavaSoft\Java Development Kit",
+        r"SOFTWARE\\JavaSoft\\JRE", // Oracle
+        r"SOFTWARE\\JavaSoft\\JDK",
+        r"SOFTWARE\\Eclipse Foundation\\JDK", // Eclipse
+        r"SOFTWARE\\Eclipse Adoptium\\JRE",   // Eclipse
+        r"SOFTWARE\\Eclipse Foundation\\JDK", // Eclipse
+        r"SOFTWARE\\Microsoft\\JDK",          // Microsoft
+    ];
+
+    for key in key_paths {
+        if let Ok(jre_key) = RegKey::predef(HKEY_LOCAL_MACHINE)
+            .open_subkey_with_flags(key, KEY_READ | KEY_WOW64_32KEY)
+        {
+            jre_paths.extend(get_paths_from_jre_winregkey(jre_key));
+        }
+        if let Ok(jre_key) = RegKey::predef(HKEY_LOCAL_MACHINE)
+            .open_subkey_with_flags(key, KEY_READ | KEY_WOW64_64KEY)
+        {
+            jre_paths.extend(get_paths_from_jre_winregkey(jre_key));
+        }
+    }
+
+    // Get JRE versions from potential paths concurrently
+    let j = check_java_at_filepaths(jre_paths)
+        .await
+        .into_iter()
+        .collect();
+    Ok(j)
+}
+
+// Gets paths rather than search directly as RegKeys should not be passed asynchronously (do not impl Send)
+#[cfg(target_os = "windows")]
+#[tracing::instrument]
+pub fn get_paths_from_jre_winregkey(jre_key: RegKey) -> HashSet<PathBuf> {
+    let mut jre_paths = HashSet::new();
+
+    for subkey in jre_key.enum_keys().flatten() {
+        if let Ok(subkey) = jre_key.open_subkey(subkey) {
+            let subkey_value_names =
+                [r"JavaHome", r"InstallationPath", r"\\hotspot\\MSI"];
+
+            for subkey_value in subkey_value_names {
+                let path: Result<String, std::io::Error> =
+                    subkey.get_value(subkey_value);
+                let Ok(path) = path else { continue };
+
+                jre_paths.insert(PathBuf::from(path).join("bin"));
+            }
+        }
+    }
+    jre_paths
+}
+
+// Entrypoint function (Mac)
+// Returns a Vec of unique JavaVersions from the PATH, and common Java locations
+#[cfg(target_os = "macos")]
+#[tracing::instrument]
+pub async fn get_all_jre() -> Result<Vec<JavaVersion>, JREError> {
+    // Use HashSet to avoid duplicates
+    let mut jre_paths = HashSet::new();
+
+    // Add JREs directly on PATH
+    jre_paths.extend(get_all_jre_path().await);
+    jre_paths.extend(get_all_autoinstalled_jre_path().await?);
+
+    // Hard paths for locations for commonly installed .exes
+    let java_paths = [
+        r"/Applications/Xcode.app/Contents/Applications/Application Loader.app/Contents/MacOS/itms/java",
+        r"/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home",
+        r"/System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands",
+    ];
+    for path in java_paths {
+        jre_paths.insert(PathBuf::from(path));
+    }
+    // Iterate over JavaVirtualMachines/(something)/Contents/Home/bin
+    let base_path = PathBuf::from("/Library/Java/JavaVirtualMachines/");
+    if let Ok(dir) = std::fs::read_dir(base_path) {
+        for entry in dir.flatten() {
+            let entry = entry.path().join("Contents/Home/bin");
+            jre_paths.insert(entry);
+        }
+    }
+
+    // Get JRE versions from potential paths concurrently
+    let j = check_java_at_filepaths(jre_paths)
+        .await
+        .into_iter()
+        .collect();
+    Ok(j)
+}
+
+// Entrypoint function (Linux)
+// Returns a Vec of unique JavaVersions from the PATH, and common Java locations
+#[cfg(target_os = "linux")]
+#[tracing::instrument]
+pub async fn get_all_jre() -> Result<Vec<JavaVersion>, JREError> {
+    // Use HashSet to avoid duplicates
+    let mut jre_paths = HashSet::new();
+
+    // Add JREs directly on PATH
+    jre_paths.extend(get_all_jre_path().await);
+    jre_paths.extend(get_all_autoinstalled_jre_path().await?);
+
+    // Hard paths for locations for commonly installed locations
+    let java_paths = [
+        r"/usr",
+        r"/usr/java",
+        r"/usr/lib/jvm",
+        r"/usr/lib64/jvm",
+        r"/opt/jdk",
+        r"/opt/jdks",
+    ];
+    for path in java_paths {
+        let path = PathBuf::from(path);
+        jre_paths.insert(PathBuf::from(&path).join("jre").join("bin"));
+        jre_paths.insert(PathBuf::from(&path).join("bin"));
+        if let Ok(dir) = std::fs::read_dir(path) {
+            for entry in dir.flatten() {
+                let entry_path = entry.path();
+                jre_paths.insert(entry_path.join("jre").join("bin"));
+                jre_paths.insert(entry_path.join("bin"));
+            }
+        }
+    }
+
+    // Get JRE versions from potential paths concurrently
+    let j = check_java_at_filepaths(jre_paths)
+        .await
+        .into_iter()
+        .collect();
+    Ok(j)
+}
+
+// Gets all JREs from the PATH env variable
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+async fn get_all_autoinstalled_jre_path() -> Result<HashSet<PathBuf>, JREError>
+{
+    Box::pin(async move {
+        let state = State::get().await.map_err(|_| JREError::StateError)?;
+
+        let mut jre_paths = HashSet::new();
+        let base_path = state.directories.java_versions_dir().await;
+
+        if base_path.is_dir() {
+            if let Ok(dir) = std::fs::read_dir(base_path) {
+                for entry in dir.flatten() {
+                    let file_path = entry.path().join("bin");
+
+                    if let Ok(contents) =
+                        std::fs::read_to_string(file_path.clone())
+                    {
+                        let entry = entry.path().join(contents);
+                        jre_paths.insert(entry);
+                    } else {
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            let file_path = file_path.join(JAVA_BIN);
+                            jre_paths.insert(file_path);
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(jre_paths)
+    })
+    .await
+}
+
+// Gets all JREs from the PATH env variable
+#[tracing::instrument]
+async fn get_all_jre_path() -> HashSet<PathBuf> {
+    // Iterate over values in PATH variable, where accessible JREs are referenced
+    let paths =
+        env::var("PATH").map(|x| env::split_paths(&x).collect::<HashSet<_>>());
+    paths.unwrap_or_else(|_| HashSet::new())
+}
+
+#[cfg(target_os = "windows")]
+#[allow(dead_code)]
+pub const JAVA_BIN: &str = "javaw.exe";
+
+#[cfg(not(target_os = "windows"))]
+#[allow(dead_code)]
+pub const JAVA_BIN: &str = "java";
+
+// For each example filepath in 'paths', perform check_java_at_filepath, checking each one concurrently
+// and returning a JavaVersion for every valid path that points to a java bin
+#[tracing::instrument]
+pub async fn check_java_at_filepaths(
+    paths: HashSet<PathBuf>,
+) -> HashSet<JavaVersion> {
+    let jres = stream::iter(paths.into_iter())
+        .map(|p: PathBuf| {
+            tokio::task::spawn(async move { check_java_at_filepath(&p).await })
+        })
+        .buffer_unordered(64)
+        .collect::<Vec<_>>()
+        .await;
+
+    jres.into_iter().flat_map(|x| x.ok()).flatten().collect()
+}
+
+// For example filepath 'path', attempt to resolve it and get a Java version at this path
+// If no such path exists, or no such valid java at this path exists, returns None
+#[tracing::instrument]
+#[theseus_macros::debug_pin]
+pub async fn check_java_at_filepath(path: &Path) -> Option<JavaVersion> {
+    // Attempt to canonicalize the potential java filepath
+    // If it fails, this path does not exist and None is returned (no Java here)
+    let Ok(path) = io::canonicalize(path) else {
+        return None;
+    };
+
+    // Checks for existence of Java at this filepath
+    // Adds JAVA_BIN to the end of the path if it is not already there
+    let java = if path.file_name()?.to_str()? != JAVA_BIN {
+        path.join(JAVA_BIN)
+    } else {
+        path
+    };
+
+    if !java.exists() {
+        return None;
+    };
+
+    let bytes = include_bytes!("../../library/JavaInfo.class");
+    let tempdir: PathBuf = tempfile::tempdir().ok()?.into_path();
+    if !tempdir.exists() {
+        return None;
+    }
+    let file_path = tempdir.join("JavaInfo.class");
+    io::write(&file_path, bytes).await.ok()?;
+
+    let output = Command::new(&java)
+        .arg("-cp")
+        .arg(file_path.parent().unwrap())
+        .arg("JavaInfo")
+        .output()
+        .ok()?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    let mut java_version = None;
+    let mut java_arch = None;
+
+    for line in stdout.lines() {
+        let mut parts = line.split('=');
+        let key = parts.next().unwrap_or_default();
+        let value = parts.next().unwrap_or_default();
+
+        if key == "os.arch" {
+            java_arch = Some(value);
+        } else if key == "java.version" {
+            java_version = Some(value);
+        }
+    }
+
+    // Extract version info from it
+    if let Some(arch) = java_arch {
+        if let Some(version) = java_version {
+            let path = java.to_string_lossy().to_string();
+            return Some(JavaVersion {
+                path,
+                version: version.to_string(),
+                architecture: arch.to_string(),
+            });
+        }
+    }
+    None
+}
+
+/// Extract major/minor version from a java version string
+/// Gets the minor version or an error, and assumes 1 for major version if it could not find
+/// "1.8.0_361" -> (1, 8)
+/// "20" -> (1, 20)
+pub fn extract_java_majorminor_version(
+    version: &str,
+) -> Result<(u32, u32), JREError> {
+    let mut split = version.split('.');
+    let major_opt = split.next();
+
+    let mut major;
+    // Try minor. If doesn't exist, in format like "20" so use major
+    let mut minor = if let Some(minor) = split.next() {
+        major = major_opt.unwrap_or("1").parse::<u32>()?;
+        minor.parse::<u32>()?
+    } else {
+        // Formatted like "20", only one value means that is minor version
+        major = 1;
+        major_opt
+            .ok_or_else(|| JREError::InvalidJREVersion(version.to_string()))?
+            .parse::<u32>()?
+    };
+
+    // Java start should always be 1. If more than 1, it is formatted like "17.0.1.2" and starts with minor version
+    if major > 1 {
+        minor = major;
+        major = 1;
+    }
+
+    Ok((major, minor))
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum JREError {
+    #[error("Command error : {0}")]
+    IOError(#[from] std::io::Error),
+
+    #[error("Env error: {0}")]
+    EnvError(#[from] env::VarError),
+
+    #[error("No JRE found for required version: {0}")]
+    NoJREFound(String),
+
+    #[error("Invalid JRE version string: {0}")]
+    InvalidJREVersion(String),
+
+    #[error("Parsing error: {0}")]
+    ParseError(#[from] std::num::ParseIntError),
+
+    #[error("Join error: {0}")]
+    JoinError(#[from] JoinError),
+
+    #[error("No stored tag for Minecraft Version {0}")]
+    NoMinecraftVersionFound(String),
+
+    #[error("Error getting launcher sttae")]
+    StateError,
+}

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

@@ -0,0 +1,17 @@
+//! Theseus utility functions
+pub mod fetch;
+pub mod io;
+pub mod jre;
+pub mod platform;
+
+/// Wrap a builder which uses a mut reference into one which outputs an owned value
+macro_rules! wrap_ref_builder {
+    ($id:ident = $init:expr => $transform:block) => {{
+        let mut it = $init;
+        {
+            let $id = &mut it;
+            $transform;
+        }
+        it
+    }};
+}

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

@@ -0,0 +1,102 @@
+//! Platform-related code
+use daedalus::minecraft::{Os, OsRule};
+use regex::Regex;
+
+// OS detection
+pub trait OsExt {
+    /// Get the OS of the current system
+    fn native() -> Self;
+
+    /// Gets the OS + Arch of the current system
+    fn native_arch(java_arch: &str) -> Self;
+}
+
+impl OsExt for Os {
+    fn native_arch(java_arch: &str) -> Self {
+        if std::env::consts::OS == "windows" {
+            if java_arch == "aarch64" {
+                Os::WindowsArm64
+            } else {
+                Os::Windows
+            }
+        } else if std::env::consts::OS == "linux" {
+            if java_arch == "aarch64" {
+                Os::LinuxArm64
+            } else if java_arch == "arm" {
+                Os::LinuxArm32
+            } else {
+                Os::Linux
+            }
+        } else if std::env::consts::OS == "macos" {
+            if java_arch == "aarch64" {
+                Os::OsxArm64
+            } else {
+                Os::Osx
+            }
+        } else {
+            Os::Unknown
+        }
+    }
+
+    fn native() -> Self {
+        match std::env::consts::OS {
+            "windows" => Self::Windows,
+            "macos" => Self::Osx,
+            "linux" => Self::Linux,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+// Bit width
+#[cfg(target_pointer_width = "64")]
+pub const ARCH_WIDTH: &str = "64";
+
+#[cfg(target_pointer_width = "32")]
+pub const ARCH_WIDTH: &str = "32";
+
+// Platform rule handling
+pub fn os_rule(
+    rule: &OsRule,
+    java_arch: &str,
+    // Minecraft updated over 1.18.2 (supports MacOS Natively)
+    minecraft_updated: bool,
+) -> bool {
+    let mut rule_match = true;
+
+    if let Some(ref arch) = rule.arch {
+        rule_match &= !matches!(arch.as_str(), "x86" | "arm");
+    }
+
+    if let Some(name) = &rule.name {
+        if minecraft_updated
+            && (name != &Os::LinuxArm64 || name != &Os::LinuxArm32)
+        {
+            rule_match &=
+                &Os::native() == name || &Os::native_arch(java_arch) == name;
+        } else {
+            rule_match &= &Os::native_arch(java_arch) == name;
+        }
+    }
+
+    if let Some(version) = &rule.version {
+        if let Ok(regex) = Regex::new(version.as_str()) {
+            rule_match &=
+                regex.is_match(&sys_info::os_release().unwrap_or_default());
+        }
+    }
+
+    rule_match
+}
+
+pub fn classpath_separator(java_arch: &str) -> &'static str {
+    match Os::native_arch(java_arch) {
+        Os::Osx
+        | Os::OsxArm64
+        | Os::Linux
+        | Os::LinuxArm32
+        | Os::LinuxArm64
+        | Os::Unknown => ":",
+        Os::Windows | Os::WindowsArm64 => ";",
+    }
+}