feat: more refactoring (broken)

main/app.vue

@@ -44,10 +44,6 @@ router.beforeEach(async () => {
 setupHooks();
 initialNavigation(state);
 
-// Setup playtime event listeners
-const { setupEventListeners } = usePlaytime();
-setupEventListeners();
-
 useHead({
   title: "Drop",
 });

main/components/PlaytimeDisplay.vue

@@ -1,53 +0,0 @@
-<template>
-  <div v-if="stats" class="flex flex-col gap-1">
-    <!-- Main playtime display -->
-    <div class="flex items-center gap-2">
-      <ClockIcon class="w-5 h-5 text-zinc-400" />
-      <span class="text-base text-zinc-300 font-medium">
-        {{ formatPlaytime(stats.totalPlaytimeSeconds) }} played
-      </span>
-      <span v-if="isActive && showActiveIndicator" class="text-sm text-green-400 font-medium">
-        • Playing
-      </span>
-    </div>
-    
-    <!-- Additional details when expanded -->
-    <div v-if="showDetails" class="text-xs text-zinc-400 space-y-1 ml-7">
-      <div>{{ stats.sessionCount }} session{{ stats.sessionCount !== 1 ? 's' : '' }}</div>
-      <div v-if="stats.sessionCount > 0">
-        Avg: {{ formatPlaytime(stats.averageSessionLength) }} per session
-      </div>
-      <div v-if="stats.currentSessionDuration">
-        Current session: {{ formatPlaytime(stats.currentSessionDuration) }}
-      </div>
-    </div>
-  </div>
-  
-  <!-- No playtime data -->
-  <div v-else-if="showWhenEmpty" class="flex items-center gap-2 text-zinc-500">
-    <ClockIcon class="w-5 h-5" />
-    <span class="text-base">Never played</span>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { ClockIcon } from "@heroicons/vue/20/solid";
-import type { GamePlaytimeStats } from "~/types";
-
-interface Props {
-  stats: GamePlaytimeStats | null;
-  isActive?: boolean;
-  showDetails?: boolean;
-  showWhenEmpty?: boolean;
-  showActiveIndicator?: boolean;
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  isActive: false,
-  showDetails: false,
-  showWhenEmpty: true,
-  showActiveIndicator: true,
-});
-
-const { formatPlaytime } = usePlaytime();
-</script>

main/components/PlaytimeStats.vue

@@ -1,76 +0,0 @@
-<template>
-  <div class="bg-zinc-800/50 rounded-lg p-4 space-y-4">
-    <div class="flex items-center gap-2">
-      <ChartBarIcon class="w-5 h-5 text-zinc-400" />
-      <h3 class="text-lg font-semibold text-zinc-100">Playtime Statistics</h3>
-    </div>
-    
-    <div v-if="stats" class="grid grid-cols-1 md:grid-cols-2 gap-4">
-      <!-- Total Playtime -->
-      <div class="bg-zinc-700/50 rounded-lg p-3">
-        <div class="flex items-center gap-2 mb-2">
-          <ClockIcon class="w-4 h-4 text-blue-400" />
-          <span class="text-sm font-medium text-zinc-300">Total Playtime</span>
-        </div>
-        <div class="text-2xl font-bold text-zinc-100">
-          {{ formatDetailedPlaytime(stats.totalPlaytimeSeconds) }}
-        </div>
-        <div v-if="stats.currentSessionDuration" class="text-xs text-green-400 mt-1">
-          +{{ formatPlaytime(stats.currentSessionDuration) }} this session
-        </div>
-      </div>
-      
-      <!-- Sessions -->
-      <div class="bg-zinc-700/50 rounded-lg p-3">
-        <div class="flex items-center gap-2 mb-2">
-          <PlayIcon class="w-4 h-4 text-green-400" />
-          <span class="text-sm font-medium text-zinc-300">Sessions</span>
-        </div>
-        <div class="text-2xl font-bold text-zinc-100">
-          {{ stats.sessionCount }}
-        </div>
-        <div class="text-xs text-zinc-400 mt-1">
-          Avg: {{ formatPlaytime(stats.averageSessionLength) }}
-        </div>
-      </div>
-    </div>
-    
-    <!-- No stats available -->
-    <div v-else class="text-center py-8">
-      <ClockIcon class="w-12 h-12 text-zinc-600 mx-auto mb-3" />
-      <p class="text-zinc-400">No playtime data available</p>
-      <p class="text-sm text-zinc-500 mt-1">Statistics will appear after you start playing</p>
-    </div>
-    
-    <!-- Current session indicator -->
-    <div v-if="isActive && stats" class="border-t border-zinc-700 pt-3">
-      <div class="flex items-center gap-2 text-green-400">
-        <div class="w-2 h-2 bg-green-400 rounded-full animate-pulse"></div>
-        <span class="text-sm font-medium">Currently playing</span>
-        <span v-if="stats.currentSessionDuration" class="text-xs text-zinc-400">
-          {{ formatPlaytime(stats.currentSessionDuration) }}
-        </span>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { 
-  ChartBarIcon, 
-  ClockIcon, 
-  PlayIcon 
-} from "@heroicons/vue/20/solid";
-import type { GamePlaytimeStats } from "~/types";
-
-interface Props {
-  stats: GamePlaytimeStats | null;
-  isActive?: boolean;
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  isActive: false,
-});
-
-const { formatPlaytime, formatDetailedPlaytime } = usePlaytime();
-</script>

main/composables/playtime.ts

