feat: improvements to jump calculator

.gitignore

@@ -30,5 +30,3 @@ src-tauri/perf*
 
 /*.AppImage
 /squashfs-root
-
-/target/

main/app.vue

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

main/components/Header.vue

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

main/components/HeaderUserWidget.vue

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

main/components/LibrarySearch.vue

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

main/components/PageWidget.vue

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

main/nuxt.config.ts

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

main/pages/settings/debug.vue

@@ -116,7 +116,7 @@ platformInfo.value = currentPlatform;
 async function openDataDir() {
   if (!dataDir.value) return;
   try {
-    await invoke("open_fs", { path: dataDir.value });
+    await open(dataDir.value);
   } catch (error) {
     console.error("Failed to open data dir:", error);
   }
@@ -126,7 +126,7 @@ async function openLogFile() {
   if (!dataDir.value) return;
   try {
     const logPath = `${dataDir.value}/drop.log`;
-    await invoke("open_fs", { path: logPath });
+    await open(logPath);
   } catch (error) {
     console.error("Failed to open log file:", error);
   }

main/tailwind.config.js

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

package.json

@@ -9,13 +9,12 @@
   "dependencies": {
     "@tauri-apps/api": "^2.7.0",
     "@tauri-apps/plugin-deep-link": "^2.4.1",
-    "@tauri-apps/plugin-dialog": "^2.4.0",
+    "@tauri-apps/plugin-dialog": "^2.3.2",
-    "@tauri-apps/plugin-opener": "^2.5.0",
+    "@tauri-apps/plugin-opener": "^2.4.0",
     "@tauri-apps/plugin-os": "^2.3.0",
     "@tauri-apps/plugin-shell": "^2.3.0",
     "pino": "^9.7.0",
-    "pino-pretty": "^13.1.1",
+    "pino-pretty": "^13.1.1"
-    "tauri": "^0.15.0"
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2.7.1"

shared/app.vue

@@ -0,0 +1,50 @@
+<template>
+  <NuxtLoadingIndicator color="#2563eb" />
+  <NuxtLayout class="select-none w-screen h-screen">
+    <NuxtPage />
+    <ModalStack />
+  </NuxtLayout>
+</template>
+
+<script setup lang="ts">
+import "~/composables/downloads.js";
+
+import { invoke } from "@tauri-apps/api/core";
+import { useAppState } from "./composables/app-state.js";
+import {
+  initialNavigation,
+  setupHooks,
+} from "./composables/state-navigation.js";
+
+const router = useRouter();
+
+const state = useAppState();
+
+async function fetchState() {
+  try {
+    state.value = JSON.parse(await invoke("fetch_state"));
+    if (!state.value)
+      throw createError({
+        statusCode: 500,
+        statusMessage: `App state is: ${state.value}`,
+        fatal: true,
+      });
+  } catch (e) {
+    console.error("failed to parse state", e);
+    throw e;
+  }
+}
+await fetchState();
+
+// This is inefficient but apparently we do it lol
+router.beforeEach(async () => {
+  await fetchState();
+});
+
+setupHooks();
+initialNavigation(state);
+
+useHead({
+  title: "Drop",
+});
+</script>

shared/assets/main.scss

@@ -0,0 +1,84 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+html,
+body {
+  -ms-overflow-style: none; /* IE and Edge /
+scrollbar-width: none; / Firefox */
+}
+
+/* Hide scrollbar for Chrome, Safari and Opera */
+html::-webkit-scrollbar {
+  display: none;
+}
+
+$motiva: (
+  ("MotivaSansThin.ttf", "ttf", 100, normal),
+  ("MotivaSansLight.woff.ttf", "woff", 300, normal),
+  ("MotivaSansRegular.woff.ttf", "woff", 400, normal),
+  ("MotivaSansMedium.woff.ttf", "woff", 500, normal),
+  ("MotivaSansBold.woff.ttf", "woff", 600, normal),
+  ("MotivaSansExtraBold.ttf", "woff", 700, normal),
+  ("MotivaSansBlack.woff.ttf", "woff", 900, normal)
+);
+
+$helvetica: (
+  ("Helvetica.woff", "woff", 400, normal),
+  ("Helvetica-Oblique.woff", "woff", 400, italic),
+  ("Helvetica-Bold.woff", "woff", 600, normal),
+  ("Helvetica-BoldOblique.woff", "woff", 600, italic),
+  ("helvetica-light-587ebe5a59211.woff2", "woff2", 300, normal)
+);
+
+@each $file, $format, $weight, $style in $motiva {
+  @font-face {
+    font-family: "Motiva Sans";
+    src: url("/fonts/motiva/#{$file}") format($format);
+    font-weight: $weight;
+    font-style: $style;
+  }
+}
+
+@each $file, $format, $weight, $style in $helvetica {
+  @font-face {
+    font-family: "Helvetica";
+    src: url("/fonts/helvetica/#{$file}") format($format);
+    font-weight: $weight;
+    font-style: $style;
+  }
+}
+
+@font-face {
+  font-family: "Inter";
+  src: url("/fonts/inter/InterVariable.ttf");
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "Inter";
+  src: url("/fonts/inter/InterVariable-Italic.ttf");
+  font-style: italic;
+}
+
+/* ===== Scrollbar CSS ===== */
+/* Firefox */
+* {
+  scrollbar-width: 4px;
+  scrollbar-color: #52525b #00000000;
+}
+
+/* Chrome, Edge, and Safari */
+*::-webkit-scrollbar {
+  width: 4px;
+}
+
+*::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+*::-webkit-scrollbar-thumb {
+  background-color: #52525b;
+  border-radius: 10px;
+  border: 3px solid #52525b;
+}

shared/composables/use-object.ts

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

shared/error.vue

@@ -0,0 +1,91 @@
+<template>
+  <NuxtLayout name="default">
+    <div
+      class="grid min-h-full grid-cols-1 grid-rows-[1fr,auto,1fr] lg:grid-cols-[max(50%,36rem),1fr]"
+    >
+      <header
+        class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
+      >
+        <Logo class="h-10 w-auto sm:h-12" />
+        
+      </header>
+      <main
+        class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"
+      >
+        <div class="max-w-lg">
+          <p class="text-base font-semibold leading-8 text-blue-600">
+            {{ error?.statusCode }}
+          </p>
+          <h1
+            class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
+          >
+            Oh no!
+          </h1>
+          <p
+            v-if="message"
+            class="mt-3 font-bold text-base leading-7 text-red-500"
+          >
+            {{ message }}
+          </p>
+          <p class="mt-6 text-base leading-7 text-zinc-400">
+            An error occurred while responding to your request. If you believe
+            this to be a bug, please report it. Try signing in and see if it
+            resolves the issue.
+          </p>
+          <div class="mt-10">
+            <!-- full app reload to fix errors -->
+            <a
+              href="/store"
+              class="text-sm font-semibold leading-7 text-blue-600"
+              ><span aria-hidden="true">&larr;</span> Back to store</a
+            >
+          </div>
+        </div>
+      </main>
+      <footer class="self-end lg:col-span-2 lg:col-start-1 lg:row-start-3">
+        <div class="border-t border-zinc-700 bg-zinc-900 py-10">
+          <nav
+            class="mx-auto flex w-full max-w-7xl items-center gap-x-4 px-6 text-sm leading-7 text-zinc-400 lg:px-8"
+          >
+            <NuxtLink href="/docs">Documentation</NuxtLink>
+            <svg
+              viewBox="0 0 2 2"
+              aria-hidden="true"
+              class="h-0.5 w-0.5 fill-zinc-600"
+            >
+              <circle cx="1" cy="1" r="1" />
+            </svg>
+            <a href="https://discord.gg/NHx46XKJWA" target="_blank"
+              >Support Discord</a
+            >
+          </nav>
+        </div>
+      </footer>
+      <div
+        class="hidden lg:relative lg:col-start-2 lg:row-start-1 lg:row-end-4 lg:block"
+      >
+        <img
+          src="@/assets/wallpaper.jpg"
+          alt=""
+          class="absolute inset-0 h-full w-full object-cover"
+        />
+      </div>
+    </div>
+  </NuxtLayout>
+</template>
+
+<script setup lang="ts">
+import type { NuxtError } from "#app";
+
+const props = defineProps({
+  error: Object as () => NuxtError,
+});
+
+const statusCode = props.error?.statusCode;
+const message =
+  props.error?.statusMessage ||
+  props.error?.message ||
+  "An unknown error occurred.";
+
+console.error(props.error);
+</script>

shared/nuxt.config.ts

@@ -0,0 +1,25 @@
+// https://nuxt.com/docs/api/configuration/nuxt-config
+export default defineNuxtConfig({
+  compatibilityDate: "2024-04-03",
+
+  postcss: {
+    plugins: {
+      tailwindcss: {},
+      autoprefixer: {},
+    },
+  },
+
+  css: ["~/assets/main.scss"],
+
+  ssr: false,
+
+  extends: [["../libs/drop-base"]],
+
+  app: {
+    baseURL: "/main",
+  },
+
+  devtools: {
+    enabled: false,
+  },
+});

shared/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "view",
+  "private": true,
+  "version": "0.3.3",
+  "type": "module",
+  "scripts": {
+    "build": "nuxt generate",
+    "dev": "nuxt dev",
+    "postinstall": "nuxt prepare",
+    "tauri": "tauri"
+  },
+  "dependencies": {
+    "@headlessui/vue": "^1.7.23",
+    "@heroicons/vue": "^2.1.5",
+    "@nuxtjs/tailwindcss": "^6.12.2",
+    "@tauri-apps/api": "^2.7.0",
+    "koa": "^2.16.1",
+    "markdown-it": "^14.1.0",
+    "micromark": "^4.0.1",
+    "nuxt": "^3.16.0",
+    "scss": "^0.2.4",
+    "vue-router": "latest",
+    "vuedraggable": "^4.1.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/forms": "^0.5.9",
+    "@tailwindcss/typography": "^0.5.15",
+    "@types/markdown-it": "^14.1.2",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "sass-embedded": "^1.79.4",
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.8.3",
+    "vue-tsc": "^2.2.10"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}

