chore: Most refactoring except appstate, backuperror, and main workspace

Still needs a massive go-over because there shouldn't be anything referencing tauri in any of the workspaces except the original one

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

src-tauri/Cargo.toml

@@ -1,129 +1,14 @@
-[package]
+[workspace]
-name = "drop-app"
+members = [
-version = "0.3.3"
+    "client",
-description = "The client application for the open-source, self-hosted game distribution platform Drop"
+    "database",
-authors = ["Drop OSS"]
+    "src-tauri",
-edition = "2024"
+    "process",
-
+    "remote",
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+    "utils",
-
+    "cloud_saves",
-[target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\"))".dependencies]
+    "download_manager",
-tauri-plugin-single-instance = { version = "2.0.0", features = ["deep-link"] }
+    "games",
-
-[lib]
-# The `_lib` suffix may seem redundant but it is necessary
-# to make the lib name unique and wouldn't conflict with the bin name.
-# This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
-name = "drop_app_lib"
-crate-type = ["staticlib", "cdylib", "rlib"]
-rustflags = ["-C", "target-feature=+aes,+sse2"]
-
-
-[build-dependencies]
-tauri-build = { version = "2.0.0", features = [] }
-
-[dependencies]
-tauri-plugin-shell = "2.2.1"
-serde_json = "1"
-rayon = "1.10.0"
-webbrowser = "1.0.2"
-url = "2.5.2"
-tauri-plugin-deep-link = "2"
-log = "0.4.22"
-hex = "0.4.3"
-tauri-plugin-dialog = "2"
-http = "1.1.0"
-urlencoding = "2.1.3"
-md5 = "0.7.0"
-chrono = "0.4.38"
-tauri-plugin-os = "2"
-boxcar = "0.2.7"
-umu-wrapper-lib = "0.1.0"
-tauri-plugin-autostart = "2.0.0"
-shared_child = "1.0.1"
-serde_with = "3.12.0"
-slice-deque = "0.3.0"
-throttle_my_fn = "0.2.6"
-parking_lot = "0.12.3"
-atomic-instant-full = "0.1.0"
-cacache = "13.1.0"
-http-serde = "2.1.1"
-reqwest-middleware = "0.4.0"
-reqwest-middleware-cache = "0.1.1"
-deranged = "=0.4.0"
-droplet-rs = "0.7.3"
-gethostname = "1.0.1"
-zstd = "0.13.3"
-tar = "0.4.44"
-rand = "0.9.1"
-regex = "1.11.1"
-tempfile = "3.19.1"
-schemars = "0.8.22"
-sha1 = "0.10.6"
-dirs = "6.0.0"
-whoami = "1.6.0"
-filetime = "0.2.25"
-walkdir = "2.5.0"
-known-folders = "1.2.0"
-native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
-tauri-plugin-opener = "2.4.0"
-bitcode = "0.6.6"
-reqwest-websocket = "0.5.0"
-futures-lite = "2.6.0"
-page_size = "0.6.0"
-sysinfo = "0.36.1"
-humansize = "2.1.3"
-tokio-util = { version = "0.7.16", features = ["io"] }
-futures-core = "0.3.31"
-bytes = "1.10.1"
-# tailscale = { path = "./tailscale" }
-
-[dependencies.dynfmt]
-version = "0.1.5"
-features = ["curly"]
-
-[dependencies.tauri]
-version = "2.7.0"
-features = ["protocol-asset", "tray-icon"]
-
-[dependencies.tokio]
-version = "1.40.0"
-features = ["rt", "tokio-macros", "signal"]
-
-[dependencies.log4rs]
-version = "1.3.0"
-features = ["console_appender", "file_appender"]
-
-[dependencies.rustix]
-version = "0.38.37"
-features = ["fs"]
-
-[dependencies.uuid]
-version = "1.10.0"
-features = ["v4", "fast-rng", "macro-diagnostics"]
-
-[dependencies.rustbreak]
-version = "2"
-features = ["other_errors"] # You can also use "yaml_enc" or "bin_enc"
-
-[dependencies.reqwest]
-version = "0.12.22"
-default-features = false
-features = [
-    "json",
-    "http2",
-    "blocking",
-    "rustls-tls",
-    "native-tls-alpn",
-    "rustls-tls-native-roots",
-    "stream",
 ]
 
-[dependencies.serde]
+resolver = "3"
-version = "1"
-features = ["derive", "rc"]
-
-[profile.release]
-lto = true
-codegen-units = 1
-panic = 'abort'

src-tauri/client/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "client"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bitcode = "0.6.7"
+database = { version = "0.1.0", path = "../database" }
+log = "0.4.28"
+serde = { version = "1.0.228", features = ["derive"] }
+tauri = "2.8.5"
+tauri-plugin-autostart = "2.5.0"

src-tauri/client/src/app_status.rs

@@ -0,0 +1,12 @@
+use serde::Serialize;
+
+#[derive(Clone, Copy, Serialize, Eq, PartialEq)]
+pub enum AppStatus {
+    NotConfigured,
+    Offline,
+    ServerError,
+    SignedOut,
+    SignedIn,
+    SignedInNeedsReauth,
+    ServerUnavailable,
+}

src-tauri/client/src/autostart.rs

@@ -1,4 +1,4 @@
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
+use database::{borrow_db_checked, borrow_db_mut_checked};
 use log::debug;
 use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;
@@ -64,12 +64,3 @@ pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
 
     Ok(())
 }
-#[tauri::command]
-pub fn toggle_autostart(app: AppHandle, enabled: bool) -> Result<(), String> {
-    toggle_autostart_logic(app, enabled)
-}
-
-#[tauri::command]
-pub fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
-    get_autostart_enabled_logic(app)
-}

src-tauri/client/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod autostart;
+pub mod user;
+pub mod app_status;

src-tauri/client/src/user.rs

@@ -0,0 +1,17 @@
+use bitcode::{Decode, Encode};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
+#[serde(rename_all = "camelCase")]
+pub struct User {
+    id: String,
+    username: String,
+    admin: bool,
+    display_name: String,
+    profile_picture_object_id: String,
+}
+
+#[derive(Clone)]
+pub struct CompatInfo {
+    umu_installed: bool,
+}

src-tauri/cloud_saves/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "cloud_saves"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+database = { version = "0.1.0", path = "../database" }
+dirs = "6.0.0"
+log = "0.4.28"
+regex = "1.11.3"
+rustix = "1.1.2"
+serde = "1.0.228"
+serde_json = "1.0.145"
+tar = "0.4.44"
+tempfile = "3.23.0"
+uuid = "1.18.1"
+whoami = "1.6.1"
+zstd = "0.13.3"

src-tauri/cloud_saves/src/backup_manager.rs

