fix: Folders can now be copied too

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

.github/workflows/clippy.yml

@@ -1,23 +0,0 @@
-on: push
-name: Clippy check
-jobs:
-  clippy_check:
-    runs-on: ubuntu-24.04
-    permissions:
-      checks: write
-    steps:
-      - uses: actions/checkout@v1
-      - name: install dependencies (ubuntu only)
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libglib2.0-dev libgtk-3-dev libwebkit2gtk-4.1-dev
-
-      - uses: actions-rs/toolchain@v1
-        with:
-            toolchain: nightly
-            components: clippy
-            override: true
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --manifest-path ./src-tauri/Cargo.toml

.github/workflows/release.yml

@@ -1,104 +0,0 @@
-name: 'publish'
-
-on:
-  workflow_dispatch: {}
-  release:
-    types: [published]
-  # This can be used to automatically publish nightlies at UTC nighttime
-#  schedule:
-#    - cron: "0 2 * * *" # run at 2 AM UTC
-
-# This workflow will trigger on each push to the `release` branch to create or update a GitHub release, build your app, and upload the artifacts to the release.
-
-jobs:
-  publish-tauri:
-    permissions:
-      contents: write
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - 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:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: lts/*
-
-      - 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-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.
-        run: |
-          sudo apt-get update
-          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-latest'
-        env:
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
-        run: |
-          echo $APPLE_CERTIFICATE | base64 --decode > certificate.p12
-          security create-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
-          security default-keychain -s build.keychain
-          security unlock-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
-          security set-keychain-settings -t 3600 -u build.keychain
-          
-          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
-          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-latest'
-        run: |
-          CERT_INFO=$(security find-identity -v -p codesigning build.keychain | grep "Drop OSS")
-          CERT_ID=$(echo "$CERT_INFO" | awk -F'"' '{print $2}')
-          echo "CERT_ID=$CERT_ID" >> $GITHUB_ENV
-          echo "Certificate imported. Using identity: $CERT_ID"
-
-      - name: install frontend dependencies
-        run: yarn install # change this to npm, pnpm or bun depending on which one you use.
-
-      - uses: tauri-apps/tauri-action@v0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_SIGNING_IDENTITY: ${{ env.CERT_ID }}
-          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.'
-          releaseDraft: false
-          prerelease: true
-          args: ${{ matrix.args }}

.gitignore

@@ -26,9 +26,4 @@ dist-ssr
 .output
 
 src-tauri/flamegraph.svg
-src-tauri/perf*
-
-/*.AppImage
-/squashfs-root
-
-/target/
+src-tauri/perf*

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "src-tauri/tailscale/libtailscale"]
-	path = src-tauri/tailscale/libtailscale
-	url = https://github.com/tailscale/libtailscale.git
-[submodule "libs/drop-base"]
-	path = libs/drop-base
-	url = https://github.com/drop-oss/drop-base.git
+[submodule "drop-base"]
+	path = drop-base
+	url = https://github.com/drop-oss/drop-base

Cargo.toml

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

README.md

@@ -1,21 +1,29 @@
-# Drop Desktop Client
+# Drop App
 
-The Drop Desktop Client is the companion app for [Drop](https://github.com/Drop-OSS/drop). It is the official & intended way to download and play games on your Drop server.
+Drop app is the companion app for [Drop](https://github.com/Drop-OSS/drop). It uses a Tauri base with Nuxt 3 + TailwindCSS on top of it, so we can re-use components from the web UI.
 
-## Internals
+## Running
+Before setting up the drop app, be sure that you have a server set up. 
+The instructions for this can be found on the [Drop Wiki](https://wiki.droposs.org/guides/quickstart.html)
 
-It uses a Tauri base with Nuxt 3 + TailwindCSS on top of it, so we can re-use components from the web UI.
+## Current features
+Currently supported are the following features:
+- Signin (with custom server)
+- Database registering & recovery
+- Dynamic library fetching from server
+- Installing & uninstalling games
+- Download progress monitoring
+- Launching / playing games
 
 ## Development
-Before setting up a development environemnt, be sure that you have a server set up. The instructions for this can be found on the [Drop Docs](https://docs.droposs.org/docs/guides/quickstart).
 
-Then, install dependencies with `yarn`. This'll install the custom builder's dependencies. Then, check everything works properly with `yarn tauri build`. 
+Install dependencies with `yarn`
 
-Run the app in development with `yarn tauri dev`. NVIDIA users on Linux, use shell script `./nvidia-prop-dev.sh`
+Run the app in development with `yarn tauri dev`. NVIDIA users on Linux, use shell script `./nvidia-prop-dev.sh`
 
 To manually specify the logging level, add the environment variable `RUST_LOG=[debug, info, warn, error]` to `yarn tauri dev`:
 
 e.g. `RUST_LOG=debug yarn tauri dev`
 
 ## Contributing
-Check out the contributing guide on our Developer Docs: [Drop Developer Docs - Contributing](https://developer.droposs.org/contributing).
+Check the original [Drop repo](https://github.com/Drop-OSS/drop/blob/main/CONTRIBUTING.md) for contributing guidelines. 

app.vue

@@ -1,5 +1,4 @@
 <template>
-    <NuxtLoadingIndicator color="#2563eb" />
   <NuxtLayout class="select-none w-screen h-screen">
     <NuxtPage />
     <ModalStack />
@@ -10,6 +9,8 @@
 import "~/composables/downloads.js";
 
 import { invoke } from "@tauri-apps/api/core";
+import { AppStatus } from "~/types";
+import { listen } from "@tauri-apps/api/event";
 import { useAppState } from "./composables/app-state.js";
 import {
   initialNavigation,
@@ -19,26 +20,18 @@ import {
 const router = useRouter();
 
 const state = useAppState();
+try {
+  state.value = JSON.parse(await invoke("fetch_state"));
+} catch (e) {
+  console.error("failed to parse state", e);
+}
 
-async function fetchState() {
+router.beforeEach(async () => {
   try {
     state.value = JSON.parse(await invoke("fetch_state"));
-    if (!state.value)
-      throw createError({
-        statusCode: 500,
-        statusMessage: `App state is: ${state.value}`,
-        fatal: true,
-      });
   } catch (e) {
     console.error("failed to parse state", e);
-    throw e;
   }
-}
-await fetchState();
-
-// This is inefficient but apparently we do it lol
-router.beforeEach(async () => {
-  await fetchState();
 });
 
 setupHooks();

build.mjs

@@ -1,55 +0,0 @@
-import fs from "fs";
-import process from "process";
-import childProcess from "child_process";
-import createLogger from "pino";
-
-const OUTPUT = "./.output";
-const logger = createLogger({ transport: { target: "pino-pretty" } });
-
-async function spawn(exec, opts) {
-  const output = childProcess.spawn(exec, { ...opts, shell: true });
-  output.stdout.on("data", (data) => {
-    process.stdout.write(data);
-  });
-  output.stderr.on("data", (data) => {
-    process.stderr.write(data);
-  });
-
-  return await new Promise((resolve, reject) => {
-    output.on("error", (err) => reject(err));
-    output.on("exit", () => resolve());
-  });
-}
-
-const expectedLibs = ["drop-base/package.json"];
-
-for (const lib of expectedLibs) {
-  const path = `./libs/${lib}`;
-  if (!fs.existsSync(path)) throw `Missing "${expectedLibs}". Run "git submodule update --init --recursive"`;
-}
-
-const views = fs.readdirSync(".").filter((view) => {
-  const expectedPath = `./${view}/package.json`;
-  return fs.existsSync(expectedPath);
-});
-
-fs.mkdirSync(OUTPUT, { recursive: true });
-
-for (const view of views) {
-  const loggerChild = logger.child({});
-  process.chdir(`./${view}`);
-
-  loggerChild.info(`Install deps for "${view}"`);
-  await spawn("yarn");
-
-  loggerChild.info(`Building "${view}"`);
-  await spawn("yarn build", {
-    env: { ...process.env, NUXT_APP_BASE_URL: `/${view}/` },
-  });
-
-  process.chdir("..");
-
-  fs.cpSync(`./${view}/.output/public`, `${OUTPUT}/${view}`, {
-    recursive: true,
-  });
-}

client/Cargo.toml

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

client/src/app_status.rs

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

client/src/autostart.rs

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

client/src/compat.rs

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

client/src/lib.rs

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

client/src/user.rs

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

cloud_saves/Cargo.toml

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

cloud_saves/src/backup_manager.rs

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

cloud_saves/src/lib.rs

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

components/GameStatusButton.vue

@@ -46,7 +46,7 @@
           class="absolute right-0 z-[500] mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none"
         >
           <div class="py-1">
-            <MenuItem v-if="showOptions" v-slot="{ active }">
+            <MenuItem v-slot="{ active }">
               <button
                 @click="() => emit('options')"
                 :class="[
@@ -87,8 +87,6 @@ import {
   ChevronDownIcon,
   PlayIcon,
   QueueListIcon,
-  ServerIcon,
-  StopIcon,
   WrenchIcon,
 } from "@heroicons/vue/20/solid";
 
@@ -105,18 +103,12 @@ const emit = defineEmits<{
   (e: "uninstall"): void;
   (e: "kill"): void;
   (e: "options"): void;
-  (e: "resume"): void;
 }>();
 
 const showDropdown = computed(
   () =>
     props.status.type === GameStatusEnum.Installed ||
-    props.status.type === GameStatusEnum.SetupRequired ||
-    props.status.type === GameStatusEnum.PartiallyInstalled
-);
-
-const showOptions = computed(
-  () => props.status.type === GameStatusEnum.Installed
+    props.status.type === GameStatusEnum.SetupRequired
 );
 
 const styles: { [key in GameStatusEnum]: string } = {
@@ -126,8 +118,6 @@ const styles: { [key in GameStatusEnum]: string } = {
     "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
   [GameStatusEnum.Downloading]:
     "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
-  [GameStatusEnum.Validating]:
-    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
   [GameStatusEnum.SetupRequired]:
     "bg-yellow-600 text-white hover:bg-yellow-500 focus-visible:outline-yellow-600 hover:bg-yellow-500",
   [GameStatusEnum.Installed]:
@@ -138,46 +128,38 @@ const styles: { [key in GameStatusEnum]: string } = {
     "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
   [GameStatusEnum.Running]:
     "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
-  [GameStatusEnum.PartiallyInstalled]:
-    "bg-blue-600 text-white hover:bg-blue-500 focus-visible:outline-blue-600 hover:bg-blue-500",
 };
 
 const buttonNames: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Remote]: "Install",
   [GameStatusEnum.Queued]: "Queued",
   [GameStatusEnum.Downloading]: "Downloading",
-  [GameStatusEnum.Validating]: "Validating",
   [GameStatusEnum.SetupRequired]: "Setup",
   [GameStatusEnum.Installed]: "Play",
   [GameStatusEnum.Updating]: "Updating",
   [GameStatusEnum.Uninstalling]: "Uninstalling",
   [GameStatusEnum.Running]: "Stop",
-  [GameStatusEnum.PartiallyInstalled]: "Resume",
 };
 
 const buttonIcons: { [key in GameStatusEnum]: Component } = {
   [GameStatusEnum.Remote]: ArrowDownTrayIcon,
   [GameStatusEnum.Queued]: QueueListIcon,
   [GameStatusEnum.Downloading]: ArrowDownTrayIcon,
-  [GameStatusEnum.Validating]: ServerIcon,
   [GameStatusEnum.SetupRequired]: WrenchIcon,
   [GameStatusEnum.Installed]: PlayIcon,
   [GameStatusEnum.Updating]: ArrowDownTrayIcon,
   [GameStatusEnum.Uninstalling]: TrashIcon,
-  [GameStatusEnum.Running]: StopIcon,
-  [GameStatusEnum.PartiallyInstalled]: ArrowDownTrayIcon,
+  [GameStatusEnum.Running]: PlayIcon,
 };
 
 const buttonActions: { [key in GameStatusEnum]: () => void } = {
   [GameStatusEnum.Remote]: () => emit("install"),
   [GameStatusEnum.Queued]: () => emit("queue"),
   [GameStatusEnum.Downloading]: () => emit("queue"),
-  [GameStatusEnum.Validating]: () => emit("queue"),
   [GameStatusEnum.SetupRequired]: () => emit("launch"),
   [GameStatusEnum.Installed]: () => emit("launch"),
   [GameStatusEnum.Updating]: () => emit("queue"),
   [GameStatusEnum.Uninstalling]: () => {},
   [GameStatusEnum.Running]: () => emit("kill"),
-  [GameStatusEnum.PartiallyInstalled]: () => emit("resume"),
 };
 </script>

components/Header.vue

@@ -37,12 +37,12 @@
               <component class="h-5" :is="item.icon" />
             </HeaderWidget>
           </li>
-          <OfflineHeaderWidget v-if="state?.status === AppStatus.Offline" />
+          <OfflineHeaderWidget v-if="state.status === AppStatus.Offline" />
           <HeaderUserWidget />
         </ol>
       </div>
     </div>
-    <WindowControl  />
+    <WindowControl class="h-16 w-16 p-4" />
   </div>
 </template>
 

components/HeaderButton.vue

@@ -0,0 +1,5 @@
+<template>
+    <button class="transition h-10 w-10 text-zinc-300 hover:bg-zinc-800 hover:text-zinc-100 p-2">
+        <slot />
+    </button>
+</template>

components/HeaderUserWidget.vue

@@ -1,5 +1,5 @@
 <template>
-  <Menu v-if="state?.user" as="div" class="relative inline-block">
+  <Menu v-if="state.user" as="div" class="relative inline-block">
     <MenuButton>
       <HeaderWidget>
         <div class="inline-flex items-center text-zinc-300 hover:text-white">
@@ -23,7 +23,7 @@
       <MenuItems
         class="absolute bg-zinc-900 right-0 top-10 z-50 w-56 origin-top-right focus:outline-none shadow-md"
       >
-        <div class="flex-col gap-y-2">
+        <PanelWidget class="flex-col gap-y-2">
           <NuxtLink
             to="/id/me"
             class="transition inline-flex items-center w-full py-3 px-4 hover:bg-zinc-800"
@@ -37,7 +37,7 @@
           </NuxtLink>
           <div class="h-0.5 rounded-full w-full bg-zinc-800" />
           <div class="flex flex-col mb-1">
-            <MenuItem v-if="state.user.admin" v-slot="{ active }">
+            <MenuItem v-slot="{ active }">
               <a
                 :href="adminUrl"
                 target="_blank"
@@ -65,7 +65,7 @@
               </button>
             </MenuItem>
           </div>
-        </div>
+        </PanelWidget>
       </MenuItems>
     </transition>
   </Menu>
@@ -87,7 +87,7 @@ router.afterEach(() => {
 
 const state = useAppState();
 const profilePictureUrl: string = await useObject(
-  state.value?.user?.profilePictureObjectId ?? ""
+  state.value.user?.profilePicture ?? ""
 );
 const adminUrl: string = await invoke("gen_drop_url", {
   path: "/admin",
@@ -99,6 +99,11 @@ function navigate(close: () => any, to: NavigationItem) {
 }
 
 const navigation: NavigationItem[] = [
+  {
+    label: "Account settings",
+    route: "/account",
+    prefix: "",
+  },
   {
     label: "App settings",
     route: "/settings",

components/InitiateAuthModule.vue

@@ -13,7 +13,11 @@
       <div class="max-w-lg">
         <slot />
         <div class="mt-10">
-          <div>
+          <button
+            @click="() => authWrapper_wrapper()"
+            :disabled="loading"
+            class="text-sm text-left font-semibold leading-7 text-blue-600"
+          >
             <div v-if="loading" role="status">
               <svg
                 aria-hidden="true"
@@ -33,19 +37,10 @@
               </svg>
               <span class="sr-only">Loading...</span>
             </div>
-            <span class="inline-flex gap-x-8 items-center" v-else>
-              <button
-                @click="() => authWrapper_wrapper()"
-                :disabled="loading"
-                class="px-3 py-1 inline-flex items-center gap-x-2 bg-zinc-700 rounded text-sm text-left font-semibold leading-7 text-white"
-              >
-                Sign in with your browser <ArrowTopRightOnSquareIcon class="size-4" />
-              </button>
-              <NuxtLink href="/auth/code" class="text-zinc-100 text-sm hover:text-zinc-300">
-                Use a code &rarr;
-              </NuxtLink>
+            <span v-else>
+              Sign in with your browser <span aria-hidden="true">&rarr;</span>
             </span>
-          </div>
+          </button>
 
           <div class="mt-5" v-if="offerManual">
             <h1 class="text-zinc-100 font-semibold">Having trouble?</h1>
@@ -126,7 +121,6 @@
 
 <script setup lang="ts">
 import { XCircleIcon } from "@heroicons/vue/16/solid";
-import { ArrowTopRightOnSquareIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
 
 const loading = ref(false);
@@ -142,16 +136,15 @@ async function auth() {
 }
 
 function authWrapper_wrapper() {
-  error.value = undefined;
   loading.value = true;
   auth().catch((e) => {
     loading.value = false;
     error.value = e;
-    if (offerManualTimeout) clearTimeout(offerManualTimeout);
+    if(offerManualTimeout) clearTimeout(offerManualTimeout);
   });
   offerManualTimeout = setTimeout(() => {
     offerManual.value = true;
-  }, 2000);
+  }, 10000);
 }
 
 async function continueManual() {

components/LibrarySearch.vue

@@ -0,0 +1,177 @@
+<template>
+  <div>
+    <div
+      class="relative mb-3 transition-transform duration-300 hover:scale-105 active:scale-95"
+    >
+      <div
+        class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3"
+      >
+        <MagnifyingGlassIcon class="h-5 w-5 text-zinc-400" aria-hidden="true" />
+      </div>
+      <input
+        type="text"
+        v-model="searchQuery"
+        class="block w-full rounded-lg border-0 bg-zinc-800/50 py-2 pl-10 pr-3 text-zinc-100 placeholder:text-zinc-500 focus:bg-zinc-800 focus:ring-2 focus:ring-inset focus:ring-blue-500 sm:text-sm sm:leading-6"
+        placeholder="Search library..."
+      />
+    </div>
+
+    <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5">
+      <NuxtLink
+        v-for="nav in filteredNavigation"
+        :key="nav.id"
+        :class="[
+          'transition-all duration-300 rounded-lg flex items-center py-2 px-3 hover:scale-105 active:scale-95 hover:shadow-lg hover:shadow-zinc-950/50',
+          nav.index === currentNavigation
+            ? 'bg-zinc-800 text-zinc-100 shadow-md shadow-zinc-950/20'
+            : nav.isInstalled.value
+            ? 'text-zinc-300 hover:bg-zinc-800/90 hover:text-zinc-200'
+            : 'text-zinc-500 hover:bg-zinc-800/70 hover:text-zinc-300',
+        ]"
+        :href="nav.route"
+      >
+        <div class="flex items-center w-full gap-x-3">
+          <div
+            class="flex-none transition-transform duration-300 hover:-rotate-2"
+          >
+            <img
+              class="size-8 object-cover bg-zinc-900 rounded-lg transition-all duration-300 shadow-sm"
+              :src="icons[nav.id]"
+              alt=""
+            />
+          </div>
+          <div class="flex flex-col flex-1">
+            <p
+              class="truncate text-xs font-display leading-5 flex-1 font-semibold"
+            >
+              {{ nav.label }}
+            </p>
+            <p
+              class="text-xs font-medium"
+              :class="[gameStatusTextStyle[games[nav.id].status.value.type]]"
+            >
+              {{ gameStatusText[games[nav.id].status.value.type] }}
+            </p>
+          </div>
+        </div>
+      </NuxtLink>
+    </TransitionGroup>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { MagnifyingGlassIcon } from "@heroicons/vue/20/solid";
+import { invoke } from "@tauri-apps/api/core";
+import { GameStatusEnum, type Game, type GameStatus } from "~/types";
+import { TransitionGroup } from "vue";
+import { listen } from "@tauri-apps/api/event";
+
+// Style information
+const gameStatusTextStyle: { [key in GameStatusEnum]: string } = {
+  [GameStatusEnum.Installed]: "text-green-500",
+  [GameStatusEnum.Downloading]: "text-blue-500",
+  [GameStatusEnum.Running]: "text-green-500",
+  [GameStatusEnum.Remote]: "text-zinc-500",
+  [GameStatusEnum.Queued]: "text-blue-500",
+  [GameStatusEnum.Updating]: "text-blue-500",
+  [GameStatusEnum.Uninstalling]: "text-zinc-100",
+  [GameStatusEnum.SetupRequired]: "text-yellow-500",
+};
+const gameStatusText: { [key in GameStatusEnum]: string } = {
+  [GameStatusEnum.Remote]: "Not installed",
+  [GameStatusEnum.Queued]: "Queued",
+  [GameStatusEnum.Downloading]: "Downloading...",
+  [GameStatusEnum.Installed]: "Installed",
+  [GameStatusEnum.Updating]: "Updating...",
+  [GameStatusEnum.Uninstalling]: "Uninstalling...",
+  [GameStatusEnum.SetupRequired]: "Setup required",
+  [GameStatusEnum.Running]: "Running",
+};
+
+const router = useRouter();
+
+const searchQuery = ref("");
+
+const games: {
+  [key: string]: { game: Game; status: Ref<GameStatus, GameStatus> };
+} = {};
+const icons: { [key: string]: string } = {};
+
+const rawGames: Ref<Game[], Game[]> = ref([]);
+
+async function calculateGames() {
+  rawGames.value = await invoke("fetch_library");
+  for (const game of rawGames.value) {
+    if (games[game.id]) continue;
+    games[game.id] = await useGame(game.id);
+  }
+  for (const game of rawGames.value) {
+    if (icons[game.id]) continue;
+    icons[game.id] = await useObject(game.mIconId);
+  }
+}
+
+await calculateGames();
+
+const navigation = computed(() =>
+  rawGames.value.map((game) => {
+    const status = games[game.id].status;
+
+    const isInstalled = computed(
+      () =>
+        status.value.type == GameStatusEnum.Installed ||
+        status.value.type == GameStatusEnum.SetupRequired
+    );
+
+    const item = {
+      label: game.mName,
+      route: `/library/${game.id}`,
+      prefix: `/library/${game.id}`,
+      isInstalled,
+      id: game.id,
+    };
+    return item;
+  })
+);
+const { currentNavigation, recalculateNavigation } = useCurrentNavigationIndex(
+  navigation.value
+);
+
+const filteredNavigation = computed(() => {
+  if (!searchQuery.value)
+    return navigation.value.map((e, i) => ({ ...e, index: i }));
+  const query = searchQuery.value.toLowerCase();
+  return navigation.value
+    .filter((nav) => nav.label.toLowerCase().includes(query))
+    .map((e, i) => ({ ...e, index: i }));
+});
+
+listen("update_library", async (event) => {
+  console.log("Updating library");
+  let oldNavigation = navigation.value[currentNavigation.value];
+  await calculateGames();
+  recalculateNavigation();
+  if (oldNavigation !== navigation.value[currentNavigation.value]) {
+    console.log("Triggered");
+    router.push("/library");
+  }
+});
+</script>
+
+<style scoped>
+.list-move,
+.list-enter-active,
+.list-leave-active {
+  transition: all 0.3s ease;
+}
+
+.list-enter-from,
+.list-leave-to {
+  opacity: 0;
+  transform: translateX(-30px);
+}
+
+.list-leave-active {
+  position: absolute;
+}
+</style>

components/MiniHeader.vue

@@ -1,6 +1,6 @@
 <template>
   <div
-    class="h-16 cursor-pointer flex flex-row items-center justify-between bg-zinc-950"
+    class="h-10 cursor-pointer flex flex-row items-center justify-between bg-zinc-950"
   >
     <div class="px-5 py-3 grow" @mousedown="() => window.startDragging()">
       <Wordmark class="mt-1" />

components/WindowControl.vue

@@ -1,7 +1,4 @@
 <template>
-  <HeaderButton v-if="showMinimise" @click="() => minimise()">
-    <MinusIcon />
-  </HeaderButton>
   <HeaderButton @click="() => close()">
     <XMarkIcon />
   </HeaderButton>
@@ -11,14 +8,11 @@
 import { MinusIcon, XMarkIcon } from "@heroicons/vue/16/solid";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 
+async function close(){
+  console.log(window);
+  const result = await window.close();
+  console.log(`closed window: ${result}`);
+}
+
 const window = getCurrentWindow();
-const showMinimise = await window.isMinimizable();
-
-async function close() {
-  await window.close();
-}
-
-async function minimise() {
-  await window.minimize();
-}
 </script>

composables/app-state.ts

@@ -0,0 +1,3 @@
+import type { AppState } from "~/types";
+
+export const useAppState = () => useState<AppState>("state");

composables/downloads.ts

@@ -32,5 +32,3 @@ listen("update_stats", (event) => {
   const stats = useStatsState();
   stats.value = event.payload as StatsState;
 });
-
-export const useDownloadHistory = () => useState<Array<number>>('history', () => []);

composables/game.ts

@@ -14,6 +14,7 @@ export type SerializedGameStatus = [
 ];
 
 export const parseStatus = (status: SerializedGameStatus): GameStatus => {
+  console.log(status);
   if (status[0]) {
     return {
       type: status[0].type,
@@ -43,11 +44,11 @@ export const useGame = async (gameId: string) => {
       gameStatusRegistry[gameId] = ref(parseStatus(data.status));
 
       listen(`update_game/${gameId}`, (event) => {
-        console.log(event);
         const payload: {
           status: SerializedGameStatus;
           version?: GameVersion;
         } = event.payload as any;
+        console.log(payload.status);
         gameStatusRegistry[gameId].value = parseStatus(payload.status);
         
         /**

composables/state-navigation.ts

@@ -1,11 +1,9 @@
-import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { data } from "autoprefixer";
 import { AppStatus, type AppState } from "~/types";
 
 export function setupHooks() {
   const router = useRouter();
-  const state = useAppState();
 
   listen("auth/processing", (event) => {
     router.push("/auth/processing");
@@ -17,9 +15,8 @@ export function setupHooks() {
     );
   });
 
-  listen("auth/finished", async (event) => {
-    router.push("/library");
-    state.value = JSON.parse(await invoke("fetch_state"));
+  listen("auth/finished", (event) => {
+    router.push("/store");
   });
 
   listen("download_error", (event) => {
@@ -30,31 +27,12 @@ export function setupHooks() {
         description: `Drop encountered an error while downloading your game: "${(
           event.payload as unknown as string
         ).toString()}"`,
-        buttonText: "Close",
+        buttonText: "Close"
       },
       (e, c) => c()
     );
   });
 
-  // This is for errors that (we think) aren't our fault
-  listen("launch_external_error", (event) => {
-    createModal(
-      ModalType.Confirmation,
-      {
-        title: "Did something go wrong?",
-        description:
-          "Drop detected that something might've gone wrong with launching your game. Do you want to open the log directory?",
-        buttonText: "Open",
-      },
-      async (e, c) => {
-        if (e == "confirm") {
-          await invoke("open_process_logs", { gameId: event.payload });
-        }
-        c();
-      }
-    );
-  });
-
   /*
 
   document.addEventListener("contextmenu", (event) => {
@@ -65,13 +43,7 @@ export function setupHooks() {
   */
 }
 