shared/tailwind.config.js

@@ -0,0 +1,20 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./components/**/*.{js,vue,ts}",
+    "./layouts/**/*.vue",
+    "./pages/**/*.vue",
+    "./plugins/**/*.{js,ts}",
+    "./app.vue",
+    "./error.vue",
+  ],
+  theme: {
+    extend: {
+      fontFamily: {
+        sans: ["Inter"],
+        display: ["Motiva Sans"],
+      },
+    },
+  },
+  plugins: [require("@tailwindcss/forms"), require('@tailwindcss/typography')],
+};

shared/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  // https://nuxt.com/docs/guide/concepts/typescript
+  "extends": "./.nuxt/tsconfig.json",
+  "exclude": ["src-tauri/**/*"]
+}

shared/types.ts

@@ -0,0 +1,96 @@
+import type { Component } from "vue";
+
+export type NavigationItem = {
+  prefix: string;
+  route: string;
+  label: string;
+};
+
+export type QuickActionNav = {
+  icon: Component;
+  notifications?: number;
+  action: () => Promise<void>;
+};
+
+export type User = {
+  id: string;
+  username: string;
+  admin: boolean;
+  displayName: string;
+  profilePictureObjectId: string;
+};
+
+export type AppState = {
+  status: AppStatus;
+  user?: User;
+};
+
+export type Game = {
+  id: string;
+  mName: string;
+  mShortDescription: string;
+  mDescription: string;
+  mIconObjectId: string;
+  mBannerObjectId: string;
+  mCoverObjectId: string;
+  mImageLibraryObjectIds: string[];
+  mImageCarouselObjectIds: string[];
+};
+
+export type Collection = {
+  id: string;
+  name: string;
+  isDefault: boolean;
+  entries: Array<{ gameId: string; game: Game }>;
+};
+
+export type GameVersion = {
+  launchCommandTemplate: string;
+};
+
+export enum AppStatus {
+  NotConfigured = "NotConfigured",
+  Offline = "Offline",
+  SignedOut = "SignedOut",
+  SignedIn = "SignedIn",
+  SignedInNeedsReauth = "SignedInNeedsReauth",
+  ServerUnavailable = "ServerUnavailable",
+}
+
+export enum GameStatusEnum {
+  Remote = "Remote",
+  Queued = "Queued",
+  Downloading = "Downloading",
+  Validating = "Validating",
+  Installed = "Installed",
+  Updating = "Updating",
+  Uninstalling = "Uninstalling",
+  SetupRequired = "SetupRequired",
+  Running = "Running",
+  PartiallyInstalled = "PartiallyInstalled",
+}
+
+export type GameStatus = {
+  type: GameStatusEnum;
+  version_name?: string;
+  install_dir?: string;
+};
+
+export enum DownloadableType {
+  Game = "Game",
+  Tool = "Tool",
+  DLC = "DLC",
+  Mod = "Mod",
+}
+
+export type DownloadableMetadata = {
+  id: string;
+  version: string;
+  downloadType: DownloadableType;
+};
+
+export type Settings = {
+  autostart: boolean;
+  maxDownloadThreads: number;
+  forceOffline: boolean;
+};

src-tauri/Cargo.toml

@@ -65,9 +65,7 @@ whoami = "1.6.0"
 filetime = "0.2.25"
 walkdir = "2.5.0"
 known-folders = "1.2.0"
-native_model = { version = "0.6.4", features = [
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
-    "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"
@@ -80,16 +78,6 @@ futures-core = "0.3.31"
 bytes = "1.10.1"
 # tailscale = { path = "./tailscale" }
 
-
-# Workspaces
-client = { version = "0.1.0", path = "./client" }
-database = { path = "./database" }
-process = { path = "./process" }
-remote = { version = "0.1.0", path = "./remote" }
-utils = { path = "./utils" }
-games = { version = "0.1.0", path = "./games" }
-download_manager = { version = "0.1.0", path = "./download_manager" }
-
 [dependencies.dynfmt]
 version = "0.1.5"
 features = ["curly"]
@@ -139,20 +127,3 @@ features = ["derive", "rc"]
 lto = true
 codegen-units = 1
 panic = 'abort'
-
-
-[workspace]
-members = [
-    "client",
-    "database",
-    "process",
-    "remote",
-    "utils",
-    "cloud_saves",
-    "download_manager",
-    "games",
-    "library",
-    "drop-consts",
-]
-
-resolver = "3"

src-tauri/client/Cargo.toml

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

src-tauri/client/src/app_state.rs

@@ -1,42 +0,0 @@
-use std::collections::HashMap;
-
-use database::models::Game;
-use serde::Serialize;
-
-use crate::{app_status::AppStatus, user::User};
-
-#[derive(Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AppState {
-    status: AppStatus,
-    user: Option<User>,
-    games: HashMap<String, Game>,
-}
-impl AppState {
-    pub fn new(status: AppStatus, user: Option<User>, games: HashMap<String, Game>) -> Self {
-        Self {
-            status,
-            user,
-            games,
-        }
-    }
-
-    pub fn status(&self) -> &AppStatus {
-        &self.status
-    }
-    pub fn status_mut(&mut self) -> &mut AppStatus {
-        &mut self.status
-    }
-    pub fn games(&self) -> &HashMap<String, Game> {
-        &self.games
-    }
-    pub fn games_mut(&mut self) -> &mut HashMap<String, Game> {
-        &mut self.games
-    }
-    pub fn user(&self) -> &Option<User> {
-        &self.user
-    }
-    pub fn user_mut(&mut self) -> &mut Option<User> {
-        &mut self.user
-    }
-}

src-tauri/client/src/app_status.rs

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

src-tauri/client/src/autostart.rs

@@ -1,26 +0,0 @@
-use database::borrow_db_checked;
-use log::debug;
-use tauri::AppHandle;
-use tauri_plugin_autostart::ManagerExt;
-
-// New function to sync state on startup
-pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
-    let db_handle = borrow_db_checked();
-    let should_be_enabled = db_handle.settings.autostart;
-    drop(db_handle);
-
-    let manager = app.autolaunch();
-    let current_state = manager.is_enabled().map_err(|e| e.to_string())?;
-
-    if current_state != should_be_enabled {
-        if should_be_enabled {
-            manager.enable().map_err(|e| e.to_string())?;
-            debug!("synced autostart: enabled");
-        } else {
-            manager.disable().map_err(|e| e.to_string())?;
-            debug!("synced autostart: disabled");
-        }
-    }
-
-    Ok(())
-}

src-tauri/client/src/compat.rs

@@ -1,50 +0,0 @@
-use std::{
-    ffi::OsStr,
-    path::PathBuf,
-    process::{Command, Stdio},
-    sync::LazyLock,
-};
-
-use drop_consts::{UMU_BASE_LAUNCHER_EXECUTABLE, UMU_INSTALL_DIRS};
-use log::info;
-
-pub static COMPAT_INFO: LazyLock<Option<CompatInfo>> = LazyLock::new(create_new_compat_info);
-
-pub static UMU_LAUNCHER_EXECUTABLE: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
-    let x = get_umu_executable();
-    info!("{:?}", &x);
-    x
-});
-
-#[derive(Clone)]
-pub struct CompatInfo {
-    pub 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,
-    })
-}
-
-fn get_umu_executable() -> Option<PathBuf> {
-    if check_executable_exists(UMU_BASE_LAUNCHER_EXECUTABLE) {
-        return Some(PathBuf::from(UMU_BASE_LAUNCHER_EXECUTABLE));
-    }
-
-    for dir in UMU_INSTALL_DIRS {
-        let p = PathBuf::from(dir).join(UMU_BASE_LAUNCHER_EXECUTABLE);
-        if check_executable_exists(&p) {
-            return Some(p);
-        }
-    }
-    None
-}
-fn check_executable_exists<P: AsRef<OsStr>>(exec: P) -> bool {
-    let has_umu_installed = Command::new(exec).stdout(Stdio::null()).output();
-    has_umu_installed.is_ok()
-}

src-tauri/client/src/lib.rs

@@ -1,5 +0,0 @@
-pub mod app_state;
-pub mod app_status;
-pub mod autostart;
-pub mod compat;
-pub mod user;

src-tauri/client/src/user.rs

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

src-tauri/cloud_saves/Cargo.toml

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

src-tauri/cloud_saves/src/backup_manager.rs

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

src-tauri/cloud_saves/src/error.rs

@@ -1,27 +0,0 @@
-use std::fmt::Display;
-
-use serde_with::SerializeDisplay;
-
-#[derive(Debug, SerializeDisplay, Clone, Copy)]
-
-pub enum BackupError {
-    InvalidSystem,
-
-    NotFound,
-
-    ParseError,
-}
-
-impl Display for BackupError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self {
-            BackupError::InvalidSystem => "Attempted to generate path for invalid system",
-
-            BackupError::NotFound => "Could not generate or find path",
-
-            BackupError::ParseError => "Failed to parse path",
-        };
-
-        write!(f, "{}", s)
-    }
-}

src-tauri/cloud_saves/src/lib.rs

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

src-tauri/database/Cargo.toml

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

src-tauri/database/src/db.rs