@@ -1,8 +1,11 @@
 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::{database::db::{GameVersion, DATA_ROOT_DIR}, error::backup_error::BackupError, process::process_manager::Platform};
+use crate::error::BackupError;
 
 use super::path::CommonPath;
 
@@ -45,7 +48,7 @@ impl BackupManager<'_> {
 }
 
 pub trait BackupHandler: Send + Sync {
-    fn root_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(DATA_ROOT_DIR.lock().unwrap().join("games")) }
+    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 }

src-tauri/cloud_saves/src/conditions.rs

@@ -1,4 +1,4 @@
-use crate::process::process_manager::Platform;
+use database::platform::Platform;
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum Condition {

src-tauri/cloud_saves/src/error.rs

@@ -0,0 +1,5 @@
+pub enum BackupError {
+    InvalidSystem,
+    ParseError,
+    NotFound
+}

src-tauri/cloud_saves/src/lib.rs

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

src-tauri/cloud_saves/src/metadata.rs

@@ -1,4 +1,4 @@
-use crate::database::db::GameVersion;
+use database::GameVersion;
 
 use super::conditions::{Condition};
 

src-tauri/cloud_saves/src/normalise.rs

@@ -1,7 +1,7 @@
 use std::sync::LazyLock;
 
+use database::platform::Platform;
 use regex::Regex;
-use crate::process::process_manager::Platform;
 
 use super::placeholder::*;
 

src-tauri/cloud_saves/src/resolver.rs

@@ -6,17 +6,16 @@ use std::{
     time::Duration,
 };
 
+use crate::error::BackupError;
+
 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;
 
-use crate::{
-    database::db::GameVersion, error::backup_error::BackupError, process::process_manager::Platform,
-};
-
 use super::{backup_manager::BackupManager, metadata::CloudSaveMetadata, normalise::normalize};
 
 pub fn resolve(meta: &mut CloudSaveMetadata) -> File {

src-tauri/database/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "database"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+chrono = "0.4.42"
+dirs = "6.0.0"
+log = "0.4.28"
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+rustbreak = "2.0.0"
+serde = "1.0.228"
+serde_with = "3.15.0"
+url = "2.5.7"
+whoami = "1.6.1"

src-tauri/database/src/db.rs

@@ -0,0 +1,47 @@
+use std::{
+    path::PathBuf,
+    sync::{Arc, LazyLock},
+};
+
+use rustbreak::{DeSerError, DeSerializer};
+use serde::{Serialize, de::DeserializeOwned};
+
+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)]
+static DATA_ROOT_PREFIX: &str = "drop-debug";
+
+pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> = LazyLock::new(|| {
+    Arc::new(
+        dirs::data_dir()
+            .expect("Failed to get data dir")
+            .join(DATA_ROOT_PREFIX),
+    )
+});
+
+// Custom JSON serializer to support everything we need
+#[derive(Debug, Default, Clone)]
+pub struct DropDatabaseSerializer;
+
+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()))
+    }
+
+    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()))?;
+        Ok(val)
+    }
+}

src-tauri/database/src/interface.rs

@@ -1,55 +1,11 @@
-use std::{
+use std::{fs::{self, create_dir_all}, mem::ManuallyDrop, ops::{Deref, DerefMut}, path::PathBuf, sync::{RwLockReadGuard, RwLockWriteGuard}};
-    fs::{self, create_dir_all},
-    mem::ManuallyDrop,
-    ops::{Deref, DerefMut},
-    path::PathBuf,
-    sync::{Arc, LazyLock, RwLockReadGuard, RwLockWriteGuard},
-};
 
 use chrono::Utc;
 use log::{debug, error, info, warn};
-use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
+use rustbreak::{PathDatabase, RustbreakError};
-use serde::{Serialize, de::DeserializeOwned};
 use url::Url;
 
-use crate::DB;
+use crate::{db::{DropDatabaseSerializer, DATA_ROOT_DIR, DB}, models::data::Database};
-
-use super::models::data::Database;
-
-#[cfg(not(debug_assertions))]
-static DATA_ROOT_PREFIX: &'static str = "drop";
-#[cfg(debug_assertions)]
-static DATA_ROOT_PREFIX: &str = "drop-debug";
-
-pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> = LazyLock::new(|| {
-    Arc::new(
-        dirs::data_dir()
-            .expect("Failed to get data dir")
-            .join(DATA_ROOT_PREFIX),
-    )
-});
-
-// Custom JSON serializer to support everything we need
-#[derive(Debug, Default, Clone)]
-pub struct DropDatabaseSerializer;
-
-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()))
-    }
-
-    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()))?;
-        Ok(val)
-    }
-}
 
 pub type DatabaseInterface =
     rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;

src-tauri/database/src/lib.rs

@@ -0,0 +1,21 @@
+#![feature(nonpoison_rwlock)]
+
+pub mod db;
+pub mod debug;
+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};

src-tauri/database/src/models.rs

