Monorepo missing features (#1273)

* fix tauri config

* fix package patch

* regen pnpm lock

* use new workflow

* New GH actions

* Update lockfile

* update scripts

* Fix build script

* Fix missing deps

* Fix assets eslint

* Update libraries lint

* Fix all lint configs

* update lockfile

* add fmt + clippy fails

* Separate App Tauri portion

* fix app features

* Fix lints

* install tauri cli

* update lockfile

* corepack, fix lints

* add store path

* fix unused import

* Fix tests

* Issue templates + port over tauri release

* fix actions

* fix before build command

* Add X86 target

* Update build matrix

* finalize actions

* make debug build smaller

* Use debug build to make cache smaller

* dummy commit

* change proj name

* update file name

* Use release builds for less space use

* Remove rust cache

* Readd for app build

* add merge queue trigger

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

@@ -0,0 +1,55 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+// Example function:
+// User goes to auth_url to complete flow, and when completed, authenticate_await_completion() returns the credentials
+// export async function authenticate() {
+//   const auth_url = await authenticate_begin_flow()
+//   console.log(auth_url)
+//   await authenticate_await_completion()
+// }
+
+/// Authenticate a user with Hydra - part 1
+/// This begins the authentication flow quasi-synchronously
+/// This returns a DeviceLoginSuccess object, with two relevant fields:
+///  - verification_uri: the URL to go to to complete the flow
+///  - user_code: the code to enter on the verification_uri page
+export async function login() {
+  return await invoke('auth_login')
+}
+
+/// Retrieves the default user
+/// user is UUID
+export async function get_default_user() {
+  return await invoke('plugin:auth|auth_get_default_user')
+}
+
+/// Updates the default user
+/// user is UUID
+export async function set_default_user(user) {
+  return await invoke('plugin:auth|auth_set_default_user', { user })
+}
+
+/// Remove a user account from the database
+/// user is UUID
+export async function remove_user(user) {
+  return await invoke('plugin:auth|auth_remove_user', { user })
+}
+
+/// Returns a list of users
+/// Returns an Array of Credentials
+export async function users() {
+  return await invoke('plugin:auth|auth_users')
+}
+
+// Get a user by UUID
+// Prefer to use refresh() instead of this because it will refresh the credentials
+// user is UUID
+// Returns Credentials (of user)
+export async function get_user(user) {
+  return await invoke('plugin:auth|auth_get_user', { user })
+}

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

@@ -0,0 +1,107 @@
+/*
+    Event listeners for interacting with the Rust api
+    These are all async functions that return a promise that resolves to the payload object (whatever Rust is trying to deliver)
+*/
+
+/*
+    callback is a function that takes a single argument, which is the payload object (whatever Rust is trying to deliver)
+
+    You can call these to await any kind of emitted signal from Rust, and then do something with the payload object
+    An example place to put this is at the start of main.js before the state is initialized- that way
+    you can listen for any emitted signal from Rust and do something with it as the state is being initialized
+
+    Example:
+      import { loading_listener } from '@/helpers/events'
+      await loading_listener((event) => {
+        // event.event is the event name (useful if you want to use a single callback fn for multiple event types)
+        // event.payload is the payload object
+        console.log(event)
+      })
+      
+    Putting that in a script will print any emitted signal from rust
+*/
+import { listen } from '@tauri-apps/api/event'
+
+/// Payload for the 'loading' event
+/*
+    LoadingPayload {
+        event: {
+          type: string, one of  "StateInit", "PackDownload", etc
+          (Optional fields depending on event type)
+          pack_name: name of the pack
+          pack_id, optional, the id of the modpack
+          pack_version, optional, the version of the modpack
+          profile_name: name of the profile
+          profile_uuid: unique identification of the profile
+
+        }
+        loader_uuid: unique identification of the loading bar
+        fraction: number, (as a fraction of 1, how much we've loaded so far). If null, by convention, loading is finished
+        message: message to display to the user
+    }
+*/
+export async function loading_listener(callback) {
+  return await listen('loading', (event) => callback(event.payload))
+}
+
+/// Payload for the 'process' event
+/*
+    ProcessPayload {
+        uuid: unique identification of the process in the state (currently identified by PID, but that will change)
+        pid: process ID
+        event: event type ("Launched", "Finished")
+        message: message to display to the user
+    }
+*/
+export async function process_listener(callback) {
+  return await listen('process', (event) => callback(event.payload))
+}
+
+/// Payload for the 'profile' event
+/*
+    ProfilePayload {
+        uuid: unique identification of the process in the state (currently identified by path, but that will change)
+        name: name of the profile
+        profile_path: relative path to profile (used for path identification)
+        path: path to profile (used for opening the profile in the OS file explorer)
+        event: event type ("Created", "Added", "Edited", "Removed")
+    }
+*/
+export async function profile_listener(callback) {
+  return await listen('profile', (event) => callback(event.payload))
+}
+
+/// Payload for the 'command' event
+/*
+  CommandPayload {
+    event: event type ("InstallMod", "InstallModpack", "InstallVersion"),
+    id: string id of the mod/modpack/version to install
+  }
+*/
+export async function command_listener(callback) {
+  return await listen('command', (event) => {
+    callback(event.payload)
+  })
+}
+
+/// Payload for the 'warning' event
+/*
+    WarningPayload {
+        message: message to display to the user
+    }
+*/
+export async function warning_listener(callback) {
+  return await listen('warning', (event) => callback(event.payload))
+}
+
+/// Payload for the 'offline' event
+/*
+  OfflinePayload {
+    offline: bool, true or false
+  }
+*/
+export async function offline_listener(callback) {
+  return await listen('offline', (event) => {
+    return callback(event.payload)
+  })
+}

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

@@ -0,0 +1,18 @@
+import { ofetch } from 'ofetch'
+import { handleError } from '@/store/state.js'
+import { getVersion } from '@tauri-apps/api/app'
+
+export const useFetch = async (url, item, isSilent) => {
+  try {
+    const version = await getVersion()
+
+    return await ofetch(url, {
+      headers: { 'User-Agent': `modrinth/theseus/${version} (support@modrinth.com)` },
+    })
+  } catch (err) {
+    if (!isSilent) {
+      handleError({ message: `Error fetching ${item}` })
+    }
+    console.error(err)
+  }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+import { create } from './profile'
+
+/*
+  API for importing instances from other launchers
+  launcherType can be one of the following:
+  - MultiMC
+  - GDLauncher
+  - ATLauncher
+  - Curseforge
+  - PrismLauncher
+  - Unknown (shouldn't be used, but is used internally if the launcher type isn't recognized)
+
+  For each launcher type, we can get a guess of the default path for the launcher, and a list of importable instances
+  For most launchers, this will be the application's data directory, with two exceptions:
+  - MultiMC: this goes to the app directory (wherever the app is)
+  - Curseforge: this goes to the 'minecraft' subdirectory of the data directory, as Curseforge has multiple games
+
+*/
+
+/// Gets a list of importable instances from a launcher type and base path
+/// eg: get_importable_instances("MultiMC", "C:/MultiMC")
+/// returns ["Instance 1", "Instance 2"]
+export async function get_importable_instances(launcherType, basePath) {
+  return await invoke('plugin:import|import_get_importable_instances', { launcherType, basePath })
+}
+
+/// Import an instance from a launcher type and base path
+/// eg: import_instance("profile-name-to-go-to", "MultiMC", "C:/MultiMC", "Instance 1")
+export async function import_instance(launcherType, basePath, instanceFolder) {
+  // create a basic, empty instance (most properties will be filled in by the import process)
+  // We do NOT watch the fs for changes to avoid duplicate events during installation
+  // fs watching will be enabled once the instance is imported
+  const profilePath = await create(instanceFolder, '1.19.4', 'vanilla', 'latest', null, true)
+
+  return await invoke('plugin:import|import_import_instance', {
+    profilePath,
+    launcherType,
+    basePath,
+    instanceFolder,
+  })
+}
+
+/// Checks if this instance is valid for importing, given a certain launcher type
+/// eg: is_valid_importable_instance("C:/MultiMC/Instance 1", "MultiMC")
+export async function is_valid_importable_instance(instanceFolder, launcherType) {
+  return await invoke('plugin:import|import_is_valid_importable_instance', {
+    instanceFolder,
+    launcherType,
+  })
+}
+
+/// Gets the default path for the given launcher type
+/// null if it can't be found or doesn't exist
+/// eg: get_default_launcher_path("MultiMC")
+export async function get_default_launcher_path(launcherType) {
+  return await invoke('plugin:import|import_get_default_launcher_path', { launcherType })
+}

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

@@ -0,0 +1,43 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+/*
+
+JavaVersion {
+    path: Path
+    version: String
+}
+
+*/
+
+// Finds all the installation of Java 7, if it exists
+// Returns [JavaVersion]
+export async function find_filtered_jres(version) {
+  return await invoke('plugin:jre|jre_find_filtered_jres', { version })
+}
+
+// Gets java version from a specific path by trying to run 'java -version' on it.
+// This also validates it, as it returns null if no valid java version is found at the path
+export async function get_jre(path) {
+  return await invoke('plugin:jre|jre_get_jre', { path })
+}
+
+// Tests JRE version by running 'java -version' on it.
+// Returns true if the version is valid, and matches given (after extraction)
+export async function test_jre(path, majorVersion, minorVersion) {
+  return await invoke('plugin:jre|jre_test_jre', { path, majorVersion, minorVersion })
+}
+
+// Automatically installs specified java version
+export async function auto_install_java(javaVersion) {
+  return await invoke('plugin:jre|jre_auto_install_java', { javaVersion })
+}
+
+// Get max memory in KiB
+export async function get_max_memory() {
+  return await invoke('plugin:jre|jre_get_max_memory')
+}

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

@@ -0,0 +1,61 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+/*
+A log is a struct containing the filename string, stdout, and stderr, as follows:
+
+pub struct Logs {
+    pub filename:  String,
+    pub stdout: String,
+    pub stderr: String,
+}
+*/
+
+/// Get all logs that exist for a given profile
+/// This is returned as an array of Log objects, sorted by filename (the folder name, when the log was created)
+export async function get_logs(profilePath, clearContents) {
+  return await invoke('plugin:logs|logs_get_logs', { profilePath, clearContents })
+}
+
+/// Get a profile's log by filename
+export async function get_logs_by_filename(profilePath, logType, filename) {
+  return await invoke('plugin:logs|logs_get_logs_by_filename', { profilePath, logType, filename })
+}
+
+/// Get a profile's log text only by filename
+export async function get_output_by_filename(profilePath, logType, filename) {
+  return await invoke('plugin:logs|logs_get_output_by_filename', { profilePath, logType, filename })
+}
+
+/// Delete a profile's log by filename
+export async function delete_logs_by_filename(profilePath, logType, filename) {
+  return await invoke('plugin:logs|logs_delete_logs_by_filename', {
+    profilePath,
+    logType,
+    filename,
+  })
+}
+
+/// Delete all logs for a given profile
+export async function delete_logs(profilePath) {
+  return await invoke('plugin:logs|logs_delete_logs', { profilePath })
+}
+
+/// Get the latest log for a given profile and cursor (startpoint to read withi nthe file)
+/// Returns:
+/*
+  {
+    cursor: u64
+    output: String
+    new_file: bool <- the cursor was too far, meaning that the file was likely rotated/reset. This signals to the frontend to clear the log and start over with this struct.
+  }
+*/
+
+// From latest.log directly
+export async function get_latest_log_cursor(profilePath, cursor) {
+  return await invoke('plugin:logs|logs_get_latest_log_cursor', { profilePath, cursor })
+}

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

@@ -0,0 +1,39 @@
+import { invoke } from '@tauri-apps/api/tauri'
+
+/// Gets the game versions from daedalus
+// Returns a VersionManifest
+export async function get_game_versions() {
+  return await invoke('plugin:metadata|metadata_get_game_versions')
+}
+
+// Gets the fabric versions from daedalus
+// Returns Manifest
+export async function get_fabric_versions() {
+  const c = await invoke('plugin:metadata|metadata_get_fabric_versions')
+  console.log('Getting fabric versions', c)
+  return c
+}
+
+// Gets the forge versions from daedalus
+// Returns Manifest
+export async function get_forge_versions() {
+  const c = await invoke('plugin:metadata|metadata_get_forge_versions')
+  console.log('Getting forge versions', c)
+  return c
+}
+
+// Gets the quilt versions from daedalus
+// Returns Manifest
+export async function get_quilt_versions() {
+  const c = await invoke('plugin:metadata|metadata_get_quilt_versions')
+  console.log('Getting quilt versions', c)
+  return c
+}
+
+// Gets the neoforge versions from daedalus
+// Returns Manifest
+export async function get_neoforge_versions() {
+  const c = await invoke('plugin:metadata|metadata_get_neoforge_versions')
+  console.log('Getting neoforge versions', c)
+  return c
+}

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

@@ -0,0 +1,57 @@
+import mixpanel from 'mixpanel-browser'
+
+// mixpanel_track
+function trackWrapper(originalTrack) {
+  return function (event_name, properties = {}) {
+    try {
+      originalTrack(event_name, properties)
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+export const mixpanel_track = trackWrapper(mixpanel.track.bind(mixpanel))
+
+// mixpanel_opt_out_tracking()
+function optOutTrackingWrapper(originalOptOutTracking) {
+  return function () {
+    try {
+      originalOptOutTracking()
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+export const mixpanel_opt_out_tracking = optOutTrackingWrapper(
+  mixpanel.opt_out_tracking.bind(mixpanel),
+)
+
+// mixpanel_opt_in_tracking()
+function optInTrackingWrapper(originalOptInTracking) {
+  return function () {
+    try {
+      originalOptInTracking()
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+export const mixpanel_opt_in_tracking = optInTrackingWrapper(
+  mixpanel.opt_in_tracking.bind(mixpanel),
+)
+
+// mixpanel_init
+function initWrapper(originalInit) {
+  return function (token, config = {}) {
+    try {
+      originalInit(token, config)
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+export const mixpanel_init = initWrapper(mixpanel.init.bind(mixpanel))
+
+export const mixpanel_is_loaded = () => {
+  return mixpanel.__loaded
+}

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

@@ -0,0 +1,47 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+export async function authenticate_begin_flow(provider) {
+  return await invoke('plugin:mr_auth|authenticate_begin_flow', { provider })
+}
+
+export async function authenticate_await_completion() {
+  return await invoke('plugin:mr_auth|authenticate_await_completion')
+}
+
+export async function cancel_flow() {
+  return await invoke('plugin:mr_auth|cancel_flow')
+}
+export async function login_pass(username, password, challenge) {
+  return await invoke('plugin:mr_auth|login_pass', { username, password, challenge })
+}
+
+export async function login_2fa(code, flow) {
+  return await invoke('plugin:mr_auth|login_2fa', { code, flow })
+}
+
+export async function create_account(username, email, password, challenge, signUpNewsletter) {
+  return await invoke('plugin:mr_auth|create_account', {
+    username,
+    email,
+    password,
+    challenge,
+    signUpNewsletter,
+  })
+}
+
+export async function refresh() {
+  return await invoke('plugin:mr_auth|refresh')
+}
+
+export async function logout() {
+  return await invoke('plugin:mr_auth|logout')
+}
+
+export async function get() {
+  return await invoke('plugin:mr_auth|get')
+}

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

@@ -0,0 +1,45 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+import { create } from './profile'
+
+// Installs pack from a version ID
+export async function install(projectId, versionId, packTitle, iconUrl) {
+  const location = {
+    type: 'fromVersionId',
+    project_id: projectId,
+    version_id: versionId,
+    title: packTitle,
+    icon_url: iconUrl,
+  }
+  const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
+  const profile = await create(
+    profile_creator.name,
+    profile_creator.gameVersion,
+    profile_creator.modloader,
+    profile_creator.loaderVersion,
+    profile_creator.icon,
+  )
+
+  return await invoke('plugin:pack|pack_install', { location, profile })
+}
+
+// Installs pack from a path
+export async function install_from_file(path) {
+  const location = {
+    type: 'fromFile',
+    path: path,
+  }
+  const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
+  const profile = await create(
+    profile_creator.name,
+    profile_creator.gameVersion,
+    profile_creator.modloader,
+    profile_creator.loaderVersion,
+    profile_creator.icon,
+  )
+  return await invoke('plugin:pack|pack_install', { location, profile })
+}

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

@@ -0,0 +1,53 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+/// Gets if a process has finished by UUID
+/// Returns bool
+export async function has_finished_by_uuid(uuid) {
+  return await invoke('plugin:process|process_has_finished_by_uuid', { uuid })
+}
+
+/// Gets process exit status by UUID
+/// Returns u32
+export async function get_exit_status_by_uuid(uuid) {
+  return await invoke('plugin:process|process_get_exit_status_by_uuid', { uuid })
+}
+
+/// Gets all process IDs
+/// Returns [u32]
+export async function get_all_uuids() {
+  return await invoke('plugin:process|process_get_all_uuids')
+}
+
+/// Gets all running process IDs
+/// Returns [u32]
+export async function get_all_running_uuids() {
+  return await invoke('plugin:process|process_get_all_running_uuids')
+}
+
+/// Gets all running process IDs with a given profile path
+/// Returns [u32]
+export async function get_uuids_by_profile_path(profilePath) {
+  return await invoke('plugin:process|process_get_uuids_by_profile_path', { profilePath })
+}
+
+/// Gets all running process IDs with a given profile path
+/// Returns [u32]
+export async function get_all_running_profile_paths(profilePath) {
+  return await invoke('plugin:process|process_get_all_running_profile_paths', { profilePath })
+}
+
+/// Gets all running process IDs with a given profile path
+/// Returns [u32]
+export async function get_all_running_profiles() {
+  return await invoke('plugin:process|process_get_all_running_profiles')
+}
+
+/// Kills a process by UUID
+export async function kill_by_uuid(uuid) {
+  return await invoke('plugin:process|process_kill_by_uuid', { uuid })
+}

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

@@ -0,0 +1,180 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+/// Add instance
+/*
+    name: String,           // the name of the profile, and relative path to create
+    game_version: String,   // the game version of the profile
+    modloader: ModLoader,   // the modloader to use
+    - ModLoader is an enum, with the following variants: Vanilla, Forge, Fabric, Quilt
+    loader_version: String, // the modloader version to use, set to "latest", "stable", or the ID of your chosen loader
+    icon: Path,  // the icon for the profile
+    - icon is a path to an image file, which will be copied into the profile directory
+*/
+
+export async function create(name, gameVersion, modloader, loaderVersion, icon, noWatch) {
+  //Trim string name to avoid "Unable to find directory"
+  name = name.trim()
+  return await invoke('plugin:profile_create|profile_create', {
+    name,
+    gameVersion,
+    modloader,
+    loaderVersion,
+    icon,
+    noWatch,
+  })
+}
+
+// duplicate a profile
+export async function duplicate(path) {
+  return await invoke('plugin:profile_create|profile_duplicate', { path })
+}
+
+// Remove a profile
+export async function remove(path) {
+  return await invoke('plugin:profile|profile_remove', { path })
+}
+
+// Get a profile by path
+// Returns a Profile
+export async function get(path, clearProjects) {
+  return await invoke('plugin:profile|profile_get', { path, clearProjects })
+}
+
+// Get a profile's full fs path
+// Returns a path
+export async function get_full_path(path) {
+  return await invoke('plugin:profile|profile_get_full_path', { path })
+}
+
+// Get's a mod's full fs path
+// Returns a path
+export async function get_mod_full_path(path, projectPath) {
+  return await invoke('plugin:profile|profile_get_mod_full_path', { path, projectPath })
+}
+
+// Get optimal java version from profile
+// Returns a java version
+export async function get_optimal_jre_key(path) {
+  return await invoke('plugin:profile|profile_get_optimal_jre_key', { path })
+}
+
+// Get a copy of the profile set
+// Returns hashmap of path -> Profile
+export async function list(clearProjects) {
+  return await invoke('plugin:profile|profile_list', { clearProjects })
+}
+
+export async function check_installed(path, projectId) {
+  return await invoke('plugin:profile|profile_check_installed', { path, projectId })
+}
+
+// Installs/Repairs a profile
+export async function install(path, force) {
+  return await invoke('plugin:profile|profile_install', { path, force })
+}
+
+// Updates all of a profile's projects
+export async function update_all(path) {
+  return await invoke('plugin:profile|profile_update_all', { path })
+}
+
+// Updates a specified project
+export async function update_project(path, projectPath) {
+  return await invoke('plugin:profile|profile_update_project', { path, projectPath })
+}
+
+// Add a project to a profile from a version
+// Returns a path to the new project file
+export async function add_project_from_version(path, versionId) {
+  return await invoke('plugin:profile|profile_add_project_from_version', { path, versionId })
+}
+
+// Add a project to a profile from a path + project_type
+// Returns a path to the new project file
+export async function add_project_from_path(path, projectPath, projectType) {
+  return await invoke('plugin:profile|profile_add_project_from_path', {
+    path,
+    projectPath,
+    projectType,
+  })
+}
+
+// Toggle disabling a project
+export async function toggle_disable_project(path, projectPath) {
+  return await invoke('plugin:profile|profile_toggle_disable_project', { path, projectPath })
+}
+
+// Remove a project
+export async function remove_project(path, projectPath) {
+  return await invoke('plugin:profile|profile_remove_project', { path, projectPath })
+}
+
+// Update a managed Modrinth profile to a specific version
+export async function update_managed_modrinth_version(path, versionId) {
+  return await invoke('plugin:profile|profile_update_managed_modrinth_version', { path, versionId })
+}
+
+// Repair a managed Modrinth profile
+export async function update_repair_modrinth(path) {
+  return await invoke('plugin:profile|profile_repair_managed_modrinth', { path })
+}
+
+// Export a profile to .mrpack
+/// included_overrides is an array of paths to override folders to include (ie: 'mods', 'resource_packs')
+// Version id is optional (ie: 1.1.5)
+export async function export_profile_mrpack(
+  path,
+  exportLocation,
+  includedOverrides,
+  versionId,
+  description,
+  name,
+) {
+  return await invoke('plugin:profile|profile_export_mrpack', {
+    path,
+    exportLocation,
+    includedOverrides,
+    versionId,
+    description,
+    name,
+  })
+}
+
+// Given a folder path, populate an array of all the subfolders
+// Intended to be used for finding potential override folders
+// profile
+// -- mods
+// -- resourcepacks
+// -- file1
+// => [mods, resourcepacks]
+// allows selection for 'included_overrides' in export_profile_mrpack
+export async function get_pack_export_candidates(profilePath) {
+  return await invoke('plugin:profile|profile_get_pack_export_candidates', { profilePath })
+}
+
+// Run Minecraft using a pathed profile
+// Returns PID of child
+export async function run(path) {
+  return await invoke('plugin:profile|profile_run', { path })
+}
+
+// Run Minecraft using a pathed profile
+// Waits for end
+export async function run_wait(path) {
+  return await invoke('plugin:profile|profile_run_wait', { path })
+}
+
+// Edits a profile
+export async function edit(path, editProfile) {
+  return await invoke('plugin:profile|profile_edit', { path, editProfile })
+}
+
+// Edits a profile's icon
+export async function edit_icon(path, iconPath) {
+  return await invoke('plugin:profile|profile_edit_icon', { path, iconPath })
+}

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

@@ -0,0 +1,49 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+// Settings object
+/*
+
+Settings {
+    "memory": MemorySettings,
+    "game_resolution": [int int],
+    "custom_java_args": [String ...],
+    "custom_env_args" : [(string, string) ... ]>,
+    "java_globals": Hash of (string, Path),
+    "default_user": Uuid string (can be null),
+    "hooks": Hooks,
+    "max_concurrent_downloads": uint,
+    "version": u32,
+    "collapsed_navigation": bool,
+}
+
+Memorysettings {
+    "min": u32, can be null,
+    "max": u32,
+}
+
+*/
+
+// Get full settings object
+export async function get() {
+  return await invoke('plugin:settings|settings_get')
+}
+
+// Set full settings object
+export async function set(settings) {
+  return await invoke('plugin:settings|settings_set', { settings })
+}
+
+// Changes the config dir
+// Seizes the entire application state until its done
+export async function change_config_dir(newConfigDir) {
+  return await invoke('plugin:settings|settings_change_config_dir', { newConfigDir })
+}
+
+export async function is_dir_writeable(newConfigDir) {
+  return await invoke('plugin:settings|settings_is_dir_writeable', { newConfigDir })
+}

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

@@ -0,0 +1,35 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+// Initialize the theseus API state
+// This should be called during the initializion/opening of the launcher
+export async function initialize_state() {
+  return await invoke('initialize_state')
+}
+
+// Gets active progress bars
+export async function progress_bars_list() {
+  return await invoke('plugin:utils|progress_bars_list')
+}
+
+// Check if any safe loading bars are active
+export async function check_safe_loading_bars_complete() {
+  return await invoke('plugin:utils|safety_check_safe_loading_bars')
+}
+
+// Get opening command
+// For example, if a user clicks on an .mrpack to open the app.
+// This should be called once and only when the app is done booting up and ready to receive a command
+// Returns a Command struct- see events.js
+export async function get_opening_command() {
+  return await invoke('plugin:utils|get_opening_command')
+}
+
+// Wait for settings to sync
+export async function await_sync() {
+  return await invoke('plugin:utils|await_sync')
+}

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

@@ -0,0 +1,36 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import { invoke } from '@tauri-apps/api/tauri'
+
+// Gets tag bundle of all tags
+export async function get_tag_bundle() {
+  return await invoke('plugin:tags|tags_get_tag_bundle')
+}
+
+// Gets cached category tags
+export async function get_categories() {
+  return await invoke('plugin:tags|tags_get_categories')
+}
+
+// Gets cached loaders tags
+export async function get_loaders() {
+  return await invoke('plugin:tags|tags_get_loaders')
+}
+
+// Gets cached game_versions tags
+export async function get_game_versions() {
+  return await invoke('plugin:tags|tags_get_game_versions')
+}
+
+// Gets cached donation_platforms tags
+export async function get_donation_platforms() {
+  return await invoke('plugin:tags|tags_get_donation_platforms')
+}
+
+// Gets cached licenses tags
+export async function get_report_types() {
+  return await invoke('plugin:tags|tags_get_report_types')
+}

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

@@ -0,0 +1,103 @@
+import {
+  add_project_from_version as installMod,
+  check_installed,
+  get_full_path,
+  get_mod_full_path,
+} from '@/helpers/profile'
+import { useFetch } from '@/helpers/fetch.js'
+import { handleError } from '@/store/notifications.js'
+import { invoke } from '@tauri-apps/api/tauri'
+
+export async function isDev() {
+  return await invoke('is_dev')
+}
+
+// One of 'Windows', 'Linux', 'MacOS'
+export async function getOS() {
+  return await invoke('plugin:utils|get_os')
+}
+
+export async function showInFolder(path) {
+  return await invoke('plugin:utils|show_in_folder', { path })
+}
+
+export async function showLauncherLogsFolder() {
+  return await invoke('plugin:utils|show_launcher_logs_folder', {})
+}
+
+// Opens a profile's folder in the OS file explorer
+export async function showProfileInFolder(path) {
+  const fullPath = await get_full_path(path)
+  return await showInFolder(fullPath)
+}
+
+export async function highlightModInProfile(profilePath, projectPath) {
+  const fullPath = await get_mod_full_path(profilePath, projectPath)
+  return await showInFolder(fullPath)
+}
+
+export const releaseColor = (releaseType) => {
+  switch (releaseType) {
+    case 'release':
+      return 'green'
+    case 'beta':
+      return 'orange'
+    case 'alpha':
+      return 'red'
+    default:
+      return ''
+  }
+}
+
+export const installVersionDependencies = async (profile, version) => {
+  for (const dep of version.dependencies) {
+    if (dep.dependency_type !== 'required') continue
+    // disallow fabric api install on quilt
+    if (dep.project_id === 'P7dR8mSH' && profile.metadata.loader === 'quilt') continue
+    if (dep.version_id) {
+      if (
+        dep.project_id &&
+        (await check_installed(profile.path, dep.project_id).catch(handleError))
+      )
+        continue
+      await installMod(profile.path, dep.version_id)
+    } else {
+      if (
+        dep.project_id &&
+        (await check_installed(profile.path, dep.project_id).catch(handleError))
+      )
+        continue
+      const depVersions = await useFetch(
+        `https://api.modrinth.com/v2/project/${dep.project_id}/version`,
+        'dependency versions',
+      )
+      const latest = depVersions.find(
+        (v) =>
+          v.game_versions.includes(profile.metadata.game_version) &&
+          v.loaders.includes(profile.metadata.loader),
+      )
+      if (latest) {
+        await installMod(profile.path, latest.id).catch(handleError)
+      }
+    }
+  }
+}
+
+export const openLink = (url) => {
+  window.__TAURI_INVOKE__('tauri', {
+    __tauriModule: 'Shell',
+    message: {
+      cmd: 'open',
+      path: url,
+    },
+  })
+}
+
+export const refreshOffline = async () => {
+  return await invoke('plugin:utils|refresh_offline', {})
+}
+
+// returns true/false
+export const isOffline = async () => {
+  return await invoke('plugin:utils|is_offline', {})
+}