refactor: Improvements to src-tauri

Signed-off-by: quexeky <git@quexeky.dev>

Cargo.toml

@@ -0,0 +1,14 @@
+[workspace]
+members = [
+    "client",
+    "database",
+    "src-tauri",
+    "process",
+    "remote",
+    "utils",
+    "cloud_saves",
+    "download_manager",
+    "games",
+]
+
+resolver = "3"

client/src/compat.rs

@@ -1,9 +1,4 @@
-use std::{
-    ffi::OsStr,
-    path::PathBuf,
-    process::{Command, Stdio},
-    sync::LazyLock,
-};
+use std::{ffi::OsStr, path::PathBuf, process::{Command, Stdio}, sync::LazyLock};
 
 use log::info;
 

client/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod app_status;
 pub mod autostart;
-pub mod compat;
 pub mod user;
+pub mod app_status;
+pub mod compat;

client/src/user.rs

@@ -10,3 +10,4 @@ pub struct User {
     display_name: String,
     profile_picture_object_id: String,
 }
+

cloud_saves/src/backup_manager.rs

@@ -0,0 +1,105 @@
+use std::{collections::HashMap, path::PathBuf, str::FromStr};
+
+#[cfg(target_os = "linux")]
+use database::platform::Platform;
+use database::{db::DATA_ROOT_DIR, GameVersion};
+use log::warn;
+
+use crate::error::BackupError;
+
+use super::path::CommonPath;
+
+pub struct BackupManager<'a> {
+    pub current_platform: Platform,
+    pub sources: HashMap<(Platform, Platform), &'a (dyn BackupHandler + Sync + Send)>,
+}
+
+impl BackupManager<'_> {
+    pub fn new() -> Self {
+        BackupManager {
+            #[cfg(target_os = "windows")]
+            current_platform: Platform::Windows,
+
+            #[cfg(target_os = "macos")]
+            current_platform: Platform::MacOs,
+
+            #[cfg(target_os = "linux")]
+            current_platform: Platform::Linux,
+
+            sources: HashMap::from([
+                // Current platform to target platform
+                (
+                    (Platform::Windows, Platform::Windows),
+                    &WindowsBackupManager {} as &(dyn BackupHandler + Sync + Send),
+                ),
+                (
+                    (Platform::Linux, Platform::Linux),
+                    &LinuxBackupManager {} as &(dyn BackupHandler + Sync + Send),
+                ),
+                (
+                    (Platform::MacOs, Platform::MacOs),
+                    &MacBackupManager {} as &(dyn BackupHandler + Sync + Send),
+                ),
+                
+            ]),
+        }
+    }
+    
+}
+
+pub trait BackupHandler: Send + Sync {
+    fn root_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(DATA_ROOT_DIR.join("games")) }
+    fn game_translate(&self, _path: &PathBuf, game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(PathBuf::from_str(&game.game_id).unwrap()) }
+    fn base_translate(&self, path: &PathBuf, game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(self.root_translate(path, game)?.join(self.game_translate(path, game)?)) }
+    fn home_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { let c = CommonPath::Home.get().ok_or(BackupError::NotFound); println!("{:?}", c); c }
+    fn store_user_id_translate(&self, _path: &PathBuf, game: &GameVersion) -> Result<PathBuf, BackupError> { PathBuf::from_str(&game.game_id).map_err(|_| BackupError::ParseError) }
+    fn os_user_name_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(PathBuf::from_str(&whoami::username()).unwrap()) }
+    fn win_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winAppData>"); Err(BackupError::InvalidSystem) }
+    fn win_local_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winLocalAppData>"); Err(BackupError::InvalidSystem) }
+    fn win_local_app_data_low_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winLocalAppDataLow>"); Err(BackupError::InvalidSystem) }
+    fn win_documents_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winDocuments>"); Err(BackupError::InvalidSystem) }
+    fn win_public_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winPublic>"); Err(BackupError::InvalidSystem) }
+    fn win_program_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winProgramData>"); Err(BackupError::InvalidSystem) }
+    fn win_dir_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winDir>"); Err(BackupError::InvalidSystem) }
+    fn xdg_data_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected XDG Reference in Backup <xdgData>"); Err(BackupError::InvalidSystem) }
+    fn xdg_config_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected XDG Reference in Backup <xdgConfig>"); Err(BackupError::InvalidSystem) }
+    fn skip_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(PathBuf::new()) }
+}
+
+pub struct LinuxBackupManager {}
+impl BackupHandler for LinuxBackupManager {
+    fn xdg_config_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Data.get().ok_or(BackupError::NotFound)?)
+    }
+    fn xdg_data_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Config.get().ok_or(BackupError::NotFound)?)
+    }
+}
+pub struct WindowsBackupManager {}
+impl BackupHandler for WindowsBackupManager {
+    fn win_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Config.get().ok_or(BackupError::NotFound)?)
+    }
+    fn win_local_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::DataLocal.get().ok_or(BackupError::NotFound)?)
+    }
+    fn win_local_app_data_low_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::DataLocalLow.get().ok_or(BackupError::NotFound)?)
+    }
+    fn win_dir_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(PathBuf::from_str("C:/Windows").unwrap())
+    }
+    fn win_documents_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Document.get().ok_or(BackupError::NotFound)?)
+
+    }
+    fn win_program_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(PathBuf::from_str("C:/ProgramData").unwrap())
+    }
+    fn win_public_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Public.get().ok_or(BackupError::NotFound)?)
+
+    }
+}
+pub struct MacBackupManager {}
+impl BackupHandler for MacBackupManager {}

cloud_saves/src/conditions.rs

@@ -2,6 +2,5 @@ use database::platform::Platform;
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum Condition {
-    Os(Platform),
-    Other
+    Os(Platform)
 }

cloud_saves/src/lib.rs

@@ -1,8 +1,8 @@
-pub mod backup_manager;
 pub mod conditions;
-pub mod error;
 pub mod metadata;
+pub mod resolver;
+pub mod placeholder;
 pub mod normalise;
 pub mod path;
-pub mod placeholder;
-pub mod resolver;
+pub mod backup_manager;
+pub mod error;

cloud_saves/src/metadata.rs

@@ -1,6 +1,7 @@
 use database::GameVersion;
 