-export function initialNavigation(state: ReturnType<typeof useAppState>) {
-  if (!state.value)
-    throw createError({
-      statusCode: 500,
-      statusMessage: "App state not valid",
-      fatal: true,
-    });
+export function initialNavigation(state: Ref<AppState>) {
   const router = useRouter();
 
   switch (state.value.status) {
@@ -88,6 +60,6 @@ export function initialNavigation(state: ReturnType<typeof useAppState>) {
       router.push("/error/serverunavailable");
       break;
     default:
-      router.push("/library");
+      router.push("/store");
   }
 }

database/Cargo.toml

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

database/src/db.rs

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

database/src/interface.rs

@@ -1,188 +0,0 @@
-use std::{
-    fs::{self, create_dir_all},
-    mem::ManuallyDrop,
-    ops::{Deref, DerefMut},
-    path::PathBuf,
-    sync::{RwLockReadGuard, RwLockWriteGuard},
-};
-
-use chrono::Utc;
-use log::{debug, error, info, warn};
-use rustbreak::{PathDatabase, RustbreakError};
-use url::Url;
-
-use crate::{
-    db::{DATA_ROOT_DIR, DB, DropDatabaseSerializer},
-    models::data::Database,
-};
-
-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 {
-        let db_path = DATA_ROOT_DIR.join("drop.db");
-        let games_base_dir = DATA_ROOT_DIR.join("games");
-        let logs_root_dir = DATA_ROOT_DIR.join("logs");
-        let cache_dir = DATA_ROOT_DIR.join("cache");
-        let pfx_dir = DATA_ROOT_DIR.join("pfx");
-
-        debug!("creating data directory at {DATA_ROOT_DIR:?}");
-        create_dir_all(DATA_ROOT_DIR.as_path()).unwrap_or_else(|e| {
-            panic!(
-                "Failed to create directory {} with error {}",
-                DATA_ROOT_DIR.display(),
-                e
-            )
-        });
-        create_dir_all(&games_base_dir).unwrap_or_else(|e| {
-            panic!(
-                "Failed to create directory {} with error {}",
-                games_base_dir.display(),
-                e
-            )
-        });
-        create_dir_all(&logs_root_dir).unwrap_or_else(|e| {
-            panic!(
-                "Failed to create directory {} with error {}",
-                logs_root_dir.display(),
-                e
-            )
-        });
-        create_dir_all(&cache_dir).unwrap_or_else(|e| {
-            panic!(
-                "Failed to create directory {} with error {}",
-                cache_dir.display(),
-                e
-            )
-        });
-        create_dir_all(&pfx_dir).unwrap_or_else(|e| {
-            panic!(
-                "Failed to create directory {} with error {}",
-                pfx_dir.display(),
-                e
-            )
-        });
-
-        let exists = fs::exists(db_path.clone()).unwrap_or_else(|e| {
-            panic!(
-                "Failed to find if {} exists with error {}",
-                db_path.display(),
-                e
-            )
-        });
-
-        if exists {
-            match PathDatabase::load_from_path(db_path.clone()) {
-                Ok(db) => db,
-                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
-            }
-        } else {
-            let default = Database::new(games_base_dir, None, cache_dir);
-            debug!("Creating database at path {}", db_path.display());
-            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
-fn handle_invalid_database(
-    _e: RustbreakError,
-    db_path: PathBuf,
-    games_base_dir: PathBuf,
-    cache_dir: PathBuf,
-) -> rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer> {
-    warn!("{_e}");
-    let new_path = {
-        let time = Utc::now().timestamp();
-        let mut base = db_path.clone();
-        base.set_file_name(format!("drop.db.backup-{time}"));
-        base
-    };
-    info!("old database stored at: {}", new_path.to_string_lossy());
-    fs::rename(&db_path, &new_path).unwrap_or_else(|e| {
-        panic!(
-            "Could not rename database {} to {} with error {}",
-            db_path.display(),
-            new_path.display(),
-            e
-        )
-    });
-
-    let db = Database::new(games_base_dir, Some(new_path), cache_dir);
-
-    PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
-}
-
-// To automatically save the database upon drop
-pub struct DBRead<'a>(RwLockReadGuard<'a, Database>);
-pub struct DBWrite<'a>(ManuallyDrop<RwLockWriteGuard<'a, Database>>);
-impl<'a> Deref for DBWrite<'a> {
-    type Target = Database;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-impl<'a> DerefMut for DBWrite<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-impl<'a> Deref for DBRead<'a> {
-    type Target = Database;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-impl Drop for DBWrite<'_> {
-    fn drop(&mut self) {
-        unsafe {
-            ManuallyDrop::drop(&mut self.0);
-        }
-
-        match DB.save() {
-            Ok(()) => {}
-            Err(e) => {
-                error!("database failed to save with error {e}");
-                panic!("database failed to save with error {e}")
-            }
-        }
-    }
-}
-
-pub fn borrow_db_checked<'a>() -> DBRead<'a> {
-    match DB.borrow_data() {
-        Ok(data) => DBRead(data),
-        Err(e) => {
-            error!("database borrow failed with error {e}");
-            panic!("database borrow failed with error {e}");
-        }
-    }
-}
-
-pub fn borrow_db_mut_checked<'a>() -> DBWrite<'a> {
-    match DB.borrow_data_mut() {
-        Ok(data) => DBWrite(ManuallyDrop::new(data)),
-        Err(e) => {
-            error!("database borrow mut failed with error {e}");
-            panic!("database borrow mut failed with error {e}");
-        }
-    }
-}

database/src/lib.rs

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

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,
-            }
-        }
-    }
-}

