chore: Starting migrating references to database applications, auth, and base_url

Signed-off-by: quexeky <git@quexeky.dev>
2026-01-30 19:15:17 +01:00 · 2025-10-22 18:55:55 +11:00
63 changed files with 14556 additions and 14628 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,4 +1,4 @@
-name: "publish"
+name: 'publish'

 on:
  workflow_dispatch: {}
@@ -18,16 +18,16 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - platform: "macos-14" # for Arm based macs (M1 and above).
-            args: "--target aarch64-apple-darwin"
-          - platform: "macos-14" # for Intel based macs.
-            args: "--target x86_64-apple-darwin"
-          - platform: "ubuntu-22.04" # for Tauri v1 you could replace this with ubuntu-20.04.
-            args: ""
-          - platform: "ubuntu-22.04-arm"
-            args: "--target aarch64-unknown-linux-gnu"
-          - platform: "windows-latest"
-            args: ""
+          - platform: 'macos-latest' # for Arm based macs (M1 and above).
+            args: '--target aarch64-apple-darwin'
+          - platform: 'macos-latest' # for Intel based macs.
+            args: '--target x86_64-apple-darwin'
+          - platform: 'ubuntu-22.04' # for Tauri v1 you could replace this with ubuntu-20.04.
+            args: ''
+          - platform: 'ubuntu-22.04-arm'
+            args: '--target aarch64-unknown-linux-gnu'
+          - platform: 'windows-latest'
+            args: ''

    runs-on: ${{ matrix.platform }}
    steps:
@@ -36,29 +36,16 @@ jobs:
          submodules: true
          token: ${{ secrets.GITHUB_TOKEN }}