-use super::conditions::Condition;
+use super::conditions::{Condition};
+
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct CloudSaveMetadata {
@@ -15,17 +16,15 @@ pub struct GameFile {
     pub id: Option<String>,
     pub data_type: DataType,
     pub tags: Vec<Tag>,
-    pub conditions: Vec<Condition>,
+    pub conditions: Vec<Condition>
 }
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
 pub enum DataType {
     Registry,
     File,
-    Other,
+    Other
 }
-#[derive(
-    Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum Tag {
     Config,

cloud_saves/src/normalise.rs

@@ -5,6 +5,7 @@ use regex::Regex;
 
 use super::placeholder::*;
 
+
 pub fn normalize(path: &str, os: Platform) -> String {
     let mut path = path.trim().trim_end_matches(['/', '\\']).replace('\\', "/");
 
@@ -13,25 +14,18 @@ pub fn normalize(path: &str, os: Platform) -> String {
     }
 
     static CONSECUTIVE_SLASHES: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"/{2,}").unwrap());
-    static UNNECESSARY_DOUBLE_STAR_1: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"([^/*])\*{2,}").unwrap());
-    static UNNECESSARY_DOUBLE_STAR_2: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"\*{2,}([^/*])").unwrap());
+    static UNNECESSARY_DOUBLE_STAR_1: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"([^/*])\*{2,}").unwrap());
+    static UNNECESSARY_DOUBLE_STAR_2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\*{2,}([^/*])").unwrap());
     static ENDING_WILDCARD: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\*)+$").unwrap());
     static ENDING_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\.)$").unwrap());
     static INTERMEDIATE_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\./)").unwrap());
     static BLANK_SEGMENT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\s+/)").unwrap());
     static APP_DATA: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%appdata%").unwrap());
-    static APP_DATA_ROAMING: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Roaming").unwrap());
-    static APP_DATA_LOCAL: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)%localappdata%").unwrap());
-    static APP_DATA_LOCAL_2: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Local/").unwrap());
-    static USER_PROFILE: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)%userprofile%").unwrap());
-    static DOCUMENTS: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)%userprofile%/Documents").unwrap());
+    static APP_DATA_ROAMING: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Roaming").unwrap());
+    static APP_DATA_LOCAL: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%localappdata%").unwrap());
+    static APP_DATA_LOCAL_2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Local/").unwrap());
+    static USER_PROFILE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%").unwrap());
+    static DOCUMENTS: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/Documents").unwrap());
 
     for (pattern, replacement) in [
         (&CONSECUTIVE_SLASHES, "/"),
@@ -72,9 +66,7 @@ pub fn normalize(path: &str, os: Platform) -> String {
 
 fn too_broad(path: &str) -> bool {
     println!("Path: {}", path);
-    use {
-        BASE, HOME, ROOT, STORE_USER_ID, WIN_APP_DATA, WIN_DIR, WIN_DOCUMENTS, XDG_CONFIG, XDG_DATA,
-    };
+    use {BASE, HOME, ROOT, STORE_USER_ID, WIN_APP_DATA, WIN_DIR, WIN_DOCUMENTS, XDG_CONFIG, XDG_DATA};
 
     let path_lower = path.to_lowercase();
 
@@ -85,9 +77,7 @@ fn too_broad(path: &str) -> bool {
     }
 
     for item in AVOID_WILDCARDS {
-        if path.starts_with(&format!("{}/*", item))
-            || path.starts_with(&format!("{}/{}", item, STORE_USER_ID))
-        {
+        if path.starts_with(&format!("{}/*", item)) || path.starts_with(&format!("{}/{}", item, STORE_USER_ID)) {
             return true;
         }
     }
@@ -135,6 +125,7 @@ fn too_broad(path: &str) -> bool {
         }
     }
     
+
     // Drive letters:
     let drives: Regex = Regex::new(r"^[a-zA-Z]:$").unwrap();
     if drives.is_match(path) {

cloud_saves/src/path.rs

@@ -13,12 +13,12 @@ pub enum CommonPath {
 
 impl CommonPath {
     pub fn get(&self) -> Option<PathBuf> {
-        static CONFIG: LazyLock<Option<PathBuf>> = LazyLock::new(dirs::config_dir);
-        static DATA: LazyLock<Option<PathBuf>> = LazyLock::new(dirs::data_dir);
-        static DATA_LOCAL: LazyLock<Option<PathBuf>> = LazyLock::new(dirs::data_local_dir);
-        static DOCUMENT: LazyLock<Option<PathBuf>> = LazyLock::new(dirs::document_dir);
-        static HOME: LazyLock<Option<PathBuf>> = LazyLock::new(dirs::home_dir);
-        static PUBLIC: LazyLock<Option<PathBuf>> = LazyLock::new(dirs::public_dir);
+        static CONFIG: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::config_dir());
+        static DATA: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::data_dir());
+        static DATA_LOCAL: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::data_local_dir());
+        static DOCUMENT: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::document_dir());
+        static HOME: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::home_dir());
+        static PUBLIC: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::public_dir());
 
         #[cfg(windows)]
         static DATA_LOCAL_LOW: LazyLock<Option<PathBuf>> = LazyLock::new(|| {

cloud_saves/src/placeholder.rs

@@ -48,4 +48,4 @@ pub const XDG_DATA: &str = "<xdgData>"; // %WINDIR% on Windows
 pub const XDG_CONFIG: &str = "<xdgConfig>"; // $XDG_DATA_HOME on Linux
 pub const SKIP: &str = "<skip>"; // $XDG_CONFIG_HOME on Linux
 
-pub static OS_USERNAME: LazyLock<String> = LazyLock::new(whoami::username);
+pub static OS_USERNAME: LazyLock<String> = LazyLock::new(|| whoami::username());

cloud_saves/src/resolver.rs

@@ -1,13 +1,17 @@
 use std::{
-    fs::{self, File, create_dir_all},
-    io::{self, Read, Write},
+    fs::{self, create_dir_all, File},
+    io::{self, ErrorKind, Read, Write},
     path::{Path, PathBuf},
+    thread::sleep,
+    time::Duration,
 };
 
 use crate::error::BackupError;
 
-use super::{backup_manager::BackupHandler, placeholder::*};
-use database::GameVersion;
+use super::{
+    backup_manager::BackupHandler, conditions::Condition, metadata::GameFile, placeholder::*,
+};
+use database::{platform::Platform, GameVersion};
 use log::{debug, warn};
 use rustix::path::Arg;
 use tempfile::tempfile;
@@ -26,7 +30,7 @@ pub fn resolve(meta: &mut CloudSaveMetadata) -> File {
             .iter()
             .find_map(|p| match p {
                 super::conditions::Condition::Os(os) => Some(os),
-                _ => None
+                _ => None,
             })
             .cloned()
         {
@@ -59,7 +63,7 @@ pub fn resolve(meta: &mut CloudSaveMetadata) -> File {
     let binding = serde_json::to_string(meta).unwrap();
     let serialized = binding.as_bytes();
     let mut file = tempfile().unwrap();
-    file.write_all(serialized).unwrap();
+    file.write(serialized).unwrap();
     tarball.append_file("metadata", &mut file).unwrap();
     tarball.into_inner().unwrap().finish().unwrap()
 }
@@ -92,7 +96,7 @@ pub fn extract(file: PathBuf) -> Result<(), BackupError> {
             .iter()
             .find_map(|p| match p {
                 super::conditions::Condition::Os(os) => Some(os),
-                _ => None
+                _ => None,
             })
             .cloned()
         {
@@ -111,7 +115,7 @@ pub fn extract(file: PathBuf) -> Result<(), BackupError> {
         };
 
         let new_path = parse_path(file.path.into(), handler, &manifest.game_version)?;
-        create_dir_all(new_path.parent().unwrap()).unwrap();
+        create_dir_all(&new_path.parent().unwrap()).unwrap();
 
         println!(
             "Current path {:?} copying to {:?}",
@@ -128,22 +132,23 @@ pub fn copy_item<P: AsRef<Path>>(src: P, dest: P) -> io::Result<()> {
     let src_path = src.as_ref();
     let dest_path = dest.as_ref();
 
-    let metadata = fs::metadata(src_path)?;
+    let metadata = fs::metadata(&src_path)?;
 
     if metadata.is_file() {
         // Ensure the parent directory of the destination exists for a file copy
         if let Some(parent) = dest_path.parent() {
             fs::create_dir_all(parent)?;
         }
-        fs::copy(src_path, dest_path)?;
+        fs::copy(&src_path, &dest_path)?;
     } else if metadata.is_dir() {
         // For directories, we call the recursive helper function.
         // The destination for the recursive copy is the `dest_path` itself.
-        copy_dir_recursive(src_path, dest_path)?;
+        copy_dir_recursive(&src_path, &dest_path)?;
     } else {
         // Handle other file types like symlinks if necessary,
         // for now, return an error or skip.
-        return Err(io::Error::other(
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
             format!("Source {:?} is neither a file nor a directory", src_path),
         ));
     }
@@ -152,7 +157,7 @@ pub fn copy_item<P: AsRef<Path>>(src: P, dest: P) -> io::Result<()> {
 }
 
 fn copy_dir_recursive(src: &Path, dest: &Path) -> io::Result<()> {
-    fs::create_dir_all(dest)?;
+    fs::create_dir_all(&dest)?;
 
     for entry in fs::read_dir(src)? {
         let entry = entry?;
@@ -214,3 +219,43 @@ pub fn parse_path(
     println!("Final line: {:?}", &s);
     Ok(s)
 }
+
+pub fn test() {
+    let mut meta = CloudSaveMetadata {
+        files: vec![
+            GameFile {
+                path: String::from("<home>/favicon.png"),
+                id: None,
+                data_type: super::metadata::DataType::File,
+                tags: Vec::new(),
+                conditions: vec![Condition::Os(Platform::Linux)],
+            },
+            GameFile {
+                path: String::from("<home>/Documents/Pixel Art"),
+                id: None,
+                data_type: super::metadata::DataType::File,
+                tags: Vec::new(),
+                conditions: vec![Condition::Os(Platform::Linux)],
+            },
+        ],
+        game_version: GameVersion {
+            game_id: String::new(),
+            version_name: String::new(),
+            platform: Platform::Linux,
+            launch_command: String::new(),
+            launch_args: Vec::new(),
+            launch_command_template: String::new(),
+            setup_command: String::new(),
+            setup_args: Vec::new(),
+            setup_command_template: String::new(),
+            only_setup: true,
+            version_index: 0,
+            delta: false,
+            umu_id_override: None,
+        },
+        save_id: String::from("aaaaaaa"),
+    };
+    //resolve(&mut meta);
+
+    extract("save".into()).unwrap();
+}

database/src/db.rs

@@ -10,6 +10,7 @@ use crate::interface::{DatabaseImpls, DatabaseInterface};
 
 pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
 
+
 #[cfg(not(debug_assertions))]
 static DATA_ROOT_PREFIX: &str = "drop";
 #[cfg(debug_assertions)]
@@ -31,15 +32,16 @@ impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
     for DropDatabaseSerializer
 {
     fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
-        native_model::encode(val).map_err(|e| DeSerError::Internal(e.to_string()))
+        native_model::encode(val)
+            .map_err(|e| DeSerError::Internal(e.to_string()))
     }
 
     fn deserialize<R: std::io::Read>(&self, mut s: R) -> rustbreak::error::DeSerResult<T> {
         let mut buf = Vec::new();
         s.read_to_end(&mut buf)
             .map_err(|e| rustbreak::error::DeSerError::Other(e.into()))?;
-        let (val, _version) =
-            native_model::decode(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
+        let (val, _version) = native_model::decode(buf)
+            .map_err(|e| DeSerError::Internal(e.to_string()))?;
         Ok(val)
     }
 }

database/src/interface.rs

@@ -1,20 +1,11 @@
-use std::{
-    fs::{self, create_dir_all},
-    mem::ManuallyDrop,
-    ops::{Deref, DerefMut},
-    path::PathBuf,
-    sync::{RwLockReadGuard, RwLockWriteGuard},
-};
+use std::{fs::{self, create_dir_all}, mem::ManuallyDrop, ops::{Deref, DerefMut}, path::PathBuf, sync::{RwLockReadGuard, RwLockWriteGuard}};
 
 use chrono::Utc;
 use log::{debug, error, info, warn};
 use rustbreak::{PathDatabase, RustbreakError};
 use url::Url;
 
-use crate::{
-    db::{DATA_ROOT_DIR, DB, DropDatabaseSerializer},
-    models::data::Database,
-};
+use crate::{db::{DropDatabaseSerializer, DATA_ROOT_DIR, DB}, models::data::Database};
 
 pub type DatabaseInterface =
     rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;

database/src/lib.rs

@@ -2,13 +2,20 @@
 
 pub mod db;
 pub mod debug;
-pub mod interface;
 pub mod models;
 pub mod platform;
+pub mod interface;
 
+pub use models::data::{
+    ApplicationTransientStatus,
+    Database,
+    DatabaseApplications,
+    DatabaseAuth,
+    DownloadType,
+    DownloadableMetadata,
+    GameDownloadStatus,
+    GameVersion,
+    Settings
+};
 pub use db::DB;
 pub use interface::{borrow_db_checked, borrow_db_mut_checked};
-pub use models::data::{
-    ApplicationTransientStatus, Database, DatabaseApplications, DatabaseAuth, DownloadType,
-    DownloadableMetadata, GameDownloadStatus, GameVersion, Settings,
-};

database/src/models.rs

@@ -191,7 +191,9 @@ pub mod data {
 
         use serde_with::serde_as;
 
-        use super::{Deserialize, Serialize, native_model, v1};
+        use super::{
+            Deserialize, Serialize, native_model, v1,
+        };
 
         #[native_model(id = 1, version = 2, with = native_model::rmp_serde_1_3::RmpSerde, from = v1::Database)]
         #[derive(Serialize, Deserialize, Clone, Default)]
@@ -280,8 +282,7 @@ pub mod data {
             pub installed_game_version: HashMap<String, v1::DownloadableMetadata>,
 
             #[serde(skip)]
-            pub transient_statuses:
-                HashMap<v1::DownloadableMetadata, v1::ApplicationTransientStatus>,
+            pub transient_statuses: HashMap<v1::DownloadableMetadata, v1::ApplicationTransientStatus>,
         }
         impl From<v1::DatabaseApplications> for DatabaseApplications {
             fn from(value: v1::DatabaseApplications) -> Self {
@@ -302,7 +303,10 @@ pub mod data {
     mod v3 {
         use std::path::PathBuf;
 
-        use super::{Deserialize, Serialize, native_model, v1, v2};
+        use super::{
+            Deserialize, Serialize,
+            native_model, v2, v1,
+        };
         #[native_model(id = 1, version = 3, with = native_model::rmp_serde_1_3::RmpSerde, from = v2::Database)]
         #[derive(Serialize, Deserialize, Clone, Default)]
         pub struct Database {
@@ -354,20 +358,6 @@ pub mod data {
                 compat_info: None,
             }
         }
-    }
-    impl DatabaseAuth {
-        pub fn new(
-            private: String,
-            cert: String,
-            client_id: String,
-            web_token: Option<String>,
-        ) -> Self {
-            Self {
-                private,
-                cert,
-                client_id,
-                web_token,
-            }
-        }
+
     }
 }

database/src/platform.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 
+
 #[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
 pub enum Platform {
     Windows,

download_manager/src/download_manager_builder.rs

@@ -9,14 +9,11 @@ use std::{
 
 use database::DownloadableMetadata;
 use log::{debug, error, info, warn};
-use tauri::AppHandle;
+use tauri::{AppHandle, Emitter};
 use utils::{app_emit, lock, send};
 
-use crate::{
-    download_manager_frontend::DownloadStatus,
-    error::ApplicationDownloadError,
-    frontend_updates::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
-};
+
+use crate::{download_manager_frontend::DownloadStatus, error::ApplicationDownloadError, frontend_updates::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent}};
 
 use super::{
     download_manager_frontend::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},
@@ -292,10 +289,7 @@ impl DownloadManagerBuilder {
 
                 if validate_result {
                     download_agent.on_complete(&app_handle);
-                    send!(
-                        sender,
-                        DownloadManagerSignal::Completed(download_agent.metadata())
-                    );
+                    send!(sender, DownloadManagerSignal::Completed(download_agent.metadata()));
                     send!(sender, DownloadManagerSignal::UpdateUIQueue);
                     return;
                 }
@@ -376,7 +370,7 @@ impl DownloadManagerBuilder {
     fn push_ui_stats_update(&self, kbs: usize, time: usize) {
         let event_data = StatsUpdateEvent { speed: kbs, time };
 
-        app_emit!(&self.app_handle, "update_stats", event_data);
+        app_emit!(self.app_handle, "update_stats", event_data);
     }
     fn push_ui_queue_update(&self) {
         let queue = &self.download_queue.read();
@@ -395,6 +389,6 @@ impl DownloadManagerBuilder {
             .collect();
 
         let event_data = QueueUpdateEvent { queue: queue_objs };
-        app_emit!(&self.app_handle, "update_queue", event_data);
+        app_emit!(self.app_handle, "update_queue", event_data);
     }
 }

download_manager/src/download_manager_frontend.rs

@@ -14,6 +14,7 @@ use log::{debug, info};
 use serde::Serialize;
 use utils::{lock, send};
 
+
 use crate::error::ApplicationDownloadError;
 
 use super::{
@@ -79,7 +80,6 @@ pub enum DownloadStatus {
 /// The actual download queue may be accessed through the .`edit()` function,
 /// which provides raw access to the underlying queue.
 /// THIS EDITING IS BLOCKING!!!
-#[derive(Debug)]
 pub struct DownloadManager {
     terminator: Mutex<Option<JoinHandle<Result<(), ()>>>>,
     download_queue: Queue,
@@ -124,11 +124,8 @@ impl DownloadManager {
     }
     pub fn rearrange_string(&self, meta: &DownloadableMetadata, new_index: usize) {
         let mut queue = self.edit();
-        let current_index =
-            get_index_from_id(&mut queue, meta).expect("Failed to get meta index from id");
-        let to_move = queue
-            .remove(current_index)
-            .expect("Failed to remove meta at index from queue");
+        let current_index = get_index_from_id(&mut queue, meta).expect("Failed to get meta index from id");
+        let to_move = queue.remove(current_index).expect("Failed to remove meta at index from queue");
         queue.insert(new_index, to_move);
         send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
     }

download_manager/src/downloadable.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use database::DownloadableMetadata;
 use tauri::AppHandle;
 
+
 use crate::error::ApplicationDownloadError;
 
 use super::{

download_manager/src/error.rs

@@ -1,9 +1,5 @@
-use humansize::{BINARY, format_size};
-use std::{
-    fmt::{Display, Formatter},
-    io,
-    sync::{Arc, mpsc::SendError},
-};
+use std::{fmt::{Display, Formatter}, io, sync::{mpsc::SendError, Arc}};
+use humansize::{format_size, BINARY};
 
 use remote::error::RemoteAccessError;
 use serde_with::SerializeDisplay;
@@ -48,9 +44,7 @@ pub enum ApplicationDownloadError {
 impl Display for ApplicationDownloadError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            ApplicationDownloadError::NotInitialized => {
-                write!(f, "Download not initalized, did something go wrong?")
-            }
+            ApplicationDownloadError::NotInitialized => write!(f, "Download not initalized, did something go wrong?"),
             ApplicationDownloadError::DiskFull(required, available) => write!(
                 f,
                 "Game requires {}, {} remaining left on disk.",
@@ -66,9 +60,10 @@ impl Display for ApplicationDownloadError {
                 write!(f, "checksum failed to validate for download")
             }
             ApplicationDownloadError::IoError(error) => write!(f, "io error: {error}"),
-            ApplicationDownloadError::DownloadError(error) => {
-                write!(f, "Download failed with error {error:?}")
-            }
+            ApplicationDownloadError::DownloadError(error) => write!(
+                f,
+                "Download failed with error {error:?}"
+            ),
         }
     }
 }

download_manager/src/lib.rs

@@ -0,0 +1,16 @@
+#![feature(duration_millis_float)]
+#![feature(nonpoison_mutex)]
+#![feature(sync_nonpoison)]
+
+use std::sync::{nonpoison::Mutex, LazyLock};
+
+use crate::{download_manager_builder::DownloadManagerBuilder, download_manager_frontend::DownloadManager};
+
+pub mod download_manager_builder;
+pub mod download_manager_frontend;
+pub mod downloadable;
+pub mod util;
+pub mod error;
+pub mod frontend_updates;
+
+pub static DOWNLOAD_MANAGER: LazyLock<Mutex<DownloadManager>> = LazyLock::new(|| todo!());

download_manager/src/util/download_thread_control_flag.rs

@@ -1,6 +1,6 @@
 use std::sync::{
-    Arc,
     atomic::{AtomicBool, Ordering},
+    Arc,
 };
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
@@ -22,11 +22,7 @@ impl From<DownloadThreadControlFlag> for bool {
 /// false => Stop
 impl From<bool> for DownloadThreadControlFlag {
     fn from(value: bool) -> Self {
-        if value {
-            DownloadThreadControlFlag::Go
-        } else {
-            DownloadThreadControlFlag::Stop
-        }
+        if value { DownloadThreadControlFlag::Go } else { DownloadThreadControlFlag::Stop }
     }
 }
 

download_manager/src/util/progress_object.rs

@@ -15,7 +15,7 @@ use crate::download_manager_frontend::DownloadManagerSignal;
 
 use super::rolling_progress_updates::RollingProgressWindow;
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct ProgressObject {
     max: Arc<Mutex<usize>>,
     progress_instances: Arc<Mutex<Vec<Arc<AtomicUsize>>>>,
@@ -117,9 +117,7 @@ pub fn calculate_update(progress: &ProgressObject) {
     let last_update_time = progress
         .last_update_time
         .swap(Instant::now(), Ordering::SeqCst);
-    let time_since_last_update = Instant::now()
-        .duration_since(last_update_time)
-        .as_millis_f64();
+    let time_since_last_update = Instant::now().duration_since(last_update_time).as_millis_f64();
 
     let current_bytes_downloaded = progress.sum();
     let max = progress.get_max();
@@ -127,8 +125,7 @@ pub fn calculate_update(progress: &ProgressObject) {
         .bytes_last_update
         .swap(current_bytes_downloaded, Ordering::Acquire);
 
-    let bytes_since_last_update =
-        current_bytes_downloaded.saturating_sub(bytes_at_last_update) as f64;
+    let bytes_since_last_update = current_bytes_downloaded.saturating_sub(bytes_at_last_update) as f64;
 
     let kilobytes_per_second = bytes_since_last_update / time_since_last_update;
 

download_manager/src/util/queue.rs

@@ -6,7 +6,7 @@ use std::{
 use database::DownloadableMetadata;
 use utils::lock;
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Queue {
     inner: Arc<Mutex<VecDeque<DownloadableMetadata>>>,
 }

download_manager/src/util/rolling_progress_updates.rs

@@ -3,17 +3,11 @@ use std::sync::{
     atomic::{AtomicUsize, Ordering},
 };
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct RollingProgressWindow<const S: usize> {
     window: Arc<[AtomicUsize; S]>,
     current: Arc<AtomicUsize>,
 }
-impl<const S: usize> Default for RollingProgressWindow<S> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl<const S: usize> RollingProgressWindow<S> {
     pub fn new() -> Self {
         Self {

games/src/downloads/download_agent.rs

@@ -1,13 +1,8 @@
-use database::{
-    ApplicationTransientStatus, DownloadType, DownloadableMetadata, borrow_db_checked,
-    borrow_db_mut_checked,
-};
+use database::{borrow_db_checked, borrow_db_mut_checked, ApplicationTransientStatus, DownloadType, DownloadableMetadata};
 use download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
 use download_manager::downloadable::Downloadable;
 use download_manager::error::ApplicationDownloadError;
-use download_manager::util::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
+use download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
 use download_manager::util::progress_object::{ProgressHandle, ProgressObject};
 use log::{debug, error, info, warn};
 use rayon::ThreadPoolBuilder;
@@ -15,6 +10,7 @@ use remote::auth::generate_authorization_header;
 use remote::error::RemoteAccessError;
 use remote::requests::generate_url;
 use remote::utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC};
+use utils::{app_emit, lock, send};
 use std::collections::{HashMap, HashSet};
 use std::fs::{OpenOptions, create_dir_all};
 use std::io;
@@ -22,15 +18,12 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
-use tauri::AppHandle;
-use utils::{app_emit, lock, send};
+use tauri::{AppHandle, Emitter};
 
 #[cfg(target_os = "linux")]
 use rustix::fs::{FallocateFlags, fallocate};
 
-use crate::downloads::manifest::{
-    DownloadBucket, DownloadContext, DownloadDrop, DropManifest, DropValidateContext, ManifestBody,
-};
+use crate::downloads::manifest::{DownloadBucket, DownloadContext, DownloadDrop, DropManifest, DropValidateContext, ManifestBody};
 use crate::downloads::utils::get_disk_available;
 use crate::downloads::validate::validate_game_chunk;
 use crate::library::{on_game_complete, push_game_update, set_partially_installed};
@@ -104,7 +97,8 @@ impl GameDownloadAgent {
 
         result.ensure_manifest_exists().await?;
 
-        let required_space = lock!(result.manifest)
+        let required_space = lock!(result
+            .manifest)
             .as_ref()
             .unwrap()
             .values()
@@ -453,13 +447,9 @@ impl GameDownloadAgent {
 
                 let sender = self.sender.clone();
 
-                let download_context =
-                    download_contexts.get(&bucket.version).unwrap_or_else(|| {
-                        panic!(
-                            "Could not get bucket version {}. Corrupted state.",
-                            bucket.version
-                        )
-                    });
+                let download_context = download_contexts
+                    .get(&bucket.version)
+                    .unwrap_or_else(|| panic!("Could not get bucket version {}. Corrupted state.", bucket.version));
 
                 scope.spawn(move |_| {
                     // 3 attempts
@@ -697,10 +687,7 @@ impl Downloadable for GameDownloadAgent {
             Ok(_) => {}
             Err(e) => {
                 error!("could not mark game as complete: {e}");
-                send!(
-                    self.sender,
-                    DownloadManagerSignal::Error(ApplicationDownloadError::DownloadError(e))
-                );
+                send!(self.sender, DownloadManagerSignal::Error(ApplicationDownloadError::DownloadError(e)));
             }
         }
     }

games/src/downloads/download_logic.rs

@@ -11,9 +11,7 @@ use std::{
 };
 
 use download_manager::error::ApplicationDownloadError;
-use download_manager::util::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
+use download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
 use download_manager::util::progress_object::ProgressHandle;
 use log::{debug, info, warn};
 use md5::{Context, Digest};
@@ -49,7 +47,7 @@ impl DropWriter<File> {
 
     fn finish(mut self) -> io::Result<Digest> {
         self.flush()?;
-        Ok(self.hasher.finalize())
+        Ok(self.hasher.compute())
     }
 }
 // Write automatically pushes to file and hasher
@@ -118,10 +116,7 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
             let mut last_bump = 0;
             loop {
                 let size = MAX_PACKET_LENGTH.min(remaining);
-                let size = self
-                    .source
-                    .read(&mut copy_buffer[0..size])
-                    .inspect_err(|_| {
+                let size = self.source.read(&mut copy_buffer[0..size]).inspect_err(|_| {
                     info!("got error from {}", drop.filename);
                 })?;
                 remaining -= size;

games/src/downloads/drop_data.rs

@@ -1,8 +1,5 @@
 use std::{
-    collections::HashMap,
-    fs::File,
-    io::{self, Read, Write},
-    path::{Path, PathBuf},
+    collections::HashMap, fs::File, io::{self, Read, Write}, path::{Path, PathBuf}
 };
 
 use log::error;
@@ -80,10 +77,7 @@ impl DropData {
         }
     }
     pub fn set_contexts(&self, completed_contexts: &[(String, bool)]) {
-        *lock!(self.contexts) = completed_contexts
-            .iter()
-            .map(|s| (s.0.clone(), s.1))
-            .collect();
+        *lock!(self.contexts) = completed_contexts.iter().map(|s| (s.0.clone(), s.1)).collect();
     }
     pub fn set_context(&self, context: String, state: bool) {
         lock!(self.contexts).entry(context).insert_entry(state);

games/src/downloads/error.rs

@@ -0,0 +1,21 @@
+use std::fmt::{Display};
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum LibraryError {
+    MetaNotFound(String),
+    VersionNotFound(String),
+}
+impl Display for LibraryError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            LibraryError::MetaNotFound(id) => {
+                format!("Could not locate any installed version of game ID {id} in the database")
+            }
+            LibraryError::VersionNotFound(game_id) => {
+                format!("Could not locate any installed version  for game id {game_id} in the database")
+            }
+        })
+    }
+}

games/src/downloads/mod.rs

@@ -3,5 +3,5 @@ mod download_logic;
 pub mod drop_data;
 pub mod error;
 mod manifest;
-pub mod utils;
 pub mod validate;
+pub mod utils;

games/src/downloads/utils.rs

@@ -19,7 +19,7 @@ pub fn get_disk_available(mount_point: PathBuf) -> Result<u64, ApplicationDownlo
             return Ok(disk.available_space());
         }
     }
-    Err(ApplicationDownloadError::IoError(Arc::new(
-        io::Error::other("could not find disk of path"),
-    )))
+    Err(ApplicationDownloadError::IoError(Arc::new(io::Error::other(
+        "could not find disk of path",
+    ))))
 }

games/src/downloads/validate.rs

@@ -3,13 +3,7 @@ use std::{
     io::{self, BufWriter, Read, Seek, SeekFrom, Write},
 };
 
-use download_manager::{
-    error::ApplicationDownloadError,
-    util::{
-        download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
-        progress_object::ProgressHandle,
-    },
-};
+use download_manager::{error::ApplicationDownloadError, util::{download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag}, progress_object::ProgressHandle}};
 use log::debug;
 use md5::Context;
 
@@ -22,10 +16,7 @@ pub fn validate_game_chunk(
 ) -> Result<bool, ApplicationDownloadError> {
     debug!(
         "Starting chunk validation {}, {}, {} #{}",
-        ctx.path.display(),
-        ctx.index,
-        ctx.offset,
-        ctx.checksum
+        ctx.path.display(), ctx.index, ctx.offset, ctx.checksum
     );
     // If we're paused
     if control_flag.get() == DownloadThreadControlFlag::Stop {
@@ -45,12 +36,13 @@ pub fn validate_game_chunk(
 
     let mut hasher = md5::Context::new();
 
-    let completed = validate_copy(&mut source, &mut hasher, ctx.length, control_flag, progress)?;
+    let completed =
+        validate_copy(&mut source, &mut hasher, ctx.length, control_flag, progress)?;
     if !completed {
         return Ok(false);
     }
 
-    let res = hex::encode(hasher.finalize().0);
+    let res = hex::encode(hasher.compute().0);
     if res != ctx.checksum {
         return Ok(false);
     }

games/src/lib.rs

@@ -3,5 +3,4 @@
 pub mod collections;
 pub mod downloads;
 pub mod library;
-pub mod scan;
 pub mod state;

games/src/library.rs

@@ -1,20 +1,15 @@
-use bitcode::{Decode, Encode};
-use database::{
-    ApplicationTransientStatus, Database, DownloadableMetadata, GameDownloadStatus, GameVersion,
-    borrow_db_checked, borrow_db_mut_checked,
-};
-use log::{debug, error, warn};
-use remote::{
-    auth::generate_authorization_header, error::RemoteAccessError, requests::generate_url,
-    utils::DROP_CLIENT_SYNC,
-};
-use serde::{Deserialize, Serialize};
 use std::fs::remove_dir_all;
+use std::sync::Mutex;
 use std::thread::spawn;
-use tauri::AppHandle;
+use bitcode::{Decode, Encode};
+use database::{borrow_db_checked, borrow_db_mut_checked, ApplicationTransientStatus, Database, DownloadableMetadata, GameDownloadStatus, GameVersion};
+use log::{debug, error, warn};
+use remote::{auth::generate_authorization_header, error::RemoteAccessError, requests::generate_url, utils::DROP_CLIENT_SYNC};
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Emitter};
 use utils::app_emit;
 
-use crate::state::{GameStatusManager, GameStatusWithTransient};
+use crate::{downloads::error::LibraryError, state::{GameStatusManager, GameStatusWithTransient}};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FetchGameStruct {
@@ -25,11 +20,7 @@ pub struct FetchGameStruct {
 
 impl FetchGameStruct {
     pub fn new(game: Game, status: GameStatusWithTransient, version: Option<GameVersion>) -> Self {
-        Self {
-            game,
-            status,
-            version,
-        }
+        Self { game, status, version }
     }
 }
 
@@ -177,7 +168,7 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
                 );
 
                 debug!("uninstalled game id {}", &meta.id);
-                app_emit!(&app_handle, "update_library", ());
+                app_emit!(app_handle, "update_library", ());
             }
         });
     } else {
@@ -293,8 +284,41 @@ pub struct FrontendGameOptions {
     launch_string: String,
 }
 
-impl FrontendGameOptions {
-    pub fn launch_string(&self) -> &String {
-        &self.launch_string
-    }
+#[tauri::command]
+pub fn update_game_configuration(
+    game_id: String,
+    options: FrontendGameOptions,
+) -> Result<(), LibraryError> {
+    let mut handle = borrow_db_mut_checked();
+    let installed_version = handle
+        .applications
+        .installed_game_version
+        .get(&game_id)
+        .ok_or(LibraryError::MetaNotFound(game_id))?;
+
+    let id = installed_version.id.clone();
+    let version = installed_version.version.clone().ok_or(LibraryError::VersionNotFound(id.clone()))?;
+
+    let mut existing_configuration = handle
+        .applications
+        .game_versions
+        .get(&id)
+        .unwrap()
+        .get(&version)
+        .unwrap()
+        .clone();
+
+    // Add more options in here
+    existing_configuration.launch_command_template = options.launch_string;
+
+    // Add no more options past here
+
+    handle
+        .applications
+        .game_versions
+        .get_mut(&id)
+        .unwrap()
+        .insert(version.to_string(), existing_configuration);
+
+    Ok(())
 }

games/src/scan.rs

@@ -1,11 +1,16 @@
 use std::fs;
 
-use database::{DownloadType, DownloadableMetadata, borrow_db_mut_checked};
 use log::warn;
 
 use crate::{
-    downloads::drop_data::{DROP_DATA_PATH, DropData},
+    database::{
+        db::borrow_db_mut_checked,
+        models::data::{DownloadType, DownloadableMetadata},
+    },
+    games::{
+        downloads::drop_data::{DropData, DROP_DATA_PATH},
         library::set_partially_installed_db,
+    },
 };
 
 pub fn scan_install_dirs() {

main/app.vue

@@ -7,7 +7,14 @@
 </template>
 
 <script setup lang="ts">
+import "~/composables/downloads.js";
+
 import { invoke } from "@tauri-apps/api/core";
+import { useAppState } from "./composables/app-state.js";
+import {
+  initialNavigation,
+  setupHooks,
+} from "./composables/state-navigation.js";
 
 const router = useRouter();
 

main/components/Header.vue

@@ -2,7 +2,9 @@
   <div class="h-16 bg-zinc-950 flex flex-row justify-between">
     <div class="flex flex-row grow items-center pl-5 pr-2 py-3">
       <div class="inline-flex items-center gap-x-10">
+        <NuxtLink to="/store">
           <Wordmark class="h-8 mb-0.5" />
+        </NuxtLink>
         <nav class="inline-flex items-center mt-0.5">
           <ol class="inline-flex items-center gap-x-6">
             <NuxtLink

main/components/HeaderUserWidget.vue

@@ -76,6 +76,7 @@ import { Menu, MenuButton, MenuItem, MenuItems } from "@headlessui/vue";
 import { ChevronDownIcon } from "@heroicons/vue/16/solid";
 import type { NavigationItem } from "../types";
 import HeaderWidget from "./HeaderWidget.vue";
+import { useAppState } from "~/composables/app-state";
 import { invoke } from "@tauri-apps/api/core";
 
 const open = ref(false);

main/components/LibrarySearch.vue

@@ -73,7 +73,7 @@
                   alt=""
                 />
               </div>
-              <div class="flex flex-col gap-x-2">
+              <div class="inline-flex items-center gap-x-2">
                 <p
                   class="text-sm whitespace-nowrap font-display font-semibold"
                 >

main/components/PageWidget.vue

@@ -0,0 +1,7 @@
+<template>
+  <NuxtLink
+    class="inline-flex items-center gap-x-2 px-1 py-0.5 rounded bg-blue-900 text-zinc-100 hover:bg-blue-800"
+  >
+    <slot />
+  </NuxtLink>
+</template>

main/composables/use-object.ts

@@ -1,5 +1,5 @@
 import { convertFileSrc } from "@tauri-apps/api/core";
 
-export const useObject = (id: string) => {
+export const useObject = async (id: string) => {
   return convertFileSrc(id, "object");
 };

main/nuxt.config.ts

@@ -9,17 +9,13 @@ export default defineNuxtConfig({
     },
   },
 
+  css: ["~/assets/main.scss"],
+
   ssr: false,
 
-  extends: ["../shared", "../libs/drop-base"],
+  extends: [["../libs/drop-base"]],
 
   app: {
     baseURL: "/main",
-  },
-
-  devtools: {
-    enabled: false,
-  },
-
-  
+  }
 });

main/tailwind.config.js

@@ -7,7 +7,6 @@ export default {
     "./plugins/**/*.{js,ts}",
     "./app.vue",
     "./error.vue",
-    "../shared/components/**/*.vue"
   ],
   theme: {
     extend: {

process/Cargo.toml

@@ -14,6 +14,5 @@ page_size = "0.6.0"
 serde = "1.0.228"
 serde_with = "3.15.0"
 shared_child = "1.1.1"
-tauri = "2.8.5"
 tauri-plugin-opener = "2.5.0"
 utils = { version = "0.1.0", path = "../utils" }

process/src/format.rs

@@ -8,12 +8,7 @@ pub struct DropFormatArgs {
 }
 
 impl DropFormatArgs {
-    pub fn new(
-        launch_string: String,
-        working_dir: &String,
-        executable_name: &String,
-        absolute_executable_name: String,
-    ) -> Self {
+    pub fn new(launch_string: String, working_dir: &String, executable_name: &String, absolute_executable_name: String) -> Self {
         let mut positional = Vec::new();
         let mut map: HashMap<&'static str, String> = HashMap::new();
 

process/src/lib.rs

@@ -0,0 +1,14 @@
+#![feature(nonpoison_mutex)]
+#![feature(sync_nonpoison)]
+
+use std::sync::{LazyLock, nonpoison::Mutex};
+
+use crate::process_manager::ProcessManager;
+
+pub static PROCESS_MANAGER: LazyLock<Mutex<ProcessManager>> =
+    LazyLock::new(|| Mutex::new(ProcessManager::new()));
+
+pub mod error;
+pub mod format;
+pub mod process_handlers;
+pub mod process_manager;

process/src/process_handlers.rs

@@ -1,7 +1,8 @@
 use client::compat::{COMPAT_INFO, UMU_LAUNCHER_EXECUTABLE};
-use database::{Database, DownloadableMetadata, GameVersion, platform::Platform};
+use database::{platform::Platform, Database, DownloadableMetadata, GameVersion};
 use log::debug;
 
+
 use crate::{error::ProcessError, process_manager::ProcessHandler};
 
 pub struct NativeGameLauncher;
@@ -45,9 +46,7 @@ impl ProcessHandler for UMULauncher {
         };
         Ok(format!(
             "GAMEID={game_id} {umu:?} \"{launch}\" {args}",
-            umu = UMU_LAUNCHER_EXECUTABLE
-                .as_ref()
-                .expect("Failed to get UMU_LAUNCHER_EXECUTABLE as ref"),
+            umu = UMU_LAUNCHER_EXECUTABLE.as_ref().expect("Failed to get UMU_LAUNCHER_EXECUTABLE as ref"),
             launch = launch_command,
             args = args.join(" ")
         ))
@@ -87,12 +86,7 @@ impl ProcessHandler for AsahiMuvmLauncher {
             .next()
             .ok_or(ProcessError::InvalidArguments(umu_string.clone()))?
             .trim();
-        let cmd = format!(
-            "umu-run{}",
-            args_cmd
-                .next()
-                .ok_or(ProcessError::InvalidArguments(umu_string.clone()))?
-        );
+        let cmd = format!("umu-run{}", args_cmd.next().ok_or(ProcessError::InvalidArguments(umu_string.clone()))?);
 
         Ok(format!("{args} muvm -- {cmd}"))
     }

process/src/process_manager.rs

@@ -6,7 +6,6 @@ use std::{
     process::{Command, ExitStatus},
     str::FromStr,
     sync::Arc,
-    thread::spawn,
     time::{Duration, SystemTime},
 };
 
@@ -16,10 +15,10 @@ use database::{
 };
 use dynfmt::Format;
 use dynfmt::SimpleCurlyFormat;
-use games::{library::push_game_update, state::GameStatusManager};
+use games::state::GameStatusManager;
 use log::{debug, info, warn};
+use serde::{Deserialize, Serialize};
 use shared_child::SharedChild;
-use tauri::AppHandle;
 
 use crate::{
     PROCESS_MANAGER,
@@ -42,11 +41,10 @@ pub struct ProcessManager<'a> {
         (Platform, Platform),
         &'a (dyn ProcessHandler + Sync + Send + 'static),
     )>,
-    app_handle: AppHandle,
 }
 
 impl ProcessManager<'_> {
-    pub fn new(app_handle: AppHandle) -> Self {
+    pub fn new() -> Self {
         let log_output_dir = DATA_ROOT_DIR.join("logs");
 
         ProcessManager {
@@ -84,7 +82,6 @@ impl ProcessManager<'_> {
                     &UMULauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
                 ),
             ],
-            app_handle,
         }
     }
 
@@ -175,12 +172,13 @@ impl ProcessManager<'_> {
 
         let status = GameStatusManager::fetch_state(&game_id, &db_handle);
 
-        push_game_update(
-            &self.app_handle,
-            &game_id,
-            Some(version_data.clone()),
-            status,
-        );
+        // TODO
+        // push_game_update(
+        //     &self.app_handle,
+        //     &game_id,
+        //     Some(version_data.clone()),
+        //     status,
+        // );
         Ok(())
     }
 
@@ -365,12 +363,13 @@ impl ProcessManager<'_> {
             .transient_statuses
             .insert(meta.clone(), ApplicationTransientStatus::Running {});
 
-        push_game_update(
-            &self.app_handle,
-            &meta.id,
-            None,
-            (None, Some(ApplicationTransientStatus::Running {})),
-        );
+        // TODO
+        // push_game_update(
+        //     &self.app_handle,
+        //     &meta.id,
+        //     None,
+        //     (None, Some(ApplicationTransientStatus::Running {})),
+        // );
 
         let wait_thread_handle = launch_process_handle.clone();
         let wait_thread_game_id = meta.clone();
@@ -383,14 +382,12 @@ impl ProcessManager<'_> {
                 manually_killed: false,
             },
         );