database/src/platform.rs

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

download_manager/Cargo.toml

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

download_manager/src/downloadable.rs

@@ -1,31 +0,0 @@
-use std::sync::Arc;
-
-use database::DownloadableMetadata;
-use tauri::AppHandle;
-
-use crate::error::ApplicationDownloadError;
-
-use super::{
-    download_manager_frontend::DownloadStatus,
-    util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},
-};
-
-/**
- * Downloadables are responsible for managing their specific object's download state
- * e.g, the GameDownloadAgent is responsible for pushing game updates
- *
- * But the download manager manages the queue state
- */
-pub trait Downloadable: Send + Sync {
-    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
-    fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
-
-    fn progress(&self) -> Arc<ProgressObject>;
-    fn control_flag(&self) -> DownloadThreadControl;
-    fn status(&self) -> DownloadStatus;
-    fn metadata(&self) -> DownloadableMetadata;
-    fn on_queued(&self, app_handle: &AppHandle);
-    fn on_error(&self, app_handle: &AppHandle, error: &ApplicationDownloadError);
-    fn on_complete(&self, app_handle: &AppHandle);
-    fn on_cancelled(&self, app_handle: &AppHandle);
-}

download_manager/src/error.rs

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

download_manager/src/frontend_updates.rs

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

download_manager/src/lib.rs

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

download_manager/src/util/mod.rs

@@ -1,4 +0,0 @@
-pub mod download_thread_control_flag;
-pub mod progress_object;
-pub mod queue;
-pub mod rolling_progress_updates;

download_manager/src/util/queue.rs

@@ -1,45 +0,0 @@
-use std::{
-    collections::VecDeque,
-    sync::{Arc, Mutex, MutexGuard},
-};
-
-use database::DownloadableMetadata;
-use utils::lock;
-
-#[derive(Clone, Debug)]
-pub struct Queue {
-    inner: Arc<Mutex<VecDeque<DownloadableMetadata>>>,
-}
-
-#[allow(dead_code)]
-impl Default for Queue {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Queue {
-    pub fn new() -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(VecDeque::new())),
-        }
-    }
-    pub fn read(&self) -> VecDeque<DownloadableMetadata> {
-        lock!(self.inner).clone()
-    }
-    pub fn edit(&self) -> MutexGuard<'_, VecDeque<DownloadableMetadata>> {
-        lock!(self.inner)
-    }
-    pub fn pop_front(&self) -> Option<DownloadableMetadata> {
-        self.edit().pop_front()
-    }
-    pub fn exists(&self, meta: DownloadableMetadata) -> bool {
-        self.read().contains(&meta)
-    }
-    pub fn append(&self, interface: DownloadableMetadata) {
-        self.edit().push_back(interface);
-    }
-    pub fn get_by_meta(&self, meta: &DownloadableMetadata) -> Option<usize> {
-        self.read().iter().position(|data| data == meta)
-    }
-}

error.vue

@@ -7,7 +7,6 @@
         class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
       >
         <Logo class="h-10 w-auto sm:h-12" />
-        
       </header>
       <main
         class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"

games/Cargo.toml

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

games/src/collections/mod.rs

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

games/src/downloads/download_agent.rs