@@ -1,39 +0,0 @@
-use std::{
-    path::PathBuf,
-    sync::{Arc, LazyLock},
-};
-
-use drop_consts::DATA_ROOT_PREFIX;
-use rustbreak::{DeSerError, DeSerializer};
-use serde::{Serialize, de::DeserializeOwned};
-
-use crate::{interface::DatabaseImpls, models::DatabaseInterface};
-
-pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
-
-pub static DATA_ROOT_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
-        dirs::data_dir()
-            .expect("Failed to get data dir")
-            .join(DATA_ROOT_PREFIX)
-});
-
-// Custom JSON serializer to support everything we need
-#[derive(Debug, Default, Clone)]
-pub struct DropDatabaseSerializer;
-
-impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
-    for DropDatabaseSerializer
-{
-    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
-        native_model::encode(val).map_err(|e| DeSerError::Internal(e.to_string()))
-    }
-
-    fn deserialize<R: std::io::Read>(&self, mut s: R) -> rustbreak::error::DeSerResult<T> {
-        let mut buf = Vec::new();
-        s.read_to_end(&mut buf)
-            .map_err(|e| rustbreak::error::DeSerError::Other(e.into()))?;
-        let (val, _version) =
-            native_model::decode(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
-        Ok(val)
-    }
-}

src-tauri/database/src/lib.rs

@@ -1,14 +0,0 @@
-#![feature(nonpoison_rwlock)]
-
-pub mod db;
-pub mod debug;
-pub mod interface;
-pub mod models;
-pub mod platform;
-
-pub use db::DB;
-pub use interface::{borrow_db_checked, borrow_db_mut_checked};
-pub use models::{
-    ApplicationTransientStatus, Database, DatabaseApplications, DatabaseAuth, DownloadType,
-    DownloadableMetadata, GameDownloadStatus, GameVersion, Settings,
-};

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

@@ -1,110 +0,0 @@
-mod v1;
-mod v2;
-mod v3;
-mod v4;
-
-use std::{hash::Hash, path::PathBuf};
-
-use native_model::native_model;
-use serde::{Deserialize, Serialize};
-
-use std::collections::HashMap;
-
-use crate::db::DropDatabaseSerializer;
-
-
-// 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;
-pub type Database = v4::Database;
-pub type Settings = v1::Settings;
-pub type DatabaseAuth = v1::DatabaseAuth;
-
-pub type GameDownloadStatus = v2::GameDownloadStatus;
-pub type ApplicationTransientStatus = v1::ApplicationTransientStatus;
-/**
- * Need to be universally accessible by the ID, and the version is just a couple sprinkles on top
- */
-pub type DownloadableMetadata = v1::DownloadableMetadata;
-pub type DownloadType = v1::DownloadType;
-pub type DatabaseApplications = v2::DatabaseApplications;
-// pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
-
-pub type Game = v1::Game;
-
-impl Game {
-    pub fn id(&self) -> &String {
-        &self.id
-    }
-}
-
-pub type DatabaseInterface =
-    rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;
-
-pub type LibraryMetadata = v1::LibraryMetadata;
-pub type LibraryProviderMetadata = v1::LibraryProviderMetadata;
-pub type ProviderType = v1::ProviderType;
-
-pub type Collection = v1::Collection;
-pub type CollectionObject = v1::CollectionObject;
-
-impl PartialEq for DownloadableMetadata {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id && self.download_type == other.download_type
-    }
-}
-impl Hash for DownloadableMetadata {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
-        self.download_type.hash(state);
-    }
-}
-impl LibraryProviderMetadata {
-    pub fn provider(&self) -> &ProviderType {
-        &self.provider
-    }
-    pub fn id(&self) -> usize {
-        self.id
-    }
-    pub fn name(&self) -> &String {
-        &self.name
-    }
-}
-
-impl Database {
-    pub fn new<T: Into<PathBuf>>(
-        games_base_dir: T,
-        prev_database: Option<PathBuf>,
-        cache_dir: PathBuf,
-    ) -> Self {
-        Self {
-            prev_database,
-            settings: Settings::default(),
-            cache_dir,
-            compat_info: None,
-            library: v1::LibraryMetadata { providers: vec![] },
-        }
-    }
-}
-impl DatabaseAuth {
-    pub fn new(
-        private: String,
-        cert: String,
-        client_id: String,
-        web_token: Option<String>,
-    ) -> Self {
-        Self {
-            private,
-            cert,
-            client_id,
-            web_token,
-        }
-    }
-}
-
-impl LibraryMetadata {
-    pub fn providers(&self) -> &Vec<LibraryProviderMetadata> {
-        &self.providers
-    }
-}

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

@@ -1,201 +0,0 @@
-use bitcode::{Decode, Encode};
-use serde_with::serde_as;
-use std::{collections::HashMap, path::PathBuf};
-
-use crate::{models::v1, platform::Platform};
-
-use super::{Deserialize, Serialize, native_model};
-
-fn default_template() -> String {
-    "{}".to_owned()
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-#[native_model(id = 2, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-pub struct GameVersion {
-    pub game_id: String,
-    pub version_name: String,
-
-    pub platform: Platform,
-
-    pub launch_command: String,
-    pub launch_args: Vec<String>,
-    #[serde(default = "default_template")]
-    pub launch_command_template: String,
-
-    pub setup_command: String,
-    pub setup_args: Vec<String>,
-    #[serde(default = "default_template")]
-    pub setup_command_template: String,
-
-    pub only_setup: bool,
-
-    pub version_index: usize,
-    pub delta: bool,
-
-    pub umu_id_override: Option<String>,
-}
-
-#[serde_as]
-#[derive(Serialize, Clone, Deserialize, Default)]
-#[serde(rename_all = "camelCase")]
-#[native_model(id = 3, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-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, v1::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>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-#[native_model(id = 4, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-pub struct Settings {
-    pub autostart: bool,
-    pub max_download_threads: usize,
-    pub force_offline: bool, // ... other settings ...
-}
-impl Default for Settings {
-    fn default() -> Self {
-        Self {
-            autostart: false,
-            max_download_threads: 4,
-            force_offline: false,
-        }
-    }
-}
-
-// Strings are version names for a particular game
-#[derive(Serialize, Clone, Deserialize, Debug)]
-#[serde(tag = "type")]
-#[native_model(id = 5, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-pub enum GameDownloadStatus {
-    Remote {},
-    SetupRequired {
-        version_name: String,
-        install_dir: String,
-    },
-    Installed {
-        version_name: String,
-        install_dir: String,
-    },
-}
-
-// Stuff that shouldn't be synced to disk
-#[derive(Clone, Serialize, Deserialize, Debug)]
-pub enum ApplicationTransientStatus {
-    Queued { version_name: String },
-    Downloading { version_name: String },
-    Uninstalling {},
-    Updating { version_name: String },
-    Validating { version_name: String },
-    Running {},
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, Default, Encode, Decode)]
-#[native_model(id = 6, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-pub struct DatabaseAuth {
-    pub private: String,
-    pub cert: String,
-    pub client_id: String,
-    pub web_token: Option<String>,
-}
-
-#[native_model(id = 8, version = 1)]
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone, Copy)]
-pub enum DownloadType {
-    Game,
-    Tool,
-    Dlc,
-    Mod,
-}
-
-#[native_model(id = 7, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Debug, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct DownloadableMetadata {
-    pub id: String,
-    pub version: Option<String>,
-    pub download_type: v1::DownloadType,
-}
-impl DownloadableMetadata {
-    pub fn new(id: String, version: Option<String>, download_type: v1::DownloadType) -> Self {
-        Self {
-            id,
-            version,
-            download_type,
-        }
-    }
-}
-
-#[native_model(id = 1, version = 1)]
-#[derive(Serialize, Deserialize, Clone, Default)]
-pub struct Database {
-    #[serde(default)]
-    pub settings: Settings,
-    pub auth: Option<v1::DatabaseAuth>,
-    pub base_url: String,
-    pub applications: v1::DatabaseApplications,
-    pub prev_database: Option<PathBuf>,
-    pub cache_dir: PathBuf,
-}
-#[native_model(id = 15, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Serialize, Deserialize, Debug, Clone, Encode, Decode, Default)]
-pub struct LibraryMetadata {
-    pub(crate) providers: Vec<v1::LibraryProviderMetadata>
-}
-
-
-#[native_model(id = 11, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Serialize, Deserialize, Debug, Clone, Encode, Decode)]
-pub struct LibraryProviderMetadata {
-    pub(crate) id: usize,
-    pub(crate) name: String,
-    pub(crate) provider: v1::ProviderType
-}
-#[native_model(id = 10, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Serialize, Deserialize, Debug, Clone, Encode, Decode)]
-pub enum ProviderType {
-    Drop(v1::DatabaseAuth),
-}
-#[native_model(id = 12, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Serialize, Deserialize, Debug, Clone, Encode, Decode)]
-pub struct Game {
-    pub library_id: LibraryProviderMetadata,
-    pub(crate) 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>,
-}
-
-#[native_model(id = 13, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Serialize, Deserialize, Debug, Clone, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct Collection {
-    id: String,
-    name: String,
-    is_default: bool,
-    user_id: String,
-    entries: Vec<CollectionObject>,
-}
-
-#[native_model(id = 14, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct CollectionObject {
-    collection_id: String,
-    game_id: String,
-    game: Game,
-}

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