-      - name: setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-          run_install: false
-
      - name: setup node
        uses: actions/setup-node@v4
        with:
          node-version: lts/*
-          cache: pnpm
-

      - name: install Rust nightly
        uses: dtolnay/rust-toolchain@nightly
        with:
          # Those targets are only used on macos runners so it's in an `if` to slightly speed up windows and linux builds.
-          targets: ${{ matrix.platform == 'macos-14' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
-
-      - name: Rust cache
-        uses: swatinem/rust-cache@v2
-        with:
-          workspaces: './src-tauri -> target'
+          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}

      - name: install dependencies (ubuntu only)
        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm' # This must match the platform value defined above.
@@ -67,8 +54,9 @@ jobs:
          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf xdg-utils
        # webkitgtk 4.0 is for Tauri v1 - webkitgtk 4.1 is for Tauri v2.

+
      - name: Import Apple Developer Certificate
-        if: matrix.platform == 'macos-14'
+        if: matrix.platform == 'macos-latest'
        env:
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
@@ -79,30 +67,18 @@ jobs:
          security default-keychain -s build.keychain
          security unlock-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
          security set-keychain-settings -t 3600 -u build.keychain
-
-
-          echo "Created keychain"
-
-          curl https://droposs.org/drop.der --output drop.der
-
-          # swiftc libs/appletrust/add-certificate.swift
-          # ./add-certificate drop.der
-          # rm add-certificate
-
-          # echo "Added certificate to keychain using swift util"
-
-          ## Script is equivalent to:
-          sudo security authorizationdb write com.apple.trust-settings.admin allow
-          sudo security add-trusted-cert -d -r trustRoot -k build.keychain -p codeSign -u -1 drop.der
-          sudo security authorizationdb remove com.apple.trust-settings.admin
+          
+          curl https://droposs.org/drop.crt --output drop.pem
+          sudo security authorizationdb write com.apple.trust-settings.user allow
+          security add-trusted-cert -r trustRoot -k build.keychain -p codeSign -u -1 drop.pem
+          sudo security authorizationdb remove com.apple.trust-settings.user

          security import certificate.p12 -k build.keychain -P "$APPLE_CERTIFICATE_PASSWORD" -T /usr/bin/codesign
-          echo "Imported certificate"
          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" build.keychain
          security find-identity -v -p codesigning build.keychain

      - name: Verify Certificate
-        if: matrix.platform == 'macos-14'
+        if: matrix.platform == 'macos-latest'
        run: |
          CERT_INFO=$(security find-identity -v -p codesigning build.keychain | grep "Drop OSS")
          CERT_ID=$(echo "$CERT_INFO" | awk -F'"' '{print $2}')
@@ -110,7 +86,7 @@ jobs:
          echo "Certificate imported. Using identity: $CERT_ID"

      - name: install frontend dependencies
-        run: pnpm install # change this to npm, pnpm or bun depending on which one you use.
+        run: yarn install # change this to npm, pnpm or bun depending on which one you use.

      - uses: tauri-apps/tauri-action@v0
        env:
@@ -121,8 +97,8 @@ jobs:
          NO_STRIP: true
        with:
          tagName: v__VERSION__ # the action automatically replaces \_\_VERSION\_\_ with the app version.
-          releaseName: "Auto-release v__VERSION__"
-          releaseBody: "See the assets to download this version and install. This release was created automatically."
+          releaseName: 'Auto-release v__VERSION__'
+          releaseBody: 'See the assets to download this version and install. This release was created automatically.'
          releaseDraft: false
          prerelease: true
-          args: ${{ matrix.args }}
+          args: ${{ matrix.args }}
--- a/.gitlab-ci-local/.gitignore
+++ b/.gitlab-ci-local/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
--- a/build.mjs
+++ b/build.mjs
@@ -40,10 +40,10 @@ for (const view of views) {
  process.chdir(`./${view}`);

  loggerChild.info(`Install deps for "${view}"`);
-  await spawn("pnpm install");
+  await spawn("yarn");

  loggerChild.info(`Building "${view}"`);
-  await spawn("pnpm run build", {
+  await spawn("yarn build", {
    env: { ...process.env, NUXT_APP_BASE_URL: `/${view}/` },
  });

--- a/libs/appletrust/add-certificate.swift
+++ b/libs/appletrust/add-certificate.swift
@@ -1,72 +0,0 @@
-import Foundation
-import Security
-
-enum SecurityError: Error {
-    case generalError
-}
-
-func deleteCertificateFromKeyChain(_ certificateLabel: String) -> Bool {
-    let delQuery: [NSString: Any] = [
-        kSecClass: kSecClassCertificate,
-        kSecAttrLabel: certificateLabel,
-    ]
-    let delStatus: OSStatus = SecItemDelete(delQuery as CFDictionary)
-
-    return delStatus == errSecSuccess
-}
-
-func saveCertificateToKeyChain(_ certificate: SecCertificate, certificateLabel: String) throws {
-    SecKeychainSetPreferenceDomain(SecPreferencesDomain.system)
-    deleteCertificateFromKeyChain(certificateLabel)
-
-    let setQuery: [NSString: AnyObject] = [
-        kSecClass: kSecClassCertificate,
-        kSecValueRef: certificate,
-        kSecAttrLabel: certificateLabel as AnyObject,
-        kSecAttrAccessible: kSecAttrAccessibleWhenUnlocked,
-        kSecAttrCanSign: true as AnyObject,
-    ]
-    let addStatus: OSStatus = SecItemAdd(setQuery as CFDictionary, nil)
-
-    guard addStatus == errSecSuccess else {
-        throw SecurityError.generalError
-    }
-
-    var status = SecTrustSettingsSetTrustSettings(certificate, SecTrustSettingsDomain.admin, nil)
-}
-
-func getCertificateFromString(stringData: String) throws -> SecCertificate {
-    if let data = NSData(base64Encoded: stringData, options: NSData.Base64DecodingOptions.ignoreUnknownCharacters) {
-        if let certificate = SecCertificateCreateWithData(kCFAllocatorDefault, data) {
-            return certificate
-        }
-    }
-    throw SecurityError.generalError
-}
-
-if CommandLine.arguments.count != 2 {
-    print("Usage: \(CommandLine.arguments[0]) [cert.file]")
-    print("Usage: \(CommandLine.arguments[0]) --version")
-    exit(1)
-}
-
-if (CommandLine.arguments[1] == "--version") {
-    let version = "dev"
-    print(version)
-    exit(0)
-} else {
-    let fileURL = URL(fileURLWithPath: CommandLine.arguments[1])
-    do {
-        let certData = try Data(contentsOf: fileURL)
-        let certificate = SecCertificateCreateWithData(nil, certData as CFData)
-        if certificate != nil {
-            try? saveCertificateToKeyChain(certificate!, certificateLabel: "DropOSS")
-            exit(0)
-        } else {
-            print("ERROR: Unknown error while reading the \(CommandLine.arguments[1]) file.")
-        }
-    } catch {
-        print("ERROR: Unexpected error while reading the \(CommandLine.arguments[1]) file. \(error)")
-    }
-}
-exit(1)
--- a/main/components/LibrarySearch.vue
+++ b/main/components/LibrarySearch.vue
@@ -73,7 +73,7 @@
                  alt=""
                />
              </div>
-              <div class="truncate inline-flex items-center gap-x-2">
+              <div class="inline-flex items-center gap-x-2">
                <p
                  class="text-sm whitespace-nowrap font-display font-semibold"
                >
--- a/main/nuxt.config.ts
+++ b/main/nuxt.config.ts
@@ -12,7 +12,6 @@ export default defineNuxtConfig({
  css: ["~/assets/main.scss"],

  ssr: false,
-  devtools: false,

  extends: [["../libs/drop-base"]],

--- a/main/package.json
+++ b/main/package.json
@@ -1,7 +1,7 @@
 {
  "name": "view",
  "private": true,
-  "version": "0.3.4",
+  "version": "0.3.3",
  "type": "module",
  "scripts": {
    "build": "nuxt generate",
@@ -14,8 +14,6 @@
    "@heroicons/vue": "^2.1.5",
    "@nuxtjs/tailwindcss": "^6.12.2",
    "@tauri-apps/api": "^2.7.0",
-    "@tauri-apps/plugin-os": "^2.3.2",
-    "@tauri-apps/plugin-shell": "^2.3.3",
    "koa": "^2.16.1",
    "markdown-it": "^14.1.0",
    "micromark": "^4.0.1",
@@ -34,5 +32,6 @@
    "tailwindcss": "^3.4.13",
    "typescript": "^5.8.3",
    "vue-tsc": "^2.2.10"
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }
--- a/main/pnpm-lock.yaml
+++ b/main/pnpm-lock.yaml
--- a/main/pnpm-workspace.yaml
+++ b/main/pnpm-workspace.yaml
@@ -1,3 +0,0 @@
-onlyBuiltDependencies:
-  - '@parcel/watcher'
-  - esbuild
--- a/main/yarn.lock
+++ b/main/yarn.lock
--- a/nvidia-prop-dev.sh
+++ b/nvidia-prop-dev.sh
@@ -1 +1 @@
-WEBKIT_DISABLE_DMABUF_RENDERER=1 pnpm tauri dev
+WEBKIT_DISABLE_DMABUF_RENDERER=1 yarn tauri dev
--- a/optimize-appimage.sh
+++ b/optimize-appimage.sh
@@ -3,7 +3,7 @@
 ARCH=$(uname -m)

 # build tauri apps
-# NO_STRIP=true pnpm tauri build -- --verbose
+# NO_STRIP=true yarn tauri build -- --verbose

 # unpack appimage
 APPIMAGE=$(ls ./src-tauri/target/release/bundle/appimage/*.AppImage)
--- a/package.json
+++ b/package.json
@@ -7,11 +7,17 @@
    "tauri": "tauri"
  },
  "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-opener": "^2.5.0",
+    "@tauri-apps/plugin-os": "^2.3.0",
+    "@tauri-apps/plugin-shell": "^2.3.0",
    "pino": "^9.7.0",
    "pino-pretty": "^13.1.1",
    "tauri": "^0.15.0"
  },
  "devDependencies": {
-    "@tauri-apps/cli": "^2.9.4"
+    "@tauri-apps/cli": "^2.7.1"
  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,21 +0,0 @@
-onlyBuiltDependencies:
-  - sharp
-
-overrides:
-  cross-spawn@<6.0.6: '>=6.0.6'
-  cross-spawn@>=7.0.0 <7.0.5: '>=7.0.5'
-  form-data@<2.5.4: '>=2.5.4'
-  got@<11.8.5: '>=11.8.5'
-  http-cache-semantics@<4.1.1: '>=4.1.1'
-  lodash@<4.17.21: '>=4.17.21'
-  lodash@>=4.0.0 <4.17.21: '>=4.17.21'
-  minimist@>=1.0.0 <1.2.6: '>=1.2.6'
-  nth-check@<2.0.1: '>=2.0.1'
-  semver-regex@<3.1.3: '>=3.1.3'
-  semver-regex@<3.1.4: '>=3.1.4'
-  semver@>=7.0.0 <7.5.2: '>=7.5.2'
-  sharp@<0.30.5: '>=0.30.5'
-  sharp@<0.32.6: '>=0.32.6'
-  tmp@<=0.2.3: '>=0.2.4'
-  tough-cookie@<4.1.3: '>=4.1.3'
-  trim-newlines@<3.0.1: '>=3.0.1'
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -785,6 +785,7 @@ version = "0.1.0"
 dependencies = [
 "bitcode",
 "database",
+ "drop-consts",
 "log",
 "serde",
 "tauri",
@@ -797,6 +798,7 @@ version = "0.1.0"
 dependencies = [
 "database",
 "dirs 6.0.0",
+ "drop-consts",
 "log",
 "regex",
 "rustix 1.1.2",
@@ -1065,8 +1067,10 @@ checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 name = "database"
 version = "0.1.0"
 dependencies = [
+ "bitcode",
 "chrono",
 "dirs 6.0.0",
+ "drop-consts",
 "log",
 "native_model",
 "rustbreak",
@@ -1339,7 +1343,7 @@ dependencies = [

 [[package]]
 name = "drop-app"
-version = "0.3.4"
+version = "0.3.3"
 dependencies = [
 "atomic-instant-full",
 "bitcode",
@@ -1414,6 +1418,13 @@ dependencies = [
 "zstd",
 ]

+[[package]]
+name = "drop-consts"
+version = "0.1.0"
+dependencies = [
+ "dirs 6.0.0",
+]
+
 [[package]]
 name = "droplet-rs"
 version = "0.7.3"
@@ -1841,6 +1852,7 @@ dependencies = [
 "boxcar",
 "database",
 "download_manager",
+ "drop-consts",
 "hex 0.4.3",
 "log",
 "md5 0.8.0",
@@ -2739,6 +2751,15 @@ dependencies = [
 "once_cell",
 ]

+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.15"
@@ -2935,6 +2956,23 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"

+[[package]]
+name = "library"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "client",
+ "database",
+ "futures",
+ "itertools",
+ "log",
+ "remote",
+ "serde",
+ "serde_with",
+ "tauri",
+ "url",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.10"
@@ -5763,9 +5801,9 @@ dependencies = [

 [[package]]
 name = "tao"
-version = "0.34.5"
+version = "0.34.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a753bdc39c07b192151523a3f77cd0394aa75413802c883a0f6f6a0e5ee2e7"
+checksum = "6121216ff67fe4bcfe64508ea1700bc15f74937d835a07b4a209cc00a8926a84"
 dependencies = [
 "bitflags 2.9.4",
 "block2 0.6.2",
@@ -5840,9 +5878,9 @@ dependencies = [

 [[package]]
 name = "tauri"
-version = "2.9.3"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e492485dd390b35f7497401f67694f46161a2a00ffd800938d5dd3c898fb9d8"
+checksum = "d4d1d3b3dc4c101ac989fd7db77e045cc6d91a25349cd410455cb5c57d510c1c"
 dependencies = [
 "anyhow",
 "bytes",
@@ -5884,6 +5922,7 @@ dependencies = [
 "tokio",
 "tray-icon",
 "url",
+ "urlpattern",
 "webkit2gtk",
 "webview2-com",
 "window-vibrancy",
@@ -5892,9 +5931,9 @@ dependencies = [

 [[package]]
 name = "tauri-build"
-version = "2.5.2"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87d6f8cafe6a75514ce5333f115b7b1866e8e68d9672bf4ca89fc0f35697ea9d"
+checksum = "9c432ccc9ff661803dab74c6cd78de11026a578a9307610bbc39d3c55be7943f"
 dependencies = [
 "anyhow",
 "cargo_toml",
@@ -5914,9 +5953,9 @@ dependencies = [

 [[package]]
 name = "tauri-codegen"
-version = "2.5.1"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7ef707148f0755110ca54377560ab891d722de4d53297595380a748026f139f"
+checksum = "1ab3a62cf2e6253936a8b267c2e95839674e7439f104fa96ad0025e149d54d8a"
 dependencies = [
 "base64 0.22.1",
 "brotli",
@@ -5941,9 +5980,9 @@ dependencies = [

 [[package]]
 name = "tauri-macros"
-version = "2.5.1"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71664fd715ee6e382c05345ad258d6d1d50f90cf1b58c0aa726638b33c2a075d"
+checksum = "4368ea8094e7045217edb690f493b55b30caf9f3e61f79b4c24b6db91f07995e"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
@@ -6124,9 +6163,9 @@ dependencies = [

 [[package]]
 name = "tauri-runtime"
-version = "2.9.1"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9368f09358496f2229313fccb37682ad116b7f46fa76981efe116994a0628926"
+checksum = "d4cfc9ad45b487d3fded5a4731a567872a4812e9552e3964161b08edabf93846"
 dependencies = [
 "cookie",
 "dpi",
@@ -6149,9 +6188,9 @@ dependencies = [

 [[package]]
 name = "tauri-runtime-wry"
-version = "2.9.1"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "929f5df216f5c02a9e894554401bcdab6eec3e39ec6a4a7731c7067fc8688a93"
+checksum = "c1fe9d48bd122ff002064e88cfcd7027090d789c4302714e68fcccba0f4b7807"
 dependencies = [
 "gtk",
 "http 1.3.1",
@@ -6176,9 +6215,9 @@ dependencies = [

 [[package]]
 name = "tauri-utils"
-version = "2.8.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6b8bbe426abdbf52d050e52ed693130dbd68375b9ad82a3fb17efb4c8d85673"
+checksum = "41a3852fdf9a4f8fbeaa63dc3e9a85284dd6ef7200751f0bd66ceee30c93f212"
 dependencies = [
 "anyhow",
 "brotli",
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "drop-app"
-version = "0.3.4"
+version = "0.3.3"
 description = "The client application for the open-source, self-hosted game distribution platform Drop"
 authors = ["Drop OSS"]
 edition = "2024"
@@ -65,7 +65,9 @@ whoami = "1.6.0"
 filetime = "0.2.25"
 walkdir = "2.5.0"
 known-folders = "1.2.0"
-native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+native_model = { version = "0.6.4", features = [
+    "rmp_serde_1_3",
+], git = "https://github.com/Drop-OSS/native_model.git" }
 tauri-plugin-opener = "2.4.0"
 bitcode = "0.6.6"
 reqwest-websocket = "0.5.0"
@@ -93,7 +95,7 @@ version = "0.1.5"
 features = ["curly"]

 [dependencies.tauri]
-version = "2.9.3"
+version = "2.7.0"
 features = ["protocol-asset", "tray-icon"]

 [dependencies.tokio]
@@ -149,6 +151,8 @@ members = [
    "cloud_saves",
    "download_manager",
    "games",
+    "library",
+    "drop-consts",
 ]

-resolver = "3"
+resolver = "3"
--- a/src-tauri/client/Cargo.toml
+++ b/src-tauri/client/Cargo.toml
@@ -6,6 +6,7 @@ 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"
--- a/src-tauri/client/src/app_state.rs
+++ b/src-tauri/client/src/app_state.rs
@@ -0,0 +1,42 @@
+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
+    }
+}
--- a/src-tauri/client/src/compat.rs
+++ b/src-tauri/client/src/compat.rs
@@ -5,6 +5,7 @@ use std::{
    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);
@@ -30,9 +31,6 @@ fn create_new_compat_info() -> Option<CompatInfo> {
    })
 }

-const UMU_BASE_LAUNCHER_EXECUTABLE: &str = "umu-run";
-const UMU_INSTALL_DIRS: [&str; 4] = ["/app/share", "/use/local/share", "/usr/share", "/opt"];
-
 fn get_umu_executable() -> Option<PathBuf> {
    if check_executable_exists(UMU_BASE_LAUNCHER_EXECUTABLE) {
        return Some(PathBuf::from(UMU_BASE_LAUNCHER_EXECUTABLE));
--- a/src-tauri/client/src/lib.rs
+++ b/src-tauri/client/src/lib.rs
@@ -1,4 +1,5 @@
+pub mod app_state;
 pub mod app_status;
 pub mod autostart;
 pub mod compat;
-pub mod user;
+pub mod user;
--- a/src-tauri/cloud_saves/Cargo.toml
+++ b/src-tauri/cloud_saves/Cargo.toml
@@ -6,6 +6,7 @@ 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"
--- a/src-tauri/cloud_saves/src/backup_manager.rs
+++ b/src-tauri/cloud_saves/src/backup_manager.rs
@@ -2,7 +2,7 @@ use std::{collections::HashMap, path::PathBuf, str::FromStr};

 #[cfg(target_os = "linux")]
 use database::platform::Platform;
-use database::{GameVersion, db::DATA_ROOT_DIR};
+use database::{db::DATA_ROOT_DIR, GameVersion};
 use log::warn;

 use crate::error::BackupError;
--- a/src-tauri/database/Cargo.toml
+++ b/src-tauri/database/Cargo.toml
@@ -4,8 +4,10 @@ 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"
--- a/src-tauri/database/src/db.rs
+++ b/src-tauri/database/src/db.rs
@@ -3,24 +3,18 @@ use std::{
    sync::{Arc, LazyLock},
 };

+use drop_consts::DATA_ROOT_PREFIX;
 use rustbreak::{DeSerError, DeSerializer};
 use serde::{Serialize, de::DeserializeOwned};

-use crate::interface::{DatabaseImpls, DatabaseInterface};
+use crate::{interface::DatabaseImpls, models::DatabaseInterface};

 pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);

-#[cfg(not(debug_assertions))]
-static DATA_ROOT_PREFIX: &str = "drop";
-#[cfg(debug_assertions)]
-static DATA_ROOT_PREFIX: &str = "drop-debug";
-
-pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> = LazyLock::new(|| {
-    Arc::new(
+pub static DATA_ROOT_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
        dirs::data_dir()
            .expect("Failed to get data dir")
-            .join(DATA_ROOT_PREFIX),
-    )
+            .join(DATA_ROOT_PREFIX)
 });

 // Custom JSON serializer to support everything we need
--- a/src-tauri/database/src/interface.rs
+++ b/src-tauri/database/src/interface.rs
@@ -9,20 +9,14 @@ use std::{
 use chrono::Utc;
 use log::{debug, error, info, warn};
 use rustbreak::{PathDatabase, RustbreakError};
-use url::Url;

 use crate::{
-    db::{DATA_ROOT_DIR, DB, DropDatabaseSerializer},
-    models::data::Database,
+    db::{DropDatabaseSerializer, DATA_ROOT_DIR, DB},
+    models::{Database, DatabaseInterface},
 };

-pub type DatabaseInterface =
-    rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;
-
 pub trait DatabaseImpls {
    fn set_up_database() -> DatabaseInterface;
-    fn database_is_set_up(&self) -> bool;
-    fn fetch_base_url(&self) -> Url;
 }
 impl DatabaseImpls for DatabaseInterface {
    fn set_up_database() -> DatabaseInterface {
@@ -88,16 +82,6 @@ impl DatabaseImpls for DatabaseInterface {
            PathDatabase::create_at_path(db_path, default).expect("Database could not be created")
        }
    }
-
-    fn database_is_set_up(&self) -> bool {
-        !borrow_db_checked().base_url.is_empty()
-    }
-
-    fn fetch_base_url(&self) -> Url {
-        let handle = borrow_db_checked();
-        Url::parse(&handle.base_url)
-            .unwrap_or_else(|_| panic!("Failed to parse base url {}", handle.base_url))
-    }
 }

 // TODO: Make the error relelvant rather than just assume that it's a Deserialize error
--- a/src-tauri/database/src/lib.rs
+++ b/src-tauri/database/src/lib.rs
@@ -8,7 +8,7 @@ pub mod platform;

 pub use db::DB;
 pub use interface::{borrow_db_checked, borrow_db_mut_checked};
-pub use models::data::{
+pub use models::{
    ApplicationTransientStatus, Database, DatabaseApplications, DatabaseAuth, DownloadType,
    DownloadableMetadata, GameDownloadStatus, GameVersion, Settings,
 };
--- a/src-tauri/database/src/models.rs
+++ b/src-tauri/database/src/models.rs
@@ -1,373 +0,0 @@
-pub mod data {
-    use std::{hash::Hash, path::PathBuf};
-
-    use native_model::native_model;
-    use serde::{Deserialize, Serialize};
-
-    // 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 = v3::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;
-
-    use std::collections::HashMap;
-
-    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);
-        }
-    }
-
-    mod v1 {
-        use serde_with::serde_as;
-        use std::{collections::HashMap, path::PathBuf};
-
-        use crate::platform::Platform;
-
-        use super::{Deserialize, Serialize, native_model};
-
-        fn default_template() -> String {
-            "{}".to_owned()
-        }
-
-        #[derive(Serialize, Deserialize, Clone, Debug, 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, GameDownloadStatus>,
-            pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
-            pub installed_game_version: HashMap<String, DownloadableMetadata>,
-
-            #[serde(skip)]
-            pub transient_statuses: HashMap<DownloadableMetadata, 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)]
-        #[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(serde::Serialize, Clone, Deserialize)]
-        #[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: DownloadType,
-        }
-        impl DownloadableMetadata {
-            pub fn new(id: String, version: Option<String>, download_type: 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<DatabaseAuth>,
-            pub base_url: String,
-            pub applications: DatabaseApplications,
-            pub prev_database: Option<PathBuf>,
-            pub cache_dir: PathBuf,
-        }
-    }
-
-    mod v2 {
-        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,
-                }
-            }
-        }
-    }
-    mod v3 {
-        use std::path::PathBuf;
-
-        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,
-                }
-            }
-        }
-    }
-
-    impl Database {
-        pub fn new<T: Into<PathBuf>>(
-            games_base_dir: T,
-            prev_database: Option<PathBuf>,
-            cache_dir: PathBuf,
-        ) -> Self {
-            Self {
-                applications: DatabaseApplications {
-                    install_dirs: vec![games_base_dir.into()],
-                    game_statuses: HashMap::new(),
-                    game_versions: HashMap::new(),
-                    installed_game_version: HashMap::new(),
-                    transient_statuses: HashMap::new(),
-                },
-                prev_database,
-                base_url: String::new(),
-                auth: None,
-                settings: Settings::default(),
-                cache_dir,
-                compat_info: None,
-            }
-        }
-    }
-    impl DatabaseAuth {
-        pub fn new(
-            private: String,
-            cert: String,
-            client_id: String,
-            web_token: Option<String>,
-        ) -> Self {
-            Self {
-                private,
-                cert,
-                client_id,
-                web_token,
-            }
-        }
-    }
-}
--- a/src-tauri/database/src/models/mod.rs
+++ b/src-tauri/database/src/models/mod.rs
@@ -0,0 +1,110 @@
+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
+    }
+}
--- a/src-tauri/database/src/models/v1.rs
+++ b/src-tauri/database/src/models/v1.rs
@@ -0,0 +1,201 @@
+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,
+}
--- a/src-tauri/database/src/models/v2.rs
+++ b/src-tauri/database/src/models/v2.rs
@@ -0,0 +1,111 @@
+        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,
+                }
+            }
+        }
--- a/src-tauri/database/src/models/v3.rs
+++ b/src-tauri/database/src/models/v3.rs
@@ -0,0 +1,32 @@
+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,
+        }
+    }
+}
--- a/src-tauri/database/src/models/v4.rs
+++ b/src-tauri/database/src/models/v4.rs
@@ -0,0 +1,43 @@
+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![]
+                },
+            },
+        }
+    }
+}
--- a/src-tauri/database/src/platform.rs
+++ b/src-tauri/database/src/platform.rs
@@ -4,7 +4,6 @@ use serde::{Deserialize, Serialize};
 pub enum Platform {
    Windows,
    Linux,
-    #[allow(non_camel_case_types)]
    macOS,
 }

--- a/src-tauri/drop-consts/Cargo.toml
+++ b/src-tauri/drop-consts/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "drop-consts"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+dirs = "6.0.0"
--- a/src-tauri/drop-consts/src/lib.rs
+++ b/src-tauri/drop-consts/src/lib.rs
@@ -0,0 +1,16 @@
+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"];
--- a/src-tauri/games/Cargo.toml
+++ b/src-tauri/games/Cargo.toml
@@ -22,5 +22,8 @@ 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"}
+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" }
--- a/src-tauri/games/src/collections/collection.rs
+++ b/src-tauri/games/src/collections/collection.rs
@@ -1,8 +1,7 @@
 use bitcode::{Decode, Encode};
+use database::models::Game;
 use serde::{Deserialize, Serialize};

-use crate::library::Game;
-
 pub type Collections = Vec<Collection>;

 #[derive(Serialize, Deserialize, Debug, Clone, Default, Encode, Decode)]
@@ -15,7 +14,7 @@ pub struct Collection {
    entries: Vec<CollectionObject>,
 }

-#[derive(Serialize, Deserialize, Debug, Clone, Default, Encode, Decode)]
+#[derive(Serialize, Deserialize, Debug, Clone, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct CollectionObject {
    collection_id: String,
--- a/src-tauri/games/src/downloads/download_agent.rs
+++ b/src-tauri/games/src/downloads/download_agent.rs
@@ -9,6 +9,7 @@ use download_manager::util::download_thread_control_flag::{
    DownloadThreadControl, DownloadThreadControlFlag,
 };
 use download_manager::util::progress_object::{ProgressHandle, ProgressObject};
+use drop_consts::{MAX_FILES_PER_BUCKET, RETRY_COUNT, TARGET_BUCKET_SIZE};
 use log::{debug, error, info, warn};
 use rayon::ThreadPoolBuilder;
 use remote::auth::generate_authorization_header;
@@ -39,11 +40,6 @@ use crate::state::GameStatusManager;
 use super::download_logic::download_game_bucket;
 use super::drop_data::DropData;

-static RETRY_COUNT: usize = 3;
-
-const TARGET_BUCKET_SIZE: usize = 63 * 1000 * 1000;
-const MAX_FILES_PER_BUCKET: usize = (1024 / 4) - 1;
-
 pub struct GameDownloadAgent {
    pub id: String,
    pub version: String,
--- a/src-tauri/games/src/downloads/download_logic.rs
+++ b/src-tauri/games/src/downloads/download_logic.rs
@@ -39,8 +39,7 @@ impl DropWriter<File> {
            .write(true)
            .create(true)
            .truncate(false)
-            .open(&path)
-            .inspect_err(|_v| warn!("failed to open {}", path.display()))?;
+            .open(&path)?;
        Ok(Self {
            destination: BufWriter::with_capacity(1024 * 1024, destination),
            hasher: Context::new(),
@@ -123,7 +122,7 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
                    .source
                    .read(&mut copy_buffer[0..size])
                    .inspect_err(|_| {
-                        warn!("got error from {}", drop.filename);
+                        info!("got error from {}", drop.filename);
                    })?;
                remaining -= size;
                last_bump += size;
@@ -231,8 +230,7 @@ pub fn download_game_bucket(
            return Err(ApplicationDownloadError::DownloadError(
                RemoteAccessError::InvalidResponse(DropServerError {
                    status_code: 400,
-                    status_message: "Server Error".to_owned(),
-                    message: format!(
+                    status_message: format!(
                        "invalid number of Content-Lengths recieved: {i}, {lengths}"
                    ),
                }),
@@ -246,8 +244,7 @@ pub fn download_game_bucket(
            return Err(ApplicationDownloadError::DownloadError(
                RemoteAccessError::InvalidResponse(DropServerError {
                    status_code: 400,
-                    status_message: "Server Error".to_owned(),
-                    message: format!(
+                    status_message: format!(
                        "for {}, expected {}, got {} ({})",
                        drop.filename, drop.length, raw_length, length
                    ),
@@ -275,12 +272,7 @@ pub fn download_game_bucket(
    #[cfg(unix)]
    {
        for drop in bucket.drops.iter() {
-            let permission = if drop.permissions == 0 {
-                0o744
-            } else {
-                drop.permissions
-            };
-            let permissions = Permissions::from_mode(permission);
+            let permissions = Permissions::from_mode(drop.permissions);
            set_permissions(drop.path.clone(), permissions)
                .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
        }
--- a/src-tauri/games/src/downloads/drop_data.rs
+++ b/src-tauri/games/src/downloads/drop_data.rs
@@ -5,14 +5,13 @@ use std::{
    path::{Path, PathBuf},
 };

+use drop_consts::DROP_DATA_PATH;
 use log::error;
 use native_model::{Decode, Encode};
 use utils::lock;

 pub type DropData = v1::DropData;

-pub static DROP_DATA_PATH: &str = ".dropdata";
-
 pub mod v1 {
    use std::{collections::HashMap, path::PathBuf, sync::Mutex};

--- a/src-tauri/games/src/library.rs
+++ b/src-tauri/games/src/library.rs
@@ -1,7 +1,5 @@
-use bitcode::{Decode, Encode};
 use database::{
-    ApplicationTransientStatus, Database, DownloadableMetadata, GameDownloadStatus, GameVersion,
-    borrow_db_checked, borrow_db_mut_checked,
+    borrow_db_checked, borrow_db_mut_checked, models::Game, ApplicationTransientStatus, Database, DownloadableMetadata, GameDownloadStatus, GameVersion
 };
 use log::{debug, error, warn};
 use remote::{
@@ -33,26 +31,6 @@ impl FetchGameStruct {
    }
 }

-#[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
-#[serde(rename_all = "camelCase")]
-pub struct Game {
-    id: String,
-    m_name: String,
-    m_short_description: String,
-    m_description: String,
-    // mDevelopers
-    // mPublishers
-    m_icon_object_id: String,
-    m_banner_object_id: String,
-    m_cover_object_id: String,
-    m_image_library_object_ids: Vec<String>,
-    m_image_carousel_object_ids: Vec<String>,
-}
-impl Game {
-    pub fn id(&self) -> &String {
-        &self.id
-    }
-}
 #[derive(serde::Serialize, Clone)]
 pub struct GameUpdateEvent {
    pub game_id: String,
--- a/src-tauri/games/src/scan.rs
+++ b/src-tauri/games/src/scan.rs
@@ -1,10 +1,11 @@
 use std::fs;

 use database::{DownloadType, DownloadableMetadata, borrow_db_mut_checked};
+use drop_consts::DROP_DATA_PATH;
 use log::warn;

 use crate::{
-    downloads::drop_data::{DROP_DATA_PATH, DropData},
+    downloads::drop_data::DropData,
    library::set_partially_installed_db,
 };

--- a/src-tauri/games/src/state.rs
+++ b/src-tauri/games/src/state.rs
@@ -1,4 +1,4 @@
-use database::models::data::{
+use database::{
    ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus,
 };

--- a/src-tauri/library/Cargo.toml
+++ b/src-tauri/library/Cargo.toml
@@ -0,0 +1,17 @@
+[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"
--- a/src-tauri/library/src/drop/drop.rs
+++ b/src-tauri/library/src/drop/drop.rs
@@ -0,0 +1,134 @@
+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!()
+}
--- a/src-tauri/library/src/drop/mod.rs
+++ b/src-tauri/library/src/drop/mod.rs
@@ -0,0 +1 @@
+pub mod drop;
--- a/src-tauri/library/src/error.rs
+++ b/src-tauri/library/src/error.rs
@@ -0,0 +1,31 @@
+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)
+    }
+}
--- a/src-tauri/library/src/lib.rs
+++ b/src-tauri/library/src/lib.rs
@@ -0,0 +1,69 @@
+#![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);
+    }
+}
--- a/src-tauri/library/src/provider.rs
+++ b/src-tauri/library/src/provider.rs
@@ -0,0 +1,16 @@
+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;
+}
--- a/src-tauri/remote/src/auth.rs
+++ b/src-tauri/remote/src/auth.rs
@@ -60,27 +60,22 @@ impl From<HandshakeResponse> for DatabaseAuth {
    }
 }

-pub fn generate_authorization_header() -> String {
-    let certs = {
-        let db = borrow_db_checked();
-        db.auth.clone().expect("Authorisation not initialised")
-    };
-
+pub fn generate_authorization_header(auth: DatabaseAuth) -> String {
    let nonce = Utc::now().timestamp_millis().to_string();

    let signature =
-        sign_nonce(certs.private, nonce.clone()).expect("Failed to generate authorisation header");
+        sign_nonce(auth.private, nonce.clone()).expect("Failed to generate authorisation header");

-    format!("Nonce {} {} {}", certs.client_id, nonce, signature)
+    format!("Nonce {} {} {}", auth.client_id, nonce, signature)
 }

-pub async fn fetch_user() -> Result<User, RemoteAccessError> {
-    let response = make_authenticated_get(generate_url(&["/api/v1/client/user"], &[])?).await?;
+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.message == "Nonce expired" {
+        if err.status_message == "Nonce expired" {
            return Err(RemoteAccessError::OutOfSync);
        }

@@ -93,12 +88,7 @@ pub async fn fetch_user() -> Result<User, RemoteAccessError> {
        .map_err(std::convert::Into::into)
 }

-pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
-    let base_url = {
-        let db_lock = borrow_db_checked();
-        Url::parse(&db_lock.base_url.clone())?
-    };
-
+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")?;
@@ -106,8 +96,8 @@ pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
        name: format!("{} (Desktop)", hostname.display()),
        platform: env::consts::OS.to_string(),
        capabilities: HashMap::from([
-            ("PeerAPI".to_owned(), CapabilityConfiguration {}),
-            ("CloudSaves".to_owned(), CapabilityConfiguration {}),
+            ("peerAPI".to_owned(), CapabilityConfiguration {}),
+            ("cloudSaves".to_owned(), CapabilityConfiguration {}),
        ]),
        mode,
    };
@@ -117,9 +107,9 @@ pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {

    if response.status() != 200 {
        let data: DropServerError = response.json()?;
-        error!("could not start handshake: {:?}", data);
+        error!("could not start handshake: {}", data.status_message);

-        return Err(RemoteAccessError::HandshakeFailed(data.message));
+        return Err(RemoteAccessError::HandshakeFailed(data.status_message));
    }

    let response = response.text()?;
@@ -127,26 +117,17 @@ pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
    Ok(response)
 }

-pub async fn setup() -> (AppStatus, Option<User>) {
-    let auth = {
-        let data = borrow_db_checked();
-        data.auth.clone()
-    };
-
-    if auth.is_some() {
-        let user_result = match fetch_user().await {
-            Ok(data) => data,
-            Err(RemoteAccessError::FetchError(_)) => {
-                let user = get_cached_object::<User>("user").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}");
+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);
        }
-        return (AppStatus::SignedIn, Some(user_result));
+        Err(_) => return (AppStatus::SignedInNeedsReauth, None),
+    };
+    if let Err(e) = cache_object("user", &user_result) {
+        warn!("Could not cache user object with error {e}");
    }
-
-    (AppStatus::SignedOut, None)
+    return (AppStatus::SignedIn, Some(user_result));
 }
--- a/src-tauri/remote/src/cache.rs
+++ b/src-tauri/remote/src/cache.rs
@@ -17,7 +17,7 @@ macro_rules! offline {

        async move {
            if ::database::borrow_db_checked().settings.force_offline
-            || $var.lock().status == ::client::app_status::AppStatus::Offline {
+            || *$var.lock().status() == ::client::app_status::AppStatus::Offline {
            $func2( $( $arg ), *).await
        } else {
            $func1( $( $arg ), *).await
--- a/src-tauri/remote/src/error.rs
+++ b/src-tauri/remote/src/error.rs
@@ -15,7 +15,7 @@ use serde::Deserialize;
 pub struct DropServerError {
    pub status_code: usize,
    pub status_message: String,
-    pub message: String,
+    // pub message: String,
    // pub url: String,
 }

@@ -76,7 +76,7 @@ impl Display for RemoteAccessError {
            RemoteAccessError::InvalidResponse(error) => write!(
                f,
                "server returned an invalid response: {}, {}",
-                error.status_code, error.message
+                error.status_code, error.status_message
            ),
            RemoteAccessError::UnparseableResponse(error) => {
                write!(f, "server returned an invalid response: {error}")
--- a/src-tauri/remote/src/fetch_object.rs
+++ b/src-tauri/remote/src/fetch_object.rs
@@ -1,7 +1,8 @@
-use database::{DB, interface::DatabaseImpls};
+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};

@@ -10,8 +11,8 @@ use super::{
    cache::{ObjectCache, cache_object, get_cached_object},
 };

-pub async fn fetch_object_wrapper(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
-    match fetch_object(request).await {
+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}");
@@ -27,6 +28,8 @@ pub async fn fetch_object_wrapper(request: http::Request<Vec<u8>>, responder: Ur

 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..];
@@ -38,9 +41,9 @@ pub async fn fetch_object(
        return cache_result.try_into();
    }

-    let header = generate_authorization_header();
+    let header = generate_authorization_header(auth);
    let client = DROP_CLIENT_ASYNC.clone();
-    let url = format!("{}api/v1/client/object/{object_id}", DB.fetch_base_url());
+    let url = format!("{}api/v1/client/object/{object_id}", base_url);
    let response = client.get(url).header("Authorization", header).send().await;

    match response {
--- a/src-tauri/remote/src/requests.rs
+++ b/src-tauri/remote/src/requests.rs
@@ -1,4 +1,4 @@
-use database::{DB, interface::DatabaseImpls};
+use database::{DB, DatabaseAuth, interface::DatabaseImpls};
 use url::Url;

 use crate::{
@@ -8,8 +8,9 @@ use crate::{
 pub fn generate_url<T: AsRef<str>>(
    path_components: &[T],
    query: &[(T, T)],
+    base_url: Url
 ) -> Result<Url, RemoteAccessError> {
-    let mut base_url = DB.fetch_base_url();
+    let mut base_url = base_url.clone();
    for endpoint in path_components {
        base_url = base_url.join(endpoint.as_ref())?;
    }
@@ -22,10 +23,10 @@ pub fn generate_url<T: AsRef<str>>(
    Ok(base_url)
 }

-pub async fn make_authenticated_get(url: Url) -> Result<reqwest::Response, reqwest::Error> {
+pub async fn make_authenticated_get(url: Url, auth: DatabaseAuth) -> Result<reqwest::Response, reqwest::Error> {
    DROP_CLIENT_ASYNC
        .get(url)
-        .header("Authorization", generate_authorization_header())
+        .header("Authorization", generate_authorization_header(auth))
        .send()
        .await
 }
--- a/src-tauri/remote/src/server_proto.rs
+++ b/src-tauri/remote/src/server_proto.rs
@@ -1,9 +1,10 @@
 use std::str::FromStr;

-use database::borrow_db_checked;
+use database::{DatabaseAuth, borrow_db_checked};
 use http::{Request, Response, StatusCode, Uri, uri::PathAndQuery};
-use log::{error, warn};
+use log::warn;
 use tauri::UriSchemeResponder;
+use url::Url;
 use utils::webbrowser_open::webbrowser_open;

 use crate::utils::DROP_CLIENT_SYNC;
@@ -27,8 +28,8 @@ pub async fn handle_server_proto_offline(
        .expect("Failed to build error response for proto offline"))
 }

-pub async fn handle_server_proto_wrapper(request: Request<Vec<u8>>, responder: UriSchemeResponder) {
-    match handle_server_proto(request).await {
+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}");
@@ -42,23 +43,16 @@ pub async fn handle_server_proto_wrapper(request: Request<Vec<u8>>, responder: U
    }
 }

-async fn handle_server_proto(request: Request<Vec<u8>>) -> Result<Response<Vec<u8>>, StatusCode> {
-    let db_handle = borrow_db_checked();
-    let auth = match db_handle.auth.as_ref() {
-        Some(auth) => auth,
-        None => {
-            error!("Could not find auth in database");
-            return Err(StatusCode::UNAUTHORIZED);
-        }
-    };
+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 = db_handle
-        .base_url
-        .parse::<Uri>()
-        .expect("Failed to parse base url");
+    let remote_uri = base_url.as_str().parse::<Uri>().expect("Failed to parse base url");

    let path = request.uri().path();

--- a/src-tauri/src/client.rs
+++ b/src-tauri/src/client.rs
@@ -1,5 +1,6 @@
 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};
@@ -7,8 +8,6 @@ use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;
 use tauri_plugin_opener::OpenerExt;

-use crate::AppState;
-
 #[tauri::command]
 pub fn fetch_state(state: tauri::State<'_, Mutex<AppState>>) -> Result<String, String> {
    let guard = state.lock();
--- a/src-tauri/src/games.rs
+++ b/src-tauri/src/games.rs
@@ -1,12 +1,12 @@
 use std::sync::nonpoison::Mutex;

-use database::{GameDownloadStatus, GameVersion, borrow_db_checked, borrow_db_mut_checked};
+use database::{GameDownloadStatus, GameVersion, borrow_db_checked, borrow_db_mut_checked, models::Game};
 use games::{
    downloads::error::LibraryError,
-    library::{FetchGameStruct, FrontendGameOptions, Game, get_current_meta, uninstall_game_logic},
+    library::{FetchGameStruct, FrontendGameOptions, get_current_meta, uninstall_game_logic},
    state::{GameStatusManager, GameStatusWithTransient},
 };
-use log::{info, warn};
+use log::warn;
 use process::PROCESS_MANAGER;
 use remote::{
    auth::generate_authorization_header,
@@ -18,7 +18,7 @@ use remote::{
 };
 use tauri::AppHandle;

-use crate::AppState;
+use client::app_state::AppState;

 #[tauri::command]
 pub async fn fetch_library(
@@ -38,76 +38,13 @@ pub async fn fetch_library(
 pub async fn fetch_library_logic(
    state: tauri::State<'_, Mutex<AppState>>,
    hard_fresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
-    let do_hard_refresh = hard_fresh.unwrap_or(false);
-    if !do_hard_refresh && let Ok(library) = get_cached_object("library") {
-        return Ok(library);
-    }
-
-    let client = DROP_CLIENT_ASYNC.clone();
-    let response = generate_url(&["/api/v1/client/user/library"], &[])?;
-    let response = client
-        .get(response)
-        .header("Authorization", generate_authorization_header())
-        .send()
-        .await?;
-
-    if response.status() != 200 {
-        let err = response.json().await.unwrap_or(DropServerError {
-            status_code: 500,
-            status_message: "Server Error".to_owned(),
-            message: "Invalid response from server.".to_owned(),
-        });
-        warn!("{err:?}");
-        return Err(RemoteAccessError::InvalidResponse(err));
-    }
-
-    let mut games: Vec<Game> = response.json().await?;
-
-    let mut handle = state.lock();
-
-    let mut db_handle = borrow_db_mut_checked();
-
-    for game in &games {
-        handle.games.insert(game.id().clone(), game.clone());
-        if !db_handle.applications.game_statuses.contains_key(game.id()) {
-            db_handle
-                .applications
-                .game_statuses
-                .insert(game.id().clone(), GameDownloadStatus::Remote {});
-        }
-    }
-
-    // Add games that are installed but no longer in library
-    for meta in db_handle.applications.installed_game_version.values() {
-        if games.iter().any(|e| *e.id() == meta.id) {
-            continue;
-        }
-        // We should always have a cache of the object
-        // Pass db_handle because otherwise we get a gridlock
-        let game = match get_cached_object_db::<Game>(&meta.id.clone(), &db_handle) {
-            Ok(game) => game,
-            Err(err) => {
-                warn!(
-                    "{} is installed, but encountered error fetching its error: {}.",
-                    meta.id, err
-                );
-                continue;
-            }
-        };
-        games.push(game);
-    }
-
-    drop(handle);
-    drop(db_handle);
-    cache_object("library", &games)?;
-
-    Ok(games)
+) -> (Vec<Game>, Vec<LibraryError>) {
+    
 }
 pub async fn fetch_library_logic_offline(
    _state: tauri::State<'_, Mutex<AppState>>,
    _hard_refresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
+) -> (Vec<Game>, Vec<LibraryError>) {
    let mut games: Vec<Game> = get_cached_object("library")?;

    let db_handle = borrow_db_checked();
@@ -145,7 +82,7 @@ pub async fn fetch_game_logic(
                .cloned(),
        };

-        let game = state_handle.games.get(&id);
+        let game = state_handle.games().get(&id);
        if let Some(game) = game {
            let status = GameStatusManager::fetch_state(&id, &db_lock);

@@ -184,7 +121,7 @@ pub async fn fetch_game_logic(
    let game: Game = response.json().await?;

    let mut state_handle = state.lock();
-    state_handle.games.insert(id.clone(), game.clone());
+    state_handle.games_mut().insert(id.clone(), game.clone());

    let mut db_handle = borrow_db_mut_checked();

@@ -224,11 +161,6 @@ pub async fn fetch_game_version_options_logic(
        return Err(RemoteAccessError::InvalidResponse(err));
    }

-    let raw = response.text().await?;
-    info!("{}", raw);
-
-    return Err(RemoteAccessError::CorruptedState);
-
    let data: Vec<GameVersion> = response.json().await?;

    let state_lock = state.lock();
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -12,9 +12,11 @@ use std::{
    sync::nonpoison::Mutex, time::SystemTime,
 };

-use ::client::{app_status::AppStatus, autostart::sync_autostart_on_startup, user::User};
+use ::client::{
+    app_state::AppState, app_status::AppStatus, autostart::sync_autostart_on_startup,
+};
 use ::download_manager::DownloadManagerWrapper;
-use ::games::{library::Game, scan::scan_install_dirs};
+use ::games::scan::scan_install_dirs;
 use ::process::ProcessManagerWrapper;
 use ::remote::{
    auth::{self, HandshakeRequestBody, HandshakeResponse, generate_authorization_header},
@@ -36,7 +38,6 @@ use log4rs::{
    config::{Appender, Root},
    encode::pattern::PatternEncoder,
 };
-use serde::Serialize;
 use tauri::{
    AppHandle, Manager, RunEvent, WindowEvent,
    menu::{Menu, MenuItem, PredefinedMenuItem},
@@ -67,14 +68,6 @@ use process::*;
 use remote::*;
 use settings::*;

-#[derive(Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AppState {
-    status: AppStatus,
-    user: Option<User>,
-    games: HashMap<String, Game>,
-}
-
 async fn setup(handle: AppHandle) -> AppState {
    let logfile = FileAppender::builder()
        .encoder(Box::new(PatternEncoder::new(
@@ -117,11 +110,7 @@ async fn setup(handle: AppHandle) -> AppState {
    scan_install_dirs();

    if !is_set_up {
-        return AppState {
-            status: AppStatus::NotConfigured,
-            user: None,
-            games,
-        };
+        return AppState::new(AppStatus::NotConfigured, None, games);
    }

    debug!("database is set up");
@@ -179,11 +168,7 @@ async fn setup(handle: AppHandle) -> AppState {
        warn!("failed to sync autostart state: {e}");
    }

-    AppState {
-        status: app_status,
-        user,
-        games,
-    }
+    AppState::new(app_status, user, games)
 }

 pub fn custom_panic_handler(e: &PanicHookInfo) -> Option<()> {
@@ -473,14 +458,12 @@ pub async fn recieve_handshake(app: AppHandle, path: String) {

    let mut state_lock = app_state.lock();

-    state_lock.status = app_status;
-    state_lock.user = user;
+    *state_lock.status_mut() = app_status;
+    *state_lock.user_mut() = user;

    let _ = clear_cached_object("collections");
    let _ = clear_cached_object("library");

-    drop(state_lock);
-
    app_emit!(&app, "auth/finished", ());
 }

--- a/src-tauri/src/process.rs
+++ b/src-tauri/src/process.rs
@@ -1,17 +1,11 @@
-use std::sync::nonpoison::Mutex;
-
 use process::{PROCESS_MANAGER, error::ProcessError};
 use tauri::AppHandle;
 use tauri_plugin_opener::OpenerExt;

-use crate::AppState;
-
 #[tauri::command]
 pub fn launch_game(
    id: String,
-    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<(), ProcessError> {
-    let state_lock = state.lock();
    let mut process_manager_lock = PROCESS_MANAGER.lock();
    //let meta = DownloadableMetadata {
    //    id,
@@ -24,9 +18,6 @@ pub fn launch_game(
        Err(e) => return Err(e),
    }

-    drop(process_manager_lock);
-    drop(state_lock);
-
    Ok(())
 }

--- a/src-tauri/src/remote.rs
+++ b/src-tauri/src/remote.rs
@@ -1,6 +1,6 @@
 use std::{sync::nonpoison::Mutex, time::Duration};

-use client::app_status::AppStatus;
+use client::{app_state::AppState, app_status::AppStatus};
 use database::{borrow_db_checked, borrow_db_mut_checked};
 use futures_lite::StreamExt;
 use log::{debug, warn};
@@ -18,7 +18,7 @@ use tauri::{AppHandle, Manager};
 use url::Url;
 use utils::{app_emit, webbrowser_open::webbrowser_open};

-use crate::{AppState, recieve_handshake};
+use crate::{recieve_handshake};

 #[tauri::command]
 pub async fn use_remote(
@@ -45,7 +45,7 @@ pub async fn use_remote(
    }

    let mut app_state = state.lock();
-    app_state.status = AppStatus::SignedOut;
+    *app_state.status_mut() = AppStatus::SignedOut;
    drop(app_state);

    let mut db_state = borrow_db_mut_checked();
@@ -100,8 +100,8 @@ pub fn sign_out(app: AppHandle) {
    {
        let state = app.state::<Mutex<AppState>>();
        let mut app_state_handle = state.lock();
-        app_state_handle.status = AppStatus::SignedOut;
-        app_state_handle.user = None;
+        *app_state_handle.status_mut() = AppStatus::SignedOut;
+        *app_state_handle.user_mut() = None;
    }

    // Emit event for frontend
@@ -112,10 +112,9 @@ pub fn sign_out(app: AppHandle) {
 pub async fn retry_connect(state: tauri::State<'_, Mutex<AppState>>) -> Result<(), ()> {
    let (app_status, user) = setup().await;

-    let mut guard = state.lock();
-    guard.status = app_status;
-    guard.user = user;
-    drop(guard);
+    let mut state_lock = state.lock();
+    *state_lock.status_mut() = app_status;
+    *state_lock.user_mut() = user;

    Ok(())
 }
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,12 +1,12 @@
 {
  "$schema": "https://schema.tauri.app/config/2.0.0",
  "productName": "Drop Desktop Client",
-  "version": "0.3.4",
+  "version": "0.3.3",
  "identifier": "dev.drop.client",
  "build": {
-    "beforeDevCommand": "pnpm run -C main dev --port 1432",
+    "beforeDevCommand": "yarn --cwd main dev --port 1432",
    "devUrl": "http://localhost:1432/",
-    "beforeBuildCommand": "pnpm build",
+    "beforeBuildCommand": "yarn build",
    "frontendDist": "../.output"
  },
  "app": {
--- a/yarn.lock
+++ b/yarn.lock