@@ -1,716 +0,0 @@
-use database::{
-    ApplicationTransientStatus, DownloadType, DownloadableMetadata, borrow_db_checked,
-    borrow_db_mut_checked,
-};
-use download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
-use download_manager::downloadable::Downloadable;
-use download_manager::error::ApplicationDownloadError;
-use download_manager::util::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
-use download_manager::util::progress_object::{ProgressHandle, ProgressObject};
-use log::{debug, error, info, warn};
-use rayon::ThreadPoolBuilder;
-use remote::auth::generate_authorization_header;
-use remote::error::RemoteAccessError;
-use remote::requests::generate_url;
-use remote::utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC};
-use std::collections::{HashMap, HashSet};
-use std::fs::{OpenOptions, create_dir_all};
-use std::io;
-use std::path::{Path, PathBuf};
-use std::sync::mpsc::Sender;
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
-use tauri::AppHandle;
-use utils::{app_emit, lock, send};
-
-#[cfg(target_os = "linux")]
-use rustix::fs::{FallocateFlags, fallocate};
-
-use crate::downloads::manifest::{
-    DownloadBucket, DownloadContext, DownloadDrop, DropManifest, DropValidateContext, ManifestBody,
-};
-use crate::downloads::utils::get_disk_available;
-use crate::downloads::validate::validate_game_chunk;
-use crate::library::{on_game_complete, push_game_update, set_partially_installed};
-use crate::state::GameStatusManager;
-
-use super::download_logic::download_game_bucket;
-use super::drop_data::DropData;
-
-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,
-    pub control_flag: DownloadThreadControl,
-    buckets: Mutex<Vec<DownloadBucket>>,
-    context_map: Mutex<HashMap<String, bool>>,
-    pub manifest: Mutex<Option<DropManifest>>,
-    pub progress: Arc<ProgressObject>,
-    sender: Sender<DownloadManagerSignal>,
-    pub dropdata: DropData,
-    status: Mutex<DownloadStatus>,
-}
-
-impl GameDownloadAgent {
-    pub async fn new_from_index(
-        id: String,
-        version: String,
-        target_download_dir: usize,
-        sender: Sender<DownloadManagerSignal>,
-    ) -> Result<Self, ApplicationDownloadError> {
-        let base_dir = {
-            let db_lock = borrow_db_checked();
-
-            db_lock.applications.install_dirs[target_download_dir].clone()
-        };
-
-        Self::new(id, version, base_dir, sender).await
-    }
-    pub async fn new(
-        id: String,
-        version: String,
-        base_dir: PathBuf,
-        sender: Sender<DownloadManagerSignal>,
-    ) -> Result<Self, ApplicationDownloadError> {
-        // Don't run by default
-        let control_flag = DownloadThreadControl::new(DownloadThreadControlFlag::Stop);
-
-        let base_dir_path = Path::new(&base_dir);
-        let data_base_dir_path = base_dir_path.join(id.clone());
-
-        let stored_manifest =
-            DropData::generate(id.clone(), version.clone(), data_base_dir_path.clone());
-
-        let context_lock = stored_manifest.contexts.lock().unwrap().clone();
-
-        let result = Self {
-            id,
-            version,
-            control_flag,
-            manifest: Mutex::new(None),
-            buckets: Mutex::new(Vec::new()),
-            context_map: Mutex::new(HashMap::new()),
-            progress: Arc::new(ProgressObject::new(0, 0, sender.clone())),
-            sender,
-            dropdata: stored_manifest,
-            status: Mutex::new(DownloadStatus::Queued),
-        };
-
-        result.ensure_manifest_exists().await?;
-
-        let required_space = lock!(result.manifest)
-            .as_ref()
-            .unwrap()
-            .values()
-            .map(|e| {
-                e.lengths
-                    .iter()
-                    .enumerate()
-                    .filter(|(i, _)| *context_lock.get(&e.checksums[*i]).unwrap_or(&false))
-                    .map(|(_, v)| v)
-                    .sum::<usize>()
-            })
-            .sum::<usize>() as u64;
-
-        let available_space = get_disk_available(data_base_dir_path)? as u64;
-
-        if required_space > available_space {
-            return Err(ApplicationDownloadError::DiskFull(
-                required_space,
-                available_space,
-            ));
-        }
-
-        Ok(result)
-    }
-
-    // Blocking
-    pub fn setup_download(&self, app_handle: &AppHandle) -> Result<(), ApplicationDownloadError> {
-        let mut db_lock = borrow_db_mut_checked();
-        let status = ApplicationTransientStatus::Downloading {
-            version_name: self.version.clone(),
-        };
-        db_lock
-            .applications
-            .transient_statuses
-            .insert(self.metadata(), status.clone());
-        // Don't use GameStatusManager because this game isn't installed
-        push_game_update(app_handle, &self.metadata().id, None, (None, Some(status)));
-
-        if !self.check_manifest_exists() {
-            return Err(ApplicationDownloadError::NotInitialized);
-        }
-
-        self.ensure_buckets()?;
-
-        self.control_flag.set(DownloadThreadControlFlag::Go);
-
-        Ok(())
-    }
-
-    // Blocking
-    pub fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
-        self.setup_download(app_handle)?;
-        let timer = Instant::now();
-
-        info!("beginning download for {}...", self.metadata().id);
-
-        let res = self.run().map_err(ApplicationDownloadError::Communication);
-
-        debug!(
-            "{} took {}ms to download",
-            self.id,
-            timer.elapsed().as_millis()
-        );
-        res
-    }
-
-    pub fn check_manifest_exists(&self) -> bool {
-        lock!(self.manifest).is_some()
-    }
-
-    pub async fn ensure_manifest_exists(&self) -> Result<(), ApplicationDownloadError> {
-        if lock!(self.manifest).is_some() {
-            return Ok(());
-        }
-
-        self.download_manifest().await
-    }
-
-    async fn download_manifest(&self) -> Result<(), ApplicationDownloadError> {
-        let client = DROP_CLIENT_ASYNC.clone();
-        let url = generate_url(
-            &["/api/v1/client/game/manifest"],
-            &[("id", &self.id), ("version", &self.version)],
-        )
-        .map_err(ApplicationDownloadError::Communication)?;
-
-        let response = client
-            .get(url)
-            .header("Authorization", generate_authorization_header())
-            .send()
-            .await
-            .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
-
-        if response.status() != 200 {
-            return Err(ApplicationDownloadError::Communication(
-                RemoteAccessError::ManifestDownloadFailed(
-                    response.status(),
-                    response.text().await.unwrap(),
-                ),
-            ));
-        }
-
-        let manifest_download: DropManifest = response
-            .json()
-            .await
-            .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
-
-        if let Ok(mut manifest) = self.manifest.lock() {
-            *manifest = Some(manifest_download);
-            return Ok(());
-        }
-
-        Err(ApplicationDownloadError::Lock)
-    }
-
-    // Sets it up for both download and validate
-    fn setup_progress(&self) {
-        let buckets = lock!(self.buckets);
-
-        let chunk_count = buckets.iter().map(|e| e.drops.len()).sum();
-
-        let total_length = buckets
-            .iter()
-            .map(|bucket| bucket.drops.iter().map(|e| e.length).sum::<usize>())
-            .sum();
-
-        self.progress.set_max(total_length);
-        self.progress.set_size(chunk_count);
-        self.progress.reset();
-    }
-
-    pub fn ensure_buckets(&self) -> Result<(), ApplicationDownloadError> {
-        if lock!(self.buckets).is_empty() {
-            self.generate_buckets()?;
-        }
-
-        *lock!(self.context_map) = self.dropdata.get_contexts();
-
-        Ok(())
-    }
-
-    pub fn generate_buckets(&self) -> Result<(), ApplicationDownloadError> {
-        let manifest = lock!(self.manifest)
-            .clone()
-            .ok_or(ApplicationDownloadError::NotInitialized)?;
-        let game_id = self.id.clone();
-
-        let base_path = Path::new(&self.dropdata.base_path);
-        create_dir_all(base_path)?;
-
-        let mut buckets = Vec::new();
-
-        let mut current_buckets = HashMap::<String, DownloadBucket>::new();
-        let mut current_bucket_sizes = HashMap::<String, usize>::new();
-
-        for (raw_path, chunk) in manifest {
-            let path = base_path.join(Path::new(&raw_path));
-
-            let container = path
-                .parent()
-                .ok_or(ApplicationDownloadError::IoError(Arc::new(io::Error::new(
-                    io::ErrorKind::NotFound,
-                    "no parent directory",
-                ))))?;
-            create_dir_all(container)?;
-
-            let already_exists = path.exists();
-            let file = OpenOptions::new()
-                .read(true)
-                .write(true)
-                .create(true)
-                .truncate(false)
-                .open(&path)?;
-            let mut file_running_offset = 0;
-
-            for (index, length) in chunk.lengths.iter().enumerate() {
-                let drop = DownloadDrop {
-                    filename: raw_path.to_string(),
-                    start: file_running_offset,
-                    length: *length,
-                    checksum: chunk.checksums[index].clone(),
-                    permissions: chunk.permissions,
-                    path: path.clone(),
-                    index,
-                };
-                file_running_offset += *length;
-
-                if *length >= TARGET_BUCKET_SIZE {
-                    // They get their own bucket
-
-                    buckets.push(DownloadBucket {
-                        game_id: game_id.clone(),
-                        version: chunk.version_name.clone(),
-                        drops: vec![drop],
-                    });
-
-                    continue;
-                }
-
-                let current_bucket_size = current_bucket_sizes
-                    .entry(chunk.version_name.clone())
-                    .or_insert_with(|| 0);
-                let c_version_name = chunk.version_name.clone();
-                let c_game_id = game_id.clone();
-                let current_bucket = current_buckets
-                    .entry(chunk.version_name.clone())
-                    .or_insert_with(|| DownloadBucket {
-                        game_id: c_game_id,
-                        version: c_version_name,
-                        drops: vec![],
-                    });
-
-                if (*current_bucket_size + length >= TARGET_BUCKET_SIZE
-                    || current_bucket.drops.len() >= MAX_FILES_PER_BUCKET)
-                    && !current_bucket.drops.is_empty()
-                {
-                    // Move current bucket into list and make a new one
-                    buckets.push(current_bucket.clone());
-                    *current_bucket = DownloadBucket {
-                        game_id: game_id.clone(),
-                        version: chunk.version_name.clone(),
-                        drops: vec![],
-                    };
-                    *current_bucket_size = 0;
-                }
-
-                current_bucket.drops.push(drop);
-                *current_bucket_size += *length;
-            }
-
-            #[cfg(target_os = "linux")]
-            if file_running_offset > 0 && !already_exists {
-                let _ = fallocate(file, FallocateFlags::empty(), 0, file_running_offset as u64);
-            }
-        }
-
-        for (_, bucket) in current_buckets.into_iter() {
-            if !bucket.drops.is_empty() {
-                buckets.push(bucket);
-            }
-        }
-
-        info!("buckets: {}", buckets.len());
-
-        let existing_contexts = self.dropdata.get_contexts();
-        self.dropdata.set_contexts(
-            &buckets
-                .iter()
-                .flat_map(|x| x.drops.iter().map(|v| v.checksum.clone()))
-                .map(|x| {
-                    let contains = existing_contexts.get(&x).unwrap_or(&false);
-                    (x, *contains)
-                })
-                .collect::<Vec<(String, bool)>>(),
-        );
-
-        *lock!(self.buckets) = buckets;
-
-        Ok(())
-    }
-
-    fn run(&self) -> Result<bool, RemoteAccessError> {
-        self.setup_progress();
-        let max_download_threads = borrow_db_checked().settings.max_download_threads;
-
-        debug!(
-            "downloading game: {} with {} threads",
-            self.id, max_download_threads
-        );
-        let pool = ThreadPoolBuilder::new()
-            .num_threads(max_download_threads)
-            .build()
-            .unwrap_or_else(|_| {
-                panic!("failed to build thread pool with {max_download_threads} threads")
-            });
-
-        let buckets = lock!(self.buckets);
-
-        let mut download_contexts = HashMap::<String, DownloadContext>::new();
-
-        let versions = buckets
-            .iter()
-            .map(|e| &e.version)
-            .collect::<HashSet<_>>()
-            .into_iter()
-            .cloned()
-            .collect::<Vec<String>>();
-
-        info!("downloading across these versions: {versions:?}");
-
-        let completed_contexts = Arc::new(boxcar::Vec::new());
-        let completed_indexes_loop_arc = completed_contexts.clone();
-
-        for version in versions {
-            let download_context = DROP_CLIENT_SYNC
-                .post(generate_url(&["/api/v2/client/context"], &[])?)
-                .json(&ManifestBody {
-                    game: self.id.clone(),
-                    version: version.clone(),
-                })
-                .header("Authorization", generate_authorization_header())
-                .send()?;
-
-            if download_context.status() != 200 {
-                return Err(RemoteAccessError::InvalidResponse(download_context.json()?));
-            }
-
-            let download_context = download_context.json::<DownloadContext>()?;
-            info!(
-                "download context: ({}) {}",
-                &version, download_context.context
-            );
-            download_contexts.insert(version, download_context);
-        }
-
-        let download_contexts = &download_contexts;
-
-        pool.scope(|scope| {
-            let context_map = lock!(self.context_map);
-            for (index, bucket) in buckets.iter().enumerate() {
-                let mut bucket = (*bucket).clone();
-                let completed_contexts = completed_indexes_loop_arc.clone();
-
-                let progress = self.progress.get(index);
-                let progress_handle = ProgressHandle::new(progress, self.progress.clone());
-
-                // If we've done this one already, skip it
-                // Note to future DecDuck, DropData gets loaded into context_map
-                let todo_drops = bucket
-                    .drops
-                    .into_iter()
-                    .filter(|e| {
-                        let todo = !*context_map.get(&e.checksum).unwrap_or(&false);
-                        if !todo {
-                            progress_handle.skip(e.length);
-                        }
-                        todo
-                    })
-                    .collect::<Vec<DownloadDrop>>();
-
-                if todo_drops.is_empty() {
-                    continue;
-                };
-
-                bucket.drops = todo_drops;
-
-                let sender = self.sender.clone();
-
-                let download_context =
-                    download_contexts.get(&bucket.version).unwrap_or_else(|| {
-                        panic!(
-                            "Could not get bucket version {}. Corrupted state.",
-                            bucket.version
-                        )
-                    });
-
-                scope.spawn(move |_| {
-                    // 3 attempts
-                    for i in 0..RETRY_COUNT {
-                        let loop_progress_handle = progress_handle.clone();
-                        match download_game_bucket(
-                            &bucket,
-                            download_context,
-                            &self.control_flag,
-                            loop_progress_handle,
-                        ) {
-                            Ok(true) => {
-                                for drop in bucket.drops {
-                                    completed_contexts.push(drop.checksum);
-                                }
-                                return;
-                            }
-                            Ok(false) => return,
-                            Err(e) => {
-                                warn!("game download agent error: {e}");
-
-                                let retry = matches!(
-                                    &e,
-                                    ApplicationDownloadError::Communication(_)
-                                        | ApplicationDownloadError::Checksum
-                                        | ApplicationDownloadError::Lock
-                                        | ApplicationDownloadError::IoError(_)
-                                );
-
-                                if i == RETRY_COUNT - 1 || !retry {
-                                    warn!("retry logic failed, not re-attempting.");
-                                    send!(sender, DownloadManagerSignal::Error(e));
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-        });
-
-        let newly_completed = completed_contexts.clone();
-
-        let completed_lock_len = {
-            let mut context_map_lock = lock!(self.context_map);
-            for (_, item) in newly_completed.iter() {
-                context_map_lock.insert(item.clone(), true);
-            }
-
-            context_map_lock.values().filter(|x| **x).count()
-        };
-
-        let context_map_lock = lock!(self.context_map);
-        let contexts = buckets
-            .iter()
-            .flat_map(|x| x.drops.iter().map(|e| e.checksum.clone()))
-            .map(|x| {
-                let completed = context_map_lock.get(&x).unwrap_or(&false);
-                (x, *completed)
-            })
-            .collect::<Vec<(String, bool)>>();
-        drop(context_map_lock);
-
-        self.dropdata.set_contexts(&contexts);
-        self.dropdata.write();
-
-        // If there are any contexts left which are false
-        if !contexts.iter().all(|x| x.1) {
-            info!(
-                "download agent for {} exited without completing ({}/{}) ({} buckets)",
-                self.id.clone(),
-                completed_lock_len,
-                contexts.len(),
-                buckets.len()
-            );
-            return Ok(false);
-        }
-
-        Ok(true)
-    }
-
-    fn setup_validate(&self, app_handle: &AppHandle) {
-        self.setup_progress();
-
-        self.control_flag.set(DownloadThreadControlFlag::Go);
-
-        let status = ApplicationTransientStatus::Validating {
-            version_name: self.version.clone(),
-        };
-
-        let mut db_lock = borrow_db_mut_checked();
-        db_lock
-            .applications
-            .transient_statuses
-            .insert(self.metadata(), status.clone());
-        push_game_update(app_handle, &self.metadata().id, None, (None, Some(status)));
-    }
-
-    pub fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
-        self.setup_validate(app_handle);
-
-        let buckets = lock!(self.buckets);
-        let contexts: Vec<DropValidateContext> = buckets
-            .clone()
-            .into_iter()
-            .flat_map(|e| -> Vec<DropValidateContext> { e.into() })
-            .collect();
-        let max_download_threads = borrow_db_checked().settings.max_download_threads;
-
-        info!("{} validation contexts", contexts.len());
-        let pool = ThreadPoolBuilder::new()
-            .num_threads(max_download_threads)
-            .build()
-            .unwrap_or_else(|_| {
-                panic!("failed to build thread pool with {max_download_threads} threads")
-            });
-
-        let invalid_chunks = Arc::new(boxcar::Vec::new());
-        pool.scope(|scope| {
-            for (index, context) in contexts.iter().enumerate() {
-                let current_progress = self.progress.get(index);
-                let progress_handle = ProgressHandle::new(current_progress, self.progress.clone());
-                let invalid_chunks_scoped = invalid_chunks.clone();
-                let sender = self.sender.clone();
-
-                scope.spawn(move |_| {
-                    match validate_game_chunk(context, &self.control_flag, progress_handle) {
-                        Ok(true) => {}
-                        Ok(false) => {
-                            invalid_chunks_scoped.push(context.checksum.clone());
-                        }
-                        Err(e) => {
-                            error!("{e}");
-                            send!(sender, DownloadManagerSignal::Error(e));
-                        }
-                    }
-                });
-            }
-        });
-
-        // If there are any contexts left which are false
-        if !invalid_chunks.is_empty() {
-            info!("validation of game id {} failed", self.id);
-
-            for context in invalid_chunks.iter() {
-                self.dropdata.set_context(context.1.clone(), false);
-            }
-
-            self.dropdata.write();
-
-            return Ok(false);
-        }
-
-        Ok(true)
-    }
-
-    pub fn cancel(&self, app_handle: &AppHandle) {
-        // See docs on usage
-        set_partially_installed(
-            &self.metadata(),
-            self.dropdata.base_path.display().to_string(),
-            Some(app_handle),
-        );
-
-        self.dropdata.write();
-    }
-}
-
-impl Downloadable for GameDownloadAgent {
-    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
-        *lock!(self.status) = DownloadStatus::Downloading;
-        self.download(app_handle)
-    }
-
-    fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
-        *lock!(self.status) = DownloadStatus::Validating;
-        self.validate(app_handle)
-    }
-
-    fn progress(&self) -> Arc<ProgressObject> {
-        self.progress.clone()
-    }
-
-    fn control_flag(&self) -> DownloadThreadControl {
-        self.control_flag.clone()
-    }
-
-    fn metadata(&self) -> DownloadableMetadata {
-        DownloadableMetadata {
-            id: self.id.clone(),
-            version: Some(self.version.clone()),
-            download_type: DownloadType::Game,
-        }
-    }
-
-    fn on_queued(&self, app_handle: &tauri::AppHandle) {
-        *self.status.lock().unwrap() = DownloadStatus::Queued;
-        let mut db_lock = borrow_db_mut_checked();
-        let status = ApplicationTransientStatus::Queued {
-            version_name: self.version.clone(),
-        };
-        db_lock
-            .applications
-            .transient_statuses
-            .insert(self.metadata(), status.clone());
-        push_game_update(app_handle, &self.id, None, (None, Some(status)));
-    }
-
-    fn on_error(&self, app_handle: &tauri::AppHandle, error: &ApplicationDownloadError) {
-        *lock!(self.status) = DownloadStatus::Error;
-        app_emit!(app_handle, "download_error", error.to_string());
-
-        error!("error while managing download: {error:?}");
-
-        let mut handle = borrow_db_mut_checked();
-        handle
-            .applications
-            .transient_statuses
-            .remove(&self.metadata());
-
-        push_game_update(
-            app_handle,
-            &self.id,
-            None,
-            GameStatusManager::fetch_state(&self.id, &handle),
-        );
-    }
-
-    fn on_complete(&self, app_handle: &tauri::AppHandle) {
-        match on_game_complete(
-            &self.metadata(),
-            self.dropdata.base_path.to_string_lossy().to_string(),
-            app_handle,
-        ) {
-            Ok(_) => {}
-            Err(e) => {
-                error!("could not mark game as complete: {e}");
-                send!(
-                    self.sender,
-                    DownloadManagerSignal::Error(ApplicationDownloadError::DownloadError(e))
-                );
-            }
-        }
-    }
-
-    fn on_cancelled(&self, app_handle: &tauri::AppHandle) {
-        info!("cancelled {}", self.id);
-        self.cancel(app_handle);
-    }
-
-    fn status(&self) -> DownloadStatus {
-        lock!(self.status).clone()
-    }
-}

games/src/downloads/download_logic.rs

@@ -1,295 +0,0 @@
-use std::fs::{Permissions, set_permissions};
-use std::io::Read;
-#[cfg(unix)]
-use std::os::unix::fs::PermissionsExt;
-use std::sync::Arc;
-use std::time::Instant;
-use std::{
-    fs::{File, OpenOptions},
-    io::{self, BufWriter, Seek, SeekFrom, Write},
-    path::PathBuf,
-};
-
-use download_manager::error::ApplicationDownloadError;
-use download_manager::util::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
-use download_manager::util::progress_object::ProgressHandle;
-use log::{debug, info, warn};
-use md5::{Context, Digest};
-use remote::auth::generate_authorization_header;
-use remote::error::{DropServerError, RemoteAccessError};
-use remote::requests::generate_url;
-use remote::utils::DROP_CLIENT_SYNC;
-use reqwest::blocking::Response;
-
-use crate::downloads::manifest::{ChunkBody, DownloadBucket, DownloadContext, DownloadDrop};
-
-static MAX_PACKET_LENGTH: usize = 4096 * 4;
-static BUMP_SIZE: usize = 4096 * 16;
-
-pub struct DropWriter<W: Write> {
-    hasher: Context,
-    destination: BufWriter<W>,
-    progress: ProgressHandle,
-}
-impl DropWriter<File> {
-    fn new(path: PathBuf, progress: ProgressHandle) -> Result<Self, io::Error> {
-        let destination = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(false)
-            .open(&path)?;
-        Ok(Self {
-            destination: BufWriter::with_capacity(1024 * 1024, destination),
-            hasher: Context::new(),
-            progress,
-        })
-    }
-
-    fn finish(mut self) -> io::Result<Digest> {
-        self.flush()?;
-        Ok(self.hasher.finalize())
-    }
-}
-// Write automatically pushes to file and hasher
-impl Write for DropWriter<File> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.hasher
-            .write_all(buf)
-            .map_err(|e| io::Error::other(format!("Unable to write to hasher: {e}")))?;
-        let bytes_written = self.destination.write(buf)?;
-        self.progress.add(bytes_written);
-
-        Ok(bytes_written)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.hasher.flush()?;
-        self.destination.flush()
-    }
-}
-// Seek moves around destination output
-impl Seek for DropWriter<File> {
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        self.destination.seek(pos)
-    }
-}
-
-pub struct DropDownloadPipeline<'a, R: Read, W: Write> {
-    pub source: R,
-    pub drops: Vec<DownloadDrop>,
-    pub destination: Vec<DropWriter<W>>,
-    pub control_flag: &'a DownloadThreadControl,
-    #[allow(dead_code)]
-    progress: ProgressHandle,
-}
-
-impl<'a> DropDownloadPipeline<'a, Response, File> {
-    fn new(
-        source: Response,
-        drops: Vec<DownloadDrop>,
-        control_flag: &'a DownloadThreadControl,
-        progress: ProgressHandle,
-    ) -> Result<Self, io::Error> {
-        Ok(Self {
-            source,
-            destination: drops
-                .iter()
-                .map(|drop| DropWriter::new(drop.path.clone(), progress.clone()))
-                .try_collect()?,
-            drops,
-            control_flag,
-            progress,
-        })
-    }
-
-    fn copy(&mut self) -> Result<bool, io::Error> {
-        let mut copy_buffer = [0u8; MAX_PACKET_LENGTH];
-        for (index, drop) in self.drops.iter().enumerate() {
-            let destination = self
-                .destination
-                .get_mut(index)
-                .ok_or(io::Error::other("no destination"))?;
-            let mut remaining = drop.length;
-            if drop.start != 0 {
-                destination.seek(SeekFrom::Start(drop.start as u64))?;
-            }
-            let mut last_bump = 0;
-            loop {
-                let size = MAX_PACKET_LENGTH.min(remaining);
-                let size = self
-                    .source
-                    .read(&mut copy_buffer[0..size])
-                    .inspect_err(|_| {
-                        info!("got error from {}", drop.filename);
-                    })?;
-                remaining -= size;
-                last_bump += size;
-
-                destination.write_all(&copy_buffer[0..size])?;
-
-                if last_bump > BUMP_SIZE {
-                    last_bump -= BUMP_SIZE;
-                    if self.control_flag.get() == DownloadThreadControlFlag::Stop {
-                        return Ok(false);
-                    }
-                }
-
-                if remaining == 0 {
-                    break;
-                };
-            }
-
-            if self.control_flag.get() == DownloadThreadControlFlag::Stop {
-                return Ok(false);
-            }
-        }
-
-        Ok(true)
-    }
-
-    #[allow(dead_code)]
-    fn debug_skip_checksum(self) {
-        self.destination
-            .into_iter()
-            .for_each(|mut e| e.flush().unwrap());
-    }
-
-    fn finish(self) -> Result<Vec<Digest>, io::Error> {
-        let checksums = self
-            .destination
-            .into_iter()
-            .map(|e| e.finish())
-            .try_collect()?;
-        Ok(checksums)
-    }
-}
-
-pub fn download_game_bucket(
-    bucket: &DownloadBucket,
-    ctx: &DownloadContext,
-    control_flag: &DownloadThreadControl,
-    progress: ProgressHandle,
-) -> Result<bool, ApplicationDownloadError> {
-    // If we're paused
-    if control_flag.get() == DownloadThreadControlFlag::Stop {
-        progress.set(0);
-        return Ok(false);
-    }
-
-    let start = Instant::now();
-
-    let header = generate_authorization_header();
-
-    let url = generate_url(&["/api/v2/client/chunk"], &[])
-        .map_err(ApplicationDownloadError::Communication)?;
-
-    let body = ChunkBody::create(ctx, &bucket.drops);
-
-    let response = DROP_CLIENT_SYNC
-        .post(url)
-        .json(&body)
-        .header("Authorization", header)
-        .send()
-        .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
-
-    if response.status() != 200 {
-        info!("chunk request got status code: {}", response.status());
-        let raw_res = response.text().map_err(|e| {
-            ApplicationDownloadError::Communication(RemoteAccessError::FetchError(e.into()))
-        })?;
-        info!("{raw_res}");
-        if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
-            return Err(ApplicationDownloadError::Communication(
-                RemoteAccessError::InvalidResponse(err),
-            ));
-        }
-        return Err(ApplicationDownloadError::Communication(
-            RemoteAccessError::UnparseableResponse(raw_res),
-        ));
-    }
-
-    let lengths = response
-        .headers()
-        .get("Content-Lengths")
-        .ok_or(ApplicationDownloadError::Communication(
-            RemoteAccessError::UnparseableResponse("missing Content-Lengths header".to_owned()),
-        ))?
-        .to_str()
-        .map_err(|e| {
-            ApplicationDownloadError::Communication(RemoteAccessError::UnparseableResponse(
-                e.to_string(),
-            ))
-        })?;
-
-    for (i, raw_length) in lengths.split(",").enumerate() {
-        let length = raw_length.parse::<usize>().unwrap_or(0);
-        let Some(drop) = bucket.drops.get(i) else {
-            warn!("invalid number of Content-Lengths recieved: {i}, {lengths}");
-            return Err(ApplicationDownloadError::DownloadError(
-                RemoteAccessError::InvalidResponse(DropServerError {
-                    status_code: 400,
-                    status_message: format!(
-                        "invalid number of Content-Lengths recieved: {i}, {lengths}"
-                    ),
-                }),
-            ));
-        };
-        if drop.length != length {
-            warn!(
-                "for {}, expected {}, got {} ({})",
-                drop.filename, drop.length, raw_length, length
-            );
-            return Err(ApplicationDownloadError::DownloadError(
-                RemoteAccessError::InvalidResponse(DropServerError {
-                    status_code: 400,
-                    status_message: format!(
-                        "for {}, expected {}, got {} ({})",
-                        drop.filename, drop.length, raw_length, length
-                    ),
-                }),
-            ));
-        }
-    }
-
-    let timestep = start.elapsed().as_millis();
-
-    debug!("took {}ms to start downloading", timestep);
-
-    let mut pipeline =
-        DropDownloadPipeline::new(response, bucket.drops.clone(), control_flag, progress)
-            .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
-
-    let completed = pipeline
-        .copy()
-        .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
-    if !completed {
-        return Ok(false);
-    }
-
-    // If we complete the file, set the permissions (if on Linux)
-    #[cfg(unix)]
-    {
-        for drop in bucket.drops.iter() {
-            let permissions = Permissions::from_mode(drop.permissions);
-            set_permissions(drop.path.clone(), permissions)
-                .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
-        }
-    }
-
-    let checksums = pipeline
-        .finish()
-        .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
-
-    for (index, drop) in bucket.drops.iter().enumerate() {
-        let res = hex::encode(**checksums.get(index).unwrap());
-        if res != drop.checksum {
-            warn!("context didn't match... doing nothing because we will validate later.");
-            // return Ok(false);
-            // return Err(ApplicationDownloadError::Checksum);
-        }
-    }
-
-    Ok(true)
-}