@@ -1,111 +0,0 @@
-        use std::{collections::HashMap, path::PathBuf};
-
-        use serde_with::serde_as;
-
-        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)]
-        pub struct Database {
-            #[serde(default)]
-            pub settings: v1::Settings,
-            pub auth: Option<v1::DatabaseAuth>,
-            pub base_url: String,
-            pub applications: v1::DatabaseApplications,
-            #[serde(skip)]
-            pub prev_database: Option<PathBuf>,
-            pub cache_dir: PathBuf,
-            pub compat_info: Option<DatabaseCompatInfo>,
-        }
-
-        #[native_model(id = 9, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-        #[derive(Serialize, Deserialize, Clone, Default)]
-
-        pub struct DatabaseCompatInfo {
-            pub umu_installed: bool,
-        }
-
-        impl From<v1::Database> for Database {
-            fn from(value: v1::Database) -> Self {
-                Self {
-                    settings: value.settings,
-                    auth: value.auth,
-                    base_url: value.base_url,
-                    applications: value.applications,
-                    prev_database: value.prev_database,
-                    cache_dir: value.cache_dir,
-                    compat_info: None,
-                }
-            }
-        }
-        // Strings are version names for a particular game
-        #[derive(Serialize, Clone, Deserialize, Debug)]
-        #[serde(tag = "type")]
-        #[native_model(id = 5, version = 2, with = native_model::rmp_serde_1_3::RmpSerde, from = v1::GameDownloadStatus)]
-        pub enum GameDownloadStatus {
-            Remote {},
-            SetupRequired {
-                version_name: String,
-                install_dir: String,
-            },
-            Installed {
-                version_name: String,
-                install_dir: String,
-            },
-            PartiallyInstalled {
-                version_name: String,
-                install_dir: String,
-            },
-        }
-        impl From<v1::GameDownloadStatus> for GameDownloadStatus {
-            fn from(value: v1::GameDownloadStatus) -> Self {
-                match value {
-                    v1::GameDownloadStatus::Remote {} => Self::Remote {},
-                    v1::GameDownloadStatus::SetupRequired {
-                        version_name,
-                        install_dir,
-                    } => Self::SetupRequired {
-                        version_name,
-                        install_dir,
-                    },
-                    v1::GameDownloadStatus::Installed {
-                        version_name,
-                        install_dir,
-                    } => Self::Installed {
-                        version_name,
-                        install_dir,
-                    },
-                }
-            }
-        }
-        #[serde_as]
-        #[derive(Serialize, Clone, Deserialize, Default)]
-        #[serde(rename_all = "camelCase")]
-        #[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>,
-        }
-        impl From<v1::DatabaseApplications> for DatabaseApplications {
-            fn from(value: v1::DatabaseApplications) -> Self {
-                Self {
-                    game_statuses: value
-                        .game_statuses
-                        .into_iter()
-                        .map(|x| (x.0, x.1.into()))
-                        .collect::<HashMap<String, GameDownloadStatus>>(),
-                    install_dirs: value.install_dirs,
-                    game_versions: value.game_versions,
-                    installed_game_version: value.installed_game_version,
-                    transient_statuses: value.transient_statuses,
-                }
-            }
-        }

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

@@ -1,32 +0,0 @@
-use std::{collections::HashMap, path::PathBuf};
-
-use serde_with::serde_as;
-
-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 {
-    #[serde(default)]
-    pub settings: v1::Settings,
-    pub auth: Option<v1::DatabaseAuth>,
-    pub base_url: String,
-    pub applications: v2::DatabaseApplications,
-    #[serde(skip)]
-    pub prev_database: Option<PathBuf>,
-    pub cache_dir: PathBuf,
-    pub compat_info: Option<v2::DatabaseCompatInfo>,
-}
-
-impl From<v2::Database> for Database {
-    fn from(value: v2::Database) -> Self {
-        Self {
-            settings: value.settings,
-            auth: value.auth,
-            base_url: value.base_url,
-            applications: value.applications.into(),
-            prev_database: value.prev_database,
-            cache_dir: value.cache_dir,
-            compat_info: None,
-        }
-    }
-}

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

@@ -1,43 +0,0 @@
-use std::path::PathBuf;
-
-use native_model::native_model;
-use serde::{Deserialize, Serialize};
-
-use crate::models::{
-    v1::{self, LibraryMetadata},
-    v2, v3,
-};
-
-#[native_model(id = 1, version = 4, with = native_model::rmp_serde_1_3::RmpSerde, from = v3::Database)]
-#[derive(Serialize, Deserialize, Clone, Default)]
-pub struct Database {
-    #[serde(default)]
-    pub settings: v1::Settings,
-    #[serde(skip)]
-    pub prev_database: Option<PathBuf>,
-    pub cache_dir: PathBuf,
-    pub compat_info: Option<v2::DatabaseCompatInfo>,
-    pub library: v1::LibraryMetadata,
-}
-
-impl From<v3::Database> for Database {
-    fn from(value: v3::Database) -> Self {
-        Self {
-            settings: value.settings,
-            prev_database: value.prev_database,
-            cache_dir: value.cache_dir,
-            compat_info: value.compat_info,
-            library: v1::LibraryMetadata {
-                providers: if let Some(auth) = value.auth {
-                    vec![v1::LibraryProviderMetadata {
-                        id: 0,
-                        name: String::from("Default"),
-                        provider: v1::ProviderType::Drop(auth),
-                    }]
-                } else {
-                    vec![]
-                },
-            },
-        }
-    }
-}

src-tauri/database/src/platform.rs

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

src-tauri/download_manager/Cargo.toml

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

src-tauri/download_manager/src/error.rs

@@ -1,80 +0,0 @@
-use humansize::{BINARY, format_size};
-use std::{
-    fmt::{Display, Formatter},
-    io,
-    sync::{Arc, mpsc::SendError},
-};
-
-use remote::error::RemoteAccessError;
-use serde_with::SerializeDisplay;
-
-#[derive(SerializeDisplay)]
-pub enum DownloadManagerError<T> {
-    IOError(io::Error),
-    SignalError(SendError<T>),
-}
-impl<T> Display for DownloadManagerError<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            DownloadManagerError::IOError(error) => write!(f, "{error}"),
-            DownloadManagerError::SignalError(send_error) => write!(f, "{send_error}"),
-        }
-    }
-}
-impl<T> From<SendError<T>> for DownloadManagerError<T> {
-    fn from(value: SendError<T>) -> Self {
-        DownloadManagerError::SignalError(value)
-    }
-}
-impl<T> From<io::Error> for DownloadManagerError<T> {
-    fn from(value: io::Error) -> Self {
-        DownloadManagerError::IOError(value)
-    }
-}
-
-// TODO: Rename / separate from downloads
-#[derive(Debug, SerializeDisplay)]
-pub enum ApplicationDownloadError {
-    NotInitialized,
-    Communication(RemoteAccessError),
-    DiskFull(u64, u64),
-    #[allow(dead_code)]
-    Checksum,
-    Lock,
-    IoError(Arc<io::Error>),
-    DownloadError(RemoteAccessError),
-}
-
-impl Display for ApplicationDownloadError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ApplicationDownloadError::NotInitialized => {
-                write!(f, "Download not initalized, did something go wrong?")
-            }
-            ApplicationDownloadError::DiskFull(required, available) => write!(
-                f,
-                "Game requires {}, {} remaining left on disk.",
-                format_size(*required, BINARY),
-                format_size(*available, BINARY),
-            ),
-            ApplicationDownloadError::Communication(error) => write!(f, "{error}"),
-            ApplicationDownloadError::Lock => write!(
-                f,
-                "failed to acquire lock. Something has gone very wrong internally. Please restart the application"
-            ),
-            ApplicationDownloadError::Checksum => {
-                write!(f, "checksum failed to validate for download")
-            }
-            ApplicationDownloadError::IoError(error) => write!(f, "io error: {error}"),
-            ApplicationDownloadError::DownloadError(error) => {
-                write!(f, "Download failed with error {error:?}")
-            }
-        }
-    }
-}
-
-impl From<io::Error> for ApplicationDownloadError {
-    fn from(value: io::Error) -> Self {
-        ApplicationDownloadError::IoError(Arc::new(value))
-    }
-}

src-tauri/download_manager/src/frontend_updates.rs

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

src-tauri/download_manager/src/lib.rs

@@ -1,44 +0,0 @@
-#![feature(duration_millis_float)]
-#![feature(nonpoison_mutex)]
-#![feature(sync_nonpoison)]
-
-use std::{ops::Deref, sync::OnceLock};
-
-use tauri::AppHandle;
-
-use crate::{
-    download_manager_builder::DownloadManagerBuilder, download_manager_frontend::DownloadManager,
-};
-
-pub mod download_manager_builder;
-pub mod download_manager_frontend;
-pub mod downloadable;
-pub mod error;
-pub mod frontend_updates;
-pub mod util;
-
-pub static DOWNLOAD_MANAGER: DownloadManagerWrapper = DownloadManagerWrapper::new();
-
-pub struct DownloadManagerWrapper(OnceLock<DownloadManager>);
-impl DownloadManagerWrapper {
-    const fn new() -> Self {
-        DownloadManagerWrapper(OnceLock::new())
-    }
-    pub fn init(app_handle: AppHandle) {
-        DOWNLOAD_MANAGER
-            .0
-            .set(DownloadManagerBuilder::build(app_handle))
-            .expect("Failed to initialise download manager");
-    }
-}
-
-impl Deref for DownloadManagerWrapper {
-    type Target = DownloadManager;
-
-    fn deref(&self) -> &Self::Target {
-        match self.0.get() {
-            Some(download_manager) => download_manager,
-            None => unreachable!("Download manager should always be initialised"),
-        }
-    }
-}

src-tauri/drop-consts/Cargo.toml

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

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