-        spawn(move || {
+
         let result: Result<ExitStatus, std::io::Error> = launch_process_handle.wait();
 
         PROCESS_MANAGER
             .lock()
             .on_process_finish(wait_thread_game_id.id, result)
-        });
-        Ok(())
     }
 }
 

remote/src/auth.rs

@@ -2,18 +2,14 @@ use std::{collections::HashMap, env};
 
 use chrono::Utc;
 use client::{app_status::AppStatus, user::User};
-use database::{DatabaseAuth, interface::borrow_db_checked};
+use database::interface::borrow_db_checked;
 use droplet_rs::ssl::sign_nonce;
 use gethostname::gethostname;
 use log::{error, warn};
 use serde::{Deserialize, Serialize};
 use url::Url;
 
-use crate::{
-    error::{DropServerError, RemoteAccessError},
-    requests::make_authenticated_get,
-    utils::DROP_CLIENT_SYNC,
-};
+use crate::{error::{DropServerError, RemoteAccessError}, requests::make_authenticated_get, utils::DROP_CLIENT_SYNC};
 
 use super::{
     cache::{cache_object, get_cached_object},
@@ -35,31 +31,19 @@ struct InitiateRequestBody {
 
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct HandshakeRequestBody {
+struct HandshakeRequestBody {
     client_id: String,
     token: String,
 }
 
-impl HandshakeRequestBody {
-    pub fn new(client_id: String, token: String) -> Self {
-        Self { client_id, token }
-    }
-}
-
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct HandshakeResponse {
+struct HandshakeResponse {
     private: String,
     certificate: String,
     id: String,
 }
 
-impl From<HandshakeResponse> for DatabaseAuth {
-    fn from(value: HandshakeResponse) -> Self {
-        DatabaseAuth::new(value.private, value.certificate, value.id, None)
-    }
-}
-
 pub fn generate_authorization_header() -> String {
     let certs = {
         let db = borrow_db_checked();