games/src/downloads/drop_data.rs

@@ -1,94 +0,0 @@
-use std::{
-    collections::HashMap,
-    fs::File,
-    io::{self, Read, Write},
-    path::{Path, PathBuf},
-};
-
-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};
-
-    use native_model::native_model;
-    use serde::{Deserialize, Serialize};
-
-    #[derive(Serialize, Deserialize, Debug)]
-    #[native_model(id = 9, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-    pub struct DropData {
-        pub game_id: String,
-        pub game_version: String,
-        pub contexts: Mutex<HashMap<String, bool>>,
-        pub base_path: PathBuf,
-    }
-
-    impl DropData {
-        pub fn new(game_id: String, game_version: String, base_path: PathBuf) -> Self {
-            Self {
-                base_path,
-                game_id,
-                game_version,
-                contexts: Mutex::new(HashMap::new()),
-            }
-        }
-    }
-}
-
-impl DropData {
-    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
-        match DropData::read(&base_path) {
-            Ok(v) => v,
-            Err(_) => DropData::new(game_id, game_version, base_path),
-        }
-    }
-    pub fn read(base_path: &Path) -> Result<Self, io::Error> {
-        let mut file = File::open(base_path.join(DROP_DATA_PATH))?;
-
-        let mut s = Vec::new();
-        file.read_to_end(&mut s)?;
-
-        native_model::rmp_serde_1_3::RmpSerde::decode(s).map_err(|e| {
-            io::Error::new(
-                io::ErrorKind::InvalidData,
-                format!("Failed to decode drop data: {e}"),
-            )
-        })
-    }
-    pub fn write(&self) {
-        let manifest_raw = match native_model::rmp_serde_1_3::RmpSerde::encode(&self) {
-            Ok(data) => data,
-            Err(_) => return,
-        };
-
-        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
-            Ok(file) => file,
-            Err(e) => {
-                error!("{e}");
-                return;
-            }
-        };
-
-        match file.write_all(&manifest_raw) {
-            Ok(()) => {}
-            Err(e) => error!("{e}"),
-        }
-    }
-    pub fn set_contexts(&self, completed_contexts: &[(String, bool)]) {
-        *lock!(self.contexts) = completed_contexts
-            .iter()
-            .map(|s| (s.0.clone(), s.1))
-            .collect();
-    }
-    pub fn set_context(&self, context: String, state: bool) {
-        lock!(self.contexts).entry(context).insert_entry(state);
-    }
-    pub fn get_contexts(&self) -> HashMap<String, bool> {
-        lock!(self.contexts).clone()
-    }
-}