@@ -1,16 +0,0 @@
-use std::{path::PathBuf, sync::LazyLock};
-
-#[cfg(not(debug_assertions))]
-pub const DATA_ROOT_PREFIX: &str = "drop";
-#[cfg(debug_assertions)]
-pub const DATA_ROOT_PREFIX: &str = "drop-debug";
-
-pub const DROP_DATA_PATH: &str = ".dropdata";
-
-pub const RETRY_COUNT: usize = 3;
-
-pub const TARGET_BUCKET_SIZE: usize = 63 * 1000 * 1000;
-pub const MAX_FILES_PER_BUCKET: usize = (1024 / 4) - 1;
-
-pub const UMU_BASE_LAUNCHER_EXECUTABLE: &str = "umu-run";
-pub const UMU_INSTALL_DIRS: [&str; 4] = ["/app/share", "/use/local/share", "/usr/share", "/opt"];

src-tauri/games/Cargo.toml

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

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

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

src-tauri/games/src/library.rs

@@ -1,278 +0,0 @@
-use database::{
-    borrow_db_checked, borrow_db_mut_checked, models::Game, ApplicationTransientStatus, Database, DownloadableMetadata, GameDownloadStatus, GameVersion
-};
-use log::{debug, error, warn};
-use remote::{
-    auth::generate_authorization_header, error::RemoteAccessError, requests::generate_url,
-    utils::DROP_CLIENT_SYNC,
-};
-use serde::{Deserialize, Serialize};
-use std::fs::remove_dir_all;
-use std::thread::spawn;
-use tauri::AppHandle;
-use utils::app_emit;
-
-use crate::state::{GameStatusManager, GameStatusWithTransient};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct FetchGameStruct {
-    game: Game,
-    status: GameStatusWithTransient,
-    version: Option<GameVersion>,
-}
-
-impl FetchGameStruct {
-    pub fn new(game: Game, status: GameStatusWithTransient, version: Option<GameVersion>) -> Self {
-        Self {
-            game,
-            status,
-            version,
-        }
-    }
-}
-
-#[derive(serde::Serialize, Clone)]
-pub struct GameUpdateEvent {
-    pub game_id: String,
-    pub status: (
-        Option<GameDownloadStatus>,
-        Option<ApplicationTransientStatus>,
-    ),
-    pub version: Option<GameVersion>,
-}
-
-/**
- * Called by:
- *  - on_cancel, when cancelled, for obvious reasons
- *  - when downloading, so if drop unexpectedly quits, we can resume the download. hidden by the "Downloading..." transient state, though
- *  - when scanning, to import the game
- */
-pub fn set_partially_installed(
-    meta: &DownloadableMetadata,
-    install_dir: String,
-    app_handle: Option<&AppHandle>,
-) {
-    set_partially_installed_db(&mut borrow_db_mut_checked(), meta, install_dir, app_handle);
-}
-
-pub fn set_partially_installed_db(
-    db_lock: &mut Database,
-    meta: &DownloadableMetadata,
-    install_dir: String,
-    app_handle: Option<&AppHandle>,
-) {
-    db_lock.applications.transient_statuses.remove(meta);
-    db_lock.applications.game_statuses.insert(
-        meta.id.clone(),
-        GameDownloadStatus::PartiallyInstalled {
-            version_name: meta.version.as_ref().unwrap().clone(),
-            install_dir,
-        },
-    );
-    db_lock
-        .applications
-        .installed_game_version
-        .insert(meta.id.clone(), meta.clone());
-
-    if let Some(app_handle) = app_handle {
-        push_game_update(
-            app_handle,
-            &meta.id,
-            None,
-            GameStatusManager::fetch_state(&meta.id, db_lock),
-        );
-    }
-}
-
-pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle) {
-    debug!("triggered uninstall for agent");
-    let mut db_handle = borrow_db_mut_checked();
-    db_handle
-        .applications
-        .transient_statuses
-        .insert(meta.clone(), ApplicationTransientStatus::Uninstalling {});
-
-    push_game_update(
-        app_handle,
-        &meta.id,
-        None,
-        GameStatusManager::fetch_state(&meta.id, &db_handle),
-    );
-
-    let previous_state = db_handle.applications.game_statuses.get(&meta.id).cloned();
-
-    let previous_state = if let Some(state) = previous_state {
-        state
-    } else {
-        warn!("uninstall job doesn't have previous state, failing silently");
-        return;
-    };
-
-    if let Some((_, install_dir)) = match previous_state {
-        GameDownloadStatus::Installed {
-            version_name,
-            install_dir,
-        } => Some((version_name, install_dir)),
-        GameDownloadStatus::SetupRequired {
-            version_name,
-            install_dir,
-        } => Some((version_name, install_dir)),
-        GameDownloadStatus::PartiallyInstalled {
-            version_name,
-            install_dir,
-        } => Some((version_name, install_dir)),
-        _ => None,
-    } {
-        db_handle
-            .applications
-            .transient_statuses
-            .insert(meta.clone(), ApplicationTransientStatus::Uninstalling {});
-
-        drop(db_handle);
-
-        let app_handle = app_handle.clone();
-        spawn(move || {
-            if let Err(e) = remove_dir_all(install_dir) {
-                error!("{e}");
-            } else {
-                let mut db_handle = borrow_db_mut_checked();
-                db_handle.applications.transient_statuses.remove(&meta);
-                db_handle
-                    .applications
-                    .installed_game_version
-                    .remove(&meta.id);
-                db_handle
-                    .applications
-                    .game_statuses
-                    .insert(meta.id.clone(), GameDownloadStatus::Remote {});
-                let _ = db_handle.applications.transient_statuses.remove(&meta);
-
-                push_game_update(
-                    &app_handle,
-                    &meta.id,
-                    None,
-                    GameStatusManager::fetch_state(&meta.id, &db_handle),
-                );
-
-                debug!("uninstalled game id {}", &meta.id);
-                app_emit!(&app_handle, "update_library", ());
-            }
-        });
-    } else {
-        warn!("invalid previous state for uninstall, failing silently.");
-    }
-}
-
-pub fn get_current_meta(game_id: &String) -> Option<DownloadableMetadata> {
-    borrow_db_checked()
-        .applications
-        .installed_game_version
-        .get(game_id)
-        .cloned()
-}
-
-pub fn on_game_complete(
-    meta: &DownloadableMetadata,
-    install_dir: String,
-    app_handle: &AppHandle,
-) -> Result<(), RemoteAccessError> {
-    // Fetch game version information from remote
-    if meta.version.is_none() {
-        return Err(RemoteAccessError::GameNotFound(meta.id.clone()));
-    }
-
-    let client = DROP_CLIENT_SYNC.clone();
-    let response = generate_url(
-        &["/api/v1/client/game/version"],
-        &[
-            ("id", &meta.id),
-            ("version", meta.version.as_ref().unwrap()),
-        ],
-    )?;
-    let response = client
-        .get(response)
-        .header("Authorization", generate_authorization_header())
-        .send()?;
-
-    let game_version: GameVersion = response.json()?;
-
-    let mut handle = borrow_db_mut_checked();
-    handle
-        .applications
-        .game_versions
-        .entry(meta.id.clone())
-        .or_default()
-        .insert(meta.version.clone().unwrap(), game_version.clone());
-    handle
-        .applications
-        .installed_game_version
-        .insert(meta.id.clone(), meta.clone());
-
-    drop(handle);
-
-    let status = if game_version.setup_command.is_empty() {
-        GameDownloadStatus::Installed {
-            version_name: meta.version.clone().unwrap(),
-            install_dir,
-        }
-    } else {
-        GameDownloadStatus::SetupRequired {
-            version_name: meta.version.clone().unwrap(),
-            install_dir,
-        }
-    };
-
-    let mut db_handle = borrow_db_mut_checked();
-    db_handle
-        .applications
-        .game_statuses
-        .insert(meta.id.clone(), status.clone());
-    drop(db_handle);
-    app_emit!(
-        app_handle,
-        &format!("update_game/{}", meta.id),
-        GameUpdateEvent {
-            game_id: meta.id.clone(),
-            status: (Some(status), None),
-            version: Some(game_version),
-        }
-    );
-
-    Ok(())
-}
-
-pub fn push_game_update(
-    app_handle: &AppHandle,
-    game_id: &String,
-    version: Option<GameVersion>,
-    status: GameStatusWithTransient,
-) {
-    if let Some(GameDownloadStatus::Installed { .. } | GameDownloadStatus::SetupRequired { .. }) =
-        &status.0
-        && version.is_none()
-    {
-        panic!("pushed game for installed game that doesn't have version information");
-    }
-
-    app_emit!(
-        app_handle,
-        &format!("update_game/{game_id}"),
-        GameUpdateEvent {
-            game_id: game_id.clone(),
-            status,
-            version,
-        }
-    );
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FrontendGameOptions {
-    launch_string: String,
-}
-
-impl FrontendGameOptions {
-    pub fn launch_string(&self) -> &String {
-        &self.launch_string
-    }
-}

src-tauri/library/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "library"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-async-trait = "0.1.89"
-client = { version = "0.1.0", path = "../client" }
-database = { version = "0.1.0", path = "../database" }
-futures = "0.3.31"
-itertools = "0.14.0"
-log = "0.4.28"
-remote = { version = "0.1.0", path = "../remote" }
-serde = { version = "1.0.228", features = ["derive"] }
-serde_with = "3.15.0"
-tauri = "2.8.5"
-url = "2.5.7"

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

@@ -1,134 +0,0 @@
-use std::sync::nonpoison::Mutex;
-
-use async_trait::async_trait;
-use client::app_state::AppState;
-use database::{
-    DatabaseAuth, GameDownloadStatus, borrow_db_mut_checked,
-    models::{Collection, Game, LibraryProviderMetadata},
-};
-use log::warn;
-use remote::{
-    auth::generate_authorization_header,
-    cache::{cache_object, get_cached_object, get_cached_object_db},
-    error::{DropServerError, RemoteAccessError},
-    requests::generate_url,
-    utils::DROP_CLIENT_ASYNC,
-};
-use url::Url;
-
-use crate::{error::LibraryError, provider::LibraryProvider};
-
-pub struct DropLibraryProvider {
-    metadata: LibraryProviderMetadata,
-    auth: DatabaseAuth,
-    base_url: Url,
-}
-
-impl DropLibraryProvider {
-    pub fn new(metadata: LibraryProviderMetadata, auth: DatabaseAuth, base_url: Url) -> Self {
-        Self {
-            metadata,
-            auth,
-            base_url,
-        }
-    }
-}
-#[async_trait]
-impl LibraryProvider for DropLibraryProvider {
-    async fn get_library(
-        &self,
-        state: &tauri::State<'_, Mutex<AppState>>,
-    ) -> Result<Vec<Game>, LibraryError> {
-        // let do_hard_refresh = hard_fresh.unwrap_or(false);
-        if
-        /* !do_hard_refresh &&*/
-        let Ok(library) = get_cached_object("library") {
-            return Ok(library);
-        }
-
-        let client = DROP_CLIENT_ASYNC.clone();
-        let response = generate_url(&["/api/v1/client/user/library"], &[], self.base_url)?;
-        let response = client
-            .get(response)
-            .header("Authorization", generate_authorization_header(self.auth))
-            .send()
-            .await
-            .map_err(|e| LibraryError::FetchError(RemoteAccessError::FetchError(e.into())))?;
-
-        if response.status() != 200 {
-            let err = response.json().await.unwrap_or(DropServerError {
-                status_code: 500,
-                status_message: "Invalid response from server.".to_owned(),
-            });
-            warn!("{err:?}");
-            return Err(LibraryError::FetchError(
-                RemoteAccessError::InvalidResponse(err),
-            ));
-        }
-
-        let mut games: Vec<Game> = response
-            .json()
-            .await
-            .map_err(|e| RemoteAccessError::FetchError(e.into()))?;
-
-        let mut handle = state.lock();
-
-        let mut db_handle = borrow_db_mut_checked();
-
-        for game in &games {
-            handle.games_mut().insert(game.id().clone(), game.clone());
-            if !db_handle.applications.game_statuses.contains_key(game.id()) {
-                db_handle
-                    .applications
-                    .game_statuses
-                    .insert(game.id().clone(), GameDownloadStatus::Remote {});
-            }
-        }
-
-        // Add games that are installed but no longer in library
-        for meta in db_handle.applications.installed_game_version.values() {
-            if games.iter().any(|e| *e.id() == meta.id) {
-                continue;
-            }
-            // We should always have a cache of the object
-            // Pass db_handle because otherwise we get a gridlock
-            let game = match get_cached_object_db::<Game>(&meta.id.clone(), &db_handle) {
-                Ok(game) => game,
-                Err(err) => {
-                    warn!(
-                        "{} is installed, but encountered error fetching its error: {}.",
-                        meta.id, err
-                    );
-                    continue;
-                }
-            };
-            games.push(game);
-        }
-
-        drop(handle);
-        drop(db_handle);
-        cache_object("library", &games)?;
-
-        Ok(games)
-    }
-    async fn get_collections(&self) -> Result<Vec<Collection>, LibraryError> {
-        todo!()
-    }
-
-    fn install(&mut self, game_id: String) {
-        todo!()
-    }
-
-    fn uninstall(&mut self, game_id: String) {
-        todo!()
-    }
-
-    fn metadata(&self) -> LibraryProviderMetadata {
-        todo!()
-    }
-}
-
-async fn fetch_library_logic(state: &Mutex<AppState>) -> Result<Vec<Game>, RemoteAccessError> {}
-async fn fetch_library_logic_offline() -> Result<Vec<Game>, RemoteAccessError> {
-    todo!()
-}

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

@@ -1 +0,0 @@
-pub mod drop;

src-tauri/library/src/error.rs

@@ -1,31 +0,0 @@
-use std::fmt::Display;
-
-use database::models::LibraryProviderMetadata;
-use remote::error::RemoteAccessError;
-use serde_with::SerializeDisplay;
-
-#[derive(Debug, SerializeDisplay)]
-pub enum LibraryError {
-    ProviderConnection(ProviderError),
-    FetchError(RemoteAccessError)
-}
-#[derive(Debug, SerializeDisplay)]
-pub struct ProviderError {
-    provider: LibraryProviderMetadata
-}
-
-impl Display for LibraryError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        todo!()
-    }
-}
-impl Display for ProviderError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        todo!()
-    }
-}
-impl From<RemoteAccessError> for LibraryError {
-    fn from(value: RemoteAccessError) -> Self {
-        LibraryError::FetchError(value)
-    }
-}