@@ -1,193 +0,0 @@
-import { invoke } from "@tauri-apps/api/core";
-import { listen } from "@tauri-apps/api/event";
-import type { 
-  GamePlaytimeStats, 
-  PlaytimeUpdateEvent, 
-  PlaytimeSessionStartEvent, 
-  PlaytimeSessionEndEvent 
-} from "~/types";
-
-export const usePlaytime = () => {
-  const playtimeStats = useState<Record<string, GamePlaytimeStats>>('playtime-stats', () => ({}));
-  const activeSessions = useState<Set<string>>('active-sessions', () => new Set());
-
-  // Fetch playtime stats for a specific game
-  const fetchGamePlaytime = async (gameId: string): Promise<GamePlaytimeStats | null> => {
-    try {
-      const stats = await invoke<GamePlaytimeStats | null>("fetch_game_playtime", { gameId });
-      if (stats) {
-        playtimeStats.value[gameId] = stats;
-      }
-      return stats;
-    } catch (error) {
-      console.error(`Failed to fetch playtime for game ${gameId}:`, error);
-      return null;
-    }
-  };
-
-  // Fetch all playtime stats
-  const fetchAllPlaytimeStats = async (): Promise<Record<string, GamePlaytimeStats>> => {
-    try {
-      const stats = await invoke<Record<string, GamePlaytimeStats>>("fetch_all_playtime_stats");
-      playtimeStats.value = stats;
-      return stats;
-    } catch (error) {
-      console.error("Failed to fetch all playtime stats:", error);
-      return {};
-    }
-  };
-
-  // Check if a session is active
-  const isSessionActive = async (gameId: string): Promise<boolean> => {
-    try {
-      return await invoke<boolean>("is_playtime_session_active", { gameId });
-    } catch (error) {
-      console.error(`Failed to check session status for game ${gameId}:`, error);
-      return false;
-    }
-  };
-
-  // Get all active sessions
-  const getActiveSessions = async (): Promise<string[]> => {
-    try {
-      const sessions = await invoke<string[]>("get_active_playtime_sessions");
-      activeSessions.value = new Set(sessions);
-      return sessions;
-    } catch (error) {
-      console.error("Failed to get active sessions:", error);
-      return [];
-    }
-  };
-
-  // Format playtime duration
-  const formatPlaytime = (seconds: number): string => {
-    if (seconds < 60) {
-      return `${seconds}s`;
-    } else if (seconds < 3600) {
-      const minutes = Math.floor(seconds / 60);
-      return `${minutes}m`;
-    } else {
-      const hours = Math.floor(seconds / 3600);
-      const minutes = Math.floor((seconds % 3600) / 60);
-      if (minutes === 0) {
-        return `${hours}h`;
-      }
-      return `${hours}h ${minutes}m`;
-    }
-  };
-
-  // Format detailed playtime
-  const formatDetailedPlaytime = (seconds: number): string => {
-    if (seconds < 60) {
-      return `${seconds} seconds`;
-    } else if (seconds < 3600) {
-      const minutes = Math.floor(seconds / 60);
-      const remainingSeconds = seconds % 60;
-      if (remainingSeconds === 0) {
-        return `${minutes} minutes`;
-      }
-      return `${minutes} minutes, ${remainingSeconds} seconds`;
-    } else {
-      const hours = Math.floor(seconds / 3600);
-      const minutes = Math.floor((seconds % 3600) / 60);
-      if (minutes === 0) {
-        return `${hours} hours`;
-      }
-      return `${hours} hours, ${minutes} minutes`;
-    }
-  };
-
-  // Format relative time (e.g., "2 hours ago")
-  const formatRelativeTime = (timestamp: string): string => {
-    const date = new Date(timestamp);
-    const now = new Date();
-    const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000);
-
-    if (diffInSeconds < 60) {
-      return "Just now";
-    } else if (diffInSeconds < 3600) {
-      const minutes = Math.floor(diffInSeconds / 60);
-      return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`;
-    } else if (diffInSeconds < 86400) {
-      const hours = Math.floor(diffInSeconds / 3600);
-      return `${hours} hour${hours !== 1 ? 's' : ''} ago`;
-    } else if (diffInSeconds < 604800) {
-      const days = Math.floor(diffInSeconds / 86400);
-      return `${days} day${days !== 1 ? 's' : ''} ago`;
-    } else {
-      return date.toLocaleDateString();
-    }
-  };
-
-  // Get playtime stats for a game (from cache or fetch)
-  const getGamePlaytime = async (gameId: string): Promise<GamePlaytimeStats | null> => {
-    if (playtimeStats.value[gameId]) {
-      return playtimeStats.value[gameId];
-    }
-    return await fetchGamePlaytime(gameId);
-  };
-
-  // Setup event listeners
-  const setupEventListeners = () => {
-    // Listen for general playtime updates
-    listen<PlaytimeUpdateEvent>("playtime_update", (event) => {
-      const { gameId, stats, isActive } = event.payload;
-      playtimeStats.value[gameId] = stats;
-      
-      if (isActive) {
-        activeSessions.value.add(gameId);
-      } else {
-        activeSessions.value.delete(gameId);
-      }
-    });
-
-    // Listen for session start events
-    listen<PlaytimeSessionStartEvent>("playtime_session_start", (event) => {
-      const { gameId } = event.payload;
-      activeSessions.value.add(gameId);
-    });
-
-    // Listen for session end events
-    listen<PlaytimeSessionEndEvent>("playtime_session_end", (event) => {
-      const { gameId } = event.payload;
-      activeSessions.value.delete(gameId);
-    });
-  };
-
-  // Setup game-specific event listeners
-  const setupGameEventListeners = (gameId: string) => {
-    listen<PlaytimeUpdateEvent>(`playtime_update/${gameId}`, (event) => {
-      const { stats, isActive } = event.payload;
-      playtimeStats.value[gameId] = stats;
-      
-      if (isActive) {
-        activeSessions.value.add(gameId);
-      } else {
-        activeSessions.value.delete(gameId);
-      }
-    });
-
-    listen<PlaytimeSessionStartEvent>(`playtime_session_start/${gameId}`, () => {
-      activeSessions.value.add(gameId);
-    });
-
-    listen<PlaytimeSessionEndEvent>(`playtime_session_end/${gameId}`, () => {
-      activeSessions.value.delete(gameId);
-    });
-  };
-
-  return {
-    playtimeStats: readonly(playtimeStats),
-    activeSessions: readonly(activeSessions),
-    fetchGamePlaytime,
-    fetchAllPlaytimeStats,
-    isSessionActive,
-    getActiveSessions,
-    formatPlaytime,
-    formatDetailedPlaytime,
-    formatRelativeTime,
-    getGamePlaytime,
-    setupEventListeners,
-    setupGameEventListeners,
-  };
-};

main/pages/library/[id]/index.vue

@@ -18,20 +18,10 @@
     <div class="relative z-10">
       <div class="px-8 pb-4">
         <h1
-          class="text-5xl text-zinc-100 font-bold font-display drop-shadow-lg mb-4"
+          class="text-5xl text-zinc-100 font-bold font-display drop-shadow-lg mb-8"
         >
           {{ game.mName }}
         </h1>
-        
-        <!-- Playtime Display -->
-        <div class="mb-8">
-          <PlaytimeDisplay 
-            :stats="gamePlaytime" 
-            :is-active="isPlaytimeActive"
-            :show-details="false"
-            :show-active-indicator="false"
-          />
-        </div>
 
         <div class="flex flex-row gap-x-4 items-stretch mb-8">
           <!-- Do not add scale animations to this: https://stackoverflow.com/a/35683068 -->
@@ -70,12 +60,6 @@
           </div>
 
           <div class="space-y-6">
-            <!-- Playtime Statistics -->
-            <PlaytimeStats 
-              :stats="gamePlaytime" 
-              :is-active="isPlaytimeActive"
-            />
-            
             <div class="bg-zinc-800/50 rounded-xl p-6 backdrop-blur-sm">
               <h2 class="text-xl font-display font-semibold text-zinc-100 mb-4">
                 Game Images
@@ -544,19 +528,6 @@ const currentImageIndex = ref(0);
 
 const configureModalOpen = ref(false);
 
-// Playtime tracking
-const { 
-  getGamePlaytime, 
-  setupGameEventListeners,
-  activeSessions 
-} = usePlaytime();
-
-const gamePlaytime = ref(await getGamePlaytime(id));
-const isPlaytimeActive = computed(() => activeSessions.value.has(id));
-
-// Setup playtime event listeners for this game
-setupGameEventListeners(id);
-
 async function installFlow() {
   installFlowOpen.value = true;
   versionOptions.value = undefined;

main/types.ts

@@ -94,37 +94,3 @@ export type Settings = {
   maxDownloadThreads: number;
   forceOffline: boolean;
 };
-
-export type GamePlaytimeStats = {
-  gameId: string;
-  totalPlaytimeSeconds: number;
-  sessionCount: number;
-  firstPlayed: string;
-  lastPlayed: string;
-  averageSessionLength: number;
-  currentSessionDuration?: number;
-};
-
-export type PlaytimeSession = {
-  gameId: string;
-  startTime: string;
-  sessionId: string;
-};
-
-export type PlaytimeUpdateEvent = {
-  gameId: string;
-  stats: GamePlaytimeStats;
-  isActive: boolean;
-};
-
-export type PlaytimeSessionStartEvent = {
-  gameId: string;
-  startTime: string;
-};
-
-export type PlaytimeSessionEndEvent = {
-  gameId: string;
-  sessionDurationSeconds: number;
-  totalPlaytimeSeconds: number;
-  sessionCount: number;
-};

src-tauri/Cargo.toml

@@ -1,129 +1,101 @@
 [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"]
+# authors = ["Drop OSS"]
 edition = "2024"
+description = "The client application for the open-source, self-hosted game distribution platform Drop"
+
+[workspace]
+resolver = "3"
+members = ["drop-consts",
+  "drop-database",
+  "drop-downloads",
+  "drop-errors", "drop-library",
+  "drop-native-library",
+  "drop-process",
+  "drop-remote",
+]
 
 # 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]
+crate-type = ["cdylib", "rlib", "staticlib"]
 # 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 = [] }
+# rustflags = ["-C", "target-feature=+aes,+sse2"]
 
 [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"
+drop-database = { path = "./drop-database" }
+drop-downloads = { path = "./drop-downloads" }
+drop-errors = { path = "./drop-errors" }
+drop-native-library = { path = "./drop-native-library" }
+drop-process = { path = "./drop-process" }
+drop-remote = { path = "./drop-remote" }
 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"]
+hex = "0.4.3"
+http = "1.1.0"
+known-folders = "1.2.0"
+log = "0.4.22"
+md5 = "0.7.0"
+rayon = "1.10.0"
+regex = "1.11.1"
+reqwest-websocket = "0.5.0"
+serde_json = "1"
+tar = "0.4.44"
+tauri = { version = "2.7.0", features = ["protocol-asset", "tray-icon"] }
+tauri-plugin-autostart = "2.0.0"
+tauri-plugin-deep-link = "2"
+tauri-plugin-dialog = "2"
+tauri-plugin-opener = "2.4.0"
+tauri-plugin-os = "2"
+tauri-plugin-shell = "2.2.1"
+tempfile = "3.19.1"
+url = "2.5.2"
+webbrowser = "1.0.2"
+whoami = "1.6.0"
+zstd = "0.13.3"
 
 [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",
+  "blocking",
+  "http2",
+  "json",
+  "native-tls-alpn",
+  "rustls-tls",
+  "rustls-tls-native-roots",
+  "stream",
 ]
 
+[dependencies.rustix]
+version = "0.38.37"
+features = ["fs"]
+
 [dependencies.serde]
 version = "1"
 features = ["derive", "rc"]
 
+[dependencies.uuid]
+version = "1.10.0"
+features = ["fast-rng", "macro-diagnostics", "v4"]
+
+[build-dependencies]
+tauri-build = { version = "2.0.0", features = [] }
+
+[target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\"))".dependencies]
+tauri-plugin-single-instance = { version = "2.0.0", features = ["deep-link"] }
+
 [profile.release]
 lto = true
+panic = "abort"
 codegen-units = 1
-panic = 'abort'
+

src-tauri/drop-consts/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "drop-consts"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+dirs = "6.0.0"

src-tauri/drop-consts/src/lib.rs

@@ -0,0 +1,15 @@
+use std::{
+    path::PathBuf,
+    sync::{Arc, LazyLock},
+};
+
+#[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<&'static PathBuf> =
+    LazyLock::new(|| Box::leak(Box::new(dirs::data_dir().unwrap().join(DATA_ROOT_PREFIX))));
+
+pub static CACHE_DIR: LazyLock<&'static PathBuf> =
+    LazyLock::new(|| Box::leak(Box::new(DATA_ROOT_DIR.join("cache"))));

src-tauri/drop-database/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "drop-database"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bitcode = "0.6.7"
+chrono = "0.4.42"
+drop-consts = { path = "../drop-consts" }
+drop-library = { path = "../drop-library" }
+drop-native-library = { path = "../drop-native-library" }
+log = "0.4.28"
+native_model = { git = "https://github.com/Drop-OSS/native_model.git", version = "0.6.4", features = [
+  "rmp_serde_1_3",
+] }
+rustbreak = "2.0.0"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_with = "3.14.0"
+url = "2.5.7"
+whoami = "1.6.1"
+

src-tauri/drop-database/src/db.rs

@@ -7,23 +7,15 @@ use std::{
 };
 
 use chrono::Utc;
+use drop_consts::DATA_ROOT_DIR;
 use log::{debug, error, info, warn};
 use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
 use serde::{Serialize, de::DeserializeOwned};
-use url::Url;
 
 use crate::DB;
 
 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().unwrap().join(DATA_ROOT_PREFIX)));
-
 // Custom JSON serializer to support everything we need
 #[derive(Debug, Default, Clone)]
 pub struct DropDatabaseSerializer;
@@ -32,16 +24,15 @@ 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()))?;
+            .map_err(|e| rustbreak::error::DeSerError::Internal(e.to_string()))?;
+        let (val, _version) =
+            native_model::decode(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
         Ok(val)
     }
 }
@@ -51,8 +42,6 @@ pub type DatabaseInterface =
 
 pub trait DatabaseImpls {
     fn set_up_database() -> DatabaseInterface;
-    fn database_is_set_up(&self) -> bool;
-    fn fetch_base_url(&self) -> Url;
 }
 impl DatabaseImpls for DatabaseInterface {
     fn set_up_database() -> DatabaseInterface {
@@ -77,7 +66,7 @@ impl DatabaseImpls for DatabaseInterface {
                 Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
             }
         } else {
-            let default = Database::new(games_base_dir, None, cache_dir);
+            let default = Database::new(games_base_dir, None);
             debug!(
                 "Creating database at path {}",
                 db_path.as_os_str().to_str().unwrap()
@@ -85,15 +74,6 @@ impl DatabaseImpls for DatabaseInterface {
             PathDatabase::create_at_path(db_path, default).expect("Database could not be created")
         }
     }
-
-    fn database_is_set_up(&self) -> bool {
-        !self.borrow_data().unwrap().base_url.is_empty()
-    }
-
-    fn fetch_base_url(&self) -> Url {
-        let handle = self.borrow_data().unwrap();
-        Url::parse(&handle.base_url).unwrap()
-    }
 }
 
 // TODO: Make the error relelvant rather than just assume that it's a Deserialize error
@@ -116,15 +96,14 @@ fn handle_invalid_database(
     let db = Database::new(
         games_base_dir.into_os_string().into_string().unwrap(),
         Some(new_path),
-        cache_dir,
     );
 
     PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
 }
 
 // To automatically save the database upon drop
-pub struct DBRead<'a>(RwLockReadGuard<'a, Database>);
-pub struct DBWrite<'a>(ManuallyDrop<RwLockWriteGuard<'a, Database>>);
+pub struct DBRead<'a>(pub(crate) RwLockReadGuard<'a, Database>);
+pub struct DBWrite<'a>(pub(crate) ManuallyDrop<RwLockWriteGuard<'a, Database>>);
 impl<'a> Deref for DBWrite<'a> {
     type Target = Database;
 
@@ -159,23 +138,3 @@ impl Drop for DBWrite<'_> {
         }
     }
 }
-
-pub fn borrow_db_checked<'a>() -> DBRead<'a> {
-    match DB.borrow_data() {
-        Ok(data) => DBRead(data),
-        Err(e) => {
-            error!("database borrow failed with error {e}");
-            panic!("database borrow failed with error {e}");
-        }
-    }
-}
-
-pub fn borrow_db_mut_checked<'a>() -> DBWrite<'a> {
-    match DB.borrow_data_mut() {
-        Ok(data) => DBWrite(ManuallyDrop::new(data)),
-        Err(e) => {
-            error!("database borrow mut failed with error {e}");
-            panic!("database borrow mut failed with error {e}");
-        }
-    }
-}

src-tauri/drop-database/src/drop_data.rs

@@ -9,7 +9,7 @@ pub type DropData = v1::DropData;
 
 pub static DROP_DATA_PATH: &str = ".dropdata";
 
-pub mod v1 {
+mod v1 {
     use std::{collections::HashMap, path::PathBuf, sync::Mutex};
 
     use native_model::native_model;

src-tauri/drop-database/src/lib.rs

@@ -0,0 +1,34 @@
+use std::{mem::ManuallyDrop, sync::LazyLock};
+
+use log::error;
+
+use crate::db::{DBRead, DBWrite, DatabaseImpls, DatabaseInterface};
+
+pub mod db;
+pub mod debug;
+pub mod models;
+pub mod process;
+pub mod runtime_models;
+pub mod drop_data;
+
+pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
+
+pub fn borrow_db_checked<'a>() -> DBRead<'a> {
+    match DB.borrow_data() {
+        Ok(data) => DBRead(data),
+        Err(e) => {
+            error!("database borrow failed with error {e}");
+            panic!("database borrow failed with error {e}");
+        }
+    }
+}
+
+pub fn borrow_db_mut_checked<'a>() -> DBWrite<'a> {
+    match DB.borrow_data_mut() {
+        Ok(data) => DBWrite(ManuallyDrop::new(data)),
+        Err(e) => {
+            error!("database borrow mut failed with error {e}");
+            panic!("database borrow mut failed with error {e}");
+        }
+    }
+}

src-tauri/drop-database/src/models.rs

@@ -4,7 +4,7 @@ pub mod data {
     use native_model::native_model;
     use serde::{Deserialize, Serialize};
 
-    // NOTE: Within each version, you should NEVER use these types. 
+    // NOTE: Within each version, you should NEVER use these types.
     // Declare it using the actual version that it is from, i.e. v1::Settings rather than just Settings from here
 
     pub type GameVersion = v1::GameVersion;
@@ -19,11 +19,8 @@ pub mod data {
      */
     pub type DownloadableMetadata = v1::DownloadableMetadata;
     pub type DownloadType = v1::DownloadType;
-    pub type DatabaseApplications = v2::DatabaseApplications;
-    //pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
-    pub type PlaytimeData = v4::PlaytimeData;
-    pub type GamePlaytimeStats = v4::GamePlaytimeStats;
-    pub type PlaytimeSession = v4::PlaytimeSession;
+    pub type DatabaseApplications = v4::DatabaseApplications;
+    // pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
 
     use std::collections::HashMap;
 
@@ -40,10 +37,11 @@ pub mod data {
     }
 
     mod v1 {
-        use crate::process::process_manager::Platform;
         use serde_with::serde_as;
         use std::{collections::HashMap, path::PathBuf};
 
+        use crate::process::Platform;
+
         use super::{Deserialize, Serialize, native_model};
 
         fn default_template() -> String {
@@ -193,9 +191,9 @@ pub mod data {
 
         use serde_with::serde_as;
 
-        use super::{
-            Deserialize, Serialize, native_model, v1,
-        };
+        use crate::runtime_models::Game;
+
+        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)]
@@ -277,14 +275,13 @@ pub mod data {
         #[native_model(id = 3, version = 2, with = native_model::rmp_serde_1_3::RmpSerde, from=v1::DatabaseApplications)]
         pub struct DatabaseApplications {
             pub install_dirs: Vec<PathBuf>,
-            // Guaranteed to exist if the game also exists in the app state map
             pub game_statuses: HashMap<String, GameDownloadStatus>,
-            
             pub game_versions: HashMap<String, HashMap<String, v1::GameVersion>>,
             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 {
@@ -305,10 +302,7 @@ pub mod data {
     mod v3 {
         use std::path::PathBuf;
 
-        use super::{
-            Deserialize, Serialize,
-            native_model, v2, v1,
-        };
+        use super::{Deserialize, Serialize, native_model, v1, v2};
         #[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 {
@@ -338,130 +332,73 @@ pub mod data {
         }
     }
 
-    impl Database {
-        pub fn new<T: Into<PathBuf>>(
-            games_base_dir: T,
-            prev_database: Option<PathBuf>,
-            cache_dir: PathBuf,
-        ) -> Self {
-            Self {
-                applications: DatabaseApplications {
-                    install_dirs: vec![games_base_dir.into()],
-                    game_statuses: HashMap::new(),
-                    game_versions: HashMap::new(),
-                    installed_game_version: HashMap::new(),
-                    transient_statuses: HashMap::new(),
-                },
-                prev_database,
-                base_url: String::new(),
-                auth: None,
-                settings: Settings::default(),
-                cache_dir,
-                compat_info: None,
-                playtime_data: PlaytimeData::default(),
+    mod v4 {
+        use std::{collections::HashMap, path::PathBuf};
+        use drop_library::libraries::LibraryProviderIdentifier;
+        use drop_native_library::impls::DropNativeLibraryProvider;
+        use serde_with::serde_as;
+        use crate::models::data::v3;
+        use super::{Deserialize, Serialize, native_model, v1, v2};
+
+        #[derive(Serialize, Deserialize, Clone)]
+        pub enum Library {
+            NativeLibrary(DropNativeLibraryProvider),
+        }
+
+        #[serde_as]
+        #[derive(Serialize, Deserialize, Default, Clone)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 3, version = 4, with = native_model::rmp_serde_1_3::RmpSerde, from=v2::DatabaseApplications)]
+        pub struct DatabaseApplications {
+            pub install_dirs: Vec<PathBuf>,
+            pub libraries: HashMap<LibraryProviderIdentifier, Library>,
+
+            #[serde(skip)]
+            pub transient_statuses:
+                HashMap<v1::DownloadableMetadata, v1::ApplicationTransientStatus>,
+        }
+
+        impl From<v2::DatabaseApplications> for DatabaseApplications {
+            fn from(value: v2::DatabaseApplications) -> Self {
+                todo!()
             }
         }
-    }
 
-    mod v4 {
-        use std::{collections::HashMap, path::PathBuf, time::SystemTime};
-
-        use super::{
-            DatabaseApplications, DatabaseAuth, DatabaseCompatInfo, Deserialize, Serialize,
-            Settings, native_model, v3,
-        };
-
-        #[native_model(id = 1, version = 4, with = native_model::rmp_serde_1_3::RmpSerde)]
-        #[derive(Serialize, Deserialize, Clone, Default)]
+        #[native_model(id = 1, version = 4, with = native_model::rmp_serde_1_3::RmpSerde, from = v3::Database)]
+        #[derive(Serialize, Deserialize, Default, Clone)]
         pub struct Database {
             #[serde(default)]
-            pub settings: Settings,
-            pub auth: Option<DatabaseAuth>,
-            pub base_url: String,
-            pub applications: DatabaseApplications,
+            pub settings: v1::Settings,
+            pub drop_applications: DatabaseApplications,
             #[serde(skip)]
             pub prev_database: Option<PathBuf>,
-            pub cache_dir: PathBuf,
-            pub compat_info: Option<DatabaseCompatInfo>,
-            #[serde(default)]
-            pub playtime_data: PlaytimeData,
-        }
-
-        #[derive(Serialize, Deserialize, Clone, Default)]
-        #[native_model(id = 9, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-        pub struct PlaytimeData {
-            pub game_sessions: HashMap<String, GamePlaytimeStats>,
-            #[serde(skip)]
-            pub active_sessions: HashMap<String, PlaytimeSession>,
-        }
-
-        #[derive(Serialize, Deserialize, Clone, Debug)]
-        #[native_model(id = 10, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-        pub struct GamePlaytimeStats {
-            pub game_id: String,
-            pub total_playtime_seconds: u64,
-            pub session_count: u32,
-            pub first_played: SystemTime,
-            pub last_played: SystemTime,
-        }
-
-        #[derive(Serialize, Deserialize, Clone, Debug)]
-        #[native_model(id = 11, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-        pub struct PlaytimeSession {
-            pub game_id: String,
-            pub start_time: SystemTime,
-            pub session_id: String,
-        }
-
-        impl GamePlaytimeStats {
-            pub fn new(game_id: String) -> Self {
-                let now = SystemTime::now();
-                Self {
-                    game_id,
-                    total_playtime_seconds: 0,
-                    session_count: 0,
-                    first_played: now,
-                    last_played: now,
-                }
-            }
-
-            pub fn average_session_length(&self) -> u64 {
-                if self.session_count == 0 {
-                    0
-                } else {
-                    self.total_playtime_seconds / self.session_count as u64
-                }
-            }
-        }
-
-        impl PlaytimeSession {
-            pub fn new(game_id: String) -> Self {
-                Self {
-                    game_id,
-                    start_time: SystemTime::now(),
-                    session_id: uuid::Uuid::new_v4().to_string(),
-                }
-            }
-
-            pub fn duration(&self) -> std::time::Duration {
-                self.start_time.elapsed().unwrap_or_default()
-            }
         }
 
         impl From<v3::Database> for Database {
             fn from(value: v3::Database) -> Self {
-                Self {
+                Database {
                     settings: value.settings,
-                    auth: value.auth,
-                    base_url: value.base_url,
-                    applications: value.applications,
+                    drop_applications: value.applications.into(),
                     prev_database: value.prev_database,
-                    cache_dir: value.cache_dir,
-                    compat_info: value.compat_info,
-                    playtime_data: PlaytimeData::default(),
                 }
             }
         }
+    }
 
+    impl Database {
+        pub fn new<T: Into<PathBuf>>(
+            games_base_dir: T,
+            prev_database: Option<PathBuf>,
+        ) -> Self {
+            Self {
+                drop_applications: DatabaseApplications {
+                    install_dirs: vec![games_base_dir.into()],
+                    libraries: HashMap::new(),
+                    transient_statuses: HashMap::new(),
+                },
+                prev_database,
+                settings: Settings::default(),
+            }
+        }
     }
 }

src-tauri/drop-database/src/process.rs

@@ -0,0 +1,46 @@
+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,
+            _ => unimplemented!(),
+        }
+    }
+}

src-tauri/drop-database/src/runtime_models.rs

@@ -0,0 +1,28 @@
+use bitcode::{Decode, Encode};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
+#[serde(rename_all = "camelCase")]
+pub struct Game {
+    pub id: String,
+    m_name: String,
+    m_short_description: String,
+    m_description: String,
+    // mDevelopers
+    // mPublishers
+    m_icon_object_id: String,
+    m_banner_object_id: String,
+    m_cover_object_id: String,
+    m_image_library_object_ids: Vec<String>,
+    m_image_carousel_object_ids: Vec<String>,
+}
+
+#[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,
+}

src-tauri/drop-downloads/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "drop-downloads"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+atomic-instant-full = "0.1.0"
+drop-database = { path = "../drop-database" }
+drop-errors = { path = "../drop-errors" }
+# can't depend, cycle
+# drop-native-library = { path = "../drop-native-library" }
+log = "0.4.22"
+parking_lot = "0.12.4"
+serde = "1.0.219"
+tauri = { version = "2.7.0" }
+throttle_my_fn = "0.2.6"

src-tauri/drop-downloads/src/download_manager_builder.rs

@@ -7,14 +7,13 @@ use std::{
     thread::{JoinHandle, spawn},
 };
 
+use drop_database::models::data::DownloadableMetadata;
+use drop_errors::application_download_error::ApplicationDownloadError;
 use log::{debug, error, info, warn};
 use tauri::{AppHandle, Emitter};
 
 use crate::{
-    database::models::data::DownloadableMetadata,
-    download_manager::download_manager_frontend::DownloadStatus,
-    error::application_download_error::ApplicationDownloadError,
-    games::library::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
+    download_manager_frontend::DownloadStatus, events::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent}
 };
 
 use super::{
@@ -30,43 +29,6 @@ use super::{
 pub type DownloadAgent = Arc<Box<dyn Downloadable + Send + Sync>>;
 pub type CurrentProgressObject = Arc<Mutex<Option<Arc<ProgressObject>>>>;
 
-/*
-
-Welcome to the download manager, the most overengineered, glorious piece of bullshit.
-
-The download manager takes a queue of ids and their associated
-DownloadAgents, and then, one-by-one, executes them. It provides an interface
-to interact with the currently downloading agent, and manage the queue.
-
-When the DownloadManager is initialised, it is designed to provide a reference
-which can be used to provide some instructions (the DownloadManagerInterface),
-but other than that, it runs without any sort of interruptions.
-
-It does this by opening up two data structures. Primarily is the command_receiver,
-and mpsc (multi-channel-single-producer) which allows commands to be sent from
-the Interface, and queued up for the Manager to process.
-
-These have been mapped in the DownloadManagerSignal docs.
-
-The other way to interact with the DownloadManager is via the donwload_queue,
-which is just a collection of ids which may be rearranged to suit
-whichever download queue order is required.
-
-+----------------------------------------------------------------------------+
-| DO NOT ATTEMPT TO ADD OR REMOVE FROM THE QUEUE WITHOUT USING SIGNALS!!     |
-| THIS WILL CAUSE A DESYNC BETWEEN THE DOWNLOAD AGENT REGISTRY AND THE QUEUE |
-| WHICH HAS NOT BEEN ACCOUNTED FOR                                           |
-+----------------------------------------------------------------------------+
-
-This download queue does not actually own any of the DownloadAgents. It is
-simply an id-based reference system. The actual Agents are stored in the
-download_agent_registry HashMap, as ordering is no issue here. This is why
-appending or removing from the download_queue must be done via signals.
-
-Behold, my madness - quexeky
-
-*/
-
 pub struct DownloadManagerBuilder {
     download_agent_registry: HashMap<DownloadableMetadata, DownloadAgent>,
     download_queue: Queue,

src-tauri/drop-downloads/src/download_manager_frontend.rs

@@ -9,14 +9,11 @@ use std::{
     thread::JoinHandle,
 };
 
+use drop_database::models::data::DownloadableMetadata;
+use drop_errors::application_download_error::ApplicationDownloadError;
 use log::{debug, info};
 use serde::Serialize;
 
-use crate::{
-    database::models::data::DownloadableMetadata,
-    error::application_download_error::ApplicationDownloadError,
-};
-
 use super::{
     download_manager_builder::{CurrentProgressObject, DownloadAgent},
     util::queue::Queue,

src-tauri/drop-downloads/src/downloadable.rs

@@ -1,12 +1,9 @@
 use std::sync::Arc;
 
+use drop_database::models::data::DownloadableMetadata;
+use drop_errors::application_download_error::ApplicationDownloadError;
 use tauri::AppHandle;
 
-use crate::{
-    database::models::data::DownloadableMetadata,
-    error::application_download_error::ApplicationDownloadError,
-};
-
 use super::{
     download_manager_frontend::DownloadStatus,
     util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},

src-tauri/drop-downloads/src/events.rs

@@ -0,0 +1,24 @@
+use drop_database::models::data::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(Serialize, Clone)]
+pub struct StatsUpdateEvent {
+    pub speed: usize,
+    pub time: usize,
+}

src-tauri/drop-downloads/src/lib.rs

@@ -0,0 +1,7 @@
+#![feature(duration_millis_float)]
+
+pub mod download_manager_builder;
+pub mod download_manager_frontend;
+pub mod downloadable;
+pub mod events;
+pub mod util;

src-tauri/drop-downloads/src/util/progress_object.rs

@@ -10,7 +10,7 @@ use std::{
 use atomic_instant_full::AtomicInstant;
 use throttle_my_fn::throttle;
 
-use crate::download_manager::download_manager_frontend::DownloadManagerSignal;
+use crate::download_manager_frontend::DownloadManagerSignal;
 
 use super::rolling_progress_updates::RollingProgressWindow;
 

src-tauri/drop-downloads/src/util/queue.rs

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

src-tauri/drop-errors/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "drop-errors"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+http = "1.3.1"
+humansize = "2.1.3"
+reqwest = "0.12.23"
+reqwest-websocket = "0.5.1"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_with = "3.14.0"
+tauri-plugin-opener = "2.5.0"
+url = "2.5.7"

src-tauri/drop-errors/src/drop_server_error.rs

@@ -2,7 +2,7 @@ use serde::Deserialize;
 
 #[derive(Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
-pub struct DropServerError {
+pub struct ServerError {
     pub status_code: usize,
     pub status_message: String,
     // pub message: String,

src-tauri/drop-errors/src/process_error.rs

@@ -11,8 +11,7 @@ pub enum ProcessError {
     IOError(Error),
     FormatError(String), // String errors supremacy
     InvalidPlatform,
-    OpenerError(tauri_plugin_opener::Error),
-    PlaytimeError(String),
+    OpenerError(tauri_plugin_opener::Error)
 }
 
 impl Display for ProcessError {
@@ -26,7 +25,6 @@ impl Display for ProcessError {
             ProcessError::InvalidPlatform => "This game cannot be played on the current platform",
             ProcessError::FormatError(e) => &format!("Failed to format template: {e}"),
             ProcessError::OpenerError(error) => &format!("Failed to open directory: {error}"),
-            ProcessError::PlaytimeError(error) => &format!("Playtime tracking error: {error}"),
                     };
         write!(f, "{s}")
     }

src-tauri/drop-errors/src/remote_access_error.rs

@@ -8,7 +8,7 @@ use http::StatusCode;
 use serde_with::SerializeDisplay;
 use url::ParseError;
 
-use super::drop_server_error::DropServerError;
+use super::drop_server_error::ServerError;
 
 #[derive(Debug, SerializeDisplay)]
 pub enum RemoteAccessError {
@@ -18,7 +18,7 @@ pub enum RemoteAccessError {
     InvalidEndpoint,
     HandshakeFailed(String),
     GameNotFound(String),
-    InvalidResponse(DropServerError),
+    InvalidResponse(ServerError),
     UnparseableResponse(String),
     ManifestDownloadFailed(StatusCode, String),
     OutOfSync,

src-tauri/drop-library/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "drop-library"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+drop-errors = { path = "../drop-errors" }
+http = "*"
+reqwest = { version = "*", default-features = false }
+serde = { version = "*", default-features = false, features = ["derive"] }
+tauri = "*"

src-tauri/drop-library/src/errors.rs

@@ -0,0 +1,11 @@
+pub enum DropLibraryError {
+    NetworkError(reqwest::Error),
+    ServerError(drop_errors::drop_server_error::ServerError),
+    Unconfigured,
+}
+
+impl From<reqwest::Error> for DropLibraryError {
+    fn from(value: reqwest::Error) -> Self {
+        DropLibraryError::NetworkError(value)
+    }
+}

src-tauri/drop-library/src/game.rs

@@ -0,0 +1,30 @@
+use crate::libraries::LibraryProviderIdentifier;
+
+pub struct LibraryGamePreview {
+    pub library: LibraryProviderIdentifier,
+    pub internal_id: String,
+    pub name: String,
+    pub short_description: String,
+    pub icon: String,
+}
+
+pub struct LibraryGame {
+    pub library: LibraryProviderIdentifier,
+    pub internal_id: String,
+    pub name: String,
+    pub short_description: String,
+    pub md_description: String,
+    pub icon: String,
+}
+
+impl From<LibraryGame> for LibraryGamePreview {
+    fn from(value: LibraryGame) -> Self {
+        LibraryGamePreview {
+            library: value.library,
+            internal_id: value.internal_id,
+            name: value.name,
+            short_description: value.short_description,
+            icon: value.icon,
+        }
+    }
+}

src-tauri/drop-library/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod libraries;
+pub mod game;
+pub mod errors;

src-tauri/drop-library/src/libraries.rs

@@ -0,0 +1,76 @@
+use std::{
+    fmt::Display,
+    hash::{DefaultHasher, Hash, Hasher},
+};
+
+use http::Request;
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use tauri::UriSchemeResponder;
+
+use crate::{
+    errors::DropLibraryError,
+    game::{LibraryGame, LibraryGamePreview},
+};
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct LibraryProviderIdentifier {
+    internal_id: usize,
+    name: String,
+}
+
+impl PartialEq for LibraryProviderIdentifier {
+    fn eq(&self, other: &Self) -> bool {
+        self.internal_id == other.internal_id
+    }
+}
+
+impl Eq for LibraryProviderIdentifier {}
+
+impl Hash for LibraryProviderIdentifier {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.internal_id.hash(state);
+    }
+}
+
+impl Display for LibraryProviderIdentifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.name)
+    }
+}
+
+impl LibraryProviderIdentifier {
+    pub fn str_hash(&self) -> String {
+        let mut hasher = DefaultHasher::new();
+        self.hash(&mut hasher);
+        hasher.finish().to_string()
+    }
+}
+
+pub struct LibraryFetchConfig {
+    pub hard_refresh: bool,
+}
+
+pub trait DropLibraryProvider: Serialize + DeserializeOwned + Sized {
+    fn build(identifier: LibraryProviderIdentifier) -> Self;
+    fn id(&self) -> &LibraryProviderIdentifier;
+    fn load_object(
+        &self,
+        request: Request<Vec<u8>>,
+        responder: UriSchemeResponder,
+    ) -> impl Future<Output = Result<(), DropLibraryError>> + Send;
+
+    fn fetch_library(
+        &self,
+        config: &LibraryFetchConfig,
+    ) -> impl Future<Output = Result<Vec<LibraryGamePreview>, DropLibraryError>> + Send;
+    fn fetch_game(
+        &self,
+        config: &LibraryFetchConfig,
+    ) -> impl Future<Output = Result<LibraryGame, DropLibraryError>> + Send;
+
+    
+
+    fn owns_game(&self, id: &LibraryProviderIdentifier) -> bool {
+        self.id().internal_id == id.internal_id
+    }
+}

src-tauri/drop-native-library/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "drop-native-library"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bitcode = "*"
+drop-errors = { path = "../drop-errors" }
+drop-library = { path = "../drop-library" }
+drop-remote = { path = "../drop-remote" }
+log = "*"
+serde = { version = "*", features = ["derive"] }
+tauri = "*"
+url = "*"

src-tauri/drop-native-library/src/collections.rs

@@ -1,8 +1,7 @@
 use bitcode::{Decode, Encode};
+// use drop_database::runtime_models::Game;
 use serde::{Deserialize, Serialize};
 
-use crate::games::library::Game;
-
 pub type Collections = Vec<Collection>;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default, Encode, Decode)]

src-tauri/drop-native-library/src/events.rs

@@ -0,0 +1,11 @@
+use drop_database::models::data::{ApplicationTransientStatus, GameDownloadStatus, GameVersion};
+
+#[derive(serde::Serialize, Clone)]
+pub struct GameUpdateEvent {
+    pub game_id: String,
+    pub status: (
+        Option<GameDownloadStatus>,
+        Option<ApplicationTransientStatus>,
+    ),
+    pub version: Option<GameVersion>,
+}

src-tauri/drop-native-library/src/impls.rs

@@ -0,0 +1,50 @@
+use drop_library::{
+    errors::DropLibraryError, game::{LibraryGame, LibraryGamePreview}, libraries::{DropLibraryProvider, LibraryFetchConfig, LibraryProviderIdentifier}
+};
+use drop_remote::{fetch_object::fetch_object, DropRemoteContext};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct DropNativeLibraryProvider {
+    identifier: LibraryProviderIdentifier,
+    context: Option<DropRemoteContext>,
+}
+
+impl DropNativeLibraryProvider {
+    pub fn configure(&mut self, base_url: Url) {
+        self.context = Some(DropRemoteContext::new(base_url));
+    }
+}
+
+impl DropLibraryProvider for DropNativeLibraryProvider {
+    fn build(identifier: LibraryProviderIdentifier) -> Self {
+        Self {
+            identifier,
+            context: None,
+        }
+    }
+
+    fn id(&self) -> &LibraryProviderIdentifier {
+        &self.identifier
+    }
+    
+    async fn load_object(&self, request: tauri::http::Request<Vec<u8>>, responder: tauri::UriSchemeResponder) -> Result<(), DropLibraryError> {
+        let context = self.context.as_ref().ok_or(DropLibraryError::Unconfigured)?;
+        fetch_object(context, request, responder).await;
+        Ok(())
+    }
+    
+    async fn fetch_library(
+        &self,
+        config: &LibraryFetchConfig
+    ) -> Result<Vec<LibraryGamePreview>, DropLibraryError> {
+        todo!()
+    }
+    
+    async fn fetch_game(&self, config: &LibraryFetchConfig) -> Result<LibraryGame, DropLibraryError> {
+        todo!()
+    }
+
+    
+}

src-tauri/drop-native-library/src/lib.rs

@@ -0,0 +1,5 @@
+//pub mod collections;
+//pub mod library;
+//pub mod state;
+//pub mod events;
+pub mod impls;

src-tauri/drop-native-library/src/library.rs

@@ -1,30 +1,34 @@
 use std::fs::remove_dir_all;
-use std::sync::Mutex;
 use std::thread::spawn;
 
+use drop_database::borrow_db_checked;
+use drop_database::borrow_db_mut_checked;
+use drop_database::models::data::ApplicationTransientStatus;
+use drop_database::models::data::Database;
+use drop_database::models::data::DownloadableMetadata;
+use drop_database::models::data::GameDownloadStatus;
+use drop_database::models::data::GameVersion;
+use drop_database::runtime_models::Game;
+use drop_errors::drop_server_error::ServerError;
+use drop_errors::library_error::LibraryError;
+use drop_errors::remote_access_error::RemoteAccessError;
+use drop_remote::DropRemoteContext;
+use drop_remote::auth::generate_authorization_header;
+use drop_remote::cache::cache_object;
+use drop_remote::cache::cache_object_db;
+use drop_remote::cache::get_cached_object;
+use drop_remote::cache::get_cached_object_db;
+use drop_remote::requests::generate_url;
+use drop_remote::utils::DROP_CLIENT_ASYNC;
+use drop_remote::utils::DROP_CLIENT_SYNC;
 use log::{debug, error, warn};
 use serde::{Deserialize, Serialize};
 use tauri::AppHandle;
-use tauri::Emitter;
+use tauri::Emitter as _;
 
-use crate::AppState;
-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::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};
+use crate::events::GameUpdateEvent;
+use crate::state::GameStatusManager;
+use crate::state::GameStatusWithTransient;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FetchGameStruct {
@@ -33,53 +37,8 @@ pub struct FetchGameStruct {
     version: Option<GameVersion>,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
-#[serde(rename_all = "camelCase")]
-pub struct Game {
-    id: String,
-    m_name: String,
-    m_short_description: String,
-    m_description: String,
-    // mDevelopers
-    // mPublishers
-    m_icon_object_id: String,
-    m_banner_object_id: String,
-    m_cover_object_id: String,
-    m_image_library_object_ids: Vec<String>,
-    m_image_carousel_object_ids: Vec<String>,
-}
-#[derive(serde::Serialize, Clone)]
-pub struct GameUpdateEvent {
-    pub game_id: String,
-    pub status: (
-        Option<GameDownloadStatus>,
-        Option<ApplicationTransientStatus>,
-    ),
-    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<'_>>>,
+    context: &DropRemoteContext,
     hard_fresh: Option<bool>,
 ) -> Result<Vec<Game>, RemoteAccessError> {
     let do_hard_refresh = hard_fresh.unwrap_or(false);
@@ -88,15 +47,15 @@ pub async fn fetch_library_logic(
     }
 
     let client = DROP_CLIENT_ASYNC.clone();
-    let response = generate_url(&["/api/v1/client/user/library"], &[])?;
+    let response = generate_url(context, &["/api/v1/client/user/library"], &[])?;
     let response = client
         .get(response)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header(context))
         .send()
         .await?;
 
     if response.status() != 200 {
-        let err = response.json().await.unwrap_or(DropServerError {
+        let err = response.json().await.unwrap_or(ServerError {
             status_code: 500,
             status_message: "Invalid response from server.".to_owned(),
         });
@@ -106,12 +65,13 @@ pub async fn fetch_library_logic(
 
     let mut games: Vec<Game> = response.json().await?;
 
-    let mut handle = state.lock().unwrap();
-
     let mut db_handle = borrow_db_mut_checked();
 
     for game in &games {
-        handle.games.insert(game.id.clone(), game.clone());
+        db_handle
+            .applications
+            .games
+            .insert(game.id.clone(), game.clone());
         if !db_handle.applications.game_statuses.contains_key(&game.id) {
             db_handle
                 .applications
@@ -127,7 +87,7 @@ pub async fn fetch_library_logic(
         }
         // 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) {
+        let game = match get_cached_object_db::<Game>(&meta.id.clone()) {
             Ok(game) => game,
             Err(err) => {
                 warn!(
@@ -140,14 +100,12 @@ pub async fn fetch_library_logic(
         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")?;
@@ -168,12 +126,10 @@ pub async fn fetch_library_logic_offline(
     Ok(games)
 }
 pub async fn fetch_game_logic(
+    context: &DropRemoteContext,
     id: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
     let version = {
-        let state_handle = state.lock().unwrap();
-
         let db_lock = borrow_db_checked();
 
         let metadata_option = db_lock.applications.installed_game_version.get(&id);
@@ -187,7 +143,7 @@ pub async fn fetch_game_logic(
                 .cloned(),
         };
 
-        let game = state_handle.games.get(&id);
+        let game = db_lock.applications.games.get(&id);
         if let Some(game) = game {
             let status = GameStatusManager::fetch_state(&id, &db_lock);
 
@@ -206,15 +162,15 @@ pub async fn fetch_game_logic(
     };
 
     let client = DROP_CLIENT_ASYNC.clone();
-    let response = generate_url(&["/api/v1/client/game/", &id], &[])?;
+    let response = generate_url(context, &["/api/v1/client/game/", &id], &[])?;
     let response = client
         .get(response)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header(context))
         .send()
         .await?;
 
     if response.status() == 404 {
-        let offline_fetch = fetch_game_logic_offline(id.clone(), state).await;
+        let offline_fetch = fetch_game_logic_offline(id.clone()).await;
         if let Ok(fetch_data) = offline_fetch {
             return Ok(fetch_data);
         }
@@ -229,10 +185,11 @@ pub async fn fetch_game_logic(
 
     let game: Game = response.json().await?;
 
-    let mut state_handle = state.lock().unwrap();
-    state_handle.games.insert(id.clone(), game.clone());
-
     let mut db_handle = borrow_db_mut_checked();
+    db_handle
+        .applications
+        .games
+        .insert(id.clone(), game.clone());
 
     db_handle
         .applications
@@ -255,10 +212,7 @@ pub async fn fetch_game_logic(
     Ok(data)
 }
 
-pub async fn fetch_game_logic_offline(
-    id: String,
-    _state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<FetchGameStruct, RemoteAccessError> {
+pub async fn fetch_game_logic_offline(id: String) -> 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 {
@@ -284,15 +238,19 @@ pub async fn fetch_game_logic_offline(
 }
 
 pub async fn fetch_game_version_options_logic(
+    context: &DropRemoteContext,
     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 = generate_url(
+        context,
+        &["/api/v1/client/game/versions"],
+        &[("id", &game_id)],
+    )?;
     let response = client
         .get(response)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header(context))
         .send()
         .await?;
 
@@ -304,19 +262,6 @@ pub async fn fetch_game_version_options_logic(
 
     let data: Vec<GameVersion> = response.json().await?;
 
-    let state_lock = state.lock().unwrap();
-    let process_manager_lock = state_lock.process_manager.lock().unwrap();
-    let data: Vec<GameVersion> = data
-        .into_iter()
-        .filter(|v| {
-            process_manager_lock
-                .valid_platform(&v.platform, &state_lock)
-                .unwrap()
-        })
-        .collect();
-    drop(process_manager_lock);
-    drop(state_lock);
-
     Ok(data)
 }
 
@@ -449,6 +394,7 @@ pub fn get_current_meta(game_id: &String) -> Option<DownloadableMetadata> {
 }
 
 pub fn on_game_complete(
+    context: &DropRemoteContext,
     meta: &DownloadableMetadata,
     install_dir: String,
     app_handle: &AppHandle,
@@ -460,6 +406,7 @@ pub fn on_game_complete(
 
     let client = DROP_CLIENT_SYNC.clone();
     let response = generate_url(
+        context,
         &["/api/v1/client/game/version"],
         &[
             ("id", &meta.id),
@@ -468,7 +415,7 @@ pub fn on_game_complete(
     )?;
     let response = client
         .get(response)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header(context))
         .send()?;
 
     let game_version: GameVersion = response.json()?;
@@ -544,48 +491,3 @@ pub fn push_game_update(
         )
         .unwrap();
 }
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FrontendGameOptions {
-    launch_string: 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().unwrap();
-
-    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(())
-}

src-tauri/drop-native-library/src/state.rs

@@ -1,6 +1,4 @@
-use crate::database::models::data::{
-    ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus,
-};
+// use drop_database::models::data::{ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus};
 
 pub type GameStatusWithTransient = (
     Option<GameDownloadStatus>,

src-tauri/drop-process/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "drop-process"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+chrono = "0.4.42"
+drop-database = { path = "../drop-database" }
+drop-errors = { path = "../drop-errors" }
+drop-native-library = { path = "../drop-native-library" }
+dynfmt = { version = "0.1.5", features = ["curly"] }
+log = "0.4.28"
+page_size = "0.6.0"
+shared_child = "1.1.1"
+sysinfo = "0.37.0"
+tauri = "2.8.5"
+tauri-plugin-opener = "2.5.0"
+

src-tauri/drop-process/src/lib.rs

@@ -0,0 +1,4 @@
+mod format;
+mod process_handlers;
+pub mod process_manager;
+pub mod utils;

src-tauri/drop-process/src/process_handlers.rs

@@ -5,13 +5,11 @@ use std::{
     sync::LazyLock,
 };
 
+use drop_database::{models::data::{Database, DownloadableMetadata, GameVersion}, process::Platform};
 use log::{debug, info};
 
-use crate::{
-    AppState,
-    database::models::data::{Database, DownloadableMetadata, GameVersion},
-    process::process_manager::{Platform, ProcessHandler},
-};
+use crate::process_manager::ProcessHandler;
+
 
 pub struct NativeGameLauncher;
 impl ProcessHandler for NativeGameLauncher {
@@ -26,7 +24,7 @@ impl ProcessHandler for NativeGameLauncher {
         format!("\"{}\" {}", launch_command, args.join(" "))
     }
 
-    fn valid_for_platform(&self, _db: &Database, _state: &AppState, _target: &Platform) -> bool {
+    fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
         true
     }
 }
@@ -85,11 +83,8 @@ impl ProcessHandler for UMULauncher {
         )
     }
 
-    fn valid_for_platform(&self, _db: &Database, state: &AppState, _target: &Platform) -> bool {
-        let Some(ref compat_info) = state.compat_info else {
-            return false;
-        };
-        compat_info.umu_installed
+    fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
+        UMU_LAUNCHER_EXECUTABLE.is_some()
     }
 }
 
@@ -123,7 +118,7 @@ impl ProcessHandler for AsahiMuvmLauncher {
 
     #[allow(unreachable_code)]
     #[allow(unused_variables)]
-    fn valid_for_platform(&self, _db: &Database, state: &AppState, _target: &Platform) -> bool {
+    fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
         #[cfg(not(target_os = "linux"))]
         return false;
 
@@ -135,10 +130,6 @@ impl ProcessHandler for AsahiMuvmLauncher {
             return false;
         }
 
-        let Some(ref compat_info) = state.compat_info else {
-            return false;
-        };
-
-        compat_info.umu_installed
+        UMU_LAUNCHER_EXECUTABLE.is_some()
     }
 }

src-tauri/drop-process/src/process_manager.rs

@@ -10,31 +10,17 @@ use std::{
     time::{Duration, SystemTime},
 };
 
+use drop_database::{borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR, models::data::{ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus, GameVersion}, process::Platform, DB};
+use drop_errors::process_error::ProcessError;
+use drop_native_library::{library::push_game_update, state::GameStatusManager};
 use dynfmt::Format;
 use dynfmt::SimpleCurlyFormat;
 use log::{debug, info, warn};
-use serde::{Deserialize, Serialize};
 use shared_child::SharedChild;
-use tauri::{AppHandle, Emitter, Manager};
+use tauri::{AppHandle, Emitter};
 use tauri_plugin_opener::OpenerExt;
 
-use crate::{
-    AppState, DB,
-    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},
-    playtime::events::{push_session_end, push_playtime_update},
-    process::{
-        format::DropFormatArgs,
-        process_handlers::{AsahiMuvmLauncher, NativeGameLauncher, UMULauncher},
-    },
-};
+use crate::{format::DropFormatArgs, process_handlers::{AsahiMuvmLauncher, NativeGameLauncher, UMULauncher}};
 
 pub struct RunningProcess {
     handle: Arc<SharedChild>,
@@ -195,7 +181,6 @@ impl ProcessManager<'_> {
     fn fetch_process_handler(
         &self,
         db_lock: &Database,
-        state: &AppState,
         target_platform: &Platform,
     ) -> Result<&(dyn ProcessHandler + Send + Sync), ProcessError> {
         Ok(self
@@ -205,22 +190,22 @@ impl ProcessManager<'_> {
                 let (e_current, e_target) = e.0;
                 e_current == self.current_platform
                     && e_target == *target_platform
-                    && e.1.valid_for_platform(db_lock, state, target_platform)
+                    && e.1.valid_for_platform(db_lock, target_platform)
             })
             .ok_or(ProcessError::InvalidPlatform)?
             .1)
     }
 
-    pub fn valid_platform(&self, platform: &Platform, state: &AppState) -> Result<bool, String> {
+    pub fn valid_platform(&self, platform: &Platform,) -> Result<bool, String> {
         let db_lock = borrow_db_checked();
-        let process_handler = self.fetch_process_handler(&db_lock, state, platform);
+        let process_handler = self.fetch_process_handler(&db_lock, platform);
         Ok(process_handler.is_ok())
     }
 
     pub fn launch_process(
         &mut self,
         game_id: String,
-        state: &AppState,
+        process_manager_lock: &'static Mutex<ProcessManager<'static>>,
     ) -> Result<(), ProcessError> {
         if self.processes.contains_key(&game_id) {
             return Err(ProcessError::AlreadyRunning);
@@ -305,7 +290,7 @@ impl ProcessManager<'_> {
 
         let target_platform = game_version.platform;
 
-        let process_handler = self.fetch_process_handler(&db_lock, state, &target_platform)?;
+        let process_handler = self.fetch_process_handler(&db_lock, &target_platform)?;
 
         let (launch, args) = match game_status {
             GameDownloadStatus::Installed {
@@ -386,31 +371,17 @@ impl ProcessManager<'_> {
         );
 
         let wait_thread_handle = launch_process_handle.clone();
-        let wait_thread_apphandle = self.app_handle.clone();
         let wait_thread_game_id = meta.clone();
 
         spawn(move || {
             let result: Result<ExitStatus, std::io::Error> = launch_process_handle.wait();
 
-            let app_state = wait_thread_apphandle.state::<Mutex<AppState>>();
-            let app_state_handle = app_state.lock().unwrap();
-
-            // End playtime tracking before processing finish
-            let playtime_manager_lock = app_state_handle.playtime_manager.lock().unwrap();
-            if let Ok(stats) = playtime_manager_lock.end_session(wait_thread_game_id.id.clone()) {
-                debug!("Ended playtime tracking for game: {} (process finished)", wait_thread_game_id.id);
-                push_session_end(&app_state_handle.app_handle, &wait_thread_game_id.id, &stats);
-                push_playtime_update(&app_state_handle.app_handle, &wait_thread_game_id.id, stats, false);
-            }
-            drop(playtime_manager_lock);
-
-            let mut process_manager_handle = app_state_handle.process_manager.lock().unwrap();
+            let mut process_manager_handle = process_manager_lock.lock().unwrap();
             process_manager_handle.on_process_finish(wait_thread_game_id.id, result);
 
             // As everything goes out of scope, they should get dropped
             // But just to explicit about it
             drop(process_manager_handle);
-            drop(app_state_handle);
         });
 
         self.processes.insert(
@@ -425,51 +396,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,
@@ -480,5 +406,5 @@ pub trait ProcessHandler: Send + 'static {
         current_dir: &str,
     ) -> String;
 
-    fn valid_for_platform(&self, db: &Database, state: &AppState, target: &Platform) -> bool;
+    fn valid_for_platform(&self, db: &Database, target: &Platform) -> bool;
 }

src-tauri/drop-process/src/utils.rs

@@ -1,10 +1,8 @@
-use std::{path::PathBuf, sync::Arc};
+use std::{io, path::PathBuf, sync::Arc};
 
-use futures_lite::io;
+use drop_errors::application_download_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/drop-remote/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "drop-remote"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bitcode = "0.6.7"
+chrono = "0.4.42"
+drop-consts = { path = "../drop-consts" }
+drop-errors = { path = "../drop-errors" }
+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"
+serde = { version = "1.0.220", features = ["derive"] }
+tauri = "2.8.5"
+url = "2.5.7"

src-tauri/drop-remote/src/auth.rs

@@ -0,0 +1,156 @@
+use std::{collections::HashMap, env, sync::Mutex};
+
+use chrono::Utc;
+use drop_errors::{drop_server_error::ServerError, remote_access_error::RemoteAccessError};
+use droplet_rs::ssl::sign_nonce;
+use gethostname::gethostname;
+use log::{debug, error, warn};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::{
+    requests::make_authenticated_get, utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC}, DropRemoteAuth, DropRemoteContext
+};
+
+use super::requests::generate_url;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct CapabilityConfiguration {}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct InitiateRequestBody {
+    name: String,
+    platform: String,
+    capabilities: HashMap<String, CapabilityConfiguration>,
+    mode: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct HandshakeRequestBody {
+    client_id: String,
+    token: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct HandshakeResponse {
+    private: String,
+    certificate: String,
+    id: String,
+}
+
+pub fn generate_authorization_header(context: &DropRemoteContext) -> String {
+    let auth = if let Some(auth) = &context.auth {
+        auth
+    } else {
+        return "".to_owned();
+    };
+    let nonce = Utc::now().timestamp_millis().to_string();
+
+    let signature = sign_nonce(auth.private.clone(), nonce.clone()).unwrap();
+
+    format!("Nonce {} {} {}", auth.client_id, nonce, signature)
+}
+
+pub async fn fetch_user(context: &DropRemoteContext) -> Result<Vec<u8>, RemoteAccessError> {
+    let response =
+        make_authenticated_get(context, generate_url(context, &["/api/v1/client/user"], &[])?).await?;
+    if response.status() != 200 {
+        let err: ServerError = response.json().await?;
+        warn!("{err:?}");
+
+        if err.status_message == "Nonce expired" {
+            return Err(RemoteAccessError::OutOfSync);
+        }
+
+        return Err(RemoteAccessError::InvalidResponse(err));
+    }
+
+    response
+        .bytes()
+        .await
+        .map_err(std::convert::Into::into)
+        .map(|v| v.to_vec())
+}
+
+pub async fn recieve_handshake_logic(
+    context: &mut DropRemoteContext,
+    path: String,
+) -> Result<(), RemoteAccessError> {
+    let path_chunks: Vec<&str> = path.split('/').collect();
+    if path_chunks.len() != 3 {
+        //        app.emit("auth/failed", ()).unwrap();
+        return Err(RemoteAccessError::HandshakeFailed(
+            "failed to parse token".to_string(),
+        ));
+    }
+
+    let client_id = path_chunks.get(1).unwrap();
+    let token = path_chunks.get(2).unwrap();
+    let body = HandshakeRequestBody {
+        client_id: (*client_id).to_string(),
+        token: (*token).to_string(),
+    };
+
+    let endpoint = generate_url(context, &["/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 web_token = {
+        let header = generate_authorization_header(context);
+        let token = client
+            .post(generate_url(context, &["/api/v1/client/user/webtoken"], &[])?)
+            .header("Authorization", header)
+            .send()
+            .await
+            .unwrap();
+
+        token.text().await.unwrap()
+    };
+
+    context.auth = Some(DropRemoteAuth {
+        private: response_struct.private,
+        cert: response_struct.certificate,
+        client_id: response_struct.id,
+        web_token: web_token,
+    });
+
+    Ok(())
+}
+
+pub fn auth_initiate_logic(context: &DropRemoteContext, mode: String) -> Result<String, RemoteAccessError> {
+    let hostname = gethostname();
+
+    let endpoint = generate_url(context, &["/api/v1/client/auth/initiate"], &[])?;
+    let body = InitiateRequestBody {
+        name: format!("{} (Desktop)", hostname.into_string().unwrap()),
+        platform: env::consts::OS.to_string(),
+        capabilities: HashMap::from([
+            ("peerAPI".to_owned(), CapabilityConfiguration {}),
+            ("cloudSaves".to_owned(), CapabilityConfiguration {}),
+        ]),
+        mode,
+    };
+
+    let client = DROP_CLIENT_SYNC.clone();
+    let response = client.post(endpoint.to_string()).json(&body).send()?;
+
+    if response.status() != 200 {
+        let data: ServerError = response.json()?;
+        error!("could not start handshake: {}", data.status_message);
+
+        return Err(RemoteAccessError::HandshakeFailed(data.status_message));
+    }
+
+    let response = response.text()?;
+
+    Ok(response)
+}

src-tauri/drop-remote/src/cache.rs

@@ -5,18 +5,18 @@ use std::{
     time::SystemTime,
 };
 
-use crate::{
-    database::{db::borrow_db_checked, models::data::Database},
-    error::remote_access_error::RemoteAccessError,
-};
 use bitcode::{Decode, DecodeOwned, Encode};
+use drop_consts::CACHE_DIR;
+use drop_errors::remote_access_error::RemoteAccessError;
 use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
 
 #[macro_export]
 macro_rules! offline {
     ($var:expr, $func1:expr, $func2:expr, $( $arg:expr ),* ) => {
 
-        async move { if $crate::borrow_db_checked().settings.force_offline || $var.lock().unwrap().status == $crate::AppStatus::Offline {
+        // TODO add offline mode back
+        // || $var.lock().unwrap().status == AppStatus::Offline
+        async move { if drop_database::borrow_db_checked().settings.force_offline {
             $func2( $( $arg ), *).await
         } else {
             $func1( $( $arg ), *).await
@@ -57,36 +57,33 @@ fn delete_sync(base: &Path, key: &str) -> io::Result<()> {
 }
 
 pub fn cache_object<D: Encode>(key: &str, data: &D) -> Result<(), RemoteAccessError> {
-    cache_object_db(key, data, &borrow_db_checked())
+    cache_object_db(key, data)
 }
 pub fn cache_object_db<D: Encode>(
     key: &str,
     data: &D,
-    database: &Database,
 ) -> Result<(), RemoteAccessError> {
     let bytes = bitcode::encode(data);
-    write_sync(&database.cache_dir, key, bytes).map_err(RemoteAccessError::Cache)
+    write_sync(&CACHE_DIR, key, bytes).map_err(RemoteAccessError::Cache)
 }
 pub fn get_cached_object<D: Encode + DecodeOwned>(key: &str) -> Result<D, RemoteAccessError> {
-    get_cached_object_db::<D>(key, &borrow_db_checked())
+    get_cached_object_db::<D>(key)
 }
 pub fn get_cached_object_db<D: DecodeOwned>(
     key: &str,
-    db: &Database,
 ) -> Result<D, RemoteAccessError> {
-    let bytes = read_sync(&db.cache_dir, key).map_err(RemoteAccessError::Cache)?;
+    let bytes = read_sync(&CACHE_DIR, key).map_err(RemoteAccessError::Cache)?;
     let data =
         bitcode::decode::<D>(&bytes).map_err(|e| RemoteAccessError::Cache(io::Error::other(e)))?;
     Ok(data)
 }
 pub fn clear_cached_object(key: &str) -> Result<(), RemoteAccessError> {
-    clear_cached_object_db(key, &borrow_db_checked())
+    clear_cached_object_db(key)
 }
 pub fn clear_cached_object_db(
     key: &str,
-    db: &Database,
 ) -> Result<(), RemoteAccessError> {
-    delete_sync(&db.cache_dir, key).map_err(RemoteAccessError::Cache)?;
+    delete_sync(&CACHE_DIR, key).map_err(RemoteAccessError::Cache)?;
     Ok(())
 }
 

src-tauri/drop-remote/src/fetch_object.rs

@@ -1,15 +1,16 @@
-use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder};
+use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder, Request};
 use log::warn;
 use tauri::UriSchemeResponder;
 
-use crate::{database::db::DatabaseImpls, remote::utils::DROP_CLIENT_ASYNC, DB};
+
+use crate::{requests::generate_url, utils::DROP_CLIENT_ASYNC, DropRemoteContext};
 
 use super::{
     auth::generate_authorization_header,
     cache::{ObjectCache, cache_object, get_cached_object},
 };
 
-pub async fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
+pub async fn fetch_object(context: &DropRemoteContext, request: Request<Vec<u8>>, responder: UriSchemeResponder) {
     // Drop leading /
     let object_id = &request.uri().path()[1..];
 
@@ -21,9 +22,9 @@ pub async fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeR
         return;
     }
 
-    let header = generate_authorization_header();
+    let header = generate_authorization_header(context);
     let client = DROP_CLIENT_ASYNC.clone();
-    let url = format!("{}api/v1/client/object/{object_id}", DB.fetch_base_url());
+    let url = generate_url(context, &["/api/v1/client/object", object_id], &[]).expect("failed to generated object url");
     let response = client.get(url).header("Authorization", header).send().await;
 
     if response.is_err() {

src-tauri/drop-remote/src/lib.rs

@@ -0,0 +1,29 @@
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+pub mod auth;
+pub mod cache;
+pub mod fetch_object;
+pub mod requests;
+pub mod utils;
+
+#[derive(Serialize, Deserialize, Clone)]
+struct DropRemoteAuth {
+    private: String,
+    cert: String,
+    client_id: String,
+    web_token: String,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct DropRemoteContext {
+    base_url: Url,
+    auth: Option<DropRemoteAuth>,
+}
+
+
+impl DropRemoteContext {
+    pub fn new(base_url: Url) -> Self {
+        DropRemoteContext { base_url, auth: None }
+    }
+}

src-tauri/drop-remote/src/requests.rs

@@ -1,17 +1,14 @@
+use drop_errors::remote_access_error::RemoteAccessError;
 use url::Url;
 
-use crate::{
-    DB,
-    database::db::DatabaseImpls,
-    error::remote_access_error::RemoteAccessError,
-    remote::{auth::generate_authorization_header, utils::DROP_CLIENT_ASYNC},
-};
+use crate::{auth::generate_authorization_header, utils::DROP_CLIENT_ASYNC, DropRemoteContext};
 
 pub fn generate_url<T: AsRef<str>>(
+    context: &DropRemoteContext,
     path_components: &[T],
     query: &[(T, T)],
 ) -> Result<Url, RemoteAccessError> {
-    let mut base_url = DB.fetch_base_url();
+    let mut base_url = context.base_url.clone();
     for endpoint in path_components {
         base_url = base_url.join(endpoint.as_ref())?;
     }
@@ -24,10 +21,10 @@ pub fn generate_url<T: AsRef<str>>(
     Ok(base_url)
 }
 
-pub async fn make_authenticated_get(url: Url) -> Result<reqwest::Response, reqwest::Error> {
+pub async fn make_authenticated_get(context: &DropRemoteContext, url: Url) -> Result<reqwest::Response, reqwest::Error> {
     DROP_CLIENT_ASYNC
         .get(url)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header(context))
         .send()
         .await
 }

src-tauri/drop-remote/src/utils.rs

@@ -1,26 +1,12 @@
 use std::{
     fs::{self, File},
     io::Read,
-    sync::{LazyLock, Mutex},
-    time::Duration,
+    sync::LazyLock,
 };
 
-use log::{debug, info, warn};
+use drop_consts::DATA_ROOT_DIR;
+use log::{debug, info};
 use reqwest::Certificate;
-use serde::Deserialize;
-use url::Url;
-
-use crate::{
-    AppState, AppStatus,
-    database::db::{DATA_ROOT_DIR, borrow_db_mut_checked},
-    error::remote_access_error::RemoteAccessError,
-};
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct DropHealthcheck {
-    app_name: String,
-}
 
 static DROP_CERT_BUNDLE: LazyLock<Vec<Certificate>> = LazyLock::new(fetch_certificates);
 pub static DROP_CLIENT_SYNC: LazyLock<reqwest::blocking::Client> = LazyLock::new(get_client_sync);
@@ -82,37 +68,4 @@ pub fn get_client_ws() -> reqwest::Client {
         client = client.add_root_certificate(cert.clone());
     }
     client.use_rustls_tls().http1_only().build().unwrap()
-}
-
-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 = state.lock().unwrap();
-    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/auth.rs

@@ -0,0 +1,59 @@
+use std::sync::Mutex;
+
+use drop_database::{borrow_db_checked, runtime_models::User};
+use drop_errors::remote_access_error::RemoteAccessError;
+use drop_remote::{auth::{fetch_user, recieve_handshake_logic}, cache::{cache_object, clear_cached_object, get_cached_object}};
+use log::warn;
+use tauri::{AppHandle, Emitter as _, Manager as _};
+
+use crate::{AppState, AppStatus};
+
+pub async fn setup() -> (AppStatus, Option<User>) {
+    let auth = {
+        let data = borrow_db_checked();
+        data.auth.clone()
+    };
+
+    if auth.is_some() {
+        let user_result = match fetch_user().await {
+            Ok(data) => data,
+            Err(RemoteAccessError::FetchError(_)) => {
+                let user = get_cached_object::<User>("user").unwrap();
+                return (AppStatus::Offline, Some(user));
+            }
+            Err(_) => return (AppStatus::SignedInNeedsReauth, None),
+        };
+        cache_object("user", &user_result).unwrap();
+        return (AppStatus::SignedIn, Some(user_result));
+    }
+
+    (AppStatus::SignedOut, None)
+}
+
+pub async fn recieve_handshake(app: AppHandle, path: String) {
+    // Tell the app we're processing
+    app.emit("auth/processing", ()).unwrap();
+
+    let handshake_result = recieve_handshake_logic(path).await;
+    if let Err(e) = handshake_result {
+        warn!("error with authentication: {e}");
+        app.emit("auth/failed", e.to_string()).unwrap();
+        return;
+    }
+
+    let app_state = app.state::<Mutex<AppState>>();
+
+    let (app_status, user) = setup().await;
+
+    let mut state_lock = app_state.lock().unwrap();
+
+    state_lock.status = app_status;
+    state_lock.user = user;
+
+    let _ = clear_cached_object("collections");
+    let _ = clear_cached_object("library");
+
+    drop(state_lock);
+
+    app.emit("auth/finished", ()).unwrap();
+}

src-tauri/src/client/autostart.rs

@@ -1,4 +1,4 @@
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
+use drop_database::{borrow_db_checked, borrow_db_mut_checked};
 use log::debug;
 use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;

src-tauri/src/client/cleanup.rs

@@ -4,11 +4,11 @@ use tauri::AppHandle;
 use crate::AppState;
 
 #[tauri::command]
-pub fn quit(app: tauri::AppHandle, state: tauri::State<'_, std::sync::Mutex<AppState<'_>>>) {
+pub fn quit(app: tauri::AppHandle, state: tauri::State<'_, std::sync::Mutex<AppState>>) {
     cleanup_and_exit(&app, &state);
 }
 
-pub fn cleanup_and_exit(app: &AppHandle, state: &tauri::State<'_, std::sync::Mutex<AppState<'_>>>) {
+pub fn cleanup_and_exit(app: &AppHandle, state: &tauri::State<'_, std::sync::Mutex<AppState>>) {
     debug!("cleaning up and exiting application");
     let download_manager = state.lock().unwrap().download_manager.clone();
     match download_manager.ensure_terminated() {

src-tauri/src/client/commands.rs

@@ -2,7 +2,7 @@ use crate::AppState;
 
 #[tauri::command]
 pub fn fetch_state(
-    state: tauri::State<'_, std::sync::Mutex<AppState<'_>>>,
+    state: tauri::State<'_, std::sync::Mutex<AppState>>,
 ) -> Result<String, String> {
     let guard = state.lock().unwrap();
     let cloned_state = serde_json::to_string(&guard.clone()).map_err(|e| e.to_string())?;

src-tauri/src/database/commands.rs

@@ -4,17 +4,12 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use drop_database::{borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR, debug::SystemData, models::data::Settings};
+use drop_errors::download_manager_error::DownloadManagerError;
 use serde_json::Value;
 
-use crate::{
-    database::{db::borrow_db_mut_checked, scan::scan_install_dirs}, error::download_manager_error::DownloadManagerError,
-};
+use crate::database::scan::scan_install_dirs;
 
-use super::{
-    db::{borrow_db_checked, DATA_ROOT_DIR},
-    debug::SystemData,
-    models::data::Settings,
-};
 
 // Will, in future, return disk/remaining size
 // Just returns the directories that have been set up

src-tauri/src/database/mod.rs

@@ -1,5 +1,2 @@
 pub mod commands;
-pub mod db;
-pub mod debug;
-pub mod models;
 pub mod scan;

src-tauri/src/database/scan.rs

@@ -1,18 +1,9 @@
 use std::fs;
 
+use drop_database::{borrow_db_mut_checked, drop_data::{DropData, DROP_DATA_PATH}, models::data::{DownloadType, DownloadableMetadata}};
+use drop_native_library::library::set_partially_installed_db;
 use log::warn;
 
-use crate::{
-    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() {
     let mut db_lock = borrow_db_mut_checked();
     for install_dir in db_lock.applications.install_dirs.clone() {

src-tauri/src/download_manager/commands.rs

@@ -1,6 +1,8 @@
 use std::sync::Mutex;
 
-use crate::{database::models::data::DownloadableMetadata, AppState};
+use drop_database::models::data::DownloadableMetadata;
+
+use crate::AppState;
 
 #[tauri::command]
 pub fn pause_downloads(state: tauri::State<'_, Mutex<AppState>>) {

src-tauri/src/download_manager/mod.rs

@@ -1,5 +1 @@
 pub mod commands;
-pub mod download_manager_builder;
-pub mod download_manager_frontend;
-pub mod downloadable;
-pub mod util;

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

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

src-tauri/src/games/commands.rs

@@ -1,78 +0,0 @@
-use std::sync::Mutex;
-
-use tauri::AppHandle;
-
-use crate::{
-    AppState,
-    database::{
-        db::borrow_db_checked,
-        models::data::GameVersion,
-    },
-    error::{library_error::LibraryError, remote_access_error::RemoteAccessError},
-    games::library::{
-        fetch_game_logic_offline, fetch_library_logic_offline, get_current_meta,
-        uninstall_game_logic,
-    },
-    offline,
-};
-
-use super::{
-    library::{
-        FetchGameStruct, Game, fetch_game_logic, fetch_game_version_options_logic,
-        fetch_library_logic,
-    },
-    state::{GameStatusManager, GameStatusWithTransient},
-};
-
-#[tauri::command]
-pub async fn fetch_library(
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-    hard_refresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
-    offline!(
-        state,
-        fetch_library_logic,
-        fetch_library_logic_offline,
-        state,
-        hard_refresh
-    ).await
-}
-
-#[tauri::command]
-pub async fn fetch_game(
-    game_id: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<FetchGameStruct, RemoteAccessError> {
-    offline!(
-        state,
-        fetch_game_logic,
-        fetch_game_logic_offline,
-        game_id,
-        state
-    ).await
-}
-
-#[tauri::command]
-pub fn fetch_game_status(id: String) -> GameStatusWithTransient {
-    let db_handle = borrow_db_checked();
-    GameStatusManager::fetch_state(&id, &db_handle)
-}
-
-#[tauri::command]
-pub fn uninstall_game(game_id: String, app_handle: AppHandle) -> Result<(), LibraryError> {
-    let meta = match get_current_meta(&game_id) {
-        Some(data) => data,
-        None => return Err(LibraryError::MetaNotFound(game_id)),
-    };
-    uninstall_game_logic(meta, &app_handle);
-
-    Ok(())
-}
-
-#[tauri::command]
-pub async fn fetch_game_version_options(
-    game_id: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<Vec<GameVersion>, RemoteAccessError> {
-    fetch_game_version_options_logic(game_id, state).await
-}

src-tauri/src/games/mod.rs

@@ -1,5 +0,0 @@
-pub mod collections;
-pub mod commands;
-pub mod downloads;
-pub mod library;
-pub mod state;

src-tauri/src/lib.rs

@@ -5,84 +5,59 @@
 #![feature(iterator_try_collect)]
 #![deny(clippy::all)]
 
-mod database;
-mod games;
-
+mod auth;
 mod client;
+mod database;
 mod download_manager;
-mod error;
-mod playtime;
+mod native_library;
 mod process;
 mod remote;
+mod setup;
 
-use crate::database::scan::scan_install_dirs;
-use crate::process::commands::open_process_logs;
-use crate::process::process_handlers::UMU_LAUNCHER_EXECUTABLE;
+use crate::auth::recieve_handshake;
+use crate::native_library::collection_commands::{add_game_to_collection, create_collection, delete_collection, delete_game_in_collection, fetch_collection, fetch_collections};
+use crate::native_library::commands::{
+    fetch_game, fetch_game_status, fetch_game_version_options, fetch_library, uninstall_game,
+};
+use crate::native_library::downloads::commands::{download_game, resume_download};
+use crate::process::commands::{open_process_logs, update_game_configuration};
 use crate::remote::commands::auth_initiate_code;
-use crate::{database::db::DatabaseImpls, games::downloads::commands::resume_download};
-use bitcode::{Decode, Encode};
+use crate::remote::server_proto::{handle_server_proto, handle_server_proto_offline};
 use client::commands::fetch_state;
 use client::{
-    autostart::{get_autostart_enabled, sync_autostart_on_startup, toggle_autostart},
+    autostart::{get_autostart_enabled, toggle_autostart},
     cleanup::{cleanup_and_exit, quit},
 };
 use database::commands::{
     add_download_dir, delete_download_dir, fetch_download_dir_stats, fetch_settings,
     fetch_system_data, update_settings,
 };
-use database::db::{DATA_ROOT_DIR, DatabaseInterface, borrow_db_checked, borrow_db_mut_checked};
-use database::models::data::GameDownloadStatus;
 use download_manager::commands::{
     cancel_game, move_download_in_queue, pause_downloads, resume_downloads,
 };
-use download_manager::download_manager_builder::DownloadManagerBuilder;
-use download_manager::download_manager_frontend::DownloadManager;
-use games::collections::commands::{
-    add_game_to_collection, create_collection, delete_collection, delete_game_in_collection,
-    fetch_collection, fetch_collections,
-};
-use games::commands::{
-    fetch_game, fetch_game_status, fetch_game_version_options, fetch_library, uninstall_game,
-};
-use games::downloads::commands::download_game;
-use games::library::{Game, update_game_configuration};
-use log::{LevelFilter, debug, info, warn};
-use playtime::manager::PlaytimeManager;
-use playtime::commands::{
-    start_playtime_tracking, end_playtime_tracking, fetch_game_playtime, 
-    fetch_all_playtime_stats, is_playtime_session_active, get_active_playtime_sessions,
-    cleanup_orphaned_playtime_sessions
-};
-use log4rs::Config;
-use log4rs::append::console::ConsoleAppender;
-use log4rs::append::file::FileAppender;
-use log4rs::config::{Appender, Root};
-use log4rs::encode::pattern::PatternEncoder;
+use drop_database::borrow_db_mut_checked;
+use drop_database::db::DATA_ROOT_DIR;
+use drop_database::runtime_models::User;
+use drop_downloads::download_manager_frontend::DownloadManager;
+use drop_process::process_manager::ProcessManager;
+use drop_remote::{fetch_object::fetch_object, offline};
+use log::{debug, info, warn};
 use process::commands::{kill_game, launch_game};
-use process::process_manager::ProcessManager;
-use remote::auth::{self, recieve_handshake};
 use remote::commands::{
     auth_initiate, fetch_drop_object, gen_drop_url, manual_recieve_handshake, retry_connect,
     sign_out, use_remote,
 };
-use remote::fetch_object::fetch_object;
-use remote::server_proto::{handle_server_proto, handle_server_proto_offline};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::fs::File;
 use std::io::Write;
 use std::panic::PanicHookInfo;
-use std::path::Path;
-use std::str::FromStr;
 use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::SystemTime;
-use std::{
-    collections::HashMap,
-    sync::{LazyLock, Mutex},
-};
 use std::{env, panic};
 use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};
 use tauri::tray::TrayIconBuilder;
-use tauri::{AppHandle, Manager, RunEvent, WindowEvent};
+use tauri::{Manager, RunEvent, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
 
@@ -97,179 +72,18 @@ pub enum AppStatus {
     ServerUnavailable,
 }
 
-#[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,
-}
-
-fn create_new_compat_info() -> Option<CompatInfo> {
-    #[cfg(target_os = "windows")]
-    return None;
-
-    let has_umu_installed = UMU_LAUNCHER_EXECUTABLE.is_some();
-    Some(CompatInfo {
-        umu_installed: has_umu_installed,
-    })
-}
-
 #[derive(Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppState<'a> {
+pub struct AppState {
     status: AppStatus,
     user: Option<User>,
-    games: HashMap<String, Game>,
 
     #[serde(skip_serializing)]
     download_manager: Arc<DownloadManager>,
     #[serde(skip_serializing)]
-    process_manager: Arc<Mutex<ProcessManager<'a>>>,
-    #[serde(skip_serializing)]
-    playtime_manager: Arc<Mutex<PlaytimeManager>>,
-    #[serde(skip_serializing)]
-    compat_info: Option<CompatInfo>,
-    #[serde(skip_serializing)]
-    app_handle: AppHandle,
+    process_manager: &'static Mutex<ProcessManager<'static>>,
 }
 
-async fn setup(handle: AppHandle) -> AppState<'static> {
-    let logfile = FileAppender::builder()
-        .encoder(Box::new(PatternEncoder::new(
-            "{d} | {l} | {f}:{L} - {m}{n}",
-        )))
-        .append(false)
-        .build(DATA_ROOT_DIR.join("./drop.log"))
-        .unwrap();
-
-    let console = ConsoleAppender::builder()
-        .encoder(Box::new(PatternEncoder::new(
-            "{d} | {l} | {f}:{L} - {m}{n}",
-        )))
-        .build();
-
-    let log_level = env::var("RUST_LOG").unwrap_or(String::from("Info"));
-
-    let config = Config::builder()
-        .appenders(vec![
-            Appender::builder().build("logfile", Box::new(logfile)),
-            Appender::builder().build("console", Box::new(console)),
-        ])
-        .build(
-            Root::builder()
-                .appenders(vec!["logfile", "console"])
-                .build(LevelFilter::from_str(&log_level).expect("Invalid log level")),
-        )
-        .unwrap();
-
-    log4rs::init_config(config).unwrap();
-
-    let games = HashMap::new();
-    let download_manager = Arc::new(DownloadManagerBuilder::build(handle.clone()));
-    let process_manager = Arc::new(Mutex::new(ProcessManager::new(handle.clone())));
-    let playtime_manager = Arc::new(Mutex::new(PlaytimeManager::new(handle.clone())));
-    let compat_info = create_new_compat_info();
-
-    debug!("checking if database is set up");
-    let is_set_up = DB.database_is_set_up();
-
-    scan_install_dirs();
-
-    if !is_set_up {
-        return AppState {
-            status: AppStatus::NotConfigured,
-            user: None,
-            games,
-            download_manager,
-            process_manager,
-            playtime_manager,
-            compat_info,
-            app_handle: handle.clone(),
-        };
-    }
-
-    debug!("database is set up");
-
-    // TODO: Account for possible failure
-    let (app_status, user) = auth::setup().await;
-
-    let db_handle = borrow_db_checked();
-    let mut missing_games = Vec::new();
-    let statuses = db_handle.applications.game_statuses.clone();
-    drop(db_handle);
-
-    for (game_id, status) in statuses {
-        match status {
-            GameDownloadStatus::Remote {} => {}
-            GameDownloadStatus::PartiallyInstalled { .. } => {}
-            GameDownloadStatus::SetupRequired {
-                version_name: _,
-                install_dir,
-            } => {
-                let install_dir_path = Path::new(&install_dir);
-                if !install_dir_path.exists() {
-                    missing_games.push(game_id);
-                }
-            }
-            GameDownloadStatus::Installed {
-                version_name: _,
-                install_dir,
-            } => {
-                let install_dir_path = Path::new(&install_dir);
-                if !install_dir_path.exists() {
-                    missing_games.push(game_id);
-                }
-            }
-        }
-    }
-
-    info!("detected games missing: {missing_games:?}");
-
-    let mut db_handle = borrow_db_mut_checked();
-    for game_id in missing_games {
-        db_handle
-            .applications
-            .game_statuses
-            .entry(game_id)
-            .and_modify(|v| *v = GameDownloadStatus::Remote {});
-    }
-
-    drop(db_handle);
-
-    debug!("finished setup!");
-
-    // Sync autostart state
-    if let Err(e) = sync_autostart_on_startup(&handle) {
-        warn!("failed to sync autostart state: {e}");
-    }
-
-    // Clean up any orphaned playtime sessions
-    if let Err(e) = playtime_manager.lock().unwrap().cleanup_orphaned_sessions() {
-        warn!("failed to cleanup orphaned playtime sessions: {e}");
-    }
-
-    AppState {
-        status: app_status,
-        user,
-        games,
-        download_manager,
-        process_manager,
-        playtime_manager,
-        compat_info,
-        app_handle: handle.clone(),
-    }
-}
-
-pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
-
 pub fn custom_panic_handler(e: &PanicHookInfo) -> Option<()> {
     let crash_file = DATA_ROOT_DIR.join(format!(
         "crash-{}.log",
@@ -355,15 +169,7 @@ pub fn run() {
             kill_game,
             toggle_autostart,
             get_autostart_enabled,
-            open_process_logs,
-            // Playtime tracking
-            start_playtime_tracking,
-            end_playtime_tracking,
-            fetch_game_playtime,
-            fetch_all_playtime_stats,
-            is_playtime_session_active,
-            get_active_playtime_sessions,
-            cleanup_orphaned_playtime_sessions
+            open_process_logs
         ])
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_dialog::init())
@@ -375,7 +181,7 @@ pub fn run() {
             let handle = app.handle().clone();
 
             tauri::async_runtime::block_on(async move {
-                let state = setup(handle).await;
+                let state = setup::setup(handle).await;
                 info!("initialized drop client");
                 app.manage(Mutex::new(state));
 

src-tauri/src/native_library/collection_commands.rs

@@ -1,16 +1,9 @@
-use serde_json::json;
-
-use crate::{
-    error::remote_access_error::RemoteAccessError,
-    remote::{
-        auth::generate_authorization_header,
-        cache::{cache_object, get_cached_object},
-        requests::{generate_url, make_authenticated_get},
-        utils::DROP_CLIENT_ASYNC,
-    },
+use drop_errors::remote_access_error::RemoteAccessError;
+use drop_native_library::collections::{Collection, Collections};
+use drop_remote::{
+    auth::generate_authorization_header, cache::{cache_object, get_cached_object}, requests::{generate_url, make_authenticated_get}, utils::DROP_CLIENT_ASYNC
 };
-
-use super::collection::{Collection, Collections};
+use serde_json::json;
 
 #[tauri::command]
 pub async fn fetch_collections(

src-tauri/src/native_library/commands.rs

@@ -0,0 +1,76 @@
+use std::sync::Mutex;
+
+use drop_database::{borrow_db_checked, models::data::GameVersion, runtime_models::Game};
+use drop_errors::{library_error::LibraryError, remote_access_error::RemoteAccessError};
+use drop_native_library::{library::{fetch_game_logic, fetch_game_logic_offline, fetch_game_version_options_logic, fetch_library_logic, fetch_library_logic_offline, get_current_meta, uninstall_game_logic, FetchGameStruct}, state::{GameStatusManager, GameStatusWithTransient}};
+use tauri::AppHandle;
+
+use crate::{AppState, offline};
+
+#[tauri::command]
+pub async fn fetch_library(
+    state: tauri::State<'_, Mutex<AppState>>,
+    hard_refresh: Option<bool>,
+) -> Result<Vec<Game>, RemoteAccessError> {
+    offline!(
+        state,
+        fetch_library_logic,
+        fetch_library_logic_offline,
+        hard_refresh
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn fetch_game(
+    game_id: String,
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<FetchGameStruct, RemoteAccessError> {
+    offline!(
+        state,
+        fetch_game_logic,
+        fetch_game_logic_offline,
+        game_id
+    )
+    .await
+}
+
+#[tauri::command]
+pub fn fetch_game_status(id: String) -> GameStatusWithTransient {
+    let db_handle = borrow_db_checked();
+    GameStatusManager::fetch_state(&id, &db_handle)
+}
+
+#[tauri::command]
+pub fn uninstall_game(game_id: String, app_handle: AppHandle) -> Result<(), LibraryError> {
+    let meta = match get_current_meta(&game_id) {
+        Some(data) => data,
+        None => return Err(LibraryError::MetaNotFound(game_id)),
+    };
+    uninstall_game_logic(meta, &app_handle);
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn fetch_game_version_options(
+    game_id: String,
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<Vec<GameVersion>, RemoteAccessError> {
+    let all_versions = fetch_game_version_options_logic(game_id).await?;
+
+    let state_lock = state.lock().unwrap();
+    let process_manager_lock = state_lock.process_manager.lock().unwrap();
+    let data: Vec<GameVersion> = all_versions
+        .into_iter()
+        .filter(|v| {
+            process_manager_lock
+                .valid_platform(&v.platform)
+                .unwrap()
+        })
+        .collect();
+    drop(process_manager_lock);
+    drop(state_lock);
+
+    Ok(data)
+}

src-tauri/src/native_library/downloads/commands.rs

@@ -3,16 +3,11 @@ use std::{
     sync::{Arc, Mutex},
 };
 
+use drop_database::{borrow_db_checked, models::data::GameDownloadStatus};
+use drop_downloads::downloadable::Downloadable;
+use drop_errors::application_download_error::ApplicationDownloadError;
 
-use crate::{
-    AppState,
-    database::{
-        db::borrow_db_checked,
-        models::data::GameDownloadStatus,
-    },
-    download_manager::downloadable::Downloadable,
-    error::application_download_error::ApplicationDownloadError,
-};
+use crate::AppState;
 
 use super::download_agent::GameDownloadAgent;
 
@@ -21,7 +16,7 @@ pub async fn download_game(
     game_id: String,
     game_version: String,
     install_dir: usize,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
+    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<(), ApplicationDownloadError> {
     let sender = { state.lock().unwrap().download_manager.get_sender().clone() };
 
@@ -43,7 +38,7 @@ pub async fn download_game(
 #[tauri::command]
 pub async fn resume_download(
     game_id: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
+    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<(), ApplicationDownloadError> {
     let s = borrow_db_checked()
         .applications

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

@@ -1,25 +1,18 @@
-use crate::auth::generate_authorization_header;
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
-use crate::database::models::data::{
-    ApplicationTransientStatus, DownloadType, DownloadableMetadata,
-};
-use crate::download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
-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 drop_database::{borrow_db_checked, borrow_db_mut_checked};
+use drop_database::drop_data::DropData;
+use drop_database::models::data::{ApplicationTransientStatus, DownloadType, DownloadableMetadata};
+use drop_downloads::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
+use drop_downloads::downloadable::Downloadable;
+use drop_downloads::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
+use drop_downloads::util::progress_object::{ProgressHandle, ProgressObject};
+use drop_errors::application_download_error::ApplicationDownloadError;
+use drop_errors::remote_access_error::RemoteAccessError;
+use drop_native_library::library::{on_game_complete, push_game_update, set_partially_installed};
+use drop_native_library::state::GameStatusManager;
+use drop_process::utils::get_disk_available;
+use drop_remote::auth::generate_authorization_header;
+use drop_remote::requests::generate_url;
+use drop_remote::utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC};
 use log::{debug, error, info, warn};
 use rayon::ThreadPoolBuilder;
 use std::collections::{HashMap, HashSet};
@@ -33,8 +26,10 @@ use tauri::{AppHandle, Emitter};
 #[cfg(target_os = "linux")]
 use rustix::fs::{FallocateFlags, fallocate};
 
+use crate::native_library::downloads::manifest::{DownloadBucket, DownloadContext, DownloadDrop, DropManifest, DropValidateContext, ManifestBody};
+use crate::native_library::downloads::validate::validate_game_chunk;
+
 use super::download_logic::download_game_bucket;
-use super::drop_data::DropData;
 
 static RETRY_COUNT: usize = 3;
 

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

@@ -1,14 +1,11 @@
-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 drop_downloads::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
+use drop_downloads::util::progress_object::ProgressHandle;
+use drop_errors::application_download_error::ApplicationDownloadError;
+use drop_errors::drop_server_error::ServerError;
+use drop_errors::remote_access_error::RemoteAccessError;
+use drop_remote::auth::generate_authorization_header;
+use drop_remote::requests::generate_url;
+use drop_remote::utils::DROP_CLIENT_SYNC;
 use log::{debug, info, warn};
 use md5::{Context, Digest};
 use reqwest::blocking::Response;
@@ -25,6 +22,8 @@ use std::{
     path::PathBuf,
 };
 
+use crate::native_library::downloads::manifest::{ChunkBody, DownloadBucket, DownloadContext, DownloadDrop};
+
 static MAX_PACKET_LENGTH: usize = 4096 * 4;
 static BUMP_SIZE: usize = 4096 * 16;
 
@@ -198,7 +197,7 @@ pub fn download_game_bucket(
             ApplicationDownloadError::Communication(RemoteAccessError::FetchError(e.into()))
         })?;
         info!("{raw_res}");
-        if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
+        if let Ok(err) = serde_json::from_str::<ServerError>(&raw_res) {
             return Err(ApplicationDownloadError::Communication(
                 RemoteAccessError::InvalidResponse(err),
             ));

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

@@ -1,6 +1,5 @@
 pub mod commands;
 pub mod download_agent;
 mod download_logic;
-pub mod drop_data;
 mod manifest;
 pub mod validate;

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

@@ -3,17 +3,12 @@ use std::{
     io::{self, BufWriter, Read, Seek, SeekFrom, Write},
 };
 
+use drop_downloads::util::{download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag}, progress_object::ProgressHandle};
+use drop_errors::application_download_error::ApplicationDownloadError;
 use log::debug;
 use md5::Context;
 
-use crate::{
-    download_manager::util::{
-        download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
-        progress_object::ProgressHandle,
-    },
-    error::application_download_error::ApplicationDownloadError,
-    games::downloads::manifest::DropValidateContext,
-};
+use crate::native_library::downloads::manifest::DropValidateContext;
 
 pub fn validate_game_chunk(
     ctx: &DropValidateContext,

src-tauri/src/native_library/mod.rs

@@ -0,0 +1,3 @@
+pub mod collection_commands;
+pub mod commands;
+pub mod downloads;

src-tauri/src/playtime/commands.rs

@@ -1,95 +0,0 @@
-use std::collections::HashMap;
-use tauri::State;
-use std::sync::Mutex;
-
-use crate::AppState;
-use super::manager::PlaytimeStats;
-use super::events::{push_playtime_update, push_session_start, push_session_end};
-
-#[tauri::command]
-pub fn start_playtime_tracking(
-    game_id: String,
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<(), String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    match playtime_manager_lock.start_session(game_id.clone()) {
-        Ok(()) => {
-            push_session_start(&state_lock.app_handle, &game_id);
-            Ok(())
-        }
-        Err(e) => Err(e.to_string())
-    }
-}
-
-#[tauri::command]
-pub fn end_playtime_tracking(
-    game_id: String,
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<PlaytimeStats, String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    match playtime_manager_lock.end_session(game_id.clone()) {
-        Ok(stats) => {
-            push_session_end(&state_lock.app_handle, &game_id, &stats);
-            push_playtime_update(&state_lock.app_handle, &game_id, stats.clone(), false);
-            Ok(stats)
-        }
-        Err(e) => Err(e.to_string())
-    }
-}
-
-#[tauri::command]
-pub fn fetch_game_playtime(
-    game_id: String,
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<Option<PlaytimeStats>, String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    Ok(playtime_manager_lock.get_game_stats(&game_id))
-}
-
-#[tauri::command]
-pub fn fetch_all_playtime_stats(
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<HashMap<String, PlaytimeStats>, String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    Ok(playtime_manager_lock.get_all_stats())
-}
-
-#[tauri::command]
-pub fn is_playtime_session_active(
-    game_id: String,
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<bool, String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    Ok(playtime_manager_lock.is_session_active(&game_id))
-}
-
-#[tauri::command]
-pub fn get_active_playtime_sessions(
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<Vec<String>, String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    Ok(playtime_manager_lock.get_active_sessions())
-}
-
-#[tauri::command]
-pub fn cleanup_orphaned_playtime_sessions(
-    state: State<'_, Mutex<AppState<'_>>>,
-) -> Result<(), String> {
-    let state_lock = state.lock().unwrap();
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    
-    playtime_manager_lock.cleanup_orphaned_sessions()
-        .map_err(|e| e.to_string())
-}

src-tauri/src/playtime/events.rs

@@ -1,81 +0,0 @@
-use serde::Serialize;
-use tauri::{AppHandle, Emitter};
-use log::warn;
-
-use super::manager::PlaytimeStats;
-
-#[derive(Serialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct PlaytimeUpdateEvent {
-    pub game_id: String,
-    pub stats: PlaytimeStats,
-    pub is_active: bool,
-}
-
-#[derive(Serialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct PlaytimeSessionStartEvent {
-    pub game_id: String,
-    pub start_time: std::time::SystemTime,
-}
-
-#[derive(Serialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct PlaytimeSessionEndEvent {
-    pub game_id: String,
-    pub session_duration_seconds: u64,
-    pub total_playtime_seconds: u64,
-    pub session_count: u32,
-}
-
-/// Push a playtime update event to the frontend
-pub fn push_playtime_update(app_handle: &AppHandle, game_id: &str, stats: PlaytimeStats, is_active: bool) {
-    let event = PlaytimeUpdateEvent {
-        game_id: game_id.to_string(),
-        stats,
-        is_active,
-    };
-
-    if let Err(e) = app_handle.emit(&format!("playtime_update/{}", game_id), &event) {
-        warn!("Failed to emit playtime update event for {}: {}", game_id, e);
-    }
-
-    // Also emit a general playtime update event for global listeners
-    if let Err(e) = app_handle.emit("playtime_update", &event) {
-        warn!("Failed to emit general playtime update event: {}", e);
-    }
-}
-
-/// Push a session start event to the frontend
-pub fn push_session_start(app_handle: &AppHandle, game_id: &str) {
-    let event = PlaytimeSessionStartEvent {
-        game_id: game_id.to_string(),
-        start_time: std::time::SystemTime::now(),
-    };
-
-    if let Err(e) = app_handle.emit(&format!("playtime_session_start/{}", game_id), &event) {
-        warn!("Failed to emit session start event for {}: {}", game_id, e);
-    }
-
-    if let Err(e) = app_handle.emit("playtime_session_start", &event) {
-        warn!("Failed to emit general session start event: {}", e);
-    }
-}
-
-/// Push a session end event to the frontend
-pub fn push_session_end(app_handle: &AppHandle, game_id: &str, stats: &PlaytimeStats) {
-    let event = PlaytimeSessionEndEvent {
-        game_id: game_id.to_string(),
-        session_duration_seconds: stats.current_session_duration.unwrap_or(0),
-        total_playtime_seconds: stats.total_playtime_seconds,
-        session_count: stats.session_count,
-    };
-
-    if let Err(e) = app_handle.emit(&format!("playtime_session_end/{}", game_id), &event) {
-        warn!("Failed to emit session end event for {}: {}", game_id, e);
-    }
-
-    if let Err(e) = app_handle.emit("playtime_session_end", &event) {
-        warn!("Failed to emit general session end event: {}", e);
-    }
-}

src-tauri/src/playtime/manager.rs

@@ -1,255 +0,0 @@
-use std::collections::HashMap;
-use std::time::SystemTime;
-use std::fmt;
-
-use log::{debug, warn};
-use serde::{Deserialize, Serialize};
-use tauri::AppHandle;
-
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
-use crate::database::models::data::{GamePlaytimeStats, PlaytimeSession};
-use crate::error::process_error::ProcessError;
-
-#[derive(Debug)]
-pub enum PlaytimeError {
-    DatabaseError(String),
-    SessionNotFound(String),
-    SessionAlreadyActive(String),
-    InvalidGameId(String),
-}
-
-impl fmt::Display for PlaytimeError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            PlaytimeError::DatabaseError(msg) => write!(f, "Database error: {}", msg),
-            PlaytimeError::SessionNotFound(game_id) => write!(f, "Session not found for game: {}", game_id),
-            PlaytimeError::SessionAlreadyActive(game_id) => write!(f, "Session already active for game: {}", game_id),
-            PlaytimeError::InvalidGameId(game_id) => write!(f, "Invalid game ID: {}", game_id),
-        }
-    }
-}
-
-impl std::error::Error for PlaytimeError {}
-
-impl From<PlaytimeError> for ProcessError {
-    fn from(error: PlaytimeError) -> Self {
-        ProcessError::PlaytimeError(error.to_string())
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct PlaytimeStats {
-    pub game_id: String,
-    pub total_playtime_seconds: u64,
-    pub session_count: u32,
-    pub first_played: SystemTime,
-    pub last_played: SystemTime,
-    pub average_session_length: u64,
-    pub current_session_duration: Option<u64>,
-}
-
-impl From<GamePlaytimeStats> for PlaytimeStats {
-    fn from(stats: GamePlaytimeStats) -> Self {
-        let average_length = stats.average_session_length();
-        Self {
-            game_id: stats.game_id,
-            total_playtime_seconds: stats.total_playtime_seconds,
-            session_count: stats.session_count,
-            first_played: stats.first_played,
-            last_played: stats.last_played,
-            average_session_length: average_length,
-            current_session_duration: None,
-        }
-    }
-}
-
-pub struct PlaytimeManager {
-    app_handle: AppHandle,
-}
-
-impl PlaytimeManager {
-    pub fn new(app_handle: AppHandle) -> Self {
-        Self { app_handle }
-    }
-
-    /// Start tracking playtime for a game
-    pub fn start_session(&self, game_id: String) -> Result<(), PlaytimeError> {
-        debug!("Starting playtime session for game: {}", game_id);
-
-        let mut db_handle = borrow_db_mut_checked();
-        
-        // Check if session is already active
-        if db_handle.playtime_data.active_sessions.contains_key(&game_id) {
-            warn!("Session already active for game: {}", game_id);
-            return Err(PlaytimeError::SessionAlreadyActive(game_id));
-        }
-
-        // Create new session
-        let session = PlaytimeSession::new(game_id.clone());
-        db_handle.playtime_data.active_sessions.insert(game_id.clone(), session);
-
-        debug!("Started playtime tracking for game: {}", game_id);
-        Ok(())
-    }
-
-    /// End tracking playtime for a game and update stats
-    pub fn end_session(&self, game_id: String) -> Result<PlaytimeStats, PlaytimeError> {
-        debug!("Ending playtime session for game: {}", game_id);
-
-        let mut db_handle = borrow_db_mut_checked();
-        
-        // Get active session
-        let session = db_handle.playtime_data.active_sessions.remove(&game_id)
-            .ok_or_else(|| PlaytimeError::SessionNotFound(game_id.clone()))?;
-
-        let session_duration = session.duration().as_secs();
-        debug!("Session duration for {}: {} seconds", game_id, session_duration);
-
-        // Update or create game stats
-        let stats = db_handle.playtime_data.game_sessions
-            .entry(game_id.clone())
-            .or_insert_with(|| GamePlaytimeStats::new(game_id.clone()));
-
-        // Update stats
-        stats.total_playtime_seconds += session_duration;
-        stats.session_count += 1;
-        stats.last_played = SystemTime::now();
-
-        // If this is the first session, update first_played
-        if stats.session_count == 1 {
-            stats.first_played = session.start_time;
-        }
-
-        let result_stats = PlaytimeStats {
-            game_id: stats.game_id.clone(),
-            total_playtime_seconds: stats.total_playtime_seconds,
-            session_count: stats.session_count,
-            first_played: stats.first_played,
-            last_played: stats.last_played,
-            average_session_length: stats.average_session_length(),
-            current_session_duration: Some(session_duration),
-        };
-
-        debug!("Updated playtime stats for {}: {} total seconds, {} sessions", 
-               game_id, stats.total_playtime_seconds, stats.session_count);
-
-        Ok(result_stats)
-    }
-
-    /// Get playtime stats for a specific game
-    pub fn get_game_stats(&self, game_id: &str) -> Option<PlaytimeStats> {
-        let db_handle = borrow_db_checked();
-        
-        if let Some(stats) = db_handle.playtime_data.game_sessions.get(game_id) {
-            let mut playtime_stats: PlaytimeStats = stats.clone().into();
-            
-            // If there's an active session, include current session duration
-            if let Some(session) = db_handle.playtime_data.active_sessions.get(game_id) {
-                playtime_stats.current_session_duration = Some(session.duration().as_secs());
-            }
-            
-            Some(playtime_stats)
-        } else {
-            None
-        }
-    }
-
-    /// Get playtime stats for all games
-    pub fn get_all_stats(&self) -> HashMap<String, PlaytimeStats> {
-        let db_handle = borrow_db_checked();
-        let mut result = HashMap::new();
-
-        for (game_id, stats) in &db_handle.playtime_data.game_sessions {
-            let mut playtime_stats: PlaytimeStats = stats.clone().into();
-            
-            // If there's an active session, include current session duration
-            if let Some(session) = db_handle.playtime_data.active_sessions.get(game_id) {
-                playtime_stats.current_session_duration = Some(session.duration().as_secs());
-            }
-            
-            result.insert(game_id.clone(), playtime_stats);
-        }
-
-        result
-    }
-
-    /// Check if a game has an active session
-    pub fn is_session_active(&self, game_id: &str) -> bool {
-        let db_handle = borrow_db_checked();
-        db_handle.playtime_data.active_sessions.contains_key(game_id)
-    }
-
-    /// Get active sessions (for debugging/monitoring)
-    pub fn get_active_sessions(&self) -> Vec<String> {
-        let db_handle = borrow_db_checked();
-        db_handle.playtime_data.active_sessions.keys().cloned().collect()
-    }
-
-    /// Clean up any orphaned sessions (called on startup)
-    pub fn cleanup_orphaned_sessions(&self) -> Result<(), PlaytimeError> {
-        debug!("Cleaning up orphaned playtime sessions");
-        
-        let mut db_handle = borrow_db_mut_checked();
-        let orphaned_sessions: Vec<String> = db_handle.playtime_data.active_sessions.keys().cloned().collect();
-        
-        for game_id in orphaned_sessions {
-            warn!("Found orphaned session for game: {}, ending it", game_id);
-            
-            if let Some(session) = db_handle.playtime_data.active_sessions.remove(&game_id) {
-                let session_duration = session.duration().as_secs();
-                
-                // Only count sessions that lasted more than 5 seconds to avoid counting crashes
-                if session_duration > 5 {
-                    let stats = db_handle.playtime_data.game_sessions
-                        .entry(game_id.clone())
-                        .or_insert_with(|| GamePlaytimeStats::new(game_id.clone()));
-
-                    stats.total_playtime_seconds += session_duration;
-                    stats.session_count += 1;
-                    stats.last_played = SystemTime::now();
-
-                    if stats.session_count == 1 {
-                        stats.first_played = session.start_time;
-                    }
-
-                    debug!("Recovered orphaned session for {}: {} seconds", game_id, session_duration);
-                } else {
-                    debug!("Discarded short orphaned session for {}: {} seconds", game_id, session_duration);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    // Future server-side methods (ready for migration)
-    
-    /// Start session with server sync (placeholder for future implementation)
-    #[allow(dead_code)]
-    pub async fn sync_session_start(&self, game_id: String) -> Result<(), PlaytimeError> {
-        // For now, just call local method
-        self.start_session(game_id)?;
-        
-        // Future: Send to server
-        // let response = self.api_client.post("/api/v1/playtime/start")
-        //     .json(&StartSessionRequest { game_id })
-        //     .send().await?;
-        
-        Ok(())
-    }
-
-    /// End session with server sync (placeholder for future implementation)
-    #[allow(dead_code)]
-    pub async fn sync_session_end(&self, game_id: String) -> Result<PlaytimeStats, PlaytimeError> {
-        // For now, just call local method
-        let stats = self.end_session(game_id)?;
-        
-        // Future: Send to server
-        // let response = self.api_client.post("/api/v1/playtime/end")
-        //     .json(&EndSessionRequest { game_id, duration: stats.current_session_duration })
-        //     .send().await?;
-        
-        Ok(stats)
-    }
-}

src-tauri/src/playtime/mod.rs

@@ -1,3 +0,0 @@
-pub mod commands;
-pub mod events;
-pub mod manager;

src-tauri/src/process/commands.rs

@@ -1,6 +1,10 @@
 use std::sync::Mutex;
 
-use crate::{error::process_error::ProcessError, AppState};
+use drop_database::borrow_db_mut_checked;
+use drop_errors::{library_error::LibraryError, process_error::ProcessError};
+use serde::Deserialize;
+
+use crate::AppState;
 
 #[tauri::command]
 pub fn launch_game(
@@ -16,28 +20,14 @@ pub fn launch_game(
     //    download_type: DownloadType::Game,
     //};
 
-    match process_manager_lock.launch_process(id.clone(), &state_lock) {
-        Ok(()) => {
-            // Start playtime tracking after successful launch
-            drop(process_manager_lock);
-            
-            let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-            if let Err(e) = playtime_manager_lock.start_session(id.clone()) {
-                log::warn!("Failed to start playtime tracking for {}: {}", id, e);
-            } else {
-                log::debug!("Started playtime tracking for game: {}", id);
-                crate::playtime::events::push_session_start(&state_lock.app_handle, &id);
-            }
-            drop(playtime_manager_lock);
-        }
-        Err(e) => {
-            drop(process_manager_lock);
-            drop(state_lock);
-            return Err(e);
-        }
+    match process_manager_lock.launch_process(id, state_lock.process_manager) {
+        Ok(()) => {}
+        Err(e) => return Err(e),
     }
 
+    drop(process_manager_lock);
     drop(state_lock);
+
     Ok(())
 }
 
@@ -47,18 +37,6 @@ pub fn kill_game(
     state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<(), ProcessError> {
     let state_lock = state.lock().unwrap();
-    let mut process_manager_lock = state_lock.process_manager.lock().unwrap();
-    
-    // End playtime tracking before killing the game
-    drop(process_manager_lock);
-    let playtime_manager_lock = state_lock.playtime_manager.lock().unwrap();
-    if let Ok(stats) = playtime_manager_lock.end_session(game_id.clone()) {
-        log::debug!("Ended playtime tracking for game: {} (manual kill)", game_id);
-        crate::playtime::events::push_session_end(&state_lock.app_handle, &game_id, &stats);
-        crate::playtime::events::push_playtime_update(&state_lock.app_handle, &game_id, stats, false);
-    }
-    drop(playtime_manager_lock);
-    
     let mut process_manager_lock = state_lock.process_manager.lock().unwrap();
     process_manager_lock
         .kill_game(game_id)
@@ -74,3 +52,48 @@ pub fn open_process_logs(
     let mut process_manager_lock = state_lock.process_manager.lock().unwrap();
     process_manager_lock.open_process_logs(game_id)
 }
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendGameOptions {
+    pub launch_string: 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().unwrap();
+
+    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(())
+}

src-tauri/src/process/mod.rs

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

src-tauri/src/remote/auth.rs

@@ -1,224 +0,0 @@
-use std::{collections::HashMap, env, sync::Mutex};
-
-use chrono::Utc;
-use droplet_rs::ssl::sign_nonce;
-use gethostname::gethostname;
-use log::{debug, error, warn};
-use serde::{Deserialize, Serialize};
-use tauri::{AppHandle, Emitter, Manager};
-use url::Url;
-
-use crate::{
-    database::{
-        db::{borrow_db_checked, borrow_db_mut_checked},
-        models::data::DatabaseAuth,
-    }, error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError}, 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},
-    requests::generate_url,
-};
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct CapabilityConfiguration {}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct InitiateRequestBody {
-    name: String,
-    platform: String,
-    capabilities: HashMap<String, CapabilityConfiguration>,
-    mode: String,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct HandshakeRequestBody {
-    client_id: String,
-    token: String,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct HandshakeResponse {
-    private: String,
-    certificate: String,
-    id: String,
-}
-
-pub fn generate_authorization_header() -> String {
-    let certs = {
-        let db = borrow_db_checked();
-        db.auth.clone().unwrap()
-    };
-
-    let nonce = Utc::now().timestamp_millis().to_string();
-
-    let signature = sign_nonce(certs.private, nonce.clone()).unwrap();
-
-    format!("Nonce {} {} {}", certs.client_id, nonce, signature)
-}
-
-pub async fn fetch_user() -> Result<User, RemoteAccessError> {
-    let response = make_authenticated_get(generate_url(&["/api/v1/client/user"], &[])?).await?;
-    if response.status() != 200 {
-        let err: DropServerError = response.json().await?;
-        warn!("{err:?}");
-
-        if err.status_message == "Nonce expired" {
-            return Err(RemoteAccessError::OutOfSync);
-        }
-
-        return Err(RemoteAccessError::InvalidResponse(err));
-    }
-
-    response
-        .json::<User>()
-        .await
-        .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("auth/failed", ()).unwrap();
-        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).unwrap();
-    let token = path_chunks.get(2).unwrap();
-    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, // gets created later
-        });
-    }
-
-    let web_token = {
-        let header = generate_authorization_header();
-        let token = client
-            .post(base_url.join("/api/v1/client/user/webtoken").unwrap())
-            .header("Authorization", header)
-            .send()
-            .await
-            .unwrap();
-
-        token.text().await.unwrap()
-    };
-
-    let mut handle = borrow_db_mut_checked();
-    let mut_auth = handle.auth.as_mut().unwrap();
-    mut_auth.web_token = Some(web_token);
-
-    Ok(())
-}
-
-pub async fn recieve_handshake(app: AppHandle, path: String) {
-    // Tell the app we're processing
-    app.emit("auth/processing", ()).unwrap();
-
-    let handshake_result = recieve_handshake_logic(&app, path).await;
-    if let Err(e) = handshake_result {
-        warn!("error with authentication: {e}");
-        app.emit("auth/failed", e.to_string()).unwrap();
-        return;
-    }
-
-    let app_state = app.state::<Mutex<AppState>>();
-
-    let (app_status, user) = setup().await;
-
-    let mut state_lock = app_state.lock().unwrap();
-
-    state_lock.status = app_status;
-    state_lock.user = user;
-
-    let _ = clear_cached_object("collections");
-    let _ = clear_cached_object("library");
-
-    drop(state_lock);
-
-    app.emit("auth/finished", ()).unwrap();
-}
-
-pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
-    let base_url = {
-        let db_lock = borrow_db_checked();
-        Url::parse(&db_lock.base_url.clone())?
-    };
-
-    let hostname = gethostname();
-
-    let endpoint = base_url.join("/api/v1/client/auth/initiate")?;
-    let body = InitiateRequestBody {
-        name: format!("{} (Desktop)", hostname.into_string().unwrap()),
-        platform: env::consts::OS.to_string(),
-        capabilities: HashMap::from([
-            ("peerAPI".to_owned(), CapabilityConfiguration {}),
-            ("cloudSaves".to_owned(), CapabilityConfiguration {}),
-        ]),
-        mode,
-    };
-
-    let client = DROP_CLIENT_SYNC.clone();
-    let response = client.post(endpoint.to_string()).json(&body).send()?;
-
-    if response.status() != 200 {
-        let data: DropServerError = response.json()?;
-        error!("could not start handshake: {}", data.status_message);
-
-        return Err(RemoteAccessError::HandshakeFailed(data.status_message));
-    }
-
-    let response = response.text()?;
-
-    Ok(response)
-}
-
-pub async fn setup() -> (AppStatus, Option<User>) {
-    let auth = {
-        let data = borrow_db_checked();
-        data.auth.clone()
-    };
-
-    if auth.is_some() {
-        let user_result = match fetch_user().await {
-            Ok(data) => data,
-            Err(RemoteAccessError::FetchError(_)) => {
-                let user = get_cached_object::<User>("user").unwrap();
-                return (AppStatus::Offline, Some(user));
-            }
-            Err(_) => return (AppStatus::SignedInNeedsReauth, None),
-        };
-        cache_object("user", &user_result).unwrap();
-        return (AppStatus::SignedIn, Some(user_result));
-    }
-
-    (AppStatus::SignedOut, None)
-}

src-tauri/src/remote/commands.rs

@@ -1,5 +1,8 @@
-use std::sync::Mutex;
+use std::{sync::Mutex, time::Duration};
 
+use drop_database::{borrow_db_checked, borrow_db_mut_checked};
+use drop_errors::remote_access_error::RemoteAccessError;
+use drop_remote::{auth::{auth_initiate_logic, generate_authorization_header}, cache::{cache_object, get_cached_object}, requests::generate_url, utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC, DROP_CLIENT_WS_CLIENT}};
 use futures_lite::StreamExt;
 use log::{debug, warn};
 use reqwest_websocket::{Message, RequestBuilderExt};
@@ -7,27 +10,12 @@ use serde::Deserialize;
 use tauri::{AppHandle, Emitter, Manager};
 use url::Url;
 
-use crate::{
-    AppState, AppStatus,
-    database::db::{borrow_db_checked, borrow_db_mut_checked},
-    error::remote_access_error::RemoteAccessError,
-    remote::{
-        auth::generate_authorization_header,
-        requests::generate_url,
-        utils::{DROP_CLIENT_SYNC, DROP_CLIENT_WS_CLIENT},
-    },
-};
-
-use super::{
-    auth::{auth_initiate_logic, recieve_handshake, setup},
-    cache::{cache_object, get_cached_object},
-    utils::use_remote_logic,
-};
+use crate::{auth::{recieve_handshake, setup}, AppState, AppStatus};
 
 #[tauri::command]
 pub async fn use_remote(
     url: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
+    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<(), RemoteAccessError> {
     use_remote_logic(url, state).await
 }
@@ -87,7 +75,7 @@ pub fn sign_out(app: AppHandle) {
 }
 
 #[tauri::command]
-pub async fn retry_connect(state: tauri::State<'_, Mutex<AppState<'_>>>) -> Result<(), ()> {
+pub async fn retry_connect(state: tauri::State<'_, Mutex<AppState>>) -> Result<(), ()> {
     let (app_status, user) = setup().await;
 
     let mut guard = state.lock().unwrap();
@@ -151,7 +139,9 @@ pub fn auth_initiate_code(app: AppHandle) -> Result<String, RemoteAccessError> {
                     match response.response_type.as_str() {
                         "token" => {
                             let recieve_app = app.clone();
-                            manual_recieve_handshake(recieve_app, response.value).await.unwrap();
+                            manual_recieve_handshake(recieve_app, response.value)
+                                .await
+                                .unwrap();
                             return Ok(());
                         }
                         _ => return Err(RemoteAccessError::HandshakeFailed(response.value)),
@@ -180,3 +170,42 @@ pub async fn manual_recieve_handshake(app: AppHandle, token: String) -> Result<(
 
     Ok(())
 }
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DropHealthcheck {
+    app_name: String,
+}
+
+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 = state.lock().unwrap();
+    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/remote/mod.rs

@@ -1,8 +1,2 @@
-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 server_proto;

src-tauri/src/remote/server_proto.rs

@@ -1,10 +1,9 @@
 use std::str::FromStr;
 
+use drop_database::borrow_db_checked;
 use http::{uri::PathAndQuery, Request, Response, StatusCode, Uri};
 use tauri::UriSchemeResponder;
 
-use crate::{database::db::borrow_db_checked, remote::utils::DROP_CLIENT_SYNC};
-
 pub async fn handle_server_proto_offline(_request: Request<Vec<u8>>, responder: UriSchemeResponder) {
     let four_oh_four = Response::builder()
         .status(StatusCode::NOT_FOUND)
@@ -37,7 +36,7 @@ pub async fn handle_server_proto(request: Request<Vec<u8>>, responder: UriScheme
         return;
     }
 
-    let client = DROP_CLIENT_SYNC.clone();
+    let client = drop_remote::utils::DROP_CLIENT_SYNC.clone();
     let response = client
         .request(request.method().clone(), new_uri.to_string())
         .header("Authorization", format!("Bearer {web_token}"))

src-tauri/src/setup.rs

@@ -0,0 +1,121 @@
+use std::{env, path::Path, str::FromStr as _, sync::{Arc, Mutex}};
+
+use drop_database::{borrow_db_checked, borrow_db_mut_checked, db::{DatabaseImpls as _, DATA_ROOT_DIR}, models::data::GameDownloadStatus, DB};
+use drop_downloads::download_manager_builder::DownloadManagerBuilder;
+use drop_process::process_manager::ProcessManager;
+use log::{debug, info, warn, LevelFilter};
+use log4rs::{append::{console::ConsoleAppender, file::FileAppender}, config::{Appender, Root}, encode::pattern::PatternEncoder, Config};
+use tauri::AppHandle;
+
+use crate::{auth, client::autostart::sync_autostart_on_startup, database::scan::scan_install_dirs, AppState, AppStatus};
+
+pub async fn setup(handle: AppHandle) -> AppState {
+    let logfile = FileAppender::builder()
+        .encoder(Box::new(PatternEncoder::new(
+            "{d} | {l} | {f}:{L} - {m}{n}",
+        )))
+        .append(false)
+        .build(DATA_ROOT_DIR.join("./drop.log"))
+        .unwrap();
+
+    let console = ConsoleAppender::builder()
+        .encoder(Box::new(PatternEncoder::new(
+            "{d} | {l} | {f}:{L} - {m}{n}",
+        )))
+        .build();
+
+    let log_level = env::var("RUST_LOG").unwrap_or(String::from("Info"));
+
+    let config = Config::builder()
+        .appenders(vec![
+            Appender::builder().build("logfile", Box::new(logfile)),
+            Appender::builder().build("console", Box::new(console)),
+        ])
+        .build(
+            Root::builder()
+                .appenders(vec!["logfile", "console"])
+                .build(LevelFilter::from_str(&log_level).expect("Invalid log level")),
+        )
+        .unwrap();
+
+    log4rs::init_config(config).unwrap();
+
+    let download_manager = Arc::new(DownloadManagerBuilder::build(handle.clone()));
+    let process_manager = Box::leak(Box::new(Mutex::new(ProcessManager::new(handle.clone()))));
+
+    debug!("checking if database is set up");
+    let is_set_up = DB.database_is_set_up();
+
+    scan_install_dirs();
+
+    if !is_set_up {
+        return AppState {
+            status: AppStatus::NotConfigured,
+            user: None,
+            download_manager,
+            process_manager,
+        };
+    }
+
+    debug!("database is set up");
+
+    // TODO: Account for possible failure
+    let (app_status, user) = auth::setup().await;
+
+    let db_handle = borrow_db_checked();
+    let mut missing_games = Vec::new();
+    let statuses = db_handle.applications.game_statuses.clone();
+    drop(db_handle);
+
+    for (game_id, status) in statuses {
+        match status {
+            GameDownloadStatus::Remote {} => {}
+            GameDownloadStatus::PartiallyInstalled { .. } => {}
+            GameDownloadStatus::SetupRequired {
+                version_name: _,
+                install_dir,
+            } => {
+                let install_dir_path = Path::new(&install_dir);
+                if !install_dir_path.exists() {
+                    missing_games.push(game_id);
+                }
+            }
+            GameDownloadStatus::Installed {
+                version_name: _,
+                install_dir,
+            } => {
+                let install_dir_path = Path::new(&install_dir);
+                if !install_dir_path.exists() {
+                    missing_games.push(game_id);
+                }
+            }
+        }
+    }
+
+    info!("detected games missing: {missing_games:?}");
+
+    let mut db_handle = borrow_db_mut_checked();
+    for game_id in missing_games {
+        db_handle
+            .applications
+            .game_statuses
+            .entry(game_id)
+            .and_modify(|v| *v = GameDownloadStatus::Remote {});
+    }
+
+    drop(db_handle);
+
+    debug!("finished setup!");
+
+    // Sync autostart state
+    if let Err(e) = sync_autostart_on_startup(&handle) {
+        warn!("failed to sync autostart state: {e}");
+    }
+
+    AppState {
+        status: app_status,
+        user,
+        download_manager,
+        process_manager,
+    }
+}