games/src/downloads/error.rs

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

games/src/downloads/manifest.rs

@@ -1,98 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Serialize)]
-// Drops go in buckets
-pub struct DownloadDrop {
-    pub index: usize,
-    pub filename: String,
-    pub path: PathBuf,
-    pub start: usize,
-    pub length: usize,
-    pub checksum: String,
-    pub permissions: u32,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct DownloadBucket {
-    pub game_id: String,
-    pub version: String,
-    pub drops: Vec<DownloadDrop>,
-}
-
-#[derive(Deserialize)]
-pub struct DownloadContext {
-    pub context: String,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ChunkBodyFile {
-    filename: String,
-    chunk_index: usize,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ChunkBody {
-    pub context: String,
-    pub files: Vec<ChunkBodyFile>,
-}
-
-#[derive(Serialize)]
-pub struct ManifestBody {
-    pub game: String,
-    pub version: String,
-}
-
-impl ChunkBody {
-    pub fn create(context: &DownloadContext, drops: &[DownloadDrop]) -> ChunkBody {
-        Self {
-            context: context.context.clone(),
-            files: drops
-                .iter()
-                .map(|e| ChunkBodyFile {
-                    filename: e.filename.clone(),
-                    chunk_index: e.index,
-                })
-                .collect(),
-        }
-    }
-}
-
-pub type DropManifest = HashMap<String, DropChunk>;
-#[derive(Serialize, Deserialize, Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct DropChunk {
-    pub permissions: u32,
-    pub ids: Vec<String>,
-    pub checksums: Vec<String>,
-    pub lengths: Vec<usize>,
-    pub version_name: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct DropValidateContext {
-    pub index: usize,
-    pub offset: usize,
-    pub path: PathBuf,
-    pub checksum: String,
-    pub length: usize,
-}
-
-impl From<DownloadBucket> for Vec<DropValidateContext> {
-    fn from(value: DownloadBucket) -> Self {
-        value
-            .drops
-            .into_iter()
-            .map(|e| DropValidateContext {
-                index: e.index,
-                offset: e.start,
-                path: e.path,
-                checksum: e.checksum,
-                length: e.length,
-            })
-            .collect()
-    }
-}

games/src/downloads/mod.rs

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

games/src/downloads/utils.rs

@@ -1,25 +0,0 @@
-use std::{io, path::PathBuf, sync::Arc};
-
-use download_manager::error::ApplicationDownloadError;
-use sysinfo::{Disk, DiskRefreshKind, Disks};
-
-pub fn get_disk_available(mount_point: PathBuf) -> Result<u64, ApplicationDownloadError> {
-    let disks = Disks::new_with_refreshed_list_specifics(DiskRefreshKind::nothing().with_storage());
-
-    let mut disk_iter = disks.into_iter().collect::<Vec<&Disk>>();
-    disk_iter.sort_by(|a, b| {
-        b.mount_point()
-            .to_string_lossy()
-            .len()
-            .cmp(&a.mount_point().to_string_lossy().len())
-    });
-
-    for disk in disk_iter {
-        if mount_point.starts_with(disk.mount_point()) {
-            return Ok(disk.available_space());
-        }
-    }
-    Err(ApplicationDownloadError::IoError(Arc::new(
-        io::Error::other("could not find disk of path"),
-    )))
-}

games/src/downloads/validate.rs

@@ -1,104 +0,0 @@
-use std::{
-    fs::File,
-    io::{self, BufWriter, Read, Seek, SeekFrom, Write},
-};
-
-use download_manager::{
-    error::ApplicationDownloadError,
-    util::{
-        download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
-        progress_object::ProgressHandle,
-    },
-};
-use log::debug;
-use md5::Context;
-
-use crate::downloads::manifest::DropValidateContext;
-
-pub fn validate_game_chunk(
-    ctx: &DropValidateContext,
-    control_flag: &DownloadThreadControl,
-    progress: ProgressHandle,
-) -> Result<bool, ApplicationDownloadError> {
-    debug!(
-        "Starting chunk validation {}, {}, {} #{}",
-        ctx.path.display(),
-        ctx.index,
-        ctx.offset,
-        ctx.checksum
-    );
-    // If we're paused
-    if control_flag.get() == DownloadThreadControlFlag::Stop {
-        progress.set(0);
-        return Ok(false);
-    }
-
-    let Ok(mut source) = File::open(&ctx.path) else {
-        return Ok(false);
-    };
-
-    if ctx.offset != 0 {
-        source
-            .seek(SeekFrom::Start(ctx.offset as u64))
-            .expect("Failed to seek to file offset");
-    }
-
-    let mut hasher = md5::Context::new();
-
-    let completed = validate_copy(&mut source, &mut hasher, ctx.length, control_flag, progress)?;
-    if !completed {
-        return Ok(false);
-    }
-
-    let res = hex::encode(hasher.finalize().0);
-    if res != ctx.checksum {
-        return Ok(false);
-    }
-
-    debug!(
-        "Successfully finished verification #{}, copied {} bytes",
-        ctx.checksum, ctx.length
-    );
-
-    Ok(true)
-}
-
-fn validate_copy(
-    source: &mut File,
-    dest: &mut Context,
-    size: usize,
-    control_flag: &DownloadThreadControl,
-    progress: ProgressHandle,
-) -> Result<bool, io::Error> {
-    let copy_buf_size = 512;
-    let mut copy_buf = vec![0; copy_buf_size];
-    let mut buf_writer = BufWriter::with_capacity(1024 * 1024, dest);
-    let mut total_bytes = 0;
-
-    loop {
-        if control_flag.get() == DownloadThreadControlFlag::Stop {
-            buf_writer.flush()?;
-            return Ok(false);
-        }
-
-        let mut bytes_read = source.read(&mut copy_buf)?;
-        total_bytes += bytes_read;
-
-        // If we read over (likely), truncate our read to
-        // the right size
-        if total_bytes > size {
-            let over = total_bytes - size;
-            bytes_read -= over;
-            total_bytes = size;
-        }
-
-        buf_writer.write_all(&copy_buf[0..bytes_read])?;
-        progress.add(bytes_read);
-
-        if total_bytes >= size {
-            break;
-        }
-    }
-    buf_writer.flush()?;
-    Ok(true)
-}

games/src/lib.rs

@@ -1,7 +0,0 @@
-#![feature(iterator_try_collect)]
-
-pub mod collections;
-pub mod downloads;
-pub mod library;
-pub mod scan;
-pub mod state;

games/src/library.rs

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

games/src/scan.rs

@@ -1,47 +0,0 @@
-use std::fs;
-
-use database::{DownloadType, DownloadableMetadata, borrow_db_mut_checked};
-use log::warn;
-
-use crate::{
-    downloads::drop_data::{DROP_DATA_PATH, DropData},
-    library::set_partially_installed_db,
-};
-
-pub fn scan_install_dirs() {
-    let mut db_lock = borrow_db_mut_checked();
-    for install_dir in db_lock.applications.install_dirs.clone() {
-        let Ok(files) = fs::read_dir(install_dir) else {
-            continue;
-        };
-        for game in files.into_iter().flatten() {
-            let drop_data_file = game.path().join(DROP_DATA_PATH);
-            if !drop_data_file.exists() {
-                continue;
-            }
-            let game_id = game.file_name().display().to_string();
-            let Ok(drop_data) = DropData::read(&game.path()) else {
-                warn!(
-                    ".dropdata exists for {}, but couldn't read it. is it corrupted?",
-                    game.file_name().display()
-                );
-                continue;
-            };
-            if db_lock.applications.game_statuses.contains_key(&game_id) {
-                continue;
-            }
-
-            let metadata = DownloadableMetadata::new(
-                drop_data.game_id,
-                Some(drop_data.game_version),
-                DownloadType::Game,
-            );
-            set_partially_installed_db(
-                &mut db_lock,
-                &metadata,
-                drop_data.base_path.to_str().unwrap().to_string(),
-                None,
-            );
-        }
-    }
-}

games/src/state.rs

@@ -1,35 +0,0 @@
-use database::models::data::{
-    ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus,
-};
-
-pub type GameStatusWithTransient = (
-    Option<GameDownloadStatus>,
-    Option<ApplicationTransientStatus>,
-);
-pub struct GameStatusManager {}
-
-impl GameStatusManager {
-    pub fn fetch_state(game_id: &String, database: &Database) -> GameStatusWithTransient {
-        let online_state = database
-            .applications
-            .transient_statuses
-            .get(&DownloadableMetadata {
-                id: game_id.to_string(),
-                download_type: DownloadType::Game,
-                version: None,
-            })
-            .cloned();
-
-        let offline_state = database.applications.game_statuses.get(game_id).cloned();
-
-        if online_state.is_some() {
-            return (None, online_state);
-        }
-
-        if offline_state.is_some() {
-            return (offline_state, None);
-        }
-
-        (None, None)
-    }
-}

main/components/HeaderButton.vue

@@ -1,5 +0,0 @@
-<template>
-    <button class="transition h-full aspect-square text-zinc-300 hover:bg-zinc-800 hover:text-zinc-100 p-[1.1rem]">
-        <slot />
-    </button>
-</template>

main/components/LibrarySearch.vue

@@ -1,303 +0,0 @@
-<template>
-  <div class="flex flex-col h-full">
-    <div class="mb-3 inline-flex gap-x-2">
-      <div
-        class="relative transition-transform duration-300 hover:scale-105 active:scale-95"
-      >
-        <div
-          class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3"
-        >
-          <MagnifyingGlassIcon
-            class="h-5 w-5 text-zinc-400"
-            aria-hidden="true"
-          />
-        </div>
-        <input
-          type="text"
-          v-model="searchQuery"
-          class="block w-full rounded-lg border-0 bg-zinc-800/50 py-2 pl-10 pr-3 text-zinc-100 placeholder:text-zinc-500 focus:bg-zinc-800 focus:ring-2 focus:ring-inset focus:ring-blue-500 sm:text-sm sm:leading-6"
-          placeholder="Search library..."
-        />
-      </div>
-      <button
-        @click="() => calculateGames(true, true)"
-        class="p-1 flex items-center justify-center transition-transform duration-300 size-10 hover:scale-110 active:scale-90 rounded-lg bg-zinc-800/50 text-zinc-100"
-      >
-        <ArrowPathIcon class="size-4" />
-      </button>
-    </div>
-
-    <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5">
-      <Disclosure
-        as="div"
-        v-for="(nav, navIndex) in filteredNavigation"
-        :key="nav.id"
-        class="first:pt-0 last:pb-0"
-        v-slot="{ open }"
-        :default-open="nav.deft"
-      >
-        <dt>
-          <DisclosureButton
-            class="flex w-full items-center justify-between text-left text-gray-900 dark:text-white"
-          >
-            <span class="text-sm font-semibold font-display">{{
-              nav.name
-            }}</span>
-            <span class="ml-6 flex h-7 items-center">
-              <PlusSmallIcon v-if="!open" class="size-6" aria-hidden="true" />
-              <MinusSmallIcon v-else class="size-6" aria-hidden="true" />
-            </span>
-          </DisclosureButton>
-        </dt>
-        <DisclosurePanel as="dd" class="mt-2 flex flex-col gap-y-1.5">
-          <NuxtLink
-            v-for="item in nav.items"
-            :key="nav.id"
-            :class="[
-              'transition-all duration-300 rounded-lg flex items-center px-1 py-1.5 hover:scale-105 active:scale-95 hover:shadow-lg hover:shadow-zinc-950/50',
-              currentNavigation == item.id
-                ? 'bg-zinc-800 text-zinc-100 shadow-md shadow-zinc-950/20'
-                : item.isInstalled.value
-                ? 'text-zinc-300 hover:bg-zinc-800/90 hover:text-zinc-200'
-                : 'text-zinc-500 hover:bg-zinc-800/70 hover:text-zinc-300',
-            ]"
-            :href="item.route"
-          >
-            <div class="flex items-center w-full gap-x-2">
-              <div
-                class="flex-none transition-transform duration-300 hover:-rotate-2"
-              >
-                <img
-                  class="size-6 object-cover bg-zinc-900 rounded transition-all duration-300 shadow-sm"
-                  :src="icons[item.id]"
-                  alt=""
-                />
-              </div>
-              <div class="inline-flex items-center gap-x-2">
-                <p
-                  class="text-sm whitespace-nowrap font-display font-semibold"
-                >
-                  {{ item.label }}
-                </p>
-                <p
-                  class="truncate text-[10px] font-bold uppercase font-display"
-                  :class="[
-                    gameStatusTextStyle[games[item.id].status.value.type],
-                  ]"
-                >
-                  {{ gameStatusText[games[item.id].status.value.type] }}
-                </p>
-              </div>
-            </div>
-          </NuxtLink>
-        </DisclosurePanel>
-      </Disclosure>
-    </TransitionGroup>
-    <div
-      v-if="loading"
-      class="h-full grow flex p-8 justify-center text-zinc-100"
-    >
-      <div role="status">
-        <svg
-          aria-hidden="true"
-          class="w-6 h-6 text-transparent animate-spin fill-zinc-600"
-          viewBox="0 0 100 101"
-          fill="none"
-          xmlns="http://www.w3.org/2000/svg"
-        >
-          <path
-            d="M100 50.5908C100 78.2051 77.6142 100.591 50 100.591C22.3858 100.591 0 78.2051 0 50.5908C0 22.9766 22.3858 0.59082 50 0.59082C77.6142 0.59082 100 22.9766 100 50.5908ZM9.08144 50.5908C9.08144 73.1895 27.4013 91.5094 50 91.5094C72.5987 91.5094 90.9186 73.1895 90.9186 50.5908C90.9186 27.9921 72.5987 9.67226 50 9.67226C27.4013 9.67226 9.08144 27.9921 9.08144 50.5908Z"
-            fill="currentColor"
-          />
-          <path
-            d="M93.9676 39.0409C96.393 38.4038 97.8624 35.9116 97.0079 33.5539C95.2932 28.8227 92.871 24.3692 89.8167 20.348C85.8452 15.1192 80.8826 10.7238 75.2124 7.41289C69.5422 4.10194 63.2754 1.94025 56.7698 1.05124C51.7666 0.367541 46.6976 0.446843 41.7345 1.27873C39.2613 1.69328 37.813 4.19778 38.4501 6.62326C39.0873 9.04874 41.5694 10.4717 44.0505 10.1071C47.8511 9.54855 51.7191 9.52689 55.5402 10.0491C60.8642 10.7766 65.9928 12.5457 70.6331 15.2552C75.2735 17.9648 79.3347 21.5619 82.5849 25.841C84.9175 28.9121 86.7997 32.2913 88.1811 35.8758C89.083 38.2158 91.5421 39.6781 93.9676 39.0409Z"
-            fill="currentFill"
-          />
-        </svg>
-        <span class="sr-only">Loading...</span>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { Disclosure, DisclosureButton, DisclosurePanel } from "@headlessui/vue";
-import {
-  ArrowPathIcon,
-  MagnifyingGlassIcon,
-  MinusSmallIcon,
-  PlusSmallIcon,
-} from "@heroicons/vue/20/solid";
-import { invoke } from "@tauri-apps/api/core";
-import {
-  GameStatusEnum,
-  type Collection as Collection,
-  type Game,
-  type GameStatus,
-} from "~/types";
-import { TransitionGroup } from "vue";
-import { listen } from "@tauri-apps/api/event";
-
-// Style information
-const gameStatusTextStyle: { [key in GameStatusEnum]: string } = {
-  [GameStatusEnum.Installed]: "text-green-500",
-  [GameStatusEnum.Downloading]: "text-zinc-400",
-  [GameStatusEnum.Validating]: "text-blue-300",
-  [GameStatusEnum.Running]: "text-green-500",
-  [GameStatusEnum.Remote]: "text-zinc-700",
-  [GameStatusEnum.Queued]: "text-zinc-400",
-  [GameStatusEnum.Updating]: "text-zinc-400",
-  [GameStatusEnum.Uninstalling]: "text-zinc-100",
-  [GameStatusEnum.SetupRequired]: "text-yellow-500",
-  [GameStatusEnum.PartiallyInstalled]: "text-gray-400",
-};
-const gameStatusText: { [key in GameStatusEnum]: string } = {
-  [GameStatusEnum.Remote]: "Not installed",
-  [GameStatusEnum.Queued]: "Queued",
-  [GameStatusEnum.Downloading]: "Downloading...",
-  [GameStatusEnum.Validating]: "Validating...",
-  [GameStatusEnum.Installed]: "Installed",
-  [GameStatusEnum.Updating]: "Updating...",
-  [GameStatusEnum.Uninstalling]: "Uninstalling...",
-  [GameStatusEnum.SetupRequired]: "Setup required",
-  [GameStatusEnum.Running]: "Running",
-  [GameStatusEnum.PartiallyInstalled]: "Partially installed",
-};
-
-const router = useRouter();
-
-const searchQuery = ref("");
-
-const loading = ref(false);
-const games: {
-  [key: string]: { game: Game; status: Ref<GameStatus, GameStatus> };
-} = {};
-const icons: { [key: string]: string } = {};
-
-const collections: Ref<Collection[]> = ref([]);
-
-async function calculateGames(clearAll = false, forceRefresh = false) {
-  if (clearAll) {
-    collections.value = [];
-    loading.value = true;
-  }
-  // If we update immediately, the navigation gets re-rendered before we
-  // add all the necessary state, and it freaks tf out
-  const newGames = await invoke<Game[]>("fetch_library", {
-    hardRefresh: forceRefresh,
-  });
-  const otherCollections = await invoke<Collection[]>("fetch_collections", {
-    hardRefresh: forceRefresh,
-  });
-  const allGames = [
-    ...newGames,
-    ...otherCollections
-      .map((e) => e.entries)
-      .flat()
-      .map((e) => e.game),
-  ].filter((v, i, a) => a.indexOf(v) === i);
-
-  for (const game of allGames) {
-    if (games[game.id]) continue;
-    games[game.id] = await useGame(game.id);
-  }
-  for (const game of allGames) {
-    if (icons[game.id]) continue;
-    icons[game.id] = await useObject(game.mIconObjectId);
-  }
-
-  const libraryCollection = {
-    id: "library",
-    name: "Library",
-    isDefault: true,
-    entries: newGames.map((e) => ({ gameId: e.id, game: e })),
-  } satisfies Collection;
-
-  loading.value = false;
-  collections.value = [libraryCollection, ...otherCollections];
-}
-
-// Wait up to 300 ms for the library to load, otherwise
-// show the loading state while we while
-await new Promise<void>((r) => {
-  let hasResolved = false;
-  const resolveFunc = () => {
-    if (!hasResolved) r();
-    hasResolved = true;
-  };
-  calculateGames(true).then(resolveFunc);
-  setTimeout(resolveFunc, 300);
-});
-
-const navigation = computed(() =>
-  collections.value.map((collection) => {
-    const items = collection.entries.map(({ game }) => {
-      const status = games[game.id].status;
-
-      const isInstalled = computed(
-        () => status.value.type != GameStatusEnum.Remote
-      );
-
-      const item = {
-        label: game.mName,
-        route: `/library/${game.id}`,
-        prefix: `/library/${game.id}`,
-        isInstalled,
-        id: game.id,
-      };
-      return item;
-    });
-
-    return {
-      id: collection.id,
-      name: collection.name,
-      deft: collection.isDefault,
-      items,
-    };
-  })
-);
-
-const route = useRoute();
-const currentNavigation = computed(() => {
-  return route.path.slice("/library/".length);
-});
-
-const filteredNavigation = computed(() => {
-  if (!searchQuery.value)
-    return navigation.value.map((e, i) => ({ ...e, index: i }));
-  const query = searchQuery.value.toLowerCase();
-  return navigation.value
-    .map((c) => ({
-      ...c,
-      items: c.items.filter((nav) => nav.label.toLowerCase().includes(query)),
-    }))
-    .filter((e) => e.items.length > 0);
-});
-
-listen("update_library", async (event) => {
-  console.log("Updating library");
-  let oldNavigation = currentNavigation.value;
-  await calculateGames();
-  if (oldNavigation !== currentNavigation.value) {
-    router.push("/library");
-  }
-});
-</script>
-
-<style scoped>
-.list-move,
-.list-enter-active,
-.list-leave-active {
-  transition: all 0.3s ease;
-}
-
-.list-enter-from,
-.list-leave-to {
-  opacity: 0;
-  transform: translateX(-30px);
-}
-
-.list-leave-active {
-  position: absolute;
-}
-</style>

main/composables/app-state.ts

@@ -1,3 +0,0 @@
-import type { AppState } from "~/types";
-
-export const useAppState = () => useState<AppState | undefined>("state");

main/package.json

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

main/pages/auth/code.vue

@@ -1,37 +0,0 @@
-<template>
-  <div class="min-h-full w-full flex items-center justify-center">
-    <div class="flex flex-col items-center">
-      <div class="text-center">
-        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
-          Device authorization
-        </h1>
-        <div class="mt-4">
-          <p class="text-sm text-zinc-400 max-w-md mx-auto">
-            Open Drop on another one of your devices, and use your account
-            dropdown to "Authorize client", and enter the code below.
-          </p>
-          <div
-            class="mt-8 flex items-center justify-center gap-x-5 text-8xl font-bold text-zinc-100"
-          >
-            <span v-for="letter in code.split('')">{{ letter }}</span>
-          </div>
-        </div>
-        <div class="mt-10 flex items-center justify-center gap-x-6">
-          <NuxtLink href="/auth" class="text-sm font-semibold text-blue-600"
-            ><span aria-hidden="true">&larr;</span> Use a different method
-          </NuxtLink>
-        </div>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { invoke } from "@tauri-apps/api/core";
-
-const code = await invoke<string>("auth_initiate_code");
-
-definePageMeta({
-  layout: "mini",
-});
-</script>

main/pages/community.vue

@@ -1,25 +0,0 @@
-<template>
-  <div class="grow w-full h-full flex items-center justify-center">
-    <div class="flex flex-col items-center">
-      <WrenchScrewdriverIcon
-        class="h-12 w-12 text-blue-600"
-        aria-hidden="true"
-      />
-      <div class="mt-3 text-center sm:mt-5">
-        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
-          Under construction
-        </h1>
-        <div class="mt-4">
-          <p class="text-sm text-zinc-400 max-w-lg">
-            This page hasn't been implemented yet.
-          </p>
-        </div>
-      </div>
-    </div>
-  </div>
-</template>
-<script setup lang="ts">
-import {
-  WrenchScrewdriverIcon,
-} from "@heroicons/vue/20/solid";
-</script>

main/pages/news.vue

@@ -1,25 +0,0 @@
-<template>
-  <div class="grow w-full h-full flex items-center justify-center">
-    <div class="flex flex-col items-center">
-      <WrenchScrewdriverIcon
-        class="h-12 w-12 text-blue-600"
-        aria-hidden="true"
-      />
-      <div class="mt-3 text-center sm:mt-5">
-        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
-          Under construction
-        </h1>
-        <div class="mt-4">
-          <p class="text-sm text-zinc-400 max-w-lg">
-            This page hasn't been implemented yet.
-          </p>
-        </div>
-      </div>
-    </div>
-  </div>
-</template>
-<script setup lang="ts">
-import {
-  WrenchScrewdriverIcon,
-} from "@heroicons/vue/20/solid";
-</script>

main/pages/settings/account.vue

@@ -1,64 +0,0 @@
-<template>
-  <div class="border-b border-zinc-700 py-5">
-    <h3 class="text-base font-semibold font-display leading-6 text-zinc-100">
-      General
-    </h3>
-  </div>
-
-  <div class="mt-5 flex flex-col gap-4">
-    <div class="flex flex-row items-center justify-between">
-      <div>
-        <h3 class="text-sm font-medium leading-6 text-zinc-100">Sign out</h3>
-        <p class="mt-1 text-sm leading-6 text-zinc-400">
-          Sign out of your Drop account on this device
-        </p>
-      </div>
-      <button
-        @click="signOut"
-        type="button"
-        class="rounded-md bg-red-600 px-3 py-2 text-sm font-semibold text-white shadow-sm hover:bg-red-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-red-600"
-      >
-        Sign out
-      </button>
-    </div>
-
-    <div v-if="error" class="rounded-md bg-red-600/10 p-4">
-      <div class="flex">
-        <div class="flex-shrink-0">
-          <XCircleIcon class="h-5 w-5 text-red-600" aria-hidden="true" />
-        </div>
-        <div class="ml-3">
-          <h3 class="text-sm font-medium text-red-600">
-            {{ error }}
-          </h3>
-        </div>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { invoke } from "@tauri-apps/api/core";
-import { listen } from "@tauri-apps/api/event";
-import { useRouter } from "#imports";
-import { XCircleIcon } from "@heroicons/vue/16/solid";
-
-const router = useRouter();
-const error = ref<string | null>(null);
-
-// Listen for auth events
-onMounted(async () => {
-  await listen("auth/signedout", () => {
-    router.push("/auth/signedout");
-  });
-});
-
-async function signOut() {
-  try {
-    error.value = null;
-    await invoke("sign_out");
-  } catch (e) {
-    error.value = `Failed to sign out: ${e}`;
-  }
-}
-</script>

main/pages/settings/index.vue

@@ -1,59 +0,0 @@
-<template>
-  <div class="border-b border-zinc-700 py-5">
-    <h3 class="text-base font-semibold font-display leading-6 text-zinc-100">
-      General
-    </h3>
-  </div>
-
-  <div class="mt-5 space-y-8">
-    <div class="flex flex-row items-center justify-between">
-      <div>
-        <h3 class="text-sm font-medium leading-6 text-zinc-100">
-          Start with system
-        </h3>
-        <p class="mt-1 text-sm leading-6 text-zinc-400">
-          Drop will automatically start when you log into your computer
-        </p>
-      </div>
-      <Switch
-        v-model="autostartEnabled"
-        :class="[
-          autostartEnabled ? 'bg-blue-600' : 'bg-zinc-700',
-          'relative inline-flex h-6 w-11 flex-shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors duration-200 ease-in-out',
-        ]"
-      >
-        <span
-          :class="[
-            autostartEnabled ? 'translate-x-5' : 'translate-x-0',
-            'pointer-events-none relative inline-block h-5 w-5 transform rounded-full bg-white shadow ring-0 transition duration-200 ease-in-out',
-          ]"
-        />
-      </Switch>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { Switch } from "@headlessui/vue";
-import { invoke } from "@tauri-apps/api/core";
-
-defineProps<{}>();
-
-const autostartEnabled = ref<boolean>(false);
-
-// Load initial state
-invoke("get_autostart_enabled").then((enabled) => {
-  autostartEnabled.value = enabled as boolean;
-});
-
-// Watch for changes and update autostart
-watch(autostartEnabled, async (newValue: boolean) => {
-  try {
-    await invoke("toggle_autostart", { enabled: newValue });
-  } catch (error) {
-    console.error("Failed to toggle autostart:", error);
-    // Revert the toggle if it failed
-    autostartEnabled.value = !newValue;
-  }
-});
-</script>