src-tauri/library/src/lib.rs

@@ -1,69 +0,0 @@
-#![feature(nonpoison_mutex)]
-#![feature(sync_nonpoison)]
-
-use std::sync::{LazyLock, nonpoison::Mutex};
-
-use client::app_state::AppState;
-use database::{borrow_db_checked, models::{Game, LibraryProviderMetadata, ProviderType}};
-use futures::{StreamExt, future::join_all};
-use itertools::Itertools;
-
-use crate::{drop::drop::DropLibraryProvider, error::LibraryError, provider::LibraryProvider};
-
-pub mod drop;
-pub mod error;
-pub mod provider;
-
-pub static LIBRARY: LazyLock<Library> = LazyLock::new(Library::init);
-
-pub struct Library {
-    providers: Vec<Box<dyn LibraryProvider>>,
-}
-
-impl Library {
-    pub fn init() -> Self {
-        let metadata = borrow_db_checked();
-        let library = &metadata.library;
-        let providers = library.providers().iter().map(|provider| {
-            Library::construct(provider)
-        }).collect();
-        Self {
-            providers
-        }
-    }
-    fn construct(provider: &LibraryProviderMetadata) -> Box<dyn LibraryProvider> {
-        todo!()
-    }
-    pub async fn get_library(
-        &self,
-        state: &tauri::State<'_, Mutex<AppState>>,
-    ) -> (Vec<Game>, Vec<LibraryError>) {
-        let res = join_all(
-            self.providers
-                .iter()
-                .map(|provider| provider.get_library(state)),
-        )
-        .await
-        .into_iter()
-        .fold(
-            (Vec::new(), Vec::new()),
-            |(mut acc_ok, mut acc_err), res| {
-                match res {
-                    Ok(games) => acc_ok.extend(games),
-                    Err(e) => acc_err.push(e),
-                };
-                (acc_ok, acc_err)
-            },
-        );
-        res
-    }
-    pub fn add(&mut self, provider: LibraryProviderMetadata) {
-        let new_provider = Box::new(match provider.provider() {
-            ProviderType::Drop(_) => DropLibraryProvider::new(provider),
-        });
-        self.providers.push(new_provider);
-    }
-    pub fn remove(&mut self, id: usize) {
-        self.providers.retain(|v| v.metadata().id() != id);
-    }
-}

src-tauri/library/src/provider.rs