@@ -37,17 +37,18 @@ pub mod data {
     }
 
     mod v1 {
-        use crate::process::process_manager::Platform;
         use serde_with::serde_as;
         use std::{collections::HashMap, path::PathBuf};
 
+        use crate::platform::Platform;
+
         use super::{Deserialize, Serialize, native_model};
 
         fn default_template() -> String {
             "{}".to_owned()
         }
 
-        #[derive(Serialize, Deserialize, Clone, Debug)]
+        #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
         #[serde(rename_all = "camelCase")]
         #[native_model(id = 2, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         pub struct GameVersion {

src-tauri/database/src/platform.rs

@@ -0,0 +1,47 @@
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
+pub enum Platform {
+    Windows,
+    Linux,
+    MacOs,
+}
+
+impl Platform {
+    #[cfg(target_os = "windows")]
+    pub const HOST: Platform = Self::Windows;
+    #[cfg(target_os = "macos")]
+    pub const HOST: Platform = Self::MacOs;
+    #[cfg(target_os = "linux")]
+    pub const HOST: Platform = Self::Linux;
+
+    pub fn is_case_sensitive(&self) -> bool {
+        match self {
+            Self::Windows | Self::MacOs => false,
+            Self::Linux => true,
+        }
+    }
+}
+
+impl From<&str> for Platform {
+    fn from(value: &str) -> Self {
+        match value.to_lowercase().trim() {
+            "windows" => Self::Windows,
+            "linux" => Self::Linux,
+            "mac" | "macos" => Self::MacOs,
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl From<whoami::Platform> for Platform {
+    fn from(value: whoami::Platform) -> Self {
+        match value {
+            whoami::Platform::Windows => Platform::Windows,
+            whoami::Platform::Linux => Platform::Linux,
+            whoami::Platform::MacOS => Platform::MacOs,
+            platform => unimplemented!("Playform {} is not supported", platform),
+        }
+    }
+}

src-tauri/download_manager/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "download_manager"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+atomic-instant-full = "0.1.0"
+database = { version = "0.1.0", path = "../database" }
+humansize = "2.1.3"
+log = "0.4.28"
+parking_lot = "0.12.5"
+remote = { version = "0.1.0", path = "../remote" }
+serde = "1.0.228"
+serde_with = "3.15.0"
+tauri = "2.8.5"
+throttle_my_fn = "0.2.6"
+utils = { version = "0.1.0", path = "../utils" }

src-tauri/download_manager/src/download_manager_builder.rs

@@ -7,12 +7,13 @@ use std::{
     thread::{JoinHandle, spawn},
 };
 
+use database::DownloadableMetadata;
 use log::{debug, error, info, warn};
 use tauri::{AppHandle, Emitter};
+use utils::{app_emit, lock, send};
 
-use crate::{
+
-    app_emit, database::models::data::DownloadableMetadata, download_manager::download_manager_frontend::DownloadStatus, error::application_download_error::ApplicationDownloadError, games::library::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent}, lock, send
+use crate::{download_manager_frontend::DownloadStatus, error::ApplicationDownloadError, frontend_updates::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent}};
-};
 
 use super::{
     download_manager_frontend::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},

src-tauri/download_manager/src/download_manager_frontend.rs

@@ -9,13 +9,13 @@ use std::{
     thread::JoinHandle,
 };
 
+use database::DownloadableMetadata;
 use log::{debug, info};
 use serde::Serialize;
+use utils::{lock, send};
 
-use crate::{
+
-    database::models::data::DownloadableMetadata,
+use crate::error::ApplicationDownloadError;
-    error::application_download_error::ApplicationDownloadError, lock, send,
-};
 
 use super::{
     download_manager_builder::{CurrentProgressObject, DownloadAgent},

src-tauri/download_manager/src/downloadable.rs

@@ -1,11 +1,10 @@
 use std::sync::Arc;
 
+use database::DownloadableMetadata;
 use tauri::AppHandle;
 
-use crate::{
+
-    database::models::data::DownloadableMetadata,
+use crate::error::ApplicationDownloadError;
-    error::application_download_error::ApplicationDownloadError,
-};
 
 use super::{
     download_manager_frontend::DownloadStatus,

src-tauri/download_manager/src/error.rs

@@ -1,12 +1,32 @@
-use std::{
+use std::{fmt::{Display, Formatter}, io, sync::{mpsc::SendError, Arc}};
-    fmt::{Display, Formatter},
-    io, sync::Arc,
-};
-
-use serde_with::SerializeDisplay;
 use humansize::{format_size, BINARY};
 
-use super::remote_access_error::RemoteAccessError;
+use remote::error::RemoteAccessError;
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum DownloadManagerError<T> {
+    IOError(io::Error),
+    SignalError(SendError<T>),
+}
+impl<T> Display for DownloadManagerError<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DownloadManagerError::IOError(error) => write!(f, "{error}"),
+            DownloadManagerError::SignalError(send_error) => write!(f, "{send_error}"),
+        }
+    }
+}
+impl<T> From<SendError<T>> for DownloadManagerError<T> {
+    fn from(value: SendError<T>) -> Self {
+        DownloadManagerError::SignalError(value)
+    }
+}
+impl<T> From<io::Error> for DownloadManagerError<T> {
+    fn from(value: io::Error) -> Self {
+        DownloadManagerError::IOError(value)
+    }
+}
 
 // TODO: Rename / separate from downloads
 #[derive(Debug, SerializeDisplay)]

src-tauri/download_manager/src/frontend_updates.rs

@@ -0,0 +1,24 @@
+use database::DownloadableMetadata;
+use serde::Serialize;
+
+use crate::download_manager_frontend::DownloadStatus;
+
+#[derive(Serialize, Clone)]
+pub struct QueueUpdateEventQueueData {
+    pub meta: DownloadableMetadata,
+    pub status: DownloadStatus,
+    pub progress: f64,
+    pub current: usize,
+    pub max: usize,
+}
+
+#[derive(Serialize, Clone)]
+pub struct QueueUpdateEvent {
+    pub queue: Vec<QueueUpdateEventQueueData>,
+}
+
+#[derive(serde::Serialize, Clone)]
+pub struct StatsUpdateEvent {
+    pub speed: usize,
+    pub time: usize,
+}

src-tauri/download_manager/src/lib.rs

@@ -1,5 +1,8 @@
-pub mod commands;
+#![feature(duration_millis_float)]
+
 pub mod download_manager_builder;
 pub mod download_manager_frontend;
 pub mod downloadable;
 pub mod util;
+pub mod error;
+pub mod frontend_updates;

src-tauri/download_manager/src/util/progress_object.rs

@@ -9,8 +9,9 @@ use std::{
 
 use atomic_instant_full::AtomicInstant;
 use throttle_my_fn::throttle;
+use utils::{lock, send};
 
-use crate::{download_manager::download_manager_frontend::DownloadManagerSignal, lock, send};
+use crate::download_manager_frontend::DownloadManagerSignal;
 
 use super::rolling_progress_updates::RollingProgressWindow;
 

src-tauri/download_manager/src/util/queue.rs

@@ -3,7 +3,8 @@ use std::{
     sync::{Arc, Mutex, MutexGuard},
 };
 
-use crate::{database::models::data::DownloadableMetadata, lock};
+use database::DownloadableMetadata;
+use utils::lock;
 
 #[derive(Clone)]
 pub struct Queue {

src-tauri/games/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "games"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+atomic-instant-full = "0.1.0"
+bitcode = "0.6.7"
+boxcar = "0.2.14"
+database = { version = "0.1.0", path = "../database" }
+download_manager = { version = "0.1.0", path = "../download_manager" }
+hex = "0.4.3"
+log = "0.4.28"
+md5 = "0.8.0"
+rayon = "1.11.0"
+remote = { version = "0.1.0", path = "../remote" }
+reqwest = "0.12.23"
+rustix = "1.1.2"
+serde = { version = "1.0.228", features = ["derive"] }
+serde_with = "3.15.0"
+sysinfo = "0.37.2"
+tauri = "2.8.5"
+throttle_my_fn = "0.2.6"
+utils = { version = "0.1.0", path = "../utils" }
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+serde_json = "1.0.145"

src-tauri/games/src/collections/collection.rs

@@ -1,7 +1,7 @@
 use bitcode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
-use crate::games::library::Game;
+use crate::library::Game;
 
 pub type Collections = Vec<Collection>;
 

src-tauri/games/src/collections/mod.rs

@@ -1,2 +1 @@
 pub mod collection;
-pub mod commands;

src-tauri/games/src/downloads/download_agent.rs

@@ -1,28 +1,16 @@
-use crate::auth::generate_authorization_header;
+use database::{borrow_db_checked, borrow_db_mut_checked, ApplicationTransientStatus, DownloadType, DownloadableMetadata};
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
+use download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
-use crate::database::models::data::{
+use download_manager::downloadable::Downloadable;
-    ApplicationTransientStatus, DownloadType, DownloadableMetadata,
+use download_manager::error::ApplicationDownloadError;
-};
+use download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
-use crate::download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
+use download_manager::util::progress_object::{ProgressHandle, ProgressObject};
-use crate::download_manager::downloadable::Downloadable;
-use crate::download_manager::util::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
-use crate::download_manager::util::progress_object::{ProgressHandle, ProgressObject};
-use crate::error::application_download_error::ApplicationDownloadError;
-use crate::error::remote_access_error::RemoteAccessError;
-use crate::games::downloads::manifest::{
-    DownloadBucket, DownloadContext, DownloadDrop, DropManifest, DropValidateContext, ManifestBody,
-};
-use crate::games::downloads::validate::validate_game_chunk;
-use crate::games::library::{on_game_complete, push_game_update, set_partially_installed};
-use crate::games::state::GameStatusManager;
-use crate::process::utils::get_disk_available;
-use crate::remote::requests::generate_url;
-use crate::remote::utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC};
-use crate::{app_emit, lock, send};
 use log::{debug, error, info, warn};
 use rayon::ThreadPoolBuilder;
+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;
@@ -35,6 +23,12 @@ 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::utils::get_disk_available;
+use crate::downloads::validate::validate_game_chunk;
+use crate::library::{on_game_complete, push_game_update, set_partially_installed};
+use crate::state::GameStatusManager;
+
 use super::download_logic::download_game_bucket;
 use super::drop_data::DropData;
 

src-tauri/games/src/downloads/download_logic.rs

@@ -1,18 +1,3 @@
-use crate::download_manager::util::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
-use crate::download_manager::util::progress_object::ProgressHandle;
-use crate::error::application_download_error::ApplicationDownloadError;
-use crate::error::drop_server_error::DropServerError;
-use crate::error::remote_access_error::RemoteAccessError;
-use crate::games::downloads::manifest::{ChunkBody, DownloadBucket, DownloadContext, DownloadDrop};
-use crate::remote::auth::generate_authorization_header;
-use crate::remote::requests::generate_url;
-use crate::remote::utils::DROP_CLIENT_SYNC;
-use log::{debug, info, warn};
-use md5::{Context, Digest};
-use reqwest::blocking::Response;
-
 use std::fs::{Permissions, set_permissions};
 use std::io::Read;
 #[cfg(unix)]
@@ -25,6 +10,19 @@ use std::{
     path::PathBuf,
 };
 
+use download_manager::error::ApplicationDownloadError;
+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};
+use remote::auth::generate_authorization_header;
+use remote::error::{DropServerError, RemoteAccessError};
+use remote::requests::generate_url;
+use remote::utils::DROP_CLIENT_SYNC;
+use reqwest::blocking::Response;
+
+use crate::downloads::manifest::{ChunkBody, DownloadBucket, DownloadContext, DownloadDrop};
+
 static MAX_PACKET_LENGTH: usize = 4096 * 4;
 static BUMP_SIZE: usize = 4096 * 16;
 

src-tauri/games/src/downloads/drop_data.rs

@@ -4,8 +4,7 @@ use std::{
 
 use log::error;
 use native_model::{Decode, Encode};
-
+use utils::lock;
-use crate::lock;
 
 pub type DropData = v1::DropData;
 

src-tauri/games/src/downloads/mod.rs

@@ -1,6 +1,7 @@
-pub mod commands;
 pub mod download_agent;
 mod download_logic;
 pub mod drop_data;
+pub mod error;
 mod manifest;
 pub mod validate;
+pub mod utils;

src-tauri/games/src/downloads/utils.rs

@@ -1,10 +1,8 @@
-use std::{path::PathBuf, sync::Arc};
+use std::{io, path::PathBuf, sync::Arc};
 
-use futures_lite::io;
+use download_manager::error::ApplicationDownloadError;
 use sysinfo::{Disk, DiskRefreshKind, Disks};
 
-use crate::error::application_download_error::ApplicationDownloadError;
-
 pub fn get_disk_available(mount_point: PathBuf) -> Result<u64, ApplicationDownloadError> {
     let disks = Disks::new_with_refreshed_list_specifics(DiskRefreshKind::nothing().with_storage());
 

src-tauri/games/src/downloads/validate.rs

@@ -3,17 +3,11 @@ 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 log::debug;
 use md5::Context;
 
-use crate::{
+use crate::downloads::manifest::DropValidateContext;
-    download_manager::util::{
-        download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
-        progress_object::ProgressHandle,
-    },
-    error::application_download_error::ApplicationDownloadError,
-    games::downloads::manifest::DropValidateContext,
-};
 
 pub fn validate_game_chunk(
     ctx: &DropValidateContext,

src-tauri/games/src/lib.rs

@@ -1,5 +1,6 @@
+#![feature(iterator_try_collect)]
+
 pub mod collections;
-pub mod commands;
 pub mod downloads;
 pub mod library;
 pub mod state;

src-tauri/games/src/library.rs

@@ -1,32 +1,15 @@
 use std::fs::remove_dir_all;
 use std::sync::Mutex;
 use std::thread::spawn;
-
+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;
-use tauri::Emitter;
+use utils::app_emit;
 
-use crate::AppState;
+use crate::{downloads::error::LibraryError, state::{GameStatusManager, GameStatusWithTransient}};
-use crate::app_emit;
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
-use crate::database::models::data::Database;
-use crate::database::models::data::{
-    ApplicationTransientStatus, DownloadableMetadata, GameDownloadStatus, GameVersion,
-};
-use crate::download_manager::download_manager_frontend::DownloadStatus;
-use crate::error::drop_server_error::DropServerError;
-use crate::error::library_error::LibraryError;
-use crate::error::remote_access_error::RemoteAccessError;
-use crate::games::state::{GameStatusManager, GameStatusWithTransient};
-use crate::lock;
-use crate::remote::auth::generate_authorization_header;
-use crate::remote::cache::cache_object_db;
-use crate::remote::cache::{cache_object, get_cached_object, get_cached_object_db};
-use crate::remote::requests::generate_url;
-use crate::remote::utils::DROP_CLIENT_ASYNC;
-use crate::remote::utils::DROP_CLIENT_SYNC;
-use bitcode::{Decode, Encode};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FetchGameStruct {
@@ -60,264 +43,6 @@ pub struct GameUpdateEvent {
     pub version: Option<GameVersion>,
 }
 
-#[derive(Serialize, Clone)]
-pub struct QueueUpdateEventQueueData {
-    pub meta: DownloadableMetadata,
-    pub status: DownloadStatus,
-    pub progress: f64,
-    pub current: usize,
-    pub max: usize,
-}
-
-#[derive(serde::Serialize, Clone)]
-pub struct QueueUpdateEvent {
-    pub queue: Vec<QueueUpdateEventQueueData>,
-}
-
-#[derive(serde::Serialize, Clone)]
-pub struct StatsUpdateEvent {
-    pub speed: usize,
-    pub time: usize,
-}
-
-pub async fn fetch_library_logic(
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-    hard_fresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
-    let do_hard_refresh = hard_fresh.unwrap_or(false);
-    if !do_hard_refresh && let Ok(library) = get_cached_object("library") {
-        return Ok(library);
-    }
-
-    let client = DROP_CLIENT_ASYNC.clone();
-    let response = generate_url(&["/api/v1/client/user/library"], &[])?;
-    let response = client
-        .get(response)
-        .header("Authorization", generate_authorization_header())
-        .send()
-        .await?;
-
-    if response.status() != 200 {
-        let err = response.json().await.unwrap_or(DropServerError {
-            status_code: 500,
-            status_message: "Invalid response from server.".to_owned(),
-        });
-        warn!("{err:?}");
-        return Err(RemoteAccessError::InvalidResponse(err));
-    }
-
-    let mut games: Vec<Game> = response.json().await?;
-
-    let mut handle = lock!(state);
-
-    let mut db_handle = borrow_db_mut_checked();
-
-    for game in &games {
-        handle.games.insert(game.id.clone(), game.clone());
-        if !db_handle.applications.game_statuses.contains_key(&game.id) {
-            db_handle
-                .applications
-                .game_statuses
-                .insert(game.id.clone(), GameDownloadStatus::Remote {});
-        }
-    }
-
-    // Add games that are installed but no longer in library
-    for meta in db_handle.applications.installed_game_version.values() {
-        if games.iter().any(|e| e.id == meta.id) {
-            continue;
-        }
-        // We should always have a cache of the object
-        // Pass db_handle because otherwise we get a gridlock
-        let game = match get_cached_object_db::<Game>(&meta.id.clone(), &db_handle) {
-            Ok(game) => game,
-            Err(err) => {
-                warn!(
-                    "{} is installed, but encountered error fetching its error: {}.",
-                    meta.id, err
-                );
-                continue;
-            }
-        };
-        games.push(game);
-    }
-
-    drop(handle);
-    drop(db_handle);
-    cache_object("library", &games)?;
-
-    Ok(games)
-}
-pub async fn fetch_library_logic_offline(
-    _state: tauri::State<'_, Mutex<AppState<'_>>>,
-    _hard_refresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
-    let mut games: Vec<Game> = get_cached_object("library")?;
-
-    let db_handle = borrow_db_checked();
-
-    games.retain(|game| {
-        matches!(
-            &db_handle
-                .applications
-                .game_statuses
-                .get(&game.id)
-                .unwrap_or(&GameDownloadStatus::Remote {}),
-            GameDownloadStatus::Installed { .. } | GameDownloadStatus::SetupRequired { .. }
-        )
-    });
-
-    Ok(games)
-}
-pub async fn fetch_game_logic(
-    id: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<FetchGameStruct, RemoteAccessError> {
-    let version = {
-        let state_handle = lock!(state);
-
-        let db_lock = borrow_db_checked();
-
-        let metadata_option = db_lock.applications.installed_game_version.get(&id);
-        let version = match metadata_option {
-            None => None,
-            Some(metadata) => db_lock
-                .applications
-                .game_versions
-                .get(&metadata.id)
-                .map(|v| v.get(metadata.version.as_ref().unwrap()).unwrap())
-                .cloned(),
-        };
-
-        let game = state_handle.games.get(&id);
-        if let Some(game) = game {
-            let status = GameStatusManager::fetch_state(&id, &db_lock);
-
-            let data = FetchGameStruct {
-                game: game.clone(),
-                status,
-                version,
-            };
-
-            cache_object_db(&id, game, &db_lock)?;
-
-            return Ok(data);
-        }
-
-        version
-    };
-
-    let client = DROP_CLIENT_ASYNC.clone();
-    let response = generate_url(&["/api/v1/client/game/", &id], &[])?;
-    let response = client
-        .get(response)
-        .header("Authorization", generate_authorization_header())
-        .send()
-        .await?;
-
-    if response.status() == 404 {
-        let offline_fetch = fetch_game_logic_offline(id.clone(), state).await;
-        if let Ok(fetch_data) = offline_fetch {
-            return Ok(fetch_data);
-        }
-
-        return Err(RemoteAccessError::GameNotFound(id));
-    }
-    if response.status() != 200 {
-        let err = response.json().await?;
-        warn!("{err:?}");
-        return Err(RemoteAccessError::InvalidResponse(err));
-    }
-
-    let game: Game = response.json().await?;
-
-    let mut state_handle = lock!(state);
-    state_handle.games.insert(id.clone(), game.clone());
-
-    let mut db_handle = borrow_db_mut_checked();
-
-    db_handle
-        .applications
-        .game_statuses
-        .entry(id.clone())
-        .or_insert(GameDownloadStatus::Remote {});
-
-    let status = GameStatusManager::fetch_state(&id, &db_handle);
-
-    drop(db_handle);
-
-    let data = FetchGameStruct {
-        game: game.clone(),
-        status,
-        version,
-    };
-
-    cache_object(&id, &game)?;
-
-    Ok(data)
-}
-
-pub async fn fetch_game_logic_offline(
-    id: String,
-    _state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<FetchGameStruct, RemoteAccessError> {
-    let db_handle = borrow_db_checked();
-    let metadata_option = db_handle.applications.installed_game_version.get(&id);
-    let version = match metadata_option {
-        None => None,
-        Some(metadata) => db_handle
-            .applications
-            .game_versions
-            .get(&metadata.id)
-            .map(|v| v.get(metadata.version.as_ref().unwrap()).unwrap())
-            .cloned(),
-    };
-
-    let status = GameStatusManager::fetch_state(&id, &db_handle);
-    let game = get_cached_object::<Game>(&id)?;
-
-    drop(db_handle);
-
-    Ok(FetchGameStruct {
-        game,
-        status,
-        version,
-    })
-}
-
-pub async fn fetch_game_version_options_logic(
-    game_id: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<Vec<GameVersion>, RemoteAccessError> {
-    let client = DROP_CLIENT_ASYNC.clone();
-
-    let response = generate_url(&["/api/v1/client/game/versions"], &[("id", &game_id)])?;
-    let response = client
-        .get(response)
-        .header("Authorization", generate_authorization_header())
-        .send()
-        .await?;
-
-    if response.status() != 200 {
-        let err = response.json().await?;
-        warn!("{err:?}");
-        return Err(RemoteAccessError::InvalidResponse(err));
-    }
-
-    let data: Vec<GameVersion> = response.json().await?;
-
-    let state_lock = lock!(state);
-    let process_manager_lock = lock!(state_lock.process_manager);
-    let data: Vec<GameVersion> = data
-        .into_iter()
-        .filter(|v| process_manager_lock.valid_platform(&v.platform, &state_lock))
-        .collect();
-    drop(process_manager_lock);
-    drop(state_lock);
-
-    Ok(data)
-}
-
 /**
  * Called by:
  *  - on_cancel, when cancelled, for obvious reasons

src-tauri/games/src/state.rs

@@ -1,4 +1,4 @@
-use crate::database::models::data::{
+use database::models::data::{
     ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus,
 };
 

src-tauri/process/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "process"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+chrono = "0.4.42"
+client = { version = "0.1.0", path = "../client" }
+database = { version = "0.1.0", path = "../database" }
+dynfmt = "0.1.5"
+log = "0.4.28"
+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" }

src-tauri/process/src/lib.rs

@@ -1,5 +1,4 @@
-pub mod commands;
 pub mod process_manager;
 pub mod process_handlers;
 pub mod format;
-pub mod utils;
+pub mod error;

src-tauri/process/src/process_handlers.rs

@@ -5,14 +5,11 @@ use std::{
     sync::LazyLock,
 };
 
+use database::{platform::Platform, Database, DownloadableMetadata, GameVersion};
 use log::{debug, info};
 
-use crate::{
+
-    AppState,
+use crate::{error::ProcessError, process_manager::ProcessHandler};
-    database::models::data::{Database, DownloadableMetadata, GameVersion},
-    error::process_error::ProcessError,
-    process::process_manager::{Platform, ProcessHandler},
-};
 
 pub struct NativeGameLauncher;
 impl ProcessHandler for NativeGameLauncher {

src-tauri/process/src/process_manager.rs

@@ -10,6 +10,7 @@ use std::{
     time::{Duration, SystemTime},
 };
 
+use database::{borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR, platform::Platform, ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus, GameVersion};
 use dynfmt::Format;
 use dynfmt::SimpleCurlyFormat;
 use log::{debug, info, warn};
@@ -17,24 +18,10 @@ use serde::{Deserialize, Serialize};
 use shared_child::SharedChild;
 use tauri::{AppHandle, Emitter, Manager};
 use tauri_plugin_opener::OpenerExt;
+use utils::lock;
+
+use crate::{error::ProcessError, format::DropFormatArgs, process_handlers::{AsahiMuvmLauncher, NativeGameLauncher, UMULauncher}};
 
-use crate::{
-    AppState,
-    database::{
-        db::{DATA_ROOT_DIR, borrow_db_checked, borrow_db_mut_checked},
-        models::data::{
-            ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata,
-            GameDownloadStatus, GameVersion,
-        },
-    },
-    error::process_error::ProcessError,
-    games::{library::push_game_update, state::GameStatusManager},
-    process::{
-        format::DropFormatArgs,
-        process_handlers::{AsahiMuvmLauncher, NativeGameLauncher, UMULauncher},
-    },
-    lock,
-};
 
 pub struct RunningProcess {
     handle: Arc<SharedChild>,
@@ -421,51 +408,6 @@ impl ProcessManager<'_> {
     }
 }
 
-#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
-pub enum Platform {
-    Windows,
-    Linux,
-    MacOs,
-}
-
-impl Platform {
-    #[cfg(target_os = "windows")]
-    pub const HOST: Platform = Self::Windows;
-    #[cfg(target_os = "macos")]
-    pub const HOST: Platform = Self::MacOs;
-    #[cfg(target_os = "linux")]
-    pub const HOST: Platform = Self::Linux;
-
-    pub fn is_case_sensitive(&self) -> bool {
-        match self {
-            Self::Windows | Self::MacOs => false,
-            Self::Linux => true,
-        }
-    }
-}
-
-impl From<&str> for Platform {
-    fn from(value: &str) -> Self {
-        match value.to_lowercase().trim() {
-            "windows" => Self::Windows,
-            "linux" => Self::Linux,
-            "mac" | "macos" => Self::MacOs,
-            _ => unimplemented!(),
-        }
-    }
-}
-
-impl From<whoami::Platform> for Platform {
-    fn from(value: whoami::Platform) -> Self {
-        match value {
-            whoami::Platform::Windows => Platform::Windows,
-            whoami::Platform::Linux => Platform::Linux,
-            whoami::Platform::MacOS => Platform::MacOs,
-            _ => unimplemented!(),
-        }
-    }
-}
-
 pub trait ProcessHandler: Send + 'static {
     fn create_launch_process(
         &self,

src-tauri/remote/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "remote"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bitcode = "0.6.7"
+chrono = "0.4.42"
+client = { version = "0.1.0", path = "../client" }
+database = { version = "0.1.0", path = "../database" }
+droplet-rs = "0.7.3"
+gethostname = "1.0.2"
+hex = "0.4.3"
+http = "1.3.1"
+log = "0.4.28"
+md5 = "0.8.0"
+reqwest = "0.12.23"
+reqwest-websocket = "0.5.1"
+serde = "1.0.228"
+serde_with = "3.15.0"
+tauri = "2.8.5"
+url = "2.5.7"
+utils = { version = "0.1.0", path = "../utils" }

src-tauri/remote/src/auth.rs

@@ -1,19 +1,15 @@
-use std::{collections::HashMap, env, sync::Mutex};
+use std::{collections::HashMap, env};
 
 use chrono::Utc;
+use client::{app_status::AppStatus, user::User};
+use database::interface::borrow_db_checked;
 use droplet_rs::ssl::sign_nonce;
 use gethostname::gethostname;
-use log::{debug, error, warn};
+use log::{error, warn};
 use serde::{Deserialize, Serialize};
-use tauri::{AppHandle, Emitter, Manager};
 use url::Url;
 
-use crate::{
+use crate::{error::{DropServerError, RemoteAccessError}, requests::make_authenticated_get, utils::DROP_CLIENT_SYNC};
-    app_emit, database::{
-        db::{borrow_db_checked, borrow_db_mut_checked},
-        models::data::DatabaseAuth,
-    }, error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError}, lock, remote::{cache::clear_cached_object, requests::make_authenticated_get, utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC}}, AppState, AppStatus, User
-};
 
 use super::{
     cache::{cache_object, get_cached_object},
@@ -81,94 +77,6 @@ pub async fn fetch_user() -> Result<User, RemoteAccessError> {
         .map_err(std::convert::Into::into)
 }
 
-async fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAccessError> {
-    let path_chunks: Vec<&str> = path.split('/').collect();
-    if path_chunks.len() != 3 {
-        app_emit!(app, "auth/failed", ());
-        return Err(RemoteAccessError::HandshakeFailed(
-            "failed to parse token".to_string(),
-        ));
-    }
-
-    let base_url = {
-        let handle = borrow_db_checked();
-        Url::parse(handle.base_url.as_str())?
-    };
-
-    let client_id = path_chunks
-        .get(1)
-        .expect("Failed to get client id from path chunks");
-    let token = path_chunks
-        .get(2)
-        .expect("Failed to get token from path chunks");
-    let body = HandshakeRequestBody {
-        client_id: (client_id).to_string(),
-        token: (token).to_string(),
-    };
-
-    let endpoint = base_url.join("/api/v1/client/auth/handshake")?;
-    let client = DROP_CLIENT_ASYNC.clone();
-    let response = client.post(endpoint).json(&body).send().await?;
-    debug!("handshake responsded with {}", response.status().as_u16());
-    if !response.status().is_success() {
-        return Err(RemoteAccessError::InvalidResponse(response.json().await?));
-    }
-    let response_struct: HandshakeResponse = response.json().await?;
-
-    {
-        let mut handle = borrow_db_mut_checked();
-        handle.auth = Some(DatabaseAuth {
-            private: response_struct.private,
-            cert: response_struct.certificate,
-            client_id: response_struct.id,
-            web_token: None,
-        });
-    }
-
-    let web_token = {
-        let header = generate_authorization_header();
-        let token = client
-            .post(base_url.join("/api/v1/client/user/webtoken")?)
-            .header("Authorization", header)
-            .send()
-            .await?;
-
-        token.text().await?
-    };
-    let mut handle = borrow_db_mut_checked();
-    handle.auth.as_mut().unwrap().web_token = Some(web_token);
-
-    Ok(())
-}
-
-pub async fn recieve_handshake(app: AppHandle, path: String) {
-    // Tell the app we're processing
-    app_emit!(app, "auth/processing", ());
-
-    let handshake_result = recieve_handshake_logic(&app, path).await;
-    if let Err(e) = handshake_result {
-        warn!("error with authentication: {e}");
-        app_emit!(app, "auth/failed", e.to_string());
-        return;
-    }
-
-    let app_state = app.state::<Mutex<AppState>>();
-
-    let (app_status, user) = setup().await;
-
-    let mut state_lock = lock!(app_state);
-
-    state_lock.status = app_status;
-    state_lock.user = user;
-
-    let _ = clear_cached_object("collections");
-    let _ = clear_cached_object("library");
-
-    drop(state_lock);
-
-    app_emit!(app, "auth/finished", ());
-}
-
 pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
     let base_url = {
         let db_lock = borrow_db_checked();

src-tauri/remote/src/cache.rs

@@ -5,13 +5,12 @@ use std::{
     time::SystemTime,
 };
 
-use crate::{
-    database::{db::borrow_db_checked, models::data::Database},
-    error::{cache_error::CacheError, remote_access_error::RemoteAccessError},
-};
 use bitcode::{Decode, DecodeOwned, Encode};
+use database::{borrow_db_checked, Database};
 use http::{header::{CONTENT_TYPE}, response::Builder as ResponseBuilder, Response};
 
+use crate::error::{CacheError, RemoteAccessError};
+
 #[macro_export]
 macro_rules! offline {
     ($var:expr, $func1:expr, $func2:expr, $( $arg:expr ),* ) => {

src-tauri/remote/src/error.rs

@@ -4,11 +4,21 @@ use std::{
     sync::Arc,
 };
 
-use http::StatusCode;
+use http::{header::ToStrError, HeaderName, StatusCode};
 use serde_with::SerializeDisplay;
 use url::ParseError;
 
-use super::drop_server_error::DropServerError;
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DropServerError {
+    pub status_code: usize,
+    pub status_message: String,
+    // pub message: String,
+    // pub url: String,
+}
+
 
 #[derive(Debug, SerializeDisplay)]
 pub enum RemoteAccessError {
@@ -104,3 +114,23 @@ impl From<ParseError> for RemoteAccessError {
     }
 }
 impl std::error::Error for RemoteAccessError {}
+
+#[derive(Debug, SerializeDisplay)]
+pub enum CacheError {
+    HeaderNotFound(HeaderName),
+    ParseError(ToStrError),
+    Remote(RemoteAccessError),
+    ConstructionError(http::Error)
+}
+
+impl Display for CacheError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            CacheError::HeaderNotFound(header_name) => format!("Could not find header {header_name} in cache"),
+            CacheError::ParseError(to_str_error) => format!("Could not parse cache with error {to_str_error}"),
+            CacheError::Remote(remote_access_error) => format!("Cache got remote access error: {remote_access_error}"),
+            CacheError::ConstructionError(error) => format!("Could not construct cache body with error {error}"),
+        };
+        write!(f, "{s}")
+    }
+}

src-tauri/remote/src/fetch_object.rs

@@ -1,8 +1,9 @@
+use database::{interface::DatabaseImpls, DB};
 use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder, Response};
 use log::{debug, warn};
 use tauri::UriSchemeResponder;
 
-use crate::{database::db::DatabaseImpls, error::cache_error::CacheError, remote::utils::DROP_CLIENT_ASYNC, DB};
+use crate::{error::CacheError, utils::DROP_CLIENT_ASYNC};
 
 use super::{
     auth::generate_authorization_header,

src-tauri/remote/src/lib.rs

@@ -1,8 +1,10 @@
 pub mod auth;
 #[macro_use]
 pub mod cache;
-pub mod commands;
 pub mod fetch_object;
 pub mod requests;
 pub mod server_proto;
 pub mod utils;
+pub mod error;
+
+pub use auth::setup;

src-tauri/remote/src/requests.rs

@@ -1,10 +1,8 @@
+use database::{interface::DatabaseImpls, DB};
 use url::Url;
 
 use crate::{
-    DB,
+    auth::generate_authorization_header, error::RemoteAccessError, utils::DROP_CLIENT_ASYNC,
-    database::db::DatabaseImpls,
-    error::remote_access_error::RemoteAccessError,
-    remote::{auth::generate_authorization_header, utils::DROP_CLIENT_ASYNC},
 };
 
 pub fn generate_url<T: AsRef<str>>(

src-tauri/remote/src/server_proto.rs

@@ -1,10 +1,12 @@
 use std::str::FromStr;
 
+use database::borrow_db_checked;
 use http::{uri::PathAndQuery, Request, Response, StatusCode, Uri};
 use log::{error, warn};
 use tauri::UriSchemeResponder;
+use utils::webbrowser_open::webbrowser_open;
 
-use crate::{database::db::borrow_db_checked, remote::utils::DROP_CLIENT_SYNC, utils::webbrowser_open::webbrowser_open};
+use crate::utils::DROP_CLIENT_SYNC;
 
 pub async fn handle_server_proto_offline_wrapper(request: Request<Vec<u8>>, responder: UriSchemeResponder) {
     responder.respond(match handle_server_proto_offline(request).await {

src-tauri/remote/src/utils.rs

@@ -1,18 +1,13 @@
 use std::{
     fs::{self, File},
     io::Read,
-    sync::{LazyLock, Mutex},
+    sync::LazyLock,
-    time::Duration,
 };
 
+use database::db::DATA_ROOT_DIR;
 use log::{debug, info, warn};
 use reqwest::Certificate;
 use serde::Deserialize;
-use url::Url;
-
-use crate::{
-    database::db::{borrow_db_mut_checked, DATA_ROOT_DIR}, error::remote_access_error::RemoteAccessError, lock, AppState, AppStatus
-};
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -109,37 +104,4 @@ pub fn get_client_ws() -> reqwest::Client {
         .http1_only()
         .build()
         .expect("Failed to build websocket client")
-}
+}
-
-pub async fn use_remote_logic(
-    url: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<(), RemoteAccessError> {
-    debug!("connecting to url {url}");
-    let base_url = Url::parse(&url)?;
-
-    // Test Drop url
-    let test_endpoint = base_url.join("/api/v1")?;
-    let client = DROP_CLIENT_ASYNC.clone();
-    let response = client
-        .get(test_endpoint.to_string())
-        .timeout(Duration::from_secs(3))
-        .send()
-        .await?;
-
-    let result: DropHealthcheck = response.json().await?;
-
-    if result.app_name != "Drop" {
-        warn!("user entered drop endpoint that connected, but wasn't identified as Drop");
-        return Err(RemoteAccessError::InvalidEndpoint);
-    }
-
-    let mut app_state = lock!(state);
-    app_state.status = AppStatus::SignedOut;
-    drop(app_state);
-
-    let mut db_state = borrow_db_mut_checked();
-    db_state.base_url = base_url.to_string();
-
-    Ok(())
-}

src-tauri/src-tauri/Cargo.toml

@@ -0,0 +1,137 @@
+[package]
+name = "drop-app"
+version = "0.3.3"
+description = "The client application for the open-source, self-hosted game distribution platform Drop"
+authors = ["Drop OSS"]
+edition = "2024"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\"))".dependencies]
+tauri-plugin-single-instance = { version = "2.0.0", features = ["deep-link"] }
+
+[lib]
+# The `_lib` suffix may seem redundant but it is necessary
+# to make the lib name unique and wouldn't conflict with the bin name.
+# This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
+name = "drop_app_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+rustflags = ["-C", "target-feature=+aes,+sse2"]
+
+
+[build-dependencies]
+tauri-build = { version = "2.0.0", features = [] }
+
+[dependencies]
+tauri-plugin-shell = "2.2.1"
+serde_json = "1"
+rayon = "1.10.0"
+webbrowser = "1.0.2"
+url = "2.5.2"
+tauri-plugin-deep-link = "2"
+log = "0.4.22"
+hex = "0.4.3"
+tauri-plugin-dialog = "2"
+http = "1.1.0"
+urlencoding = "2.1.3"
+md5 = "0.7.0"
+chrono = "0.4.38"
+tauri-plugin-os = "2"
+boxcar = "0.2.7"
+umu-wrapper-lib = "0.1.0"
+tauri-plugin-autostart = "2.0.0"
+shared_child = "1.0.1"
+serde_with = "3.12.0"
+slice-deque = "0.3.0"
+throttle_my_fn = "0.2.6"
+parking_lot = "0.12.3"
+atomic-instant-full = "0.1.0"
+cacache = "13.1.0"
+http-serde = "2.1.1"
+reqwest-middleware = "0.4.0"
+reqwest-middleware-cache = "0.1.1"
+deranged = "=0.4.0"
+droplet-rs = "0.7.3"
+gethostname = "1.0.1"
+zstd = "0.13.3"
+tar = "0.4.44"
+rand = "0.9.1"
+regex = "1.11.1"
+tempfile = "3.19.1"
+schemars = "0.8.22"
+sha1 = "0.10.6"
+dirs = "6.0.0"
+whoami = "1.6.0"
+filetime = "0.2.25"
+walkdir = "2.5.0"
+known-folders = "1.2.0"
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+tauri-plugin-opener = "2.4.0"
+bitcode = "0.6.6"
+reqwest-websocket = "0.5.0"
+futures-lite = "2.6.0"
+page_size = "0.6.0"
+sysinfo = "0.36.1"
+humansize = "2.1.3"
+tokio-util = { version = "0.7.16", features = ["io"] }
+futures-core = "0.3.31"
+bytes = "1.10.1"
+# tailscale = { path = "./tailscale" }
+
+
+# Workspaces
+client = { path = "../client" }
+database = { path = "../database" }
+process = { path = "../process" }
+remote = { path = "../remote" }
+utils = { path = "../utils" }
+
+[dependencies.dynfmt]
+version = "0.1.5"
+features = ["curly"]
+
+[dependencies.tauri]
+version = "2.7.0"
+features = ["protocol-asset", "tray-icon"]
+
+[dependencies.tokio]
+version = "1.40.0"
+features = ["rt", "tokio-macros", "signal"]
+
+[dependencies.log4rs]
+version = "1.3.0"
+features = ["console_appender", "file_appender"]
+
+[dependencies.rustix]
+version = "0.38.37"
+features = ["fs"]
+
+[dependencies.uuid]
+version = "1.10.0"
+features = ["v4", "fast-rng", "macro-diagnostics"]
+
+[dependencies.rustbreak]
+version = "2"
+features = ["other_errors"] # You can also use "yaml_enc" or "bin_enc"
+
+[dependencies.reqwest]
+version = "0.12.22"
+default-features = false
+features = [
+    "json",
+    "http2",
+    "blocking",
+    "rustls-tls",
+    "native-tls-alpn",
+    "rustls-tls-native-roots",
+    "stream",
+]
+
+[dependencies.serde]
+version = "1"
+features = ["derive", "rc"]
+
+[profile.release]
+lto = true
+codegen-units = 1
+panic = 'abort'

src-tauri/src-tauri/gen/schemas/capabilities.json

@@ -0,0 +1 @@
+{}