main/pages/settings/interface.vue

@@ -1,23 +0,0 @@
-<template>
-  <div class="grow w-full h-full flex items-center justify-center">
-    <div class="flex flex-col items-center">
-      <WrenchScrewdriverIcon
-        class="h-12 w-12 text-blue-600"
-        aria-hidden="true"
-      />
-      <div class="mt-3 text-center sm:mt-5">
-        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
-          Under construction
-        </h1>
-        <div class="mt-4">
-          <p class="text-sm text-zinc-400 max-w-lg">
-            This page hasn't been implemented yet.
-          </p>
-        </div>
-      </div>
-    </div>
-  </div>
-</template>
-<script setup lang="ts">
-import { WrenchScrewdriverIcon } from "@heroicons/vue/20/solid";
-</script>

main/pages/store/index.vue

@@ -1,37 +0,0 @@
-<template>
-  <div class="grow w-full h-full flex items-center justify-center">
-    <div class="flex flex-col items-center">
-      <BuildingStorefrontIcon
-        class="h-12 w-12 text-blue-600"
-        aria-hidden="true"
-      />
-      <div class="mt-3 text-center sm:mt-5">
-        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
-          Store not supported in client
-        </h1>
-        <div class="mt-4">
-          <p class="text-sm text-zinc-400 max-w-lg">
-            Currently, Drop requires you to view the store in your browser.
-            Please click the button below to open it in your default browser.
-          </p>
-          <NuxtLink
-            :href="storeUrl"
-            target="_blank"
-            class="mt-6 transition text-sm/6 font-semibold text-zinc-400 hover:text-zinc-100 inline-flex gap-x-2 items-center duration-200 hover:scale-105"
-          >
-            Open Store <ArrowTopRightOnSquareIcon class="size-4" />
-          </NuxtLink>
-        </div>
-      </div>
-    </div>
-  </div>
-</template>
-<script setup lang="ts">
-import {
-  ArrowTopRightOnSquareIcon,
-  BuildingStorefrontIcon,
-} from "@heroicons/vue/20/solid";
-import { invoke } from "@tauri-apps/api/core";
-
-const storeUrl = await invoke<string>("gen_drop_url", { path: "/store" });
-</script>