@@ -1,16 +0,0 @@
-use std::sync::nonpoison::Mutex;
-
-use async_trait::async_trait;
-use client::app_state::AppState;
-use database::models::{Collection, Game, LibraryProviderMetadata};
-
-use crate::error::LibraryError;
-
-#[async_trait]
-pub trait LibraryProvider: Sync + Send {
-    async fn get_library(&self, state: &tauri::State<'_, Mutex<AppState>>) -> Result<Vec<Game>, LibraryError>;
-    async fn get_collections(&self) -> Result<Vec<Collection>, LibraryError>;
-    fn install(&mut self, game_id: String);
-    fn uninstall(&mut self, game_id: String);
-    fn metadata(&self) -> LibraryProviderMetadata;
-}

src-tauri/process/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "process"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-chrono = "0.4.42"
-client = { version = "0.1.0", path = "../client" }
-database = { version = "0.1.0", path = "../database" }
-dynfmt = "0.1.5"
-games = { version = "0.1.0", path = "../games" }
-log = "0.4.28"
-page_size = "0.6.0"
-serde = "1.0.228"
-serde_with = "3.15.0"
-shared_child = "1.1.1"
-tauri = "2.8.5"
-tauri-plugin-opener = "2.5.0"
-utils = { version = "0.1.0", path = "../utils" }

src-tauri/process/src/lib.rs

@@ -1,41 +0,0 @@
-#![feature(nonpoison_mutex)]
-#![feature(sync_nonpoison)]
-
-use std::{
-    ops::Deref,
-    sync::{OnceLock, nonpoison::Mutex},
-};
-
-use tauri::AppHandle;
-
-use crate::process_manager::ProcessManager;
-
-pub static PROCESS_MANAGER: ProcessManagerWrapper = ProcessManagerWrapper::new();
-
-pub mod error;
-pub mod format;
-pub mod process_handlers;
-pub mod process_manager;
-
-pub struct ProcessManagerWrapper(OnceLock<Mutex<ProcessManager<'static>>>);
-impl ProcessManagerWrapper {
-    const fn new() -> Self {
-        ProcessManagerWrapper(OnceLock::new())
-    }
-    pub fn init(app_handle: AppHandle) {
-        PROCESS_MANAGER
-            .0
-            .set(Mutex::new(ProcessManager::new(app_handle)))
-            .unwrap_or_else(|_| panic!("Failed to initialise Process Manager")); // Using panic! here because we can't implement Debug
-    }
-}
-impl Deref for ProcessManagerWrapper {
-    type Target = Mutex<ProcessManager<'static>>;
-
-    fn deref(&self) -> &Self::Target {
-        match self.0.get() {
-            Some(process_manager) => process_manager,
-            None => unreachable!("Download manager should always be initialised"),
-        }
-    }
-}

src-tauri/remote/Cargo.toml

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

src-tauri/remote/src/auth.rs

@@ -1,133 +0,0 @@
-use std::{collections::HashMap, env};
-
-use chrono::Utc;
-use client::{app_status::AppStatus, user::User};
-use database::{DatabaseAuth, interface::borrow_db_checked};
-use droplet_rs::ssl::sign_nonce;
-use gethostname::gethostname;
-use log::{error, warn};
-use serde::{Deserialize, Serialize};
-use url::Url;
-
-use crate::{
-    error::{DropServerError, RemoteAccessError},
-    requests::make_authenticated_get,
-    utils::DROP_CLIENT_SYNC,
-};
-
-use 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")]
-pub struct HandshakeRequestBody {
-    client_id: String,
-    token: String,
-}
-
-impl HandshakeRequestBody {
-    pub fn new(client_id: String, token: String) -> Self {
-        Self { client_id, token }
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct HandshakeResponse {
-    private: String,
-    certificate: String,
-    id: String,
-}
-
-impl From<HandshakeResponse> for DatabaseAuth {
-    fn from(value: HandshakeResponse) -> Self {
-        DatabaseAuth::new(value.private, value.certificate, value.id, None)
-    }
-}
-
-pub fn generate_authorization_header(auth: DatabaseAuth) -> String {
-    let nonce = Utc::now().timestamp_millis().to_string();
-
-    let signature =
-        sign_nonce(auth.private, nonce.clone()).expect("Failed to generate authorisation header");
-
-    format!("Nonce {} {} {}", auth.client_id, nonce, signature)
-}
-
-pub async fn fetch_user(auth: DatabaseAuth, base_url: Url) -> Result<User, RemoteAccessError> {
-    let response = make_authenticated_get(generate_url(&["/api/v1/client/user"], &[], base_url)?, auth).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)
-}
-
-pub fn auth_initiate_logic(mode: String, base_url: Url) -> Result<String, RemoteAccessError> {
-    let hostname = gethostname();
-
-    let endpoint = base_url.join("/api/v1/client/auth/initiate")?;
-    let body = InitiateRequestBody {
-        name: format!("{} (Desktop)", hostname.display()),
-        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(auth: DatabaseAuth, base_url: Url) -> (AppStatus, Option<User>) {
-    let user_result = match fetch_user(auth, base_url).await {
-        Ok(data) => data,
-        Err(RemoteAccessError::FetchError(_)) => {
-            let user = get_cached_object::<User>("user").ok();
-            return (AppStatus::Offline, user);
-        }
-        Err(_) => return (AppStatus::SignedInNeedsReauth, None),
-    };
-    if let Err(e) = cache_object("user", &user_result) {
-        warn!("Could not cache user object with error {e}");
-    }
-    return (AppStatus::SignedIn, Some(user_result));
-}

src-tauri/remote/src/fetch_object.rs

@@ -1,85 +0,0 @@
-use database::{DB, DatabaseAuth, interface::DatabaseImpls};
-use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
-use log::{debug, warn};
-use tauri::UriSchemeResponder;
-use url::Url;
-
-use crate::{error::CacheError, utils::DROP_CLIENT_ASYNC};
-
-use super::{
-    auth::generate_authorization_header,
-    cache::{ObjectCache, cache_object, get_cached_object},
-};
-
-pub async fn fetch_object_wrapper(request: http::Request<Vec<u8>>, responder: UriSchemeResponder, auth: DatabaseAuth, base_url: Url) {
-    match fetch_object(request, auth, base_url).await {
-        Ok(r) => responder.respond(r),
-        Err(e) => {
-            warn!("Cache error: {e}");
-            responder.respond(
-                Response::builder()
-                    .status(500)
-                    .body(Vec::new())
-                    .expect("Failed to build error response"),
-            );
-        }
-    };
-}
-
-pub async fn fetch_object(
-    request: http::Request<Vec<u8>>,
-    auth: DatabaseAuth,
-    base_url: Url
-) -> Result<Response<Vec<u8>>, CacheError> {
-    // Drop leading /
-    let object_id = &request.uri().path()[1..];
-
-    let cache_result = get_cached_object::<ObjectCache>(object_id);
-    if let Ok(cache_result) = &cache_result
-        && !cache_result.has_expired()
-    {
-        return cache_result.try_into();
-    }
-
-    let header = generate_authorization_header(auth);
-    let client = DROP_CLIENT_ASYNC.clone();
-    let url = format!("{}api/v1/client/object/{object_id}", base_url);
-    let response = client.get(url).header("Authorization", header).send().await;
-
-    match response {
-        Ok(r) => {
-            let resp_builder = ResponseBuilder::new().header(
-                CONTENT_TYPE,
-                r.headers()
-                    .get("Content-Type")
-                    .expect("Failed get Content-Type header"),
-            );
-            let data = match r.bytes().await {
-                Ok(data) => Vec::from(data),
-                Err(e) => {
-                    warn!("Could not get data from cache object {object_id} with error {e}",);
-                    Vec::new()
-                }
-            };
-            let resp = resp_builder
-                .body(data)
-                .expect("Failed to build object cache response body");
-            if cache_result.map_or(true, |x| x.has_expired()) {
-                cache_object::<ObjectCache>(object_id, &resp.clone().try_into()?)
-                    .expect("Failed to create cached object");
-            }
-
-            Ok(resp)
-        }
-        Err(e) => {
-            debug!("Object fetch failed with error {e}. Attempting to download from cache");
-            match cache_result {
-                Ok(cache_result) => cache_result.try_into(),
-                Err(e) => {
-                    warn!("{e}");
-                    Err(CacheError::Remote(e))
-                }
-            }
-        }
-    }
-}

src-tauri/remote/src/server_proto.rs

@@ -1,102 +0,0 @@
-use std::str::FromStr;
-
-use database::{DatabaseAuth, borrow_db_checked};
-use http::{Request, Response, StatusCode, Uri, uri::PathAndQuery};
-use log::warn;
-use tauri::UriSchemeResponder;
-use url::Url;
-use utils::webbrowser_open::webbrowser_open;
-
-use crate::utils::DROP_CLIENT_SYNC;
-
-pub async fn handle_server_proto_offline_wrapper(
-    request: Request<Vec<u8>>,
-    responder: UriSchemeResponder,
-) {
-    responder.respond(match handle_server_proto_offline(request).await {
-        Ok(res) => res,
-        Err(_) => unreachable!(),
-    });
-}
-
-pub async fn handle_server_proto_offline(
-    _request: Request<Vec<u8>>,
-) -> Result<Response<Vec<u8>>, StatusCode> {
-    Ok(Response::builder()
-        .status(StatusCode::NOT_FOUND)
-        .body(Vec::new())
-        .expect("Failed to build error response for proto offline"))
-}
-
-pub async fn handle_server_proto_wrapper(request: Request<Vec<u8>>, responder: UriSchemeResponder, auth: DatabaseAuth, base_url: Url) {
-    match handle_server_proto(request, auth, base_url).await {
-        Ok(r) => responder.respond(r),
-        Err(e) => {
-            warn!("Cache error: {e}");
-            responder.respond(
-                Response::builder()
-                    .status(e)
-                    .body(Vec::new())
-                    .expect("Failed to build error response"),
-            );
-        }
-    }
-}
-
-async fn handle_server_proto(
-    request: Request<Vec<u8>>,
-    auth: DatabaseAuth,
-    base_url: Url,
-) -> Result<Response<Vec<u8>>, StatusCode> {
-    let web_token = match &auth.web_token {
-        Some(token) => token,
-        None => return Err(StatusCode::UNAUTHORIZED),
-    };
-    let remote_uri = base_url.as_str().parse::<Uri>().expect("Failed to parse base url");
-
-    let path = request.uri().path();
-
-    let mut new_uri = request.uri().clone().into_parts();
-    new_uri.path_and_query = Some(
-        PathAndQuery::from_str(&format!("{path}?noWrapper=true"))
-            .expect("Failed to parse request path in proto"),
-    );
-    new_uri.authority = remote_uri.authority().cloned();
-    new_uri.scheme = remote_uri.scheme().cloned();
-    let err_msg = &format!("Failed to build new uri from parts {new_uri:?}");
-    let new_uri = Uri::from_parts(new_uri).expect(err_msg);
-
-    let whitelist_prefix = ["/store", "/api", "/_", "/fonts"];
-
-    if whitelist_prefix.iter().all(|f| !path.starts_with(f)) {
-        webbrowser_open(new_uri.to_string());
-        return Ok(Response::new(Vec::new()));
-    }
-
-    let client = DROP_CLIENT_SYNC.clone();
-    let response = match client
-        .request(request.method().clone(), new_uri.to_string())
-        .header("Authorization", format!("Bearer {web_token}"))
-        .headers(request.headers().clone())
-        .send()
-    {
-        Ok(response) => response,
-        Err(e) => {
-            warn!("Could not send response. Got {e} when sending");
-            return Err(e.status().unwrap_or(StatusCode::BAD_REQUEST));
-        }
-    };
-
-    let response_status = response.status();
-    let response_body = match response.bytes() {
-        Ok(bytes) => bytes,
-        Err(e) => return Err(e.status().unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)),
-    };
-
-    let http_response = Response::builder()
-        .status(response_status)
-        .body(response_body.to_vec())
-        .expect("Failed to build server proto response");
-
-    Ok(http_response)
-}

src-tauri/remote/src/utils.rs

@@ -1,119 +0,0 @@
-use std::{
-    fs::{self, File},
-    io::Read,
-    sync::LazyLock,
-};
-
-use database::db::DATA_ROOT_DIR;
-use log::{debug, info, warn};
-use reqwest::Certificate;
-use serde::Deserialize;
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DropHealthcheck {
-    app_name: String,
-}
-impl DropHealthcheck {
-    pub fn app_name(&self) -> &String {
-        &self.app_name
-    }
-}
-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);
-pub static DROP_CLIENT_ASYNC: LazyLock<reqwest::Client> = LazyLock::new(get_client_async);
-pub static DROP_CLIENT_WS_CLIENT: LazyLock<reqwest::Client> = LazyLock::new(get_client_ws);
-
-fn fetch_certificates() -> Vec<Certificate> {
-    let certificate_dir = DATA_ROOT_DIR.join("certificates");
-
-    let mut certs = Vec::new();
-    match fs::read_dir(certificate_dir) {
-        Ok(c) => {
-            for entry in c {
-                match entry {
-                    Ok(c) => {
-                        let mut buf = Vec::new();
-                        match File::open(c.path()) {
-                            Ok(f) => f,
-                            Err(e) => {
-                                warn!(
-                                    "Failed to open file at {} with error {}",
-                                    c.path().display(),
-                                    e
-                                );
-                                continue;
-                            }
-                        }
-                        .read_to_end(&mut buf)
-                        .unwrap_or_else(|e| {
-                            panic!(
-                                "Failed to read to end of certificate file {} with error {}",
-                                c.path().display(),
-                                e
-                            )
-                        });
-
-                        match Certificate::from_pem_bundle(&buf) {
-                            Ok(certificates) => {
-                                for cert in certificates {
-                                    certs.push(cert);
-                                }
-                                info!(
-                                    "added {} certificate(s) from {}",
-                                    certs.len(),
-                                    c.file_name().display()
-                                );
-                            }
-                            Err(e) => warn!(
-                                "Invalid certificate file {} with error {}",
-                                c.path().display(),
-                                e
-                            ),
-                        }
-                    }
-                    Err(_) => todo!(),
-                }
-            }
-        }
-        Err(e) => {
-            debug!("not loading certificates due to error: {e}");
-        }
-    };
-    certs
-}
-
-pub fn get_client_sync() -> reqwest::blocking::Client {
-    let mut client = reqwest::blocking::ClientBuilder::new();
-
-    for cert in DROP_CERT_BUNDLE.iter() {
-        client = client.add_root_certificate(cert.clone());
-    }
-    client
-        .use_rustls_tls()
-        .build()
-        .expect("Failed to build synchronous client")
-}
-pub fn get_client_async() -> reqwest::Client {
-    let mut client = reqwest::ClientBuilder::new();
-
-    for cert in DROP_CERT_BUNDLE.iter() {
-        client = client.add_root_certificate(cert.clone());
-    }
-    client
-        .use_rustls_tls()
-        .build()
-        .expect("Failed to build asynchronous client")
-}
-pub fn get_client_ws() -> reqwest::Client {
-    let mut client = reqwest::ClientBuilder::new();
-
-    for cert in DROP_CERT_BUNDLE.iter() {
-        client = client.add_root_certificate(cert.clone());
-    }
-    client
-        .use_rustls_tls()
-        .http1_only()
-        .build()
-        .expect("Failed to build websocket client")
-}

src-tauri/src/client.rs

@@ -1,81 +0,0 @@
-use std::sync::nonpoison::Mutex;
-
-use client::app_state::AppState;
-use database::{borrow_db_checked, borrow_db_mut_checked};
-use download_manager::DOWNLOAD_MANAGER;
-use log::{debug, error};
-use tauri::AppHandle;
-use tauri_plugin_autostart::ManagerExt;
-use tauri_plugin_opener::OpenerExt;
-
-#[tauri::command]
-pub fn fetch_state(state: tauri::State<'_, Mutex<AppState>>) -> Result<String, String> {
-    let guard = state.lock();
-    let cloned_state = serde_json::to_string(&guard.clone()).map_err(|e| e.to_string())?;
-    drop(guard);
-    Ok(cloned_state)
-}
-
-#[tauri::command]
-pub fn quit(app: tauri::AppHandle) {
-    cleanup_and_exit(&app);
-}
-
-pub fn cleanup_and_exit(app: &AppHandle) {
-    debug!("cleaning up and exiting application");
-    match DOWNLOAD_MANAGER.ensure_terminated() {
-        Ok(res) => match res {
-            Ok(()) => debug!("download manager terminated correctly"),
-            Err(()) => error!("download manager failed to terminate correctly"),
-        },
-        Err(e) => panic!("{e:?}"),
-    }
-
-    app.exit(0);
-}
-
-#[tauri::command]
-pub fn toggle_autostart(app: AppHandle, enabled: bool) -> Result<(), String> {
-    let manager = app.autolaunch();
-    if enabled {
-        manager.enable().map_err(|e| e.to_string())?;
-        debug!("enabled autostart");
-    } else {
-        manager.disable().map_err(|e| e.to_string())?;
-        debug!("eisabled autostart");
-    }
-
-    // Store the state in DB
-    let mut db_handle = borrow_db_mut_checked();
-    db_handle.settings.autostart = enabled;
-    Ok(())
-}
-
-#[tauri::command]
-pub fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
-    let db_handle = borrow_db_checked();
-    let db_state = db_handle.settings.autostart;
-    drop(db_handle);
-
-    // Get actual system state
-    let manager = app.autolaunch();
-    let system_state = manager.is_enabled()?;
-
-    // If they don't match, sync to DB state
-    if db_state != system_state {
-        if db_state {
-            manager.enable()?;
-        } else {
-            manager.disable()?;
-        }
-    }
-
-    Ok(db_state)
-}
-
-#[tauri::command]
-pub fn open_fs(path: String, app_handle: AppHandle) -> Result<(), tauri_plugin_opener::Error> {
-    app_handle
-        .opener()
-        .open_path(path, None::<&str>)
-}

src-tauri/src/client/autostart.rs

@@ -0,0 +1,75 @@
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
+use log::debug;
+use tauri::AppHandle;
+use tauri_plugin_autostart::ManagerExt;
+
+pub fn toggle_autostart_logic(app: AppHandle, enabled: bool) -> Result<(), String> {
+    let manager = app.autolaunch();
+    if enabled {
+        manager.enable().map_err(|e| e.to_string())?;
+        debug!("enabled autostart");
+    } else {
+        manager.disable().map_err(|e| e.to_string())?;
+        debug!("eisabled autostart");
+    }
+
+    // Store the state in DB
+    let mut db_handle = borrow_db_mut_checked();
+    db_handle.settings.autostart = enabled;
+    drop(db_handle);
+
+    Ok(())
+}
+
+pub fn get_autostart_enabled_logic(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
+    // First check DB state
+    let db_handle = borrow_db_checked();
+    let db_state = db_handle.settings.autostart;
+    drop(db_handle);
+
+    // Get actual system state
+    let manager = app.autolaunch();
+    let system_state = manager.is_enabled()?;
+
+    // If they don't match, sync to DB state
+    if db_state != system_state {
+        if db_state {
+            manager.enable()?;
+        } else {
+            manager.disable()?;
+        }
+    }
+
+    Ok(db_state)
+}
+
+// New function to sync state on startup
+pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
+    let db_handle = borrow_db_checked();
+    let should_be_enabled = db_handle.settings.autostart;
+    drop(db_handle);
+
+    let manager = app.autolaunch();
+    let current_state = manager.is_enabled().map_err(|e| e.to_string())?;
+
+    if current_state != should_be_enabled {
+        if should_be_enabled {
+            manager.enable().map_err(|e| e.to_string())?;
+            debug!("synced autostart: enabled");
+        } else {
+            manager.disable().map_err(|e| e.to_string())?;
+            debug!("synced autostart: disabled");
+        }
+    }
+
+    Ok(())
+}
+#[tauri::command]
+pub fn toggle_autostart(app: AppHandle, enabled: bool) -> Result<(), String> {
+    toggle_autostart_logic(app, enabled)
+}
+
+#[tauri::command]
+pub fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
+    get_autostart_enabled_logic(app)
+}

src-tauri/src/client/cleanup.rs

@@ -0,0 +1,23 @@
+use log::{debug, error};
+use tauri::AppHandle;
+
+use crate::AppState;
+
+#[tauri::command]
+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<'_>>>) {
+    debug!("cleaning up and exiting application");
+    let download_manager = state.lock().unwrap().download_manager.clone();
+    match download_manager.ensure_terminated() {
+        Ok(res) => match res {
+            Ok(()) => debug!("download manager terminated correctly"),
+            Err(()) => error!("download manager failed to terminate correctly"),
+        },
+        Err(e) => panic!("{e:?}"),
+    }
+
+    app.exit(0);
+}

src-tauri/src/client/commands.rs

@@ -0,0 +1,11 @@
+use crate::AppState;
+
+#[tauri::command]
+pub fn fetch_state(
+    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())?;
+    drop(guard);
+    Ok(cloned_state)
+}

src-tauri/src/client/mod.rs

@@ -0,0 +1,3 @@
+pub mod autostart;
+pub mod cleanup;
+pub mod commands;

src-tauri/src/cloud_saves/backup_manager.rs

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

src-tauri/src/cloud_saves/conditions.rs

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