main/tsconfig.json

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

nuxt.config.ts

@@ -13,9 +13,5 @@ export default defineNuxtConfig({
 
   ssr: false,
 
-  extends: [["../libs/drop-base"]],
-
-  app: {
-    baseURL: "/main",
-  }
+  extends: [["./drop-base"]],
 });

optimize-appimage.sh

@@ -1,22 +0,0 @@
-## This script is largely useless, because there's not much we can do about AppImage size
-
-ARCH=$(uname -m)
-
-# build tauri apps
-# NO_STRIP=true yarn tauri build -- --verbose
-
-# unpack appimage
-APPIMAGE=$(ls ./src-tauri/target/release/bundle/appimage/*.AppImage)
-"$APPIMAGE" --appimage-extract
-
-# strip binary
-APPIMAGE_UNPACK="./squashfs-root"
-find $APPIMAGE_UNPACK -type f -exec strip -s {} \;
-
-APPIMAGETOOL=$(echo "obsolete-appimagetool-$ARCH.AppImage")
-wget -O $APPIMAGETOOL "https://github.com/AppImage/AppImageKit/releases/download/13/$APPIMAGETOOL"
-chmod +x $APPIMAGETOOL
-
-APPIMAGE_OUTPUT=$(./$APPIMAGETOOL $APPIMAGE_UNPACK | grep ".AppImage" | grep squashfs-root | awk '{ print $6 }')
-
-mv $APPIMAGE_OUTPUT "$APPIMAGE"

package.json

@@ -1,23 +1,43 @@
 {
   "name": "drop-app",
   "private": true,
+  "version": "0.2.0-beta",
   "type": "module",
   "scripts": {
-    "build": "node ./build.mjs",
+    "build": "nuxt build",
+    "dev": "nuxt dev",
+    "generate": "nuxt generate",
+    "preview": "nuxt preview",
+    "postinstall": "nuxt prepare",
     "tauri": "tauri"
   },
   "dependencies": {
-    "@tauri-apps/api": "^2.7.0",
-    "@tauri-apps/plugin-deep-link": "^2.4.1",
-    "@tauri-apps/plugin-dialog": "^2.3.2",
-    "@tauri-apps/plugin-opener": "^2.4.0",
-    "@tauri-apps/plugin-os": "^2.3.0",
-    "@tauri-apps/plugin-shell": "^2.3.0",
-    "pino": "^9.7.0",
-    "pino-pretty": "^13.1.1",
-    "tauri": "^0.15.0"
+    "@headlessui/vue": "^1.7.23",
+    "@heroicons/vue": "^2.1.5",
+    "@nuxtjs/tailwindcss": "^6.12.2",
+    "@tauri-apps/api": ">=2.0.0",
+    "@tauri-apps/plugin-deep-link": "~2",
+    "@tauri-apps/plugin-dialog": "^2.0.1",
+    "@tauri-apps/plugin-os": "~2",
+    "@tauri-apps/plugin-shell": "^2.2.1",
+    "koa": "^2.16.1",
+    "markdown-it": "^14.1.0",
+    "micromark": "^4.0.1",
+    "nuxt": "^3.16.0",
+    "scss": "^0.2.4",
+    "vue": "latest",
+    "vue-router": "latest",
+    "vuedraggable": "^4.1.0"
   },
   "devDependencies": {
-    "@tauri-apps/cli": "^2.7.1"
-  }
+    "@tailwindcss/forms": "^0.5.9",
+    "@tailwindcss/typography": "^0.5.15",
+    "@tauri-apps/cli": ">=2.0.0",
+    "@types/markdown-it": "^14.1.2",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "sass-embedded": "^1.79.4",
+    "tailwindcss": "^3.4.13"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

pages/account.vue

@@ -0,0 +1,72 @@
+<template>
+  <div class="mx-auto max-w-7xl px-8">
+    <div class="border-b border-zinc-700 py-5">
+      <h3 class="text-base font-semibold font-display leading-6 text-zinc-100">
+        Account
+      </h3>
+    </div>
+
+    <div class="mt-5">
+      <div class="divide-y divide-zinc-700">
+        <div class="py-6">
+          <div class="flex flex-col gap-4">
+            <div class="flex flex-row items-center justify-between">
+              <div>
+                <h3 class="text-sm font-medium leading-6 text-zinc-100">Sign out</h3>
+                <p class="mt-1 text-sm leading-6 text-zinc-400">
+                  Sign out of your Drop account on this device
+                </p>
+              </div>
+              <button
+                @click="signOut"
+                type="button"
+                class="rounded-md bg-red-600 px-3 py-2 text-sm font-semibold text-white shadow-sm hover:bg-red-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-red-600"
+              >
+                Sign out
+              </button>
+            </div>
+
+            <div v-if="error" class="rounded-md bg-red-600/10 p-4">
+              <div class="flex">
+                <div class="flex-shrink-0">
+                  <XCircleIcon class="h-5 w-5 text-red-600" aria-hidden="true" />
+                </div>
+                <div class="ml-3">
+                  <h3 class="text-sm font-medium text-red-600">
+                    {{ error }}
+                  </h3>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from '@tauri-apps/api/event'
+import { useRouter } from '#imports'
+import { XCircleIcon } from "@heroicons/vue/16/solid";
+
+const router = useRouter()
+const error = ref<string | null>(null)
+
+// Listen for auth events
+onMounted(async () => {
+  await listen('auth/signedout', () => {
+    router.push('/auth/signedout')
+  })
+})
+
+async function signOut() {
+  try {
+    error.value = null
+    await invoke('sign_out')
+  } catch (e) {
+    error.value = `Failed to sign out: ${e}`
+  }
+}
+</script>