Update .github/workflows/release.yml

* feat: depot api downloads

* feat: frontend fixes and experimental webview store

* feat: sync downloader

* feat: cleanup and fixes

* feat: encrypted database and fixed resuming

* feat: launch option selector

* fix: autostart when no options

* fix: clippy

* fix: clippy x2

* feat: executor launch

* feat: executor launch

* feat: not installed error handling

* feat: better offline handling

* feat: dependency popup

* fix: cancelation and resuming issues

* feat: dedup by platform

* feat: new ui for additional components and fix dl manager clog

* feat: auto-queue dependencies

* feat: depot scanning and ranking

* feat: new library fetching stack

* In-app store page (Windows + macOS) (#176)

* feat: async store loading

* feat: fix overscroll behaviour

* fix: query params in server protocol

* fix: clippy

.github/workflows/release.yml

@@ -114,7 +114,7 @@ jobs:
 
       - uses: tauri-apps/tauri-action@v0
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
           APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
           APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
           APPLE_SIGNING_IDENTITY: ${{ env.CERT_ID }}

main/app.vue

@@ -15,6 +15,8 @@ import {
   initialNavigation,
   setupHooks,
 } from "./composables/state-navigation.js";
+import { listen } from "@tauri-apps/api/event";
+import type { AppState } from "./types.js";
 
 const router = useRouter();
 
@@ -36,9 +38,8 @@ async function fetchState() {
 }
 await fetchState();
 
-// This is inefficient but apparently we do it lol
+listen("update_state", (event) => {
-router.beforeEach(async () => {
+  state.value = event.payload as AppState;
-  await fetchState();
 });
 
 setupHooks();

main/assets/main.scss

@@ -6,6 +6,7 @@ html,
 body {
   -ms-overflow-style: none; /* IE and Edge /
 scrollbar-width: none; / Firefox */
+  overscroll-behavior: none;
 }
 
 /* Hide scrollbar for Chrome, Safari and Opera */

main/components/DependencyRequiredModal.vue

@@ -0,0 +1,106 @@
+<template>
+  <ModalTemplate :model-value="true">
+    <template #default
+      ><div class="flex items-start gap-x-3">
+        <img :src="useObject(game.mIconObjectId)" class="size-12" />
+        <div class="mt-3 text-center sm:mt-0 sm:text-left">
+          <h3 class="text-base font-semibold text-zinc-100">
+            Missing required dependency "{{ game.mName }}"
+          </h3>
+          <div class="mt-2">
+            <p class="text-sm text-zinc-400">
+              To launch this game, you need to have "{{ game.mName }}" ({{
+                version.displayName ?? version.versionPath
+              }}) installed.
+            </p>
+          </div>
+        </div>
+      </div>
+      <InstallDirectorySelector
+        :install-dirs="installDirs"
+        v-model="installDir"
+      />
+
+      <div v-if="installError" class="mt-1 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">
+              {{ installError }}
+            </h3>
+          </div>
+        </div>
+      </div>
+    </template>
+    <template #buttons>
+      <LoadingButton
+        @click="() => install()"
+        :loading="installLoading"
+        :disabled="installLoading"
+        type="submit"
+        class="ml-2 w-full sm:w-fit"
+      >
+        Install
+      </LoadingButton>
+      <button
+        type="button"
+        class="mt-3 inline-flex w-full justify-center rounded-md bg-zinc-800 px-3 py-2 text-sm font-semibold text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 hover:bg-zinc-900 sm:mt-0 sm:w-auto"
+        @click="cancel"
+        ref="cancelButtonRef"
+      >
+        Cancel
+      </button>
+    </template>
+  </ModalTemplate>
+</template>
+
+<script setup lang="ts">
+import { invoke } from "@tauri-apps/api/core";
+import { XCircleIcon } from "@heroicons/vue/24/solid";
+
+const model = defineModel<{ gameId: string; versionId: string }>({
+  required: true,
+});
+
+const { game, status } = await useGame(model.value.gameId);
+
+const versionOptions = await invoke<Array<VersionOption>>(
+  "fetch_game_version_options",
+  {
+    gameId: game.id,
+  }
+);
+const version = versionOptions.find(
+  (v) => v.versionId === model.value.versionId
+)!;
+
+const installDirs = await invoke<string[]>("fetch_download_dir_stats");
+const installDir = ref(0);
+
+function cancel() {
+  // @ts-expect-error
+  model.value = undefined;
+}
+
+const installError = ref<string | undefined>();
+const installLoading = ref(false);
+
+async function install() {
+  try {
+    installLoading.value = true;
+    await invoke("download_game", {
+      gameId: game.id,
+      versionId: model.value.versionId,
+      installDir: installDir.value,
+      targetPlatform: version.platform,
+    });
+    cancel();
+  } catch (error) {
+    installError.value = (error as string).toString();
+  }
+
+  installLoading.value = false;
+}
+</script>

main/components/InstallDirectorySelector.vue

@@ -0,0 +1,87 @@
+<template>
+  <Listbox as="div" v-model="installDir">
+    <ListboxLabel class="block text-sm/6 font-medium text-zinc-100"
+      >Install to</ListboxLabel
+    >
+    <div class="relative mt-2">
+      <ListboxButton
+        class="relative w-full cursor-default rounded-md bg-zinc-800 py-1.5 pl-3 pr-10 text-left text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 focus:outline-none focus:ring-2 focus:ring-blue-600 sm:text-sm/6"
+      >
+        <span class="block truncate">{{ installDirs[installDir] }}</span>
+        <span
+          class="pointer-events-none absolute inset-y-0 right-0 flex items-center pr-2"
+        >
+          <ChevronUpDownIcon class="h-5 w-5 text-gray-400" aria-hidden="true" />
+        </span>
+      </ListboxButton>
+
+      <transition
+        leave-active-class="transition ease-in duration-100"
+        leave-from-class="opacity-100"
+        leave-to-class="opacity-0"
+      >
+        <ListboxOptions
+          class="absolute z-10 mt-1 max-h-60 w-full overflow-auto rounded-md bg-zinc-900 py-1 text-base shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none sm:text-sm"
+        >
+          <ListboxOption
+            as="template"
+            v-for="(dir, dirIdx) in installDirs"
+            :key="dir"
+            :value="dirIdx"
+            v-slot="{ active, selected }"
+          >
+            <li
+              :class="[
+                active ? 'bg-blue-600 text-white' : 'text-zinc-300',
+                'relative cursor-default select-none py-2 pl-3 pr-9',
+              ]"
+            >
+              <span
+                :class="[
+                  selected ? 'font-semibold text-zinc-100' : 'font-normal',
+                  'block truncate',
+                ]"
+                >{{ dir }}</span
+              >
+
+              <span
+                v-if="selected"
+                :class="[
+                  active ? 'text-white' : 'text-blue-600',
+                  'absolute inset-y-0 right-0 flex items-center pr-4',
+                ]"
+              >
+                <CheckIcon class="h-5 w-5" aria-hidden="true" />
+              </span>
+            </li>
+          </ListboxOption>
+        </ListboxOptions>
+      </transition>
+    </div>
+    <div class="text-zinc-400 text-sm mt-2">
+      Add more install directories in
+      <PageWidget to="/settings/downloads">
+        <WrenchIcon class="size-3" />
+        Settings
+      </PageWidget>
+    </div>
+  </Listbox>
+</template>
+
+<script setup lang="ts">
+import {
+  Listbox,
+  ListboxButton,
+  ListboxLabel,
+  ListboxOption,
+  ListboxOptions,
+} from "@headlessui/vue";
+import {
+  CheckIcon,
+  ChevronUpDownIcon,
+  WrenchIcon,
+} from "@heroicons/vue/20/solid";
+
+const installDir = defineModel<number>({ required: true });
+const { installDirs } = defineProps<{ installDirs: string[] }>();
+</script>

main/components/LibrarySearch.vue

@@ -27,12 +27,12 @@
       </button>
     </div>
 
-    <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5">
+    <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5 h-full">
       <Disclosure
         as="div"
         v-for="(nav, navIndex) in filteredNavigation"
         :key="nav.id"
-        class="first:pt-0 last:pb-0"
+        :class="['first:pt-0 last:pb-0', nav.tools ? 'mt-auto' : '']"
         v-slot="{ open }"
         :default-open="nav.deft"
       >
@@ -43,9 +43,12 @@
             <span class="text-sm font-semibold font-display">{{
               nav.name
             }}</span>
-            <span class="ml-6 flex h-7 items-center">
+            <span class="ml-6 relative flex size-4">
-              <PlusSmallIcon v-if="!open" class="size-6" aria-hidden="true" />
+              <MinusIcon class="absolute inset-0 size-4" aria-hidden="true" />
-              <MinusSmallIcon v-else class="size-6" aria-hidden="true" />
+              <MinusIcon
+                :class="[                !open ? 'rotate-90' : 'rotate-0', 'transition-all absolute inset-0 size-4']"
+                aria-hidden="true"
+              />
             </span>
           </DisclosureButton>
         </dt>
@@ -69,14 +72,12 @@
               >
                 <img
                   class="size-6 object-cover bg-zinc-900 rounded transition-all duration-300 shadow-sm"
-                  :src="icons[item.id]"
+                  :src="useObject(item.icon)"
                   alt=""
                 />
               </div>
-              <div class="inline-flex items-center gap-x-2">
+              <div class="truncate inline-flex items-center gap-x-2">
-                <p
+                <p class="text-sm whitespace-nowrap font-display font-semibold">
-                  class="text-sm whitespace-nowrap font-display font-semibold"
-                >
                   {{ item.label }}
                 </p>
                 <p
@@ -125,8 +126,8 @@ import { Disclosure, DisclosureButton, DisclosurePanel } from "@headlessui/vue";
 import {
   ArrowPathIcon,
   MagnifyingGlassIcon,
-  MinusSmallIcon,
+  MinusIcon,
-  PlusSmallIcon,
+  PlusIcon,
 } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
 import {
@@ -143,7 +144,7 @@ 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.Running]: "text-blue-500",
   [GameStatusEnum.Remote]: "text-zinc-700",
   [GameStatusEnum.Queued]: "text-zinc-400",
   [GameStatusEnum.Updating]: "text-zinc-400",
@@ -172,49 +173,76 @@ 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) {
+  try {
+    await calculateGamesLogic(clearAll, forceRefresh);
+  } catch (e) {
+    createModal(
+      ModalType.Notification,
+      {
+        title: "Failed to fetch library",
+        description: `Drop encountered an error while fetching your library: ${e}`,
+      },
+      (_, c) => c(),
+    );
+  }
+  loading.value = false;
+}
+
+type FetchLibraryResponse = {
+  library: Game[];
+  collections: Collection[];
+  other: Game[];
+};
+
+async function calculateGamesLogic(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", {
+  const library = await invoke<FetchLibraryResponse>("fetch_library", {
-    hardRefresh: forceRefresh,
-  });
-  const otherCollections = await invoke<Collection[]>("fetch_collections", {
     hardRefresh: forceRefresh,
   });
   const allGames = [
-    ...newGames,
+    ...library.library,
-    ...otherCollections
+    ...library.collections
       .map((e) => e.entries)
       .flat()
       .map((e) => e.game),
+    ...library.other,
   ].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 })),
+    entries: library.library.map((e) => ({ gameId: e.id, game: e })),
+  } satisfies Collection;
+
+  const otherCollection = {
+    id: "other",
+    name: "Tools & Launchers",
+    isDefault: false,
+    isTools: true,
+    entries: library.other.map((v) => ({ gameId: v.id, game: v })),
   } satisfies Collection;
 
   loading.value = false;
-  collections.value = [libraryCollection, ...otherCollections];
+  collections.value = [
+    libraryCollection,
+    ...library.collections,
+    ...(library.other.length > 0 ? [otherCollection] : []),
+  ];
 }
 
 // Wait up to 300 ms for the library to load, otherwise
@@ -235,15 +263,17 @@ const navigation = computed(() =>
       const status = games[game.id].status;
 
       const isInstalled = computed(
-        () => status.value.type != GameStatusEnum.Remote
+        () => status.value.type != GameStatusEnum.Remote,
       );
 
       const item = {
         label: game.mName,
         route: `/library/${game.id}`,
         prefix: `/library/${game.id}`,
+        icon: game.mIconObjectId,
         isInstalled,
         id: game.id,
+        type: game.type,
       };
       return item;
     });
@@ -252,9 +282,10 @@ const navigation = computed(() =>
       id: collection.id,
       name: collection.name,
       deft: collection.isDefault,
+      tools: collection.isTools ?? false,
       items,
     };
-  })
+  }),
 );
 
 const route = useRoute();
@@ -277,7 +308,7 @@ const filteredNavigation = computed(() => {
 listen("update_library", async (event) => {
   console.log("Updating library");
   let oldNavigation = currentNavigation.value;
-  await calculateGames();
+  await calculateGames(false, true);
   if (oldNavigation !== currentNavigation.value) {
     router.push("/library");
   }

main/components/OfflineHeaderWidget.vue

@@ -1,9 +1,15 @@
 <script setup lang="ts">
 import { ArrowDownTrayIcon, CloudIcon } from "@heroicons/vue/20/solid";
+import { invoke } from "@tauri-apps/api/core";
+
+async function checkOffline() {
+  const isOffline = await invoke("check_online");
+}
 </script>
 
 <template>
-  <div
+  <button
+    @click="checkOffline"
     class="transition inline-flex items-center rounded-sm px-4 py-1.5 bg-zinc-900 text-sm text-zinc-400 gap-x-2"
   >
     <div class="relative">
@@ -13,5 +19,5 @@ import { ArrowDownTrayIcon, CloudIcon } from "@heroicons/vue/20/solid";
       />
     </div>
     Offline
-  </div>
+  </button>
 </template>

main/composables/downloads.ts

@@ -34,3 +34,17 @@ listen("update_stats", (event) => {
 });
 
 export const useDownloadHistory = () => useState<Array<number>>('history', () => []);
+
+export function formatKilobytes(bytes: number): string {
+  const units = ["K", "M", "G", "T", "P"];
+  let value = bytes;
+  let unitIndex = 0;
+  const scalar = 1000;
+
+  while (value >= scalar && unitIndex < units.length - 1) {
+    value /= scalar;
+    unitIndex++;
+  }
+
+  return `${value.toFixed(1)} ${units[unitIndex]}`;
+}

main/composables/game.ts

@@ -43,7 +43,6 @@ 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;
@@ -72,3 +71,23 @@ export const useGame = async (gameId: string) => {
 export type FrontendGameConfiguration = {
   launchString: string;
 };
+
+export type LaunchResult =
+  | { result: "Success" }
+  | { result: "InstallRequired"; data: [string, string] };
+
+export type VersionOption = {
+  versionId: string;
+  displayName?: string;
+  versionPath: string;
+  platform: string;
+  size: number;
+  requiredContent: Array<{
+    gameId: string;
+    versionId: string;
+    name: string;
+    iconObjectId: string;
+    shortDescription: string;
+    size: number;
+  }>;
+};

main/composables/use-object.ts

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

main/package.json

@@ -13,7 +13,7 @@
     "@headlessui/vue": "^1.7.23",
     "@heroicons/vue": "^2.1.5",
     "@nuxtjs/tailwindcss": "^6.12.2",
-    "@tauri-apps/api": "^2.7.0",
+    "@tauri-apps/api": "^2.9.1",
     "@tauri-apps/plugin-os": "^2.3.2",
     "@tauri-apps/plugin-shell": "^2.3.3",
     "koa": "^2.16.1",

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

@@ -170,8 +170,8 @@
         </div>
       </div>
 
-      <form class="space-y-6">
+      <div class="space-y-6">
-        <div v-if="versionOptions && versionOptions.length > 0">
+        <div v-if="versionOptions && versionOptions.length > 0 && currentVersionOption">
           <Listbox as="div" v-model="installVersionIndex">
             <ListboxLabel class="block text-sm/6 font-medium text-zinc-100"
               >Version</ListboxLabel
@@ -181,9 +181,16 @@
                 class="relative w-full cursor-default rounded-md bg-zinc-800 py-1.5 pl-3 pr-10 text-left text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 focus:outline-none focus:ring-2 focus:ring-blue-600 sm:text-sm/6"
               >
                 <span class="block truncate"
-                  >{{ versionOptions[installVersionIndex].versionName }}
+                  >{{
+                    currentVersionOption.displayName ||
+                    currentVersionOption.versionPath
+                  }}
                   on
-                  {{ versionOptions[installVersionIndex].platform }}</span
+                  {{ currentVersionOption.platform }} ({{
+                    formatKilobytes(
+                      currentVersionOption.size / 1024
+                    )
+                  }}B)</span
                 >
                 <span
                   class="pointer-events-none absolute inset-y-0 right-0 flex items-center pr-2"
@@ -206,7 +213,7 @@
                   <ListboxOption
                     as="template"
                     v-for="(version, versionIdx) in versionOptions"
-                    :key="version.versionName"
+                    :key="version.versionId"
                     :value="versionIdx"
                     v-slot="{ active, selected }"
                   >
@@ -223,8 +230,12 @@
                             : 'font-normal',
                           'block truncate',
                         ]"
-                        >{{ version.versionName }} on
+                        >{{ version.displayName || version.versionPath }} on
-                        {{ version.platform }}</span
+                        {{ version.platform }} ({{
+                          formatKilobytes(
+                            versionOptions[installVersionIndex].size / 1024
+                          )
+                        }}B)</span
                       >
 
                       <span
@@ -281,82 +292,86 @@
           </div>
         </div>
         <div v-if="installDirs">
-          <Listbox as="div" v-model="installDir">
+          <InstallDirectorySelector
-            <ListboxLabel class="block text-sm/6 font-medium text-zinc-100"
+            :install-dirs="installDirs"
-              >Install to</ListboxLabel
+            v-model="installDir"
+          />
+        </div>
+        <div
+          v-if="
+            currentVersionOption?.requiredContent &&
+            currentVersionOption.requiredContent.length > 0
+          "
         >
-            <div class="relative mt-2">
+          <div class="border-b border-white/10 py-2">
-              <ListboxButton
+            <h3 class="text-sm font-semibold text-white">
-                class="relative w-full cursor-default rounded-md bg-zinc-800 py-1.5 pl-3 pr-10 text-left text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 focus:outline-none focus:ring-2 focus:ring-blue-600 sm:text-sm/6"
+              Install additional dependencies?
+            </h3>
+            <p class="mt-1 text-xs text-gray-400">
+              This game requires additional content to run. Click the components
+              to automatically queue for download.
+            </p>
+          </div>
+          <ul role="list" class="mt-2 divide-y divide-white/5">
+            <li
+              v-for="content in currentVersionOption
+                .requiredContent"
+              :key="content.versionId"
+              :class="[
+                !installDepsDisabled[content.versionId]
+                  ? 'bg-zinc-950 ring-2 ring-zinc-800'
+                  : '',
+                'rounded-lg relative flex justify-between px-2 py-3',
+              ]"
             >
-                <span class="block truncate">{{
+              <div class="flex min-w-0 gap-x-2">
-                  installDirs[installDir]
+                <img
-                }}</span>
+                  class="size-12 flex-none"
-                <span
+                  :src="useObject(content.iconObjectId)"
-                  class="pointer-events-none absolute inset-y-0 right-0 flex items-center pr-2"
+                  alt=""
+                />
+                <div class="min-w-0 flex-auto">
+                  <p class="text-sm/6 font-semibold text-white">
+                    <button
+                      @click="
+                        () =>
+                          (installDepsDisabled[content.versionId] =
+                            !installDepsDisabled[content.versionId])
+                      "
                     >
-                  <ChevronUpDownIcon
+                      <span class="absolute inset-x-0 -top-px bottom-0"></span>
-                    class="h-5 w-5 text-gray-400"
+                      {{ content.name }}
+                    </button>
+                  </p>
+                  <p class="mt-1 flex text-xs/5 text-gray-400">
+                    {{ content.shortDescription }}
+                  </p>
+                </div>
+              </div>
+              <div class="flex shrink-0 items-center gap-x-2">
+                <div class="hidden sm:flex sm:flex-col sm:items-end">
+                  <p
+                    class="inline-flex items-center gap-x-1 text-xs/5 text-gray-400"
+                  >
+                    {{ formatKilobytes(content.size / 1024) }}B
+                    <ServerIcon class="size-3" />
+                  </p>
+                </div>
+                <CheckIcon
+                  v-if="!installDepsDisabled[content.versionId]"
+                  class="size-5 flex-none text-green-500"
                   aria-hidden="true"
                 />
-                </span>
+                <MinusIcon
-              </ListboxButton>
+                  v-else
-
+                  class="size-5 flex-none text-gray-500"
-              <transition
+                  aria-hidden="true"
-                leave-active-class="transition ease-in duration-100"
+                />
-                leave-from-class="opacity-100"
+              </div>
-                leave-to-class="opacity-0"
-              >
-                <ListboxOptions
-                  class="absolute z-10 mt-1 max-h-60 w-full overflow-auto rounded-md bg-zinc-900 py-1 text-base shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none sm:text-sm"
-                >
-                  <ListboxOption
-                    as="template"
-                    v-for="(dir, dirIdx) in installDirs"
-                    :key="dir"
-                    :value="dirIdx"
-                    v-slot="{ active, selected }"
-                  >
-                    <li
-                      :class="[
-                        active ? 'bg-blue-600 text-white' : 'text-zinc-300',
-                        'relative cursor-default select-none py-2 pl-3 pr-9',
-                      ]"
-                    >
-                      <span
-                        :class="[
-                          selected
-                            ? 'font-semibold text-zinc-100'
-                            : 'font-normal',
-                          'block truncate',
-                        ]"
-                        >{{ dir }}</span
-                      >
-
-                      <span
-                        v-if="selected"
-                        :class="[
-                          active ? 'text-white' : 'text-blue-600',
-                          'absolute inset-y-0 right-0 flex items-center pr-4',
-                        ]"
-                      >
-                        <CheckIcon class="h-5 w-5" aria-hidden="true" />
-                      </span>
             </li>
-                  </ListboxOption>
+          </ul>
-                </ListboxOptions>
-              </transition>
         </div>
-            <div class="text-zinc-400 text-sm mt-2">
-              Add more install directories in
-              <PageWidget to="/settings/downloads">
-                <WrenchIcon class="size-3" />
-                Settings
-              </PageWidget>
       </div>
-          </Listbox>
-        </div>
-      </form>
 
       <div v-if="installError" class="mt-1 rounded-md bg-red-600/10 p-4">
         <div class="flex">
@@ -392,6 +407,48 @@
     </template>
   </ModalTemplate>
 
+  <ModalTemplate :model-value="launchOptionsOpen">
+    <template #default>
+      <div class="sm:flex sm:items-start">
+        <div class="mt-3 text-center sm:mt-0 sm:text-left">
+          <h3 class="text-base font-semibold text-zinc-100">
+            Launch {{ game.mName }}
+          </h3>
+          <div class="mt-2">
+            <p class="text-sm text-zinc-400">
+              The instance admin has configured multiple ways to start this
+              game. Select an option to start.
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <ol class="space-y-2">
+        <li v-for="(launchData, launchIdx) in launchOptions!">
+          <button
+            class="transition w-full rounded-sm bg-zinc-800 inline-flex items-center text-sm py-2 px-3 gap-x-2 text-zinc-100 hover:text-zinc-300 hover:bg-zinc-700"
+            @click="() => launchIndex(launchIdx)"
+          >
+            <PlayIcon class="size-4" />
+            <span>
+              {{ launchData.name }}
+            </span>
+          </button>
+        </li>
+      </ol>
+    </template>
+    <template #buttons>
+      <button
+        type="button"
+        class="mt-3 inline-flex w-full justify-center rounded-md bg-zinc-800 px-3 py-2 text-sm font-semibold text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 hover:bg-zinc-900 sm:mt-0 sm:w-auto"
+        @click="launchOptions = undefined"
+        ref="cancelButtonRef"
+      >
+        Cancel
+      </button>
+    </template>
+  </ModalTemplate>
+
   <!-- 
   Dear future DecDuck,
   This v-if is necessary for Vue rendering reasons
@@ -470,6 +527,11 @@
       </div>
     </div>
   </Transition>
+
+  <DependencyRequiredModal
+    v-if="dependencyRequiredModal"
+    v-model="dependencyRequiredModal"
+  />
 </template>
 
 <script setup lang="ts">
@@ -489,9 +551,10 @@ import {
   XMarkIcon,
   ArrowsPointingOutIcon,
   PhotoIcon,
+  PlayIcon,
 } from "@heroicons/vue/20/solid";
 import { BuildingStorefrontIcon } from "@heroicons/vue/24/outline";
-import { XCircleIcon } from "@heroicons/vue/24/solid";
+import { MinusIcon, ServerIcon, XCircleIcon } from "@heroicons/vue/24/solid";
 import { invoke } from "@tauri-apps/api/core";
 import { micromark } from "micromark";
 import { GameStatusEnum } from "~/types";
@@ -520,9 +583,7 @@ const mediaUrls = await Promise.all(
 const htmlDescription = micromark(game.value.mDescription);
 
 const installFlowOpen = ref(false);
-const versionOptions = ref<
+const versionOptions = ref<undefined | Array<VersionOption>>();
-  undefined | Array<{ versionName: string; platform: string }>
->();
 const installDirs = ref<undefined | Array<string>>();
 const currentImageIndex = ref(0);
 
@@ -548,15 +609,31 @@ const installLoading = ref(false);
 const installError = ref<string | undefined>();
 const installVersionIndex = ref(0);
 const installDir = ref(0);
+const installDepsDisabled = ref<{ [key: string]: boolean }>({});
+
+const currentVersionOption = computed(() => versionOptions.value?.[installVersionIndex.value]);
 async function install() {
   try {
     if (!versionOptions.value) throw new Error("Versions have not been loaded");
     installLoading.value = true;
+    const versionOption = versionOptions.value[installVersionIndex.value];
+
+    const games = [
+      { gameId: game.value.id, versionId: versionOption.versionId },
+      ...versionOption.requiredContent
+        .filter((v) => !installDepsDisabled.value[v.versionId])
+        .map((v) => ({ gameId: v.gameId, versionId: v.versionId })),
+    ];
+
+    for (const game of games) {
       await invoke("download_game", {
-      gameId: game.value.id,
+        gameId: game.gameId,
-      gameVersion: versionOptions.value[installVersionIndex.value].versionName,
+        versionId: game.versionId,
         installDir: installDir.value,
+        targetPlatform: versionOption.platform,
       });
+    }
+
     installFlowOpen.value = false;
   } catch (error) {
     installError.value = (error as string).toString();
@@ -573,9 +650,24 @@ async function resumeDownload() {
   }
 }
 
+const launchOptions = ref<Array<{ name: string }> | undefined>(undefined);
+const launchOptionsOpen = computed(() => launchOptions.value !== undefined);
+
 async function launch() {
+  if (status.value.type == GameStatusEnum.SetupRequired) {
+    await launchIndex(0);
+    return;
+  }
   try {
-    await invoke("launch_game", { id: game.value.id });
+    const fetchedLaunchOptions = await invoke<Array<{ name: string }>>(
+      "get_launch_options",
+      { id: game.value.id }
+    );
+    if (fetchedLaunchOptions.length == 1) {
+      await launchIndex(0);
+      return;
+    }
+    launchOptions.value = fetchedLaunchOptions;
   } catch (e) {
     createModal(
       ModalType.Notification,
@@ -590,6 +682,36 @@ async function launch() {
   }
 }
 
+const dependencyRequiredModal = ref<
+  { gameId: string; versionId: string } | undefined
+>(undefined);
+
+async function launchIndex(index: number) {
+  launchOptions.value = undefined;
+  try {
+    const result = await invoke<LaunchResult>("launch_game", {
+      id: game.value.id,
+      index,
+    });
+    if (result.result == "InstallRequired") {
+      dependencyRequiredModal.value = {
+        gameId: result.data[0],
+        versionId: result.data[1],
+      };
+    }
+  } catch (e) {
+    createModal(
+      ModalType.Notification,
+      {
+        title: `Couldn't run "${game.value.mName}"`,
+        description: `Drop failed to launch "${game.value.mName}": ${e}`,
+        buttonText: "Close",
+      },
+      (e, c) => c()
+    );
+  }
+}
+
 async function queue() {
   router.push("/queue");
 }

main/pages/queue.vue

@@ -7,7 +7,7 @@
         class="bg-zinc-900 z-10 w-32 flex flex-col gap-x-2 font-display items-left justify-center pl-2"
       >
         <span class="font-bold text-zinc-100">{{ formatKilobytes(stats.speed) }}B/s</span>
-        <span v-if="stats.time > 0" class="text-xs text-zinc-400"
+        <span class="text-xs text-zinc-400"
           >{{ formatTime(stats.time) }} left</span
         >
       </div>
@@ -184,21 +184,10 @@ async function cancelGame(meta: DownloadableMetadata) {
   await invoke("cancel_game", { meta });
 }
 
-function formatKilobytes(bytes: number): string {
-  const units = ["K", "M", "G", "T", "P"];
-  let value = bytes;
-  let unitIndex = 0;
-  const scalar = 1000;
-
-  while (value >= scalar && unitIndex < units.length - 1) {
-    value /= scalar;
-    unitIndex++;
-  }
-
-  return `${value.toFixed(1)} ${units[unitIndex]}`;
-}
-
 function formatTime(seconds: number): string {
+  if (seconds == 0) {
+    return `0s`;
+  }
   if (seconds < 60) {
     return `${Math.round(seconds)}s`;
   }

main/pages/store/index.vue

@@ -1,37 +1,12 @@
 <template>
-  <div class="grow w-full h-full flex items-center justify-center">
+  <iframe :src="convertedStoreUrl" class="grow w-full h-full" />
-    <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";
+import { convertFileSrc, invoke } from "@tauri-apps/api/core";
 
-const storeUrl = await invoke<string>("gen_drop_url", { path: "/store" });
+const convertedStoreUrl = convertFileSrc("store", "server");
 </script>

main/pnpm-lock.yaml

@@ -18,8 +18,8 @@ importers:
         specifier: ^6.12.2
         version: 6.14.0(magicast@0.5.1)(yaml@2.8.1)
       '@tauri-apps/api':
-        specifier: ^2.7.0
+        specifier: ^2.9.1
-        version: 2.9.0
+        version: 2.9.1
       '@tauri-apps/plugin-os':
         specifier: ^2.3.2
         version: 2.3.2
@@ -1115,8 +1115,8 @@ packages:
     peerDependencies:
       vue: ^2.7.0 || ^3.0.0
 
-  '@tauri-apps/api@2.9.0':
+  '@tauri-apps/api@2.9.1':
-    resolution: {integrity: sha512-qD5tMjh7utwBk9/5PrTA/aGr3i5QaJ/Mlt7p8NilQ45WgbifUNPyKWsA63iQ8YfQq6R8ajMapU+/Q8nMcPRLNw==}
+    resolution: {integrity: sha512-IGlhP6EivjXHepbBic618GOmiWe4URJiIeZFlB7x3czM0yDHHYviH1Xvoiv4FefdkQtn6v7TuwWCRfOGdnVUGw==}
 
   '@tauri-apps/plugin-os@2.3.2':
     resolution: {integrity: sha512-n+nXWeuSeF9wcEsSPmRnBEGrRgOy6jjkSU+UVCOV8YUGKb2erhDOxis7IqRXiRVHhY8XMKks00BJ0OAdkpf6+A==}
@@ -5049,15 +5049,15 @@ snapshots:
       '@tanstack/virtual-core': 3.13.12
       vue: 3.5.24(typescript@5.9.3)
 
-  '@tauri-apps/api@2.9.0': {}
+  '@tauri-apps/api@2.9.1': {}
 
   '@tauri-apps/plugin-os@2.3.2':
     dependencies:
-      '@tauri-apps/api': 2.9.0
+      '@tauri-apps/api': 2.9.1
 
   '@tauri-apps/plugin-shell@2.3.3':
     dependencies:
-      '@tauri-apps/api': 2.9.0
+      '@tauri-apps/api': 2.9.1
 
   '@tybys/wasm-util@0.10.1':
     dependencies:

main/types.ts

@@ -27,6 +27,7 @@ export type AppState = {
 
 export type Game = {
   id: string;
+  type: "Game" | "Executor" | "Redist";
   mName: string;
   mShortDescription: string;
   mDescription: string;
@@ -41,6 +42,7 @@ export type Collection = {
   id: string;
   name: string;
   isDefault: boolean;
+  isTools?: boolean;
   entries: Array<{ gameId: string; game: Game }>;
 };
 

nvidia-prop-dev.sh

@@ -1 +1 @@
-WEBKIT_DISABLE_DMABUF_RENDERER=1 pnpm tauri dev
+GSK_RENDERER=ngl pnpm tauri dev

src-tauri/Cargo.toml

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

src-tauri/client/Cargo.toml

@@ -4,9 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-bitcode = "0.6.7"
+bitcode = "*"
-database = { version = "0.1.0", path = "../database" }
+database = { version = "*", path = "../database" }
-log = "0.4.28"
+log = "*"
-serde = { version = "1.0.228", features = ["derive"] }
+serde = { version = "*", features = ["derive"] }
-tauri = "2.8.5"
+tauri = "*"
-tauri-plugin-autostart = "2.5.0"
+tauri-plugin-autostart = "*"

src-tauri/client/src/app_state.rs

@@ -0,0 +1,10 @@
+use serde::Serialize;
+
+use crate::{app_status::AppStatus, user::User};
+
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AppState {
+    pub status: AppStatus,
+    pub user: Option<User>
+}

src-tauri/client/src/lib.rs

@@ -2,3 +2,4 @@ pub mod app_status;
 pub mod autostart;
 pub mod compat;
 pub mod user;
+pub mod app_state;

src-tauri/database/Cargo.toml

@@ -4,11 +4,15 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+aes = "0.8.4"
+anyhow = "*"
 chrono = "0.4.42"
+ctr = "0.9.2"
 dirs = "6.0.0"
+keyring = { version = "3.6.3", features = ["apple-native", "crypto-rust", "linux-native-sync-persistent", "windows-native"] }
 log = "0.4.28"
-native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+rand = "0.9.2"
-rustbreak = "2.0.0"
+ron = "0.12.0"
 serde = "1.0.228"
 serde_with = "3.15.0"
 url = "2.5.7"

src-tauri/database/src/db.rs

@@ -3,10 +3,10 @@ use std::{
     sync::{Arc, LazyLock},
 };
 
-use rustbreak::{DeSerError, DeSerializer};
+use keyring::Entry;
-use serde::{Serialize, de::DeserializeOwned};
+use log::info;
 
-use crate::interface::{DatabaseImpls, DatabaseInterface};
+use crate::interface::{DatabaseInterface};
 
 pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
 
@@ -23,23 +23,15 @@ pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> = LazyLock::new(|| {
     )
 });
 
-// Custom JSON serializer to support everything we need
+pub(crate) static KEY_IV: LazyLock<([u8; 16], [u8; 16])> = LazyLock::new(|| {
-#[derive(Debug, Default, Clone)]
+    let entry = Entry::new("drop", "database_key").expect("failed to open keyring");
-pub struct DropDatabaseSerializer;
+    let mut key = entry.get_secret().unwrap_or_else(|_| {
-
+        let mut buffer = [0u8; 32];
-impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
+        rand::fill(&mut buffer);
-    for DropDatabaseSerializer
+        entry.set_secret(&buffer).expect("failed to save key");
-{
+        info!("created new database key");
-    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
+        buffer.to_vec()
-        native_model::encode(val).map_err(|e| DeSerError::Internal(e.to_string()))
+    });
-    }
+    let new = key.split_off(16);
-
+    (new.try_into().expect("failed to extract key"), key.try_into().expect("failed to extract iv"))
-    fn deserialize<R: std::io::Read>(&self, mut s: R) -> rustbreak::error::DeSerResult<T> {
+});
-        let mut buf = Vec::new();
-        s.read_to_end(&mut buf)
-            .map_err(|e| rustbreak::error::DeSerError::Other(e.into()))?;
-        let (val, _version) =
-            native_model::decode(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
-        Ok(val)
-    }
-}

src-tauri/database/src/interface.rs

@@ -2,30 +2,32 @@ use std::{
     fs::{self, create_dir_all},
     mem::ManuallyDrop,
     ops::{Deref, DerefMut},
-    path::PathBuf,
+    path::{Path, PathBuf},
-    sync::{RwLockReadGuard, RwLockWriteGuard},
+    sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard},
 };
 
+use aes::cipher::{KeyIvInit as _, StreamCipher as _};
+use anyhow::Error;
 use chrono::Utc;
 use log::{debug, error, info, warn};
-use rustbreak::{PathDatabase, RustbreakError};
 use url::Url;
 
 use crate::{
-    db::{DATA_ROOT_DIR, DB, DropDatabaseSerializer},
+    db::{DATA_ROOT_DIR, DB, KEY_IV},
-    models::data::Database,
+    models::{
+        self,
+        data::{Database, DatabaseVersionSerializable},
+    },
 };
 
-pub type DatabaseInterface =
+type Aes128Ctr64LE = ctr::Ctr64LE<aes::Aes128>;
-    rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;
 
-pub trait DatabaseImpls {
+pub struct DatabaseInterface {
-    fn set_up_database() -> DatabaseInterface;
+    data: RwLock<models::data::Database>,
-    fn database_is_set_up(&self) -> bool;
+    path: PathBuf,
-    fn fetch_base_url(&self) -> Url;
 }
-impl DatabaseImpls for DatabaseInterface {
+impl DatabaseInterface {
-    fn set_up_database() -> DatabaseInterface {
+    pub fn set_up_database() -> Self {
         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");
@@ -78,36 +80,95 @@ impl DatabaseImpls for DatabaseInterface {
         });
 
         if exists {
-            match PathDatabase::load_from_path(db_path.clone()) {
+            match DatabaseInterface::open_at_path(&db_path) {
-                Ok(db) => db,
+                Ok(db) => db.unwrap(),
-                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
+                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir)
+                    .expect("failed to recover from failed database"),
             }
         } 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")
+            DatabaseInterface::create_at_path(&db_path, default)
+                .expect("Database could not be created")
         }
     }
 
-    fn database_is_set_up(&self) -> bool {
+    pub fn open_at_path(db_path: &Path) -> Result<Option<DatabaseInterface>, Error> {
+        if !db_path.exists() {
+            return Ok(None);
+        };
+        let mut database_data = std::fs::read(db_path)?;
+        let (key, iv) = *KEY_IV;
+        let mut cipher = Aes128Ctr64LE::new(&key.into(), &iv.into());
+        cipher.apply_keystream(&mut database_data);
+
+        let database_data = String::from_utf8(database_data)?;
+
+        let database_data: DatabaseVersionSerializable = ron::from_str(&database_data)?;
+        Ok(Some(DatabaseInterface {
+            data: RwLock::new(database_data.0),
+            path: db_path.to_path_buf(),
+        }))
+    }
+
+    pub fn create_at_path(db_path: &Path, database: Database) -> Result<DatabaseInterface, Error> {
+        let database = DatabaseVersionSerializable(database);
+        let mut database_data = ron::to_string(&database)?.into_bytes();
+
+        let (key, iv) = *KEY_IV;
+        let mut cipher = Aes128Ctr64LE::new(&key.into(), &iv.into());
+        cipher.apply_keystream(&mut database_data);
+
+        std::fs::write(db_path, database_data)?;
+        Ok(DatabaseInterface {
+            data: RwLock::new(database.0),
+            path: db_path.to_path_buf(),
+        })
+    }
+
+    pub fn database_is_set_up(&self) -> bool {
         !borrow_db_checked().base_url.is_empty()
     }
 
-    fn fetch_base_url(&self) -> Url {
+    pub 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))
     }
+
+    fn save(&self) -> Result<(), Error> {
+        let lock = self.data.read().expect("failed to lock database to save");
+        DatabaseInterface::create_at_path(&self.path, lock.clone())?;
+        Ok(())
+    }
+
+    fn borrow_data(
+        &self,
+    ) -> Result<
+        std::sync::RwLockReadGuard<'_, Database>,
+        PoisonError<std::sync::RwLockReadGuard<'_, Database>>,
+    > {
+        self.data.read()
+    }
+
+    fn borrow_data_mut(
+        &self,
+    ) -> Result<
+        std::sync::RwLockWriteGuard<'_, Database>,
+        PoisonError<std::sync::RwLockWriteGuard<'_, Database>>,
+    > {
+        self.data.write()
+    }
 }
 
 // TODO: Make the error relelvant rather than just assume that it's a Deserialize error
 fn handle_invalid_database(
-    _e: RustbreakError,
+    error: Error,
     db_path: PathBuf,
     games_base_dir: PathBuf,
     cache_dir: PathBuf,
-) -> rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer> {
+) -> Result<DatabaseInterface, Error> {
-    warn!("{_e}");
+    warn!("{error:?}");
     let new_path = {
         let time = Utc::now().timestamp();
         let mut base = db_path.clone();
@@ -126,7 +187,7 @@ fn handle_invalid_database(
 
     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")
+    Ok(DatabaseInterface::create_at_path(&db_path, db).expect("Database could not be created"))
 }
 
 // To automatically save the database upon drop

src-tauri/database/src/models.rs

@@ -1,26 +1,24 @@
 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 Database = v1::Database;
     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 GameDownloadStatus = v1::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 DatabaseApplications = v1::DatabaseApplications;
-    // pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
 
     use std::collections::HashMap;
 
@@ -36,13 +34,44 @@ pub mod data {
         }
     }
 
+    #[derive(Serialize, Deserialize)]
+    enum DatabaseVersionEnum {
+        V1 { database: v1::Database },
+    }
+
+    pub struct DatabaseVersionSerializable(pub(crate) Database);
+
+    impl Serialize for DatabaseVersionSerializable {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer,
+        {
+            // Always serialize to latest version
+            DatabaseVersionEnum::V1 {
+                database: self.0.clone(),
+            }
+            .serialize(serializer)
+        }
+    }
+
+    impl<'de> Deserialize<'de> for DatabaseVersionSerializable {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: serde::Deserializer<'de>,
+        {
+            Ok(match DatabaseVersionEnum::deserialize(deserializer)? {
+                DatabaseVersionEnum::V1 { database } => DatabaseVersionSerializable(database),
+            })
+        }
+    }
+
     mod v1 {
         use serde_with::serde_as;
         use std::{collections::HashMap, path::PathBuf};
 
         use crate::platform::Platform;
 
-        use super::{Deserialize, Serialize, native_model};
+        use super::{Deserialize, Serialize};
 
         fn default_template() -> String {
             "{}".to_owned()
@@ -50,49 +79,58 @@ pub mod data {
 
         #[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 version_id: String,
 
-            pub platform: Platform,
+            pub display_name: Option<String>,
-
+            pub version_path: String,
-            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(default = "default_template")]
+            pub launch_template: String,
+
+            pub launches: Vec<LaunchConfiguration>,
+            pub setups: Vec<SetupConfiguration>,
         }
 
-        #[serde_as]
+        #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-        #[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 LaunchConfiguration {
-        pub struct DatabaseApplications {
+            pub launch_id: String,
-            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 name: String,
-            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+            pub command: String,
+            pub platform: Platform,
+            pub umu_id_override: Option<String>,
+
+            pub executor: Option<LaunchConfigurationExecutor>,
+        }
+
+        #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+        #[serde(rename_all = "camelCase")]
+        /**
+         * This is intended to be used to look up the actual launch configuration that we store elsewhere
+         */
+        pub struct LaunchConfigurationExecutor {
+            pub launch_id: String,
+            pub game_id: String,
+            pub version_id: String,
+        }
+
+        #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+        #[serde(rename_all = "camelCase")]
+        pub struct SetupConfiguration {
+            pub command: String,
+            pub platform: Platform,
         }
 
         #[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,
@@ -108,129 +146,8 @@ pub mod data {
             }
         }
 
-        // 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 {
@@ -246,89 +163,84 @@ pub mod data {
                 install_dir: String,
             },
         }
-        impl From<v1::GameDownloadStatus> for GameDownloadStatus {
+        // Stuff that shouldn't be synced to disk
-            fn from(value: v1::GameDownloadStatus) -> Self {
+        #[derive(Clone, Serialize, Deserialize, Debug)]
-                match value {
+        pub enum ApplicationTransientStatus {
-                    v1::GameDownloadStatus::Remote {} => Self::Remote {},
+            Queued { version_id: String },
-                    v1::GameDownloadStatus::SetupRequired {
+            Downloading { version_id: String },
-                        version_name,
+            Uninstalling {},
-                        install_dir,
+            Updating { version_id: String },
-                    } => Self::SetupRequired {
+            Validating { version_id: String },
-                        version_name,
+            Running {},
-                        install_dir,
+        }
-                    },
+
-                    v1::GameDownloadStatus::Installed {
+        #[derive(serde::Serialize, Clone, Deserialize)]
-                        version_name,
+        pub struct DatabaseAuth {
-                        install_dir,
+            pub private: String,
-                    } => Self::Installed {
+            pub cert: String,
-                        version_name,
+            pub client_id: String,
-                        install_dir,
+            pub web_token: Option<String>,
-                    },
+        }
+
+        #[derive(
+            Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone, Copy,
+        )]
+        pub enum DownloadType {
+            Game,
+            Tool,
+            Dlc,
+            Mod,
+        }
+
+        #[derive(Debug, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+        #[serde(rename_all = "camelCase")]
+        pub struct DownloadableMetadata {
+            pub id: String,
+            pub version: String,
+            pub target_platform: Platform,
+            pub download_type: DownloadType,
+        }
+        impl DownloadableMetadata {
+            pub fn new(
+                id: String,
+                version: String,
+                target_platform: Platform,
+                download_type: DownloadType,
+            ) -> Self {
+                Self {
+                    id,
+                    version,
+                    target_platform,
+                    download_type,
                 }
             }
         }
+
         #[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 game_versions: HashMap<String, GameVersion>,
-            pub installed_game_version: HashMap<String, v1::DownloadableMetadata>,
+            pub installed_game_version: HashMap<String, DownloadableMetadata>,
 
             #[serde(skip)]
-            pub transient_statuses:
+            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
-                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 settings: Settings,
-            pub auth: Option<v1::DatabaseAuth>,
+            pub auth: Option<DatabaseAuth>,
             pub base_url: String,
-            pub applications: v2::DatabaseApplications,
+            pub applications: 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,
-                }
-            }
         }
     }
 
@@ -351,7 +263,6 @@ pub mod data {
                 auth: None,
                 settings: Settings::default(),
                 cache_dir,
-                compat_info: None,
             }
         }
     }

src-tauri/database/src/platform.rs

@@ -1,9 +1,10 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug, PartialOrd, Ord)]
 pub enum Platform {
     Windows,
     Linux,
+    #[allow(non_camel_case_types)]
     macOS,
 }
 

src-tauri/download_manager/Cargo.toml

@@ -4,14 +4,17 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-atomic-instant-full = "0.1.0"
+async-trait = "0.1.89"
+atomic-instant-full = "0.1"
 database = { version = "0.1.0", path = "../database" }
+futures-util = "0.3.31"
 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"
+tauri = "*"
 throttle_my_fn = "0.2.6"
+tokio = { version = "1.48.0", features = ["sync"] }
 utils = { version = "0.1.0", path = "../utils" }

src-tauri/download_manager/src/depot_manager.rs

@@ -0,0 +1,144 @@
+use std::{
+    collections::HashMap,
+    sync::RwLock,
+    time::{Duration, Instant},
+};
+
+use futures_util::StreamExt;
+use remote::{
+    error::RemoteAccessError,
+    requests::{generate_url, make_authenticated_get},
+    utils::DROP_CLIENT_ASYNC,
+};
+use serde::Deserialize;
+use tauri::Url;
+
+use crate::util::semaphore::{SyncSemaphore, SyncSemaphorePermit};
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DepotManifestContent {
+    version_id: String,
+    //compression: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DepotManifest {
+    content: HashMap<String, Vec<DepotManifestContent>>,
+}
+
+struct Depot {
+    endpoint: String,
+    manifest: Option<DepotManifest>,
+    latest_speed: Option<usize>, // bytes per second
+    current_downloads: SyncSemaphore,
+}
+
+pub struct DepotManager {
+    depots: RwLock<Vec<Depot>>,
+}
+
+#[derive(Deserialize)]
+struct ServersideDepot {
+    endpoint: String,
+}
+
+const SPEEDTEST_TIMEOUT: Duration = Duration::from_secs(4);
+
+impl DepotManager {
+    pub fn new() -> Self {
+        Self {
+            depots: RwLock::new(Vec::new()),
+        }
+    }
+
+    pub async fn sync_depots(&self) -> Result<(), RemoteAccessError> {
+        let depots = make_authenticated_get(generate_url(&["/api/v1/client/depots"], &[])?).await?;
+        let depots: Vec<ServersideDepot> = depots.json().await?;
+
+        let mut new_depots = depots
+            .into_iter()
+            .map(|depot| Depot {
+                endpoint: if depot.endpoint.ends_with("/") {
+                    depot.endpoint
+                } else {
+                    format!("{}/", depot.endpoint)
+                },
+                manifest: None,
+                latest_speed: None,
+                current_downloads: SyncSemaphore::new(),
+            })
+            .collect::<Vec<Depot>>();
+
+        for depot in &mut new_depots {
+            let manifest_url = Url::parse(&depot.endpoint)?.join("manifest.json")?;
+            let manifest = DROP_CLIENT_ASYNC.get(manifest_url).send().await?;
+            let manifest: DepotManifest = manifest.json().await?;
+            depot.manifest.replace(manifest);
+
+            let speedtest_url = Url::parse(&depot.endpoint)?.join("speedtest")?;
+            let speedtest = DROP_CLIENT_ASYNC.get(speedtest_url).send().await?;
+
+            let mut stream = speedtest.bytes_stream();
+            let start = Instant::now();
+            let mut total_length = 0;
+
+            while let Some(chunk) = stream.next().await {
+                let length = chunk?.len();
+                total_length += length;
+                if SPEEDTEST_TIMEOUT <= start.elapsed() {
+                    break;
+                }
+            }
+
+            let elapsed = start.elapsed().as_millis() as usize;
+            let speed = if elapsed == 0 { usize::MAX } else { (total_length / elapsed) * 1000 };
+            depot.latest_speed.replace(speed);
+        }
+
+        let mut depot_lock = self.depots.write().unwrap();
+        *depot_lock = new_depots;
+
+        Ok(())
+    }
+
+    pub fn next_depot(
+        &self,
+        game_id: &str,
+        version_id: &str,
+    ) -> Result<(String, SyncSemaphorePermit), RemoteAccessError> {
+        let lock = self.depots.read().unwrap();
+        let best_depot = lock
+            .iter()
+            .filter(|v| {
+                let manifest = match &v.manifest {
+                    Some(v) => v,
+                    None => return false,
+                };
+
+                let versions = match manifest.content.get(game_id) {
+                    Some(v) => v,
+                    None => return false,
+                };
+
+                let _version = match versions.iter().find(|v| v.version_id == version_id) {
+                    Some(v) => v,
+                    None => return false,
+                };
+
+                true
+            })
+            .max_by(|x, y| {
+                let x_speed = x.latest_speed.unwrap_or(0) / x.current_downloads.permits();
+                let y_speed = y.latest_speed.unwrap_or(0) / y.current_downloads.permits();
+                x_speed.cmp(&y_speed)
+            })
+            .ok_or(RemoteAccessError::NoDepots)?;
+
+        Ok((
+            best_depot.endpoint.clone(),
+            best_depot.current_downloads.acquire(),
+        ))
+    }
+}

src-tauri/download_manager/src/download_manager_builder.rs

@@ -1,18 +1,19 @@
+use core::panic;
 use std::{
     collections::HashMap,
-    sync::{
+    sync::{Arc, Mutex},
-        Arc, Mutex,
+    time::Duration,
-        mpsc::{Receiver, Sender, channel},
-    },
-    thread::{JoinHandle, spawn},
 };
 
 use database::DownloadableMetadata;
 use log::{debug, error, info, warn};
-use tauri::AppHandle;
+use tauri::{AppHandle, async_runtime::JoinHandle};
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::{sync::mpsc, time::timeout};
 use utils::{app_emit, lock, send};
 
 use crate::{
+    depot_manager::DepotManager,
     download_manager_frontend::DownloadStatus,
     error::ApplicationDownloadError,
     frontend_updates::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
@@ -83,10 +84,11 @@ pub struct DownloadManagerBuilder {
 impl DownloadManagerBuilder {
     pub fn build(app_handle: AppHandle) -> DownloadManager {
         let queue = Queue::new();
-        let (command_sender, command_receiver) = channel();
+        let (command_sender, command_receiver) = mpsc::channel(1500);
         let active_progress = Arc::new(Mutex::new(None));
         let status = Arc::new(Mutex::new(DownloadManagerStatus::Empty));
 
+        let depot_manager = Arc::new(DepotManager::new());
         let manager = Self {
             download_agent_registry: HashMap::new(),
             download_queue: queue.clone(),
@@ -100,74 +102,87 @@ impl DownloadManagerBuilder {
             active_control_flag: None,
         };
 
-        let terminator = spawn(|| manager.manage_queue());
+        let terminator = tauri::async_runtime::spawn(async move {
+            let result = manager.manage_queue().await;
+            info!("download manager exited with result: {:?}", result);
+        });
 
-        DownloadManager::new(terminator, queue, active_progress, command_sender)
+        DownloadManager::new(terminator, queue, active_progress, command_sender, depot_manager)
     }
 
     fn set_status(&self, status: DownloadManagerStatus) {
         *lock!(self.status) = status;
     }
 
-    fn remove_and_cleanup_front_download(&mut self, meta: &DownloadableMetadata) -> DownloadAgent {
+    async fn remove_and_cleanup_front_download(
+        &mut self,
+        meta: &DownloadableMetadata,
+    ) -> DownloadAgent {
         self.download_queue.pop_front();
         let download_agent = self.download_agent_registry.remove(meta).unwrap();
-        self.cleanup_current_download();
+        self.cleanup_current_download().await;
         download_agent
     }
 
     // CAREFUL WITH THIS FUNCTION
     // Make sure the download thread is terminated
-    fn cleanup_current_download(&mut self) {
+    async fn cleanup_current_download(&mut self) {
         self.active_control_flag = None;
         *lock!(self.progress) = None;
 
+        if let Some(unfinished_thread) = {
             let mut download_thread_lock = lock!(self.current_download_thread);
-
+            download_thread_lock.take()
-        if let Some(unfinished_thread) = download_thread_lock.take()
+        } {
-            && !unfinished_thread.is_finished()
+            let _ = unfinished_thread.await;
-        {
-            unfinished_thread.join().unwrap();
         }
-        drop(download_thread_lock);
     }
 
-    fn stop_and_wait_current_download(&self) -> bool {
+    async fn stop_and_wait_current_download(&self) -> bool {
         self.set_status(DownloadManagerStatus::Paused);
         if let Some(current_flag) = &self.active_control_flag {
             current_flag.set(DownloadThreadControlFlag::Stop);
-        }
 
+            if let Some(current_download_thread) = {
                 let mut download_thread_lock = lock!(self.current_download_thread);
-        if let Some(current_download_thread) = download_thread_lock.take() {
+                download_thread_lock.take()
-            return current_download_thread.join().is_ok();
+            } {
+                let result = timeout(Duration::from_secs(4), async {
+                    current_download_thread.await.is_ok()
+                })
+                .await;
+                if let Ok(result) = result {
+                    return result;
                 };
+                panic!("failed to cleanup download: timeout after 4 seconds");
+            };
+        }
 
         true
     }
 
-    fn manage_queue(mut self) -> Result<(), ()> {
+    async fn manage_queue(mut self) -> Result<(), ()> {
         loop {
-            let signal = match self.command_receiver.recv() {
+            let signal = match self.command_receiver.recv().await {
-                Ok(signal) => signal,
+                Some(signal) => signal,
-                Err(_) => return Err(()),
+                None => return Err(()),
             };
 
             match signal {
                 DownloadManagerSignal::Go => {
-                    self.manage_go_signal();
+                    self.manage_go_signal().await;
                 }
                 DownloadManagerSignal::Stop => {
                     self.manage_stop_signal();
                 }
                 DownloadManagerSignal::Completed(meta) => {
-                    self.manage_completed_signal(meta);
+                    self.manage_completed_signal(meta).await;
                 }
                 DownloadManagerSignal::Queue(download_agent) => {
-                    self.manage_queue_signal(download_agent);
+                    self.manage_queue_signal(download_agent).await;
                 }
                 DownloadManagerSignal::Error(e) => {
-                    self.manage_error_signal(e);
+                    self.manage_error_signal(e).await;
                 }
                 DownloadManagerSignal::UpdateUIQueue => {
                     self.push_ui_queue_update();
@@ -176,16 +191,16 @@ impl DownloadManagerBuilder {
                     self.push_ui_stats_update(kbs, time);
                 }
                 DownloadManagerSignal::Finish => {
-                    self.stop_and_wait_current_download();
+                    self.stop_and_wait_current_download().await;
                     return Ok(());
                 }
                 DownloadManagerSignal::Cancel(meta) => {
-                    self.manage_cancel_signal(&meta);
+                    self.manage_cancel_signal(&meta).await;
                 }
             }
         }
     }
-    fn manage_queue_signal(&mut self, download_agent: DownloadAgent) {
+    async fn manage_queue_signal(&mut self, download_agent: DownloadAgent) {
         debug!("got signal Queue");
         let meta = download_agent.metadata();
 
@@ -203,7 +218,7 @@ impl DownloadManagerBuilder {
         send!(self.sender, DownloadManagerSignal::UpdateUIQueue);
     }
 
-    fn manage_go_signal(&mut self) {
+    async fn manage_go_signal(&mut self) {
         debug!("got signal Go");
         if self.download_agent_registry.is_empty() {
             debug!(
@@ -249,9 +264,10 @@ impl DownloadManagerBuilder {
         let mut download_thread_lock = lock!(self.current_download_thread);
         let app_handle = self.app_handle.clone();
 
-        *download_thread_lock = Some(spawn(move || {
+        *download_thread_lock = Some(tauri::async_runtime::spawn(async move {
             loop {
-                let download_result = match download_agent.download(&app_handle) {
+                let download_result =
+                    match download_agent.download(&app_handle).await {
                         // Ok(true) is for completed and exited properly
                         Ok(v) => v,
                         Err(e) => {
@@ -291,7 +307,7 @@ impl DownloadManagerBuilder {
                 }
 
                 if validate_result {
-                    download_agent.on_complete(&app_handle);
+                    download_agent.on_complete(&app_handle).await;
                     send!(
                         sender,
                         DownloadManagerSignal::Completed(download_agent.metadata())
@@ -307,40 +323,35 @@ impl DownloadManagerBuilder {
         active_control_flag.set(DownloadThreadControlFlag::Go);
     }
     fn manage_stop_signal(&mut self) {
-        debug!("got signal Stop");
-
         if let Some(active_control_flag) = self.active_control_flag.clone() {
             self.set_status(DownloadManagerStatus::Paused);
             active_control_flag.set(DownloadThreadControlFlag::Stop);
         }
     }
-    fn manage_completed_signal(&mut self, meta: DownloadableMetadata) {
+    async fn manage_completed_signal(&mut self, meta: DownloadableMetadata) {
-        debug!("got signal Completed");
         if let Some(interface) = self.download_queue.read().front()
             && interface == &meta
         {
-            self.remove_and_cleanup_front_download(&meta);
+            self.remove_and_cleanup_front_download(&meta).await;
         }
 
         self.push_ui_queue_update();
         send!(self.sender, DownloadManagerSignal::Go);
     }
-    fn manage_error_signal(&mut self, error: ApplicationDownloadError) {
+    async fn manage_error_signal(&mut self, error: ApplicationDownloadError) {
-        debug!("got signal Error");
+        info!("got signal Error");
         if let Some(metadata) = self.download_queue.read().front()
             && let Some(current_agent) = self.download_agent_registry.get(metadata)
         {
             current_agent.on_error(&self.app_handle, &error);
 
-            self.stop_and_wait_current_download();
+            self.stop_and_wait_current_download().await;
-            self.remove_and_cleanup_front_download(metadata);
+            self.remove_and_cleanup_front_download(metadata).await;
         }
         self.push_ui_queue_update();
         self.set_status(DownloadManagerStatus::Error);
     }
-    fn manage_cancel_signal(&mut self, meta: &DownloadableMetadata) {
+    async fn manage_cancel_signal(&mut self, meta: &DownloadableMetadata) {
-        debug!("got signal Cancel");
-
         // If the current download is the one we're tryna cancel
         if let Some(current_metadata) = self.download_queue.read().front()
             && current_metadata == meta
@@ -348,13 +359,13 @@ impl DownloadManagerBuilder {
         {
             self.set_status(DownloadManagerStatus::Paused);
             current_download.on_cancelled(&self.app_handle);
-            self.stop_and_wait_current_download();
+            self.stop_and_wait_current_download().await;
+            self.set_status(DownloadManagerStatus::Empty);
 
             self.download_queue.pop_front();
 
-            self.cleanup_current_download();
+            self.cleanup_current_download().await;
             self.download_agent_registry.remove(meta);
-            debug!("current download queue: {:?}", self.download_queue.read());
         }
         // else just cancel it
         else if let Some(download_agent) = self.download_agent_registry.get(meta) {
@@ -370,8 +381,8 @@ impl DownloadManagerBuilder {
                 );
             }
         }
-        self.sender.send(DownloadManagerSignal::Go).unwrap();
         self.push_ui_queue_update();
+        send!(self.sender, DownloadManagerSignal::Go);
     }
     fn push_ui_stats_update(&self, kbs: usize, time: usize) {
         let event_data = StatsUpdateEvent { speed: kbs, time };

src-tauri/download_manager/src/download_manager_frontend.rs

@@ -1,26 +1,25 @@
 use std::{
-    any::Any,
     collections::VecDeque,
     fmt::Debug,
-    sync::{
+    sync::{Arc, Mutex, MutexGuard},
-        Mutex, MutexGuard,
-        mpsc::{SendError, Sender},
-    },
-    thread::JoinHandle,
 };
 
 use database::DownloadableMetadata;
 use log::{debug, info};
 use serde::Serialize;
+use tauri::async_runtime::JoinHandle;
+use tokio::sync::mpsc::Sender;
+use tokio::sync::mpsc::error::SendError;
 use utils::{lock, send};
 
-use crate::error::ApplicationDownloadError;
+use crate::{depot_manager::DepotManager, error::ApplicationDownloadError};
 
 use super::{
     download_manager_builder::{CurrentProgressObject, DownloadAgent},
     util::queue::Queue,
 };
 
+#[derive(Debug)]
 pub enum DownloadManagerSignal {
     /// Resumes (or starts) the `DownloadManager`
     Go,
@@ -79,38 +78,47 @@ pub enum DownloadStatus {
 /// The actual download queue may be accessed through the .`edit()` function,
 /// which provides raw access to the underlying queue.
 /// THIS EDITING IS BLOCKING!!!
-#[derive(Debug)]
 pub struct DownloadManager {
-    terminator: Mutex<Option<JoinHandle<Result<(), ()>>>>,
+    terminator: Mutex<Option<JoinHandle<()>>>,
     download_queue: Queue,
     progress: CurrentProgressObject,
     command_sender: Sender<DownloadManagerSignal>,
+    depot_manager: Arc<DepotManager>,
+}
+
+impl Debug for DownloadManager {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DownloadManager").finish()
+    }
 }
 
 #[allow(dead_code)]
 impl DownloadManager {
     pub fn new(
-        terminator: JoinHandle<Result<(), ()>>,
+        terminator: JoinHandle<()>,
         download_queue: Queue,
         progress: CurrentProgressObject,
         command_sender: Sender<DownloadManagerSignal>,
+        depot_manager: Arc<DepotManager>,
     ) -> Self {
         Self {
             terminator: Mutex::new(Some(terminator)),
             download_queue,
             progress,
             command_sender,
+            depot_manager
         }
     }
 
-    pub fn queue_download(
+    pub async fn queue_download(
         &self,
         download: DownloadAgent,
     ) -> Result<(), SendError<DownloadManagerSignal>> {
         info!("creating download with meta {:?}", download.metadata());
         self.command_sender
-            .send(DownloadManagerSignal::Queue(download))?;
+            .send(DownloadManagerSignal::Queue(download))
-        self.command_sender.send(DownloadManagerSignal::Go)
+            .await?;
+        self.command_sender.send(DownloadManagerSignal::Go).await
     }
     pub fn edit(&self) -> MutexGuard<'_, VecDeque<DownloadableMetadata>> {
         self.download_queue.edit()
@@ -122,7 +130,7 @@ impl DownloadManager {
         let progress_object = (*lock!(self.progress)).clone()?;
         Some(progress_object.get_progress())
     }
-    pub fn rearrange_string(&self, meta: &DownloadableMetadata, new_index: usize) {
+    pub async fn rearrange_string(&self, meta: &DownloadableMetadata, new_index: usize) {
         let mut queue = self.edit();
         let current_index =
             get_index_from_id(&mut queue, meta).expect("Failed to get meta index from id");
@@ -132,10 +140,10 @@ impl DownloadManager {
         queue.insert(new_index, to_move);
         send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
     }
-    pub fn cancel(&self, meta: DownloadableMetadata) {
+    pub async fn cancel(&self, meta: DownloadableMetadata) {
         send!(self.command_sender, DownloadManagerSignal::Cancel(meta));
     }
-    pub fn rearrange(&self, current_index: usize, new_index: usize) {
+    pub async fn rearrange(&self, current_index: usize, new_index: usize) {
         if current_index == new_index {
             return;
         }
@@ -147,10 +155,11 @@ impl DownloadManager {
 
         debug!("moving download at index {current_index} to index {new_index}");
 
+        {
             let mut queue = self.edit();
             let to_move = queue.remove(current_index).expect("Failed to get");
             queue.insert(new_index, to_move);
-        drop(queue);
+        }
 
         if needs_pause {
             send!(self.command_sender, DownloadManagerSignal::Go);
@@ -158,20 +167,23 @@ impl DownloadManager {
         send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
         send!(self.command_sender, DownloadManagerSignal::Go);
     }
-    pub fn pause_downloads(&self) {
+    pub async fn pause_downloads(&self) {
         send!(self.command_sender, DownloadManagerSignal::Stop);
     }
-    pub fn resume_downloads(&self) {
+    pub async fn resume_downloads(&self) {
         send!(self.command_sender, DownloadManagerSignal::Go);
     }
-    pub fn ensure_terminated(&self) -> Result<Result<(), ()>, Box<dyn Any + Send>> {
+    pub async fn ensure_terminated(&self) -> Result<(), tauri::Error> {
         send!(self.command_sender, DownloadManagerSignal::Finish);
         let terminator = lock!(self.terminator).take();
-        terminator.unwrap().join()
+        terminator.unwrap().await
     }
     pub fn get_sender(&self) -> Sender<DownloadManagerSignal> {
         self.command_sender.clone()
     }
+    pub fn clone_depot_manager(&self) -> Arc<DepotManager> {
+        self.depot_manager.clone()
+    }
 }
 
 /// Takes in the locked value from .`edit()` and attempts to

src-tauri/download_manager/src/downloadable.rs

@@ -1,5 +1,6 @@
-use std::sync::Arc;
+use std::{fmt::Debug, sync::Arc};
 
+use async_trait::async_trait;
 use database::DownloadableMetadata;
 use tauri::AppHandle;
 
@@ -16,8 +17,9 @@ use super::{
  *
  * But the download manager manages the queue state
  */
-pub trait Downloadable: Send + Sync {
+#[async_trait]
-    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
+pub trait Downloadable: Send + Sync + Debug {
+    async fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
     fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
 
     fn progress(&self) -> Arc<ProgressObject>;
@@ -26,6 +28,6 @@ pub trait Downloadable: Send + Sync {
     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);
+    async fn on_complete(&self, app_handle: &AppHandle);
     fn on_cancelled(&self, app_handle: &AppHandle);
 }

src-tauri/download_manager/src/error.rs

@@ -43,6 +43,7 @@ pub enum ApplicationDownloadError {
     Lock,
     IoError(Arc<io::Error>),
     DownloadError(RemoteAccessError),
+    InvalidCommand,
 }
 
 impl Display for ApplicationDownloadError {
@@ -69,6 +70,7 @@ impl Display for ApplicationDownloadError {
             ApplicationDownloadError::DownloadError(error) => {
                 write!(f, "Download failed with error {error:?}")
             }
+            ApplicationDownloadError::InvalidCommand => write!(f, "Invalid command state"),
         }
     }
 }

src-tauri/download_manager/src/lib.rs

@@ -16,6 +16,7 @@ pub mod downloadable;
 pub mod error;
 pub mod frontend_updates;
 pub mod util;
+pub mod depot_manager;
 
 pub static DOWNLOAD_MANAGER: DownloadManagerWrapper = DownloadManagerWrapper::new();
 
@@ -28,7 +29,7 @@ impl DownloadManagerWrapper {
         DOWNLOAD_MANAGER
             .0
             .set(DownloadManagerBuilder::build(app_handle))
-            .expect("Failed to initialise download manager");
+            .expect("failed to initialise download manager");
     }
 }
 

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

@@ -2,3 +2,4 @@ pub mod download_thread_control_flag;
 pub mod progress_object;
 pub mod queue;
 pub mod rolling_progress_updates;
+pub mod semaphore;

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

@@ -2,14 +2,13 @@ use std::{
     sync::{
         Arc, Mutex,
         atomic::{AtomicUsize, Ordering},
-        mpsc::Sender,
     },
-    time::{Duration, Instant},
+    time::Instant,
 };
 
 use atomic_instant_full::AtomicInstant;
-use throttle_my_fn::throttle;
 use utils::{lock, send};
+use tokio::sync::mpsc::Sender;
 
 use crate::download_manager_frontend::DownloadManagerSignal;
 
@@ -46,7 +45,7 @@ impl ProgressHandle {
     pub fn add(&self, amount: usize) {
         self.progress
             .fetch_add(amount, std::sync::atomic::Ordering::AcqRel);
-        calculate_update(&self.progress_object);
+        tauri::async_runtime::spawn(calculate_update(self.progress_object.clone()));
     }
     pub fn skip(&self, amount: usize) {
         self.progress
@@ -112,14 +111,17 @@ impl ProgressObject {
     }
 }
 
-#[throttle(1, Duration::from_millis(20))]
+pub async fn calculate_update(progress: Arc<ProgressObject>) {
-pub fn calculate_update(progress: &ProgressObject) {
     let last_update_time = progress
         .last_update_time
-        .swap(Instant::now(), Ordering::SeqCst);
+        .load(Ordering::SeqCst);
     let time_since_last_update = Instant::now()
         .duration_since(last_update_time)
         .as_millis_f64();
+    if time_since_last_update < 250.0 {
+        return;
+    }
+    progress.last_update_time.swap(Instant::now(), Ordering::SeqCst);
 
     let current_bytes_downloaded = progress.sum();
     let max = progress.get_max();
@@ -135,25 +137,24 @@ pub fn calculate_update(progress: &ProgressObject) {
     let bytes_remaining = max.saturating_sub(current_bytes_downloaded); // bytes
 
     progress.update_window(kilobytes_per_second as usize);
-    push_update(progress, bytes_remaining);
+    push_update(&progress, bytes_remaining).await;
 }
 
-#[throttle(1, Duration::from_millis(250))]
+pub async fn push_update(progress: &ProgressObject, bytes_remaining: usize) {
-pub fn push_update(progress: &ProgressObject, bytes_remaining: usize) {
     let average_speed = progress.rolling.get_average();
     let time_remaining = (bytes_remaining / 1000) / average_speed.max(1);
 
-    update_ui(progress, average_speed, time_remaining);
+    update_ui(progress, average_speed, time_remaining).await;
-    update_queue(progress);
+    update_queue(progress).await;
 }
 
-fn update_ui(progress_object: &ProgressObject, kilobytes_per_second: usize, time_remaining: usize) {
+async fn update_ui(progress_object: &ProgressObject, kilobytes_per_second: usize, time_remaining: usize) {
     send!(
         progress_object.sender,
         DownloadManagerSignal::UpdateUIStats(kilobytes_per_second, time_remaining)
     );
 }
 
-fn update_queue(progress: &ProgressObject) {
+async fn update_queue(progress: &ProgressObject) {
     send!(progress.sender, DownloadManagerSignal::UpdateUIQueue)
 }

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

@@ -0,0 +1,28 @@
+use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
+
+pub struct SyncSemaphore {
+    inner: Arc<AtomicUsize>
+}
+
+impl SyncSemaphore {
+    pub fn new() -> Self {
+        Self { inner: Arc::new(AtomicUsize::new(0)) }
+    }
+
+    pub fn acquire(&self) -> SyncSemaphorePermit  {
+        self.inner.fetch_add(1, Ordering::Relaxed);
+        SyncSemaphorePermit(self.inner.clone())
+    }
+
+    pub fn permits(&self) -> usize {
+        self.inner.fetch_add(0, Ordering::Relaxed)
+    }
+}
+
+pub struct SyncSemaphorePermit(Arc<AtomicUsize>);
+
+impl Drop for SyncSemaphorePermit {
+    fn drop(&mut self) {
+        self.0.fetch_sub(1, Ordering::Relaxed);
+    }
+}

src-tauri/games/Cargo.toml

@@ -4,23 +4,34 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+aes = "0.8.4"
+async-scoped = { version = "0.9.0", features = ["use-tokio"] }
+async-trait = "0.1.89"
 atomic-instant-full = "0.1.0"
 bitcode = "0.6.7"
 boxcar = "0.2.14"
-database = { version = "0.1.0", path = "../database" }
+crossbeam-channel = "0.5.15"
-download_manager = { version = "0.1.0", path = "../download_manager" }
+ctr = "0.9.2"
+database = { path = "../database", version = "0.1.0" }
+download_manager = { path = "../download_manager", version = "0.1.0" }
+droplet-rs = { git = "https://github.com/Drop-OSS/droplet-rs" }
+futures-util = "*"
 hex = "0.4.3"
 log = "0.4.28"
-md5 = "0.8.0"
+native_model = { git = "https://github.com/Drop-OSS/native_model.git", version = "0.6.4", features = [
+  "rmp_serde_1_3"
+] }
 rayon = "1.11.0"
-remote = { version = "0.1.0", path = "../remote" }
+remote = { path = "../remote", version = "0.1.0" }
 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"
+serde_with = "3.15.0"
+sha2 = "0.10.9"
+sysinfo = "0.37.2"
+tauri = "*"
+throttle_my_fn = "0.2.6"
+tokio = { version = "*", features = ["rt", "sync"] }
+tokio-util = { version = "*", features = ["io"] }
+utils = { path = "../utils", version = "0.1.0" }

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

@@ -12,13 +12,13 @@ pub struct Collection {
     name: String,
     is_default: bool,
     user_id: String,
-    entries: Vec<CollectionObject>,
+    pub entries: Vec<CollectionObject>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct CollectionObject {
-    collection_id: String,
+    pub collection_id: String,
-    game_id: String,
+    pub game_id: String,
-    game: Game,
+    pub game: Game,
 }

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

@@ -1,7 +1,8 @@
+use async_trait::async_trait;
 use database::{
-    ApplicationTransientStatus, DownloadType, DownloadableMetadata, borrow_db_checked,
+    ApplicationTransientStatus, DownloadableMetadata, borrow_db_checked, borrow_db_mut_checked,
-    borrow_db_mut_checked,
 };
+use download_manager::depot_manager::DepotManager;
 use download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
 use download_manager::downloadable::Downloadable;
 use download_manager::error::ApplicationDownloadError;
@@ -9,60 +10,53 @@ use download_manager::util::download_thread_control_flag::{
     DownloadThreadControl, DownloadThreadControlFlag,
 };
 use download_manager::util::progress_object::{ProgressHandle, ProgressObject};
+use droplet_rs::manifest::Manifest;
 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 remote::utils::DROP_CLIENT_ASYNC;
-use std::collections::{HashMap, HashSet};
+use std::fmt::Debug;
-use std::fs::{OpenOptions, create_dir_all};
+use std::mem;
-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 tokio::sync::mpsc::Sender;
 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::download_logic::download_game_chunk;
 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 metadata: DownloadableMetadata,
-    pub version: String,
     pub control_flag: DownloadThreadControl,
-    buckets: Mutex<Vec<DownloadBucket>>,
+    pub manifest: Mutex<Option<Manifest>>,
-    context_map: Mutex<HashMap<String, bool>>,
-    pub manifest: Mutex<Option<DropManifest>>,
     pub progress: Arc<ProgressObject>,
+    depot_manager: Arc<DepotManager>,
     sender: Sender<DownloadManagerSignal>,
     pub dropdata: DropData,
     status: Mutex<DownloadStatus>,
 }
 
+impl Debug for GameDownloadAgent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GameDownloadAgent").finish()
+    }
+}
+
 impl GameDownloadAgent {
     pub async fn new_from_index(
-        id: String,
+        metadata: DownloadableMetadata,
-        version: String,
         target_download_dir: usize,
         sender: Sender<DownloadManagerSignal>,
+        depot_manager: Arc<DepotManager>,
     ) -> Result<Self, ApplicationDownloadError> {
         let base_dir = {
             let db_lock = borrow_db_checked();
@@ -70,53 +64,43 @@ impl GameDownloadAgent {
             db_lock.applications.install_dirs[target_download_dir].clone()
         };
 
-        Self::new(id, version, base_dir, sender).await
+        Self::new(metadata, base_dir, sender, depot_manager).await
     }
     pub async fn new(
-        id: String,
+        metadata: DownloadableMetadata,
-        version: String,
         base_dir: PathBuf,
         sender: Sender<DownloadManagerSignal>,
+        depot_manager: Arc<DepotManager>,
     ) -> 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());
+        info!("base dir {}", base_dir_path.display());
+        let data_base_dir_path = base_dir_path.join(metadata.id.clone());
+        info!("data dir path {}", data_base_dir_path.display());
 
-        let stored_manifest =
+        let stored_manifest = DropData::generate(
-            DropData::generate(id.clone(), version.clone(), data_base_dir_path.clone());
+            metadata.id.clone(),
-
+            metadata.version.clone(),
-        let context_lock = stored_manifest.contexts.lock().unwrap().clone();
+            metadata.target_platform,
+            data_base_dir_path.clone(),
+        );
         
         let result = Self {
-            id,
+            metadata,
-            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),
+            depot_manager,
         };
 
         result.ensure_manifest_exists().await?;
 
-        let required_space = lock!(result.manifest)
+        let required_space = lock!(result.manifest).as_ref().unwrap().size;
-            .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;
 
@@ -134,7 +118,7 @@ impl GameDownloadAgent {
     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(),
+            version_id: self.metadata.version.clone(),
         };
         db_lock
             .applications
@@ -147,25 +131,26 @@ impl GameDownloadAgent {
             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> {
+    pub async 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);
+        let res = self
+            .run()
+            .await
+            .map_err(ApplicationDownloadError::Communication);
 
         debug!(
             "{} took {}ms to download",
-            self.id,
+            self.metadata.id,
             timer.elapsed().as_millis()
         );
         res
@@ -187,7 +172,10 @@ impl GameDownloadAgent {
         let client = DROP_CLIENT_ASYNC.clone();
         let url = generate_url(
             &["/api/v1/client/game/manifest"],
-            &[("id", &self.id), ("version", &self.version)],
+            &[
+                ("id", &self.metadata.id),
+                ("version", &self.metadata.version),
+            ],
         )
         .map_err(ApplicationDownloadError::Communication)?;
 
@@ -207,7 +195,7 @@ impl GameDownloadAgent {
             ));
         }
 
-        let manifest_download: DropManifest = response
+        let manifest_download: Manifest = response
             .json()
             .await
             .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
@@ -222,276 +210,104 @@ impl GameDownloadAgent {
 
     // Sets it up for both download and validate
     fn setup_progress(&self) {
-        let buckets = lock!(self.buckets);
+        let manifest = lock!(self.manifest);
+        let manifest = manifest.as_ref().unwrap();
 
-        let chunk_count = buckets.iter().map(|e| e.drops.len()).sum();
+        self.progress.set_max(manifest.size.try_into().unwrap());
-
+        self.progress.set_size(manifest.chunks.len());
-        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> {
+    async fn run(&self) -> Result<bool, RemoteAccessError> {
-        if lock!(self.buckets).is_empty() {
+        self.depot_manager.sync_depots().await?;
-            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 (chunks, key) = {
+            let manifest = lock!(self.manifest);
+            let manifest = manifest.as_ref().unwrap();
+            (manifest.chunks.clone(), manifest.key)
+        };
+        let chunk_len = chunks.len();
+        let mut completed_chunks = {
+            let completed_chunks = lock!(self.dropdata.contexts);
+            completed_chunks.clone()
+        };
         let max_download_threads = borrow_db_checked().settings.max_download_threads;
 
-        debug!(
+        let (sender, recv) = crossbeam_channel::bounded(16);
-            "downloading game: {} with {} threads",
+
-            self.id, max_download_threads
+        let unsafe_self: &'static GameDownloadAgent = unsafe { mem::transmute(self) };
-        );
+        let local_completed_chunks = completed_chunks.clone();
-        let pool = ThreadPoolBuilder::new()
+
+        let download_join_handle = tauri::async_runtime::spawn_blocking(move || {
+            let thread_pool = rayon::ThreadPoolBuilder::new()
                 .num_threads(max_download_threads)
                 .build()
-            .unwrap_or_else(|_| {
+                .unwrap();
-                panic!("failed to build thread pool with {max_download_threads} threads")
+            thread_pool.scope(move |s| {
-            });
+                for (index, (chunk_id, chunk_data)) in chunks.into_iter().enumerate() {
+                    let local_sender = sender.clone();
+                    let progress = unsafe_self.progress.get(index);
+                    let progress_handle =
+                        ProgressHandle::new(progress, unsafe_self.progress.clone());
 
-        let buckets = lock!(self.buckets);
+                    let chunk_length = chunk_data.files.iter().map(|v| v.length).sum();
 
-        let mut download_contexts = HashMap::<String, DownloadContext>::new();
+                    if *local_completed_chunks.get(&chunk_id).unwrap_or(&false) {
-
+                        progress_handle.skip(chunk_length);
-        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;
+                    }
+
+                    let sender = unsafe_self.sender.clone();
+                    let (depot, permit) = match unsafe_self
+                        .depot_manager
+                        .next_depot(&unsafe_self.metadata.id, &unsafe_self.metadata.version)
+                    {
+                        Ok(v) => v,
+                        Err(err) => {
+                            tauri::async_runtime::spawn(async move {
+                                send!(sender, DownloadManagerSignal::Error(ApplicationDownloadError::Communication(err)));
+                            });
+                            return;
+                        }
                     };
 
-                bucket.drops = todo_drops;
+                    s.spawn(move |_| {
-
-                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(
+                            let base_path = unsafe_self.dropdata.base_path.clone();
-                            &bucket,
+                            match download_game_chunk(
-                            download_context,
+                                &unsafe_self.metadata.id,
-                            &self.control_flag,
+                                &unsafe_self.metadata.version,
+                                &chunk_id,
+                                &depot,
+                                &key,
+                                &chunk_data,
+                                base_path,
+                                &unsafe_self.control_flag,
                                 loop_progress_handle,
                             ) {
                                 Ok(true) => {
-                                for drop in bucket.drops {
+                                    local_sender.send(chunk_id.clone()).unwrap();
-                                    completed_contexts.push(drop.checksum);
+                                    drop(permit); // Take ownership
-                                }
                                     return;
                                 }
                                 Ok(false) => return,
                                 Err(e) => {
-                                warn!("game download agent error: {e}");
+                                    warn!("got error for chunk id {}: {e:?}", chunk_id);
 
-                                let retry = matches!(
+                                    let retry = true; /*matches!(
                                     &e,
                                     ApplicationDownloadError::Communication(_)
                                     | ApplicationDownloadError::Checksum
                                     | ApplicationDownloadError::Lock
                                     | ApplicationDownloadError::IoError(_)
-                                );
+                                    );*/
 
                                     if i == RETRY_COUNT - 1 || !retry {
                                         warn!("retry logic failed, not re-attempting.");
+                                        tauri::async_runtime::spawn(async move {
                                             send!(sender, DownloadManagerSignal::Error(e));
+                                        });
                                         return;
                                     }
                                 }
@@ -499,55 +315,54 @@ impl GameDownloadAgent {
                         }
                     });
                 }
+                drop(sender);
+            });
         });
 
-        let newly_completed = completed_contexts.clone();
+        let mut outputs = Vec::new();
-
+        while let Ok(chunk_id) = recv.recv() {
-        let completed_lock_len = {
+            outputs.push(chunk_id);
-            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()
+        download_join_handle
-        };
+            .await
+            .expect("failed to complete download");
 
-        let context_map_lock = lock!(self.context_map);
+        for completed_chunk in outputs {
-        let contexts = buckets
+            completed_chunks.insert(completed_chunk, true);
+        }
+
+        let drop_data_chunks = completed_chunks
             .iter()
-            .flat_map(|x| x.drops.iter().map(|e| e.checksum.clone()))
+            .map(|v| (v.0.to_string(), *v.1))
-            .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.set_contexts(&drop_data_chunks);
         self.dropdata.write();
 
+        info!("completed {} chunks", drop_data_chunks.len());
+
         // If there are any contexts left which are false
-        if !contexts.iter().all(|x| x.1) {
+        if completed_chunks.len() != chunk_len {
             info!(
-                "download agent for {} exited without completing ({}/{}) ({} buckets)",
+                "download agent for {} exited without completing ({}/{})",
-                self.id.clone(),
+                self.metadata.id.clone(),
-                completed_lock_len,
+                completed_chunks.len(),
-                contexts.len(),
+                chunk_len,
-                buckets.len()
             );
             return Ok(false);
         }
-
         Ok(true)
     }
 
+    #[allow(dead_code)]
     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(),
+            version_id: self.metadata.version.clone(),
         };
 
         let mut db_lock = borrow_db_mut_checked();
@@ -558,7 +373,8 @@ impl GameDownloadAgent {
         push_game_update(app_handle, &self.metadata().id, None, (None, Some(status)));
     }
 
-    pub fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
+    pub fn validate(&self, _app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
+        /*
         self.setup_validate(app_handle);
 
         let buckets = lock!(self.buckets);
@@ -612,6 +428,7 @@ impl GameDownloadAgent {
 
             return Ok(false);
         }
+         */
 
         Ok(true)
     }
@@ -628,10 +445,11 @@ impl GameDownloadAgent {
     }
 }
 
+#[async_trait]
 impl Downloadable for GameDownloadAgent {
-    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
+    async fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
         *lock!(self.status) = DownloadStatus::Downloading;
-        self.download(app_handle)
+        self.download(app_handle).await
     }
 
     fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError> {
@@ -648,24 +466,20 @@ impl Downloadable for GameDownloadAgent {
     }
 
     fn metadata(&self) -> DownloadableMetadata {
-        DownloadableMetadata {
+        self.metadata.clone()
-            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(),
+            version_id: self.metadata.version.clone(),
         };
         db_lock
             .applications
             .transient_statuses
             .insert(self.metadata(), status.clone());
-        push_game_update(app_handle, &self.id, None, (None, Some(status)));
+        push_game_update(app_handle, &self.metadata.id, None, (None, Some(status)));
     }
 
     fn on_error(&self, app_handle: &tauri::AppHandle, error: &ApplicationDownloadError) {
@@ -682,18 +496,20 @@ impl Downloadable for GameDownloadAgent {
 
         push_game_update(
             app_handle,
-            &self.id,
+            &self.metadata.id,
             None,
-            GameStatusManager::fetch_state(&self.id, &handle),
+            GameStatusManager::fetch_state(&self.metadata.id, &handle),
         );
     }
 
-    fn on_complete(&self, app_handle: &tauri::AppHandle) {
+    async 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,
-        ) {
+        )
+        .await
+        {
             Ok(_) => {}
             Err(e) => {
                 error!("could not mark game as complete: {e}");
@@ -706,7 +522,6 @@ impl Downloadable for GameDownloadAgent {
     }
 
     fn on_cancelled(&self, app_handle: &tauri::AppHandle) {
-        info!("cancelled {}", self.id);
         self.cancel(app_handle);
     }
 

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

@@ -1,175 +1,38 @@
 use std::fs::{Permissions, set_permissions};
-use std::io::Read;
+use std::io::{Read, Seek as _, SeekFrom, Write as _};
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
+use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Instant;
-use std::{
-    fs::{File, OpenOptions},
-    io::{self, BufWriter, Seek, SeekFrom, Write},
-    path::PathBuf,
-};
 
+use aes::cipher::{KeyIvInit, StreamCipher};
 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 droplet_rs::manifest::ChunkData;
-use md5::{Context, Digest};
+use log::{debug, info};
 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 sha2::Digest;
+use tauri::Url;
 
-use crate::downloads::manifest::{ChunkBody, DownloadBucket, DownloadContext, DownloadDrop};
+const READ_BUF_LEN: usize = 1024 * 1024;
 
-static MAX_PACKET_LENGTH: usize = 4096 * 4;
+type Aes128Ctr64LE = ctr::Ctr64LE<aes::Aes128>;
-static BUMP_SIZE: usize = 4096 * 16;
 
-pub struct DropWriter<W: Write> {
+#[allow(clippy::too_many_arguments)]
-    hasher: Context,
+pub fn download_game_chunk(
-    destination: BufWriter<W>,
+    game_id: &str,
-    progress: ProgressHandle,
+    version_id: &str,
-}
+    chunk_id: &str,
-impl DropWriter<File> {
+    depot: &str,
-    fn new(path: PathBuf, progress: ProgressHandle) -> Result<Self, io::Error> {
+    key: &[u8; 16],
-        let destination = OpenOptions::new()
+    chunk_data: &ChunkData,
-            .write(true)
+    base_path: PathBuf,
-            .create(true)
-            .truncate(false)
-            .open(&path)
-            .inspect_err(|_v| warn!("failed to open {}", path.display()))?;
-        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(|_| {
-                        warn!("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> {
@@ -183,14 +46,16 @@ pub fn download_game_bucket(
 
     let header = generate_authorization_header();
 
-    let url = generate_url(&["/api/v2/client/chunk"], &[])
+    let url = Url::parse(depot)
-        .map_err(ApplicationDownloadError::Communication)?;
+        .map_err(|v| ApplicationDownloadError::DownloadError(v.into()))?
-
+        .join(&format!(
-    let body = ChunkBody::create(ctx, &bucket.drops);
+            "content/{}/{}/{}",
+            game_id, version_id, chunk_id
+        ))
+        .map_err(|v| ApplicationDownloadError::DownloadError(v.into()))?;
 
     let response = DROP_CLIENT_SYNC
-        .post(url)
+        .get(url)
-        .json(&body)
         .header("Authorization", header)
         .send()
         .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
@@ -198,7 +63,7 @@ pub fn download_game_bucket(
     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()))
+            ApplicationDownloadError::Communication(RemoteAccessError::FetchErrorLegacy(e.into()))
         })?;
         info!("{raw_res}");
         if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
@@ -211,90 +76,70 @@ pub fn download_game_bucket(
         ));
     }
 
-    let lengths = response
+    if control_flag.get() == DownloadThreadControlFlag::Stop {
-        .headers()
+        progress.set(0);
-        .get("Content-Lengths")
+        return Ok(false);
-        .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 =
+    /*let stream = response
-        DropDownloadPipeline::new(response, bucket.drops.clone(), control_flag, progress)
+        .bytes_stream()
-            .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
+        .map(|v| v.map_err(|err| std::io::Error::other(err)));
+    let mut stream_reader = StreamReader::new(stream);*/
+    let mut stream_reader = response;
 
-    let completed = pipeline
+    let mut hasher = sha2::Sha256::new();
-        .copy()
+    let mut cipher = Aes128Ctr64LE::new(key.into(), &chunk_data.iv.into());
-        .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
+    let mut read_buf = vec![0u8; READ_BUF_LEN];
-    if !completed {
+    for file in &chunk_data.files {
-        return Ok(false);
+        let path = base_path.join(file.filename.clone());
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let mut file_handle = std::fs::OpenOptions::new()
+            .truncate(false)
+            .write(true)
+            .append(false)
+            .create(true)
+            .open(&path)?;
+        file_handle.seek(SeekFrom::Start(file.start.try_into().unwrap()))?;
+
+        let mut remaining = file.length;
+        while remaining > 0 {
+            let amount = stream_reader.read(&mut read_buf[0..remaining.min(READ_BUF_LEN)])?;
+            progress.add(amount);
+            remaining -= amount;
+
+            cipher.apply_keystream(&mut read_buf[0..amount]);
+            hasher.update(&read_buf[0..amount]);
+            file_handle.write_all(&read_buf[0..amount])?;
         }
 
-    // If we complete the file, set the permissions (if on Linux)
         #[cfg(unix)]
         {
-        for drop in bucket.drops.iter() {
+            drop(file_handle);
-            let permission = if drop.permissions == 0 {
+            let permissions = if file.permissions == 0 {
                 0o744
             } else {
-                drop.permissions
+                file.permissions
             };
-            let permissions = Permissions::from_mode(permission);
+            let permissions = Permissions::from_mode(permissions);
-            set_permissions(drop.path.clone(), permissions)
+            set_permissions(path, permissions)
                 .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
         }
+
+        if control_flag.get() == DownloadThreadControlFlag::Stop {
+            progress.set(0);
+            return Ok(false);
+        }
     }
 
-    let checksums = pipeline
+    let digest = hex::encode(hasher.finalize());
-        .finish()
+    if digest != chunk_data.checksum {
-        .map_err(|e| ApplicationDownloadError::IoError(Arc::new(e)))?;
+        return Err(ApplicationDownloadError::Checksum);
-
-    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)

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

@@ -5,17 +5,19 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use database::platform::Platform;
 use log::error;
 use native_model::{Decode, Encode};
 use utils::lock;
 
 pub type DropData = v1::DropData;
 
-pub static DROP_DATA_PATH: &str = ".dropdata";
+pub static DROPDATA_PATH: &str = ".dropdata";
 
 pub mod v1 {
     use std::{collections::HashMap, path::PathBuf, sync::Mutex};
 
+    use database::platform::Platform;
     use native_model::native_model;
     use serde::{Deserialize, Serialize};
 
@@ -24,16 +26,18 @@ pub mod v1 {
     pub struct DropData {
         pub game_id: String,
         pub game_version: String,
+        pub target_platform: Platform,
         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 {
+        pub fn new(game_id: String, game_version: String, target_platform: Platform, base_path: PathBuf) -> Self {
             Self {
                 base_path,
                 game_id,
                 game_version,
+                target_platform,
                 contexts: Mutex::new(HashMap::new()),
             }
         }
@@ -41,14 +45,14 @@ pub mod v1 {
 }
 
 impl DropData {
-    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+    pub fn generate(game_id: String, game_version: String, target_platform: Platform, base_path: PathBuf) -> Self {
         match DropData::read(&base_path) {
             Ok(v) => v,
-            Err(_) => DropData::new(game_id, game_version, base_path),
+            Err(_) => DropData::new(game_id, game_version, target_platform, 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 file = File::open(base_path.join(DROPDATA_PATH))?;
 
         let mut s = Vec::new();
         file.read_to_end(&mut s)?;
@@ -66,7 +70,7 @@ impl DropData {
             Err(_) => return,
         };
 
-        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
+        let mut file = match File::create(self.base_path.join(DROPDATA_PATH)) {
             Ok(file) => file,
             Err(e) => {
                 error!("{e}");

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

@@ -1,5 +1,4 @@
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize)]
@@ -21,57 +20,6 @@ pub struct DownloadBucket {
     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,

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

@@ -4,4 +4,3 @@ pub mod drop_data;
 pub mod error;
 mod manifest;
 pub mod utils;
-pub mod validate;

src-tauri/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)
-}

src-tauri/games/src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(iterator_try_collect)]
+#![feature(lock_value_accessors)]
 
 pub mod collections;
 pub mod downloads;

src-tauri/games/src/library.rs

@@ -5,8 +5,10 @@ use database::{
 };
 use log::{debug, error, warn};
 use remote::{
-    auth::generate_authorization_header, error::RemoteAccessError, requests::generate_url,
+    auth::generate_authorization_header,
-    utils::DROP_CLIENT_SYNC,
+    error::RemoteAccessError,
+    requests::generate_url,
+    utils::DROP_CLIENT_ASYNC
 };
 use serde::{Deserialize, Serialize};
 use std::fs::remove_dir_all;
@@ -18,9 +20,9 @@ use crate::state::{GameStatusManager, GameStatusWithTransient};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FetchGameStruct {
-    game: Game,
+    pub game: Game,
-    status: GameStatusWithTransient,
+    pub status: GameStatusWithTransient,
-    version: Option<GameVersion>,
+    pub version: Option<GameVersion>,
 }
 
 impl FetchGameStruct {
@@ -36,17 +38,19 @@ impl FetchGameStruct {
 #[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct Game {
-    id: String,
+    pub id: String,
-    m_name: String,
+    #[serde(rename = "type")]
-    m_short_description: String,
+    pub game_type: String,
-    m_description: String,
+    pub m_name: String,
+    pub m_short_description: String,
+    pub m_description: String,
     // mDevelopers
     // mPublishers
-    m_icon_object_id: String,
+    pub m_icon_object_id: String,
-    m_banner_object_id: String,
+    pub m_banner_object_id: String,
-    m_cover_object_id: String,
+    pub m_cover_object_id: String,
-    m_image_library_object_ids: Vec<String>,
+    pub m_image_library_object_ids: Vec<String>,
-    m_image_carousel_object_ids: Vec<String>,
+    pub m_image_carousel_object_ids: Vec<String>,
 }
 impl Game {
     pub fn id(&self) -> &String {
@@ -87,7 +91,7 @@ pub fn set_partially_installed_db(
     db_lock.applications.game_statuses.insert(
         meta.id.clone(),
         GameDownloadStatus::PartiallyInstalled {
-            version_name: meta.version.as_ref().unwrap().clone(),
+            version_name: meta.version.clone(),
             install_dir,
         },
     );
@@ -193,38 +197,29 @@ pub fn get_current_meta(game_id: &String) -> Option<DownloadableMetadata> {
         .cloned()
 }
 
-pub fn on_game_complete(
+pub async 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"],
+        &["/api/v1/client/game", &meta.id, "version", &meta.version],
-        &[
+        &[],
-            ("id", &meta.id),
-            ("version", meta.version.as_ref().unwrap()),
-        ],
     )?;
-    let response = client
+    let response = DROP_CLIENT_ASYNC
         .get(response)
         .header("Authorization", generate_authorization_header())
-        .send()?;
+        .send()
+        .await?;
 
-    let game_version: GameVersion = response.json()?;
+    let game_version: GameVersion = response.json().await?;
 
     let mut handle = borrow_db_mut_checked();
     handle
         .applications
         .game_versions
-        .entry(meta.id.clone())
+        .insert(meta.version.clone(), game_version.clone());
-        .or_default()
-        .insert(meta.version.clone().unwrap(), game_version.clone());
     handle
         .applications
         .installed_game_version
@@ -232,14 +227,19 @@ pub fn on_game_complete(
 
     drop(handle);
 
-    let status = if game_version.setup_command.is_empty() {
+    let setup_configuration = game_version
+        .setups
+        .iter()
+        .find(|v| v.platform == meta.target_platform);
+
+    let status = if setup_configuration.is_none() {
         GameDownloadStatus::Installed {
-            version_name: meta.version.clone().unwrap(),
+            version_name: meta.version.clone(),
             install_dir,
         }
     } else {
         GameDownloadStatus::SetupRequired {
-            version_name: meta.version.clone().unwrap(),
+            version_name: meta.version.clone(),
             install_dir,
         }
     };
@@ -260,6 +260,8 @@ pub fn on_game_complete(
         }
     );
 
+    app_emit!(app_handle, "update_library", ());
+
     Ok(())
 }
 

src-tauri/games/src/scan.rs

@@ -4,7 +4,7 @@ use database::{DownloadType, DownloadableMetadata, borrow_db_mut_checked};
 use log::warn;
 
 use crate::{
-    downloads::drop_data::{DROP_DATA_PATH, DropData},
+    downloads::drop_data::{DROPDATA_PATH, DropData},
     library::set_partially_installed_db,
 };
 
@@ -15,7 +15,7 @@ pub fn scan_install_dirs() {
             continue;
         };
         for game in files.into_iter().flatten() {
-            let drop_data_file = game.path().join(DROP_DATA_PATH);
+            let drop_data_file = game.path().join(DROPDATA_PATH);
             if !drop_data_file.exists() {
                 continue;
             }
@@ -33,7 +33,8 @@ pub fn scan_install_dirs() {
 
             let metadata = DownloadableMetadata::new(
                 drop_data.game_id,
-                Some(drop_data.game_version),
+                drop_data.game_version,
+                drop_data.target_platform,
                 DownloadType::Game,
             );
             set_partially_installed_db(

src-tauri/games/src/state.rs

@@ -1,5 +1,5 @@
 use database::models::data::{
-    ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus,
+    ApplicationTransientStatus, Database, DownloadType, GameDownloadStatus,
 };
 
 pub type GameStatusWithTransient = (
@@ -13,12 +13,10 @@ impl GameStatusManager {
         let online_state = database
             .applications
             .transient_statuses
-            .get(&DownloadableMetadata {
+            .iter()
-                id: game_id.to_string(),
+            .find(|v| v.0.id == *game_id && v.0.download_type == DownloadType::Game)
-                download_type: DownloadType::Game,
+            .map(|v| v.1.clone())
-                version: None,
+            .clone();
-            })
-            .cloned();
 
         let offline_state = database.applications.game_statuses.get(game_id).cloned();
 

src-tauri/process/Cargo.toml

@@ -5,15 +5,16 @@ edition = "2024"
 
 [dependencies]
 chrono = "0.4.42"
-client = { version = "0.1.0", path = "../client" }
+client = { path = "../client", version = "0.1.0" }
-database = { version = "0.1.0", path = "../database" }
+database = { path = "../database", version = "0.1.0" }
-dynfmt = "0.1.5"
+dynfmt = { version = "0.1.5", features = ["curly"] }
-games = { version = "0.1.0", path = "../games" }
+games = { path = "../games", version = "0.1.0" }
 log = "0.4.28"
 page_size = "0.6.0"
 serde = "1.0.228"
 serde_with = "3.15.0"
 shared_child = "1.1.1"
-tauri = "2.8.5"
+shell-words = "1.1.1"
-tauri-plugin-opener = "2.5.0"
+tauri = "*"
-utils = { version = "0.1.0", path = "../utils" }
+tauri-plugin-opener = "*"
+utils = { path = "../utils", version = "0.1.0" }

src-tauri/process/src/error.rs

@@ -1,17 +1,18 @@
-use std::{fmt::Display, io::Error};
+use std::{fmt::Display, io::{self, Error}, sync::Arc};
 
 use serde_with::SerializeDisplay;
 
-#[derive(SerializeDisplay)]
+#[derive(SerializeDisplay, Clone)]
 pub enum ProcessError {
     NotInstalled,
     AlreadyRunning,
     InvalidID,
     InvalidVersion,
-    IOError(Error),
+    RequiredDependency(String, String),
+    IOError(Arc<Error>),
     FormatError(String), // String errors supremacy
     InvalidPlatform,
-    OpenerError(tauri_plugin_opener::Error),
+    OpenerError(Arc<tauri_plugin_opener::Error>),
     InvalidArguments(String),
     FailedLaunch(String),
 }
@@ -33,7 +34,17 @@ impl Display for ProcessError {
             ProcessError::FailedLaunch(game_id) => {
                 &format!("Drop detected that the game {game_id} may have failed to launch properly")
             }
+            ProcessError::RequiredDependency(game_id, version_id) => &format!(
+                "Missing a required dependency to launch this game: {} {}",
+                game_id, version_id
+            ),
         };
         write!(f, "{s}")
     }
 }
+
+impl From<io::Error> for ProcessError {
+    fn from(value: io::Error) -> Self {
+        ProcessError::IOError(Arc::new(value))
+    }
+}

src-tauri/process/src/format.rs

@@ -13,6 +13,7 @@ impl DropFormatArgs {
         working_dir: &String,
         executable_name: &String,
         absolute_executable_name: String,
+        original: Option<String>,
     ) -> Self {
         let mut positional = Vec::new();
         let mut map: HashMap<&'static str, String> = HashMap::new();
@@ -23,6 +24,10 @@ impl DropFormatArgs {
         map.insert("exe", executable_name.to_string());
         map.insert("abs_exe", absolute_executable_name);
         
+        if let Some(original) = original {
+            map.insert("executor", original);
+        }
+
         Self { positional, map }
     }
 }

src-tauri/process/src/lib.rs

@@ -1,5 +1,6 @@
 #![feature(nonpoison_mutex)]
 #![feature(sync_nonpoison)]
+#![feature(extend_one)]
 
 use std::{
     ops::Deref,
@@ -16,6 +17,7 @@ pub mod error;
 pub mod format;
 pub mod process_handlers;
 pub mod process_manager;
+mod parser;
 
 pub struct ProcessManagerWrapper(OnceLock<Mutex<ProcessManager<'static>>>);
 impl ProcessManagerWrapper {

src-tauri/process/src/parser.rs

@@ -0,0 +1,50 @@
+use std::path::PathBuf;
+
+use crate::error::ProcessError;
+
+#[derive(Debug)]
+pub struct ParsedCommand {
+    pub env: Vec<String>,
+    pub command: String,
+    pub args: Vec<String>,
+}
+
+impl ParsedCommand {
+    pub fn parse(raw: String) -> Result<Self, ProcessError> {
+        let parts =
+            shell_words::split(&raw).map_err(|e| ProcessError::InvalidArguments(e.to_string()))?;
+        let args =
+            parts
+                .iter()
+                .position(|v| !v.contains("="))
+                .ok_or(ProcessError::InvalidArguments(
+                    "Cannot parse launch".to_owned(),
+                ))?;
+        let env = &parts[0..args];
+        let command = parts[args].clone();
+        let args = &parts[(args + 1)..];
+
+        Ok(Self {
+            args: args.to_vec(),
+            command,
+            env: env.to_vec(),
+        })
+    }
+
+    pub fn make_absolute(&mut self, base: PathBuf) {
+        self.command = base
+            .join(self.command.clone())
+            .to_string_lossy()
+            .to_string();
+    }
+
+    pub fn reconstruct(self) -> String {
+        let mut v = vec![];
+        v.extend(self.env);
+        v.extend_one(self.command);
+        v.extend(self.args);
+        v.join(" ")
+    }
+}
+
+pub struct LaunchParameters(pub String, pub PathBuf);

src-tauri/process/src/process_handlers.rs

@@ -1,6 +1,9 @@
+use std::fs::create_dir_all;
+
 use client::compat::{COMPAT_INFO, UMU_LAUNCHER_EXECUTABLE};
-use database::{Database, DownloadableMetadata, GameVersion, platform::Platform};
+use database::{
-use log::debug;
+    Database, DownloadableMetadata, GameVersion, db::DATA_ROOT_DIR, platform::Platform,
+};
 
 use crate::{error::ProcessError, process_manager::ProcessHandler};
 
@@ -10,11 +13,10 @@ impl ProcessHandler for NativeGameLauncher {
         &self,
         _meta: &DownloadableMetadata,
         launch_command: String,
-        args: Vec<String>,
         _game_version: &GameVersion,
         _current_dir: &str,
     ) -> Result<String, ProcessError> {
-        Ok(format!("\"{}\" {}", launch_command, args.join(" ")))
+        Ok(format!("\"{}\"", launch_command))
     }
 
     fn valid_for_platform(&self, _db: &Database, _target: &Platform) -> bool {
@@ -26,30 +28,41 @@ pub struct UMULauncher;
 impl ProcessHandler for UMULauncher {
     fn create_launch_process(
         &self,
-        _meta: &DownloadableMetadata,
+        meta: &DownloadableMetadata,
         launch_command: String,
-        args: Vec<String>,
         game_version: &GameVersion,
         _current_dir: &str,
     ) -> Result<String, ProcessError> {
-        debug!("Game override: \"{:?}\"", &game_version.umu_id_override);
+        let launch_config = game_version
-        let game_id = match &game_version.umu_id_override {
+            .launches
+            .iter()
+            .find(|v| v.platform == meta.target_platform)
+            .ok_or(ProcessError::NotInstalled)?;
+
+        let game_id = match &launch_config.umu_id_override {
             Some(game_override) => {
                 if game_override.is_empty() {
-                    game_version.game_id.clone()
+                    game_version.version_id.clone()
                 } else {
                     game_override.clone()
                 }
             }
-            None => game_version.game_id.clone(),
+            None => game_version.version_id.clone(),
         };
+        let pfx_dir = DATA_ROOT_DIR.join("pfx");
+        let pfx_dir = pfx_dir.join(meta.id.clone());
+        create_dir_all(&pfx_dir)?;
         Ok(format!(
-            "GAMEID={game_id} {umu:?} \"{launch}\" {args}",
+            "GAMEID={game_id} WINEPREFIX={} {} {umu:?} {launch}",
+            pfx_dir.to_string_lossy(),
+            match meta.target_platform {
+                Platform::Linux => "UMU_NO_PROTON=1",
+                _ => "",
+            },
             umu = UMU_LAUNCHER_EXECUTABLE
                 .as_ref()
                 .expect("Failed to get UMU_LAUNCHER_EXECUTABLE as ref"),
             launch = launch_command,
-            args = args.join(" ")
         ))
     }
 
@@ -67,7 +80,6 @@ impl ProcessHandler for AsahiMuvmLauncher {
         &self,
         meta: &DownloadableMetadata,
         launch_command: String,
-        args: Vec<String>,
         game_version: &GameVersion,
         current_dir: &str,
     ) -> Result<String, ProcessError> {
@@ -75,7 +87,6 @@ impl ProcessHandler for AsahiMuvmLauncher {
         let umu_string = umu_launcher.create_launch_process(
             meta,
             launch_command,
-            args,
             game_version,
             current_dir,
         )?;

src-tauri/process/src/process_manager.rs

@@ -4,27 +4,28 @@ use std::{
     io,
     path::PathBuf,
     process::{Command, ExitStatus},
-    str::FromStr,
     sync::Arc,
     thread::spawn,
     time::{Duration, SystemTime},
 };
 
 use database::{
-    ApplicationTransientStatus, Database, DownloadType, DownloadableMetadata, GameDownloadStatus,
+    ApplicationTransientStatus, Database, DownloadableMetadata, GameDownloadStatus, GameVersion,
-    GameVersion, borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR, platform::Platform,
+    borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR, platform::Platform,
 };
 use dynfmt::Format;
 use dynfmt::SimpleCurlyFormat;
 use games::{library::push_game_update, state::GameStatusManager};
 use log::{debug, info, warn};
+use serde::Serialize;
 use shared_child::SharedChild;
-use tauri::AppHandle;
+use tauri::{AppHandle, Emitter as _};
 
 use crate::{
     PROCESS_MANAGER,
     error::ProcessError,
     format::DropFormatArgs,
+    parser::{LaunchParameters, ParsedCommand},
     process_handlers::{AsahiMuvmLauncher, NativeGameLauncher, UMULauncher},
 };
 
@@ -45,6 +46,11 @@ pub struct ProcessManager<'a> {
     app_handle: AppHandle,
 }
 
+#[derive(Serialize)]
+pub struct LaunchOption {
+    name: String,
+}
+
 impl ProcessManager<'_> {
     pub fn new(app_handle: AppHandle) -> Self {
         let log_output_dir = DATA_ROOT_DIR.join("logs");
@@ -69,7 +75,7 @@ impl ProcessManager<'_> {
                 ),
                 (
                     (Platform::Linux, Platform::Linux),
-                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                    &UMULauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
                 ),
                 (
                     (Platform::macOS, Platform::macOS),
@@ -93,7 +99,8 @@ impl ProcessManager<'_> {
             Some(process) => {
                 process.manually_killed = true;
                 process.handle.kill()?;
-                process.handle.wait()?;
+                let exit_status = process.handle.wait()?;
+                info!("exit status: {:?}", exit_status);
                 Ok(())
             }
             None => Err(io::Error::new(
@@ -163,13 +170,12 @@ impl ProcessManager<'_> {
             && (elapsed.as_secs() <= 2 || result.map_or(true, |r| !r.success()))
         {
             warn!("drop detected that the game {game_id} may have failed to launch properly");
-            return Err(ProcessError::FailedLaunch(game_id));
+            let _ = self.app_handle.emit("launch_external_error", &game_id);
-            // let _ = self.app_handle.emit("launch_external_error", &game_id);
         }
 
-        let version_data = match db_handle.applications.game_versions.get(&game_id) {
+        let version_data = match db_handle.applications.game_versions.get(&meta.version) {
             // This unwrap here should be resolved by just making the hashmap accept an option rather than just a String
-            Some(res) => res.get(&meta.version.unwrap()).expect("Failed to get game version from installed game versions. Is the database corrupted?"),
+            Some(res) => res,
             None => todo!(),
         };
 
@@ -208,29 +214,51 @@ impl ProcessManager<'_> {
         process_handler.is_ok()
     }
 
-    /// Must be called through spawn as it is currently blocking
+    pub fn get_launch_options(game_id: String) -> Result<Vec<LaunchOption>, ProcessError> {
-    pub fn launch_process(&mut self, game_id: String) -> Result<(), ProcessError> {
+        let db_lock = borrow_db_checked();
+
+        let meta = db_lock
+            .applications
+            .installed_game_version
+            .get(&game_id)
+            .cloned()
+            .ok_or(ProcessError::NotInstalled)?;
+
+        let game_version = db_lock
+            .applications
+            .game_versions
+            .get(&meta.version)
+            .ok_or(ProcessError::InvalidVersion)?;
+
+        let launch_options = game_version
+            .launches
+            .iter()
+            .filter(|v| v.platform == meta.target_platform)
+            .map(|v| LaunchOption {
+                name: v.name.clone(),
+            })
+            .collect::<Vec<LaunchOption>>();
+
+        Ok(launch_options)
+    }
+
+    pub fn launch_process(
+        &mut self,
+        game_id: String,
+        launch_process_index: usize,
+    ) -> Result<(), ProcessError> {
         if self.processes.contains_key(&game_id) {
             return Err(ProcessError::AlreadyRunning);
         }
 
-        let version = match borrow_db_checked()
+        let mut db_lock = borrow_db_mut_checked();
+
+        let meta = db_lock
             .applications
-            .game_statuses
+            .installed_game_version
             .get(&game_id)
             .cloned()
-        {
+            .ok_or(ProcessError::NotInstalled)?;
-            Some(GameDownloadStatus::Installed { version_name, .. }) => version_name,
-            Some(GameDownloadStatus::SetupRequired { version_name, .. }) => version_name,
-            _ => return Err(ProcessError::NotInstalled),
-        };
-        let meta = DownloadableMetadata {
-            id: game_id.clone(),
-            version: Some(version.clone()),
-            download_type: DownloadType::Game,
-        };
-
-        let mut db_lock = borrow_db_mut_checked();
 
         let game_status = db_lock
             .applications
@@ -259,14 +287,12 @@ impl ProcessManager<'_> {
         let game_version = db_lock
             .applications
             .game_versions
-            .get(&game_id)
-            .ok_or(ProcessError::InvalidID)?
             .get(version_name)
             .ok_or(ProcessError::InvalidVersion)?;
 
         // TODO: refactor this path with open_process_logs
         let game_log_folder = &self.get_log_dir(game_id);
-        create_dir_all(game_log_folder).map_err(ProcessError::IOError)?;
+        create_dir_all(game_log_folder)?;
 
         let current_time = chrono::offset::Local::now();
         let log_file = OpenOptions::new()
@@ -274,8 +300,11 @@ impl ProcessManager<'_> {
             .truncate(true)
             .read(true)
             .create(true)
-            .open(game_log_folder.join(format!("{}-{}.log", &version, current_time.timestamp())))
+            .open(game_log_folder.join(format!(
-            .map_err(ProcessError::IOError)?;
+                "{}-{}.log",
+                &meta.version,
+                current_time.timestamp()
+            )))?;
 
         let error_file = OpenOptions::new()
             .write(true)
@@ -284,55 +313,141 @@ impl ProcessManager<'_> {
             .create(true)
             .open(game_log_folder.join(format!(
                 "{}-{}-error.log",
-                &version,
+                &meta.version,
                 current_time.timestamp()
-            )))
+            )))?;
-            .map_err(ProcessError::IOError)?;
 
-        let target_platform = game_version.platform;
+        let target_platform = meta.target_platform;
 
         let process_handler = self.fetch_process_handler(&db_lock, &target_platform)?;
 
-        let (launch, args) = match game_status {
+        let (target_command, executor) = match game_status {
             GameDownloadStatus::Installed {
                 version_name: _,
                 install_dir: _,
-            } => (&game_version.launch_command, &game_version.launch_args),
+            } => {
+                let (_, launch_config) = game_version
+                    .launches
+                    .iter()
+                    .filter(|v| v.platform == target_platform)
+                    .enumerate()
+                    .find(|(i, _)| *i == launch_process_index)
+                    .ok_or(ProcessError::NotInstalled)?;
+                (
+                    launch_config.command.clone(),
+                    launch_config.executor.as_ref(),
+                )
+            }
             GameDownloadStatus::SetupRequired {
                 version_name: _,
                 install_dir: _,
-            } => (&game_version.setup_command, &game_version.setup_args),
+            } => {
-            GameDownloadStatus::PartiallyInstalled {
+                let setup_config = game_version
-                version_name: _,
+                    .setups
-                install_dir: _,
+                    .iter()
-            } => unreachable!("Game registered as 'Partially Installed'"),
+                    .find(|v| v.platform == target_platform)
-            GameDownloadStatus::Remote {} => unreachable!("Game registered as 'Remote'"),
+                    .ok_or(ProcessError::NotInstalled)?;
+
+                (setup_config.command.clone(), None)
+            }
+            _ => unreachable!("Game registered as 'Partially Installed'"),
         };
 
-        #[allow(clippy::unwrap_used)]
+        let target_command = ParsedCommand::parse(target_command)?;
-        let launch = PathBuf::from_str(install_dir).unwrap().join(launch);
-        let launch = launch.display().to_string();
 
-        let launch_string = process_handler.create_launch_process(
+        let launch_parameters = if let Some(executor) = executor {
+            let err = ProcessError::RequiredDependency(
+                executor.game_id.clone(),
+                executor.version_id.clone(),
+            );
+
+            let executor_metadata = db_lock
+                .applications
+                .installed_game_version
+                .get(&executor.game_id)
+                .ok_or(err.clone())?;
+
+            let executor_game_status = db_lock
+                .applications
+                .game_statuses
+                .get(&executor.game_id)
+                .ok_or(err.clone())?;
+
+            let executor_install_dir = match executor_game_status {
+                GameDownloadStatus::Installed {
+                    version_name: _,
+                    install_dir,
+                } => Ok(install_dir),
+                GameDownloadStatus::SetupRequired {
+                    version_name: _,
+                    install_dir: _,
+                } => todo!(),
+                _ => Err(err.clone()),
+            }?;
+
+            let executor_game_version = db_lock
+                .applications
+                .game_versions
+                .get(&executor.version_id)
+                .ok_or(err.clone())?;
+
+            let executor_launch_config = executor_game_version
+                .launches
+                .iter()
+                .find(|v| v.launch_id == executor.launch_id)
+                .ok_or(err)?;
+
+            println!("{}", executor_launch_config.command);
+            let mut exe_command = ParsedCommand::parse(executor_launch_config.command.clone())?;
+            println!("{:?}", exe_command);
+            exe_command.env.extend(target_command.env);
+            exe_command.make_absolute(executor_install_dir.into());
+
+            exe_command.args.iter_mut().for_each(|v| {
+                *v = v.replace("{executor}", &target_command.command);
+            });
+
+            let executor_launch_string = process_handler.create_launch_process(
+                executor_metadata,
+                exe_command.reconstruct(),
+                executor_game_version,
+                install_dir,
+            )?;
+
+            LaunchParameters(executor_launch_string, install_dir.into())
+        } else {
+            let target_launch_string = process_handler.create_launch_process(
                 &meta,
-            launch.to_string(),
+                target_command.reconstruct(),
-            args.clone(),
                 game_version,
                 install_dir,
             )?;
 
+            let mut parsed_launch = ParsedCommand::parse(target_launch_string.clone())?;
+            let executable_name = parsed_launch.command.clone();
+            parsed_launch.make_absolute(install_dir.into());
+
             let format_args = DropFormatArgs::new(
-            launch_string,
+                target_launch_string,
                 install_dir,
-            &game_version.launch_command,
+                &executable_name,
-            launch.to_string(),
+                parsed_launch.command,
+                None,
             );
 
-        let launch_string = SimpleCurlyFormat
+            let target_launch_string = SimpleCurlyFormat
-            .format(&game_version.launch_command_template, format_args)
+                .format(&game_version.launch_template, &format_args)
                 .map_err(|e| ProcessError::FormatError(e.to_string()))?
                 .to_string();
 
+            let target_launch_string = SimpleCurlyFormat
+                .format(&target_launch_string, format_args)
+                .map_err(|e| ProcessError::FormatError(e.to_string()))?
+                .to_string();
+
+            LaunchParameters(target_launch_string, install_dir.into())
+        };
+
         #[cfg(target_os = "windows")]
         use std::os::windows::process::CommandExt;
         #[cfg(target_os = "windows")]
@@ -340,25 +455,27 @@ impl ProcessManager<'_> {
         #[cfg(target_os = "windows")]
         command.raw_arg(format!("/C \"{}\"", &launch_string));
 
-        info!("launching (in {install_dir}): {launch_string}",);
+        info!(
+            "launching (in {}): {}",
+            launch_parameters.1.to_string_lossy(),
+            launch_parameters.0
+        );
 
         #[cfg(unix)]
         let mut command: Command = Command::new("sh");
         #[cfg(unix)]
-        command.args(vec!["-c", &launch_string]);
+        command.args(vec!["-c", &launch_parameters.0]);
-
-        debug!("final launch string:\n\n{launch_string}\n");
 
         command
             .stderr(error_file)
             .stdout(log_file)
             .env_remove("RUST_LOG")
-            .current_dir(install_dir);
+            .current_dir(launch_parameters.1);
 
-        let child = command.spawn().map_err(ProcessError::IOError)?;
+        let child = command.spawn()?;
 
         let launch_process_handle =
-            Arc::new(SharedChild::new(child).map_err(ProcessError::IOError)?);
+            Arc::new(SharedChild::new(child)?);
 
         db_lock
             .applications
@@ -399,7 +516,6 @@ pub trait ProcessHandler: Send + 'static {
         &self,
         meta: &DownloadableMetadata,
         launch_command: String,
-        args: Vec<String>,
         game_version: &GameVersion,
         current_dir: &str,
     ) -> Result<String, ProcessError>;

src-tauri/remote/Cargo.toml

@@ -4,20 +4,31 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+async-trait = "0.1.89"
 bitcode = "0.6.7"
+bytes = "1.11.0"
 chrono = "0.4.42"
-client = { version = "0.1.0", path = "../client" }
+client = { path = "../client", version = "0.1.0" }
-database = { version = "0.1.0", path = "../database" }
+database = { path = "../database", version = "0.1.0" }
 droplet-rs = "0.7.3"
 gethostname = "1.0.2"
 hex = "0.4.3"
 http = "1.3.1"
 log = "0.4.28"
 md5 = "0.8.0"
-reqwest = "0.12.23"
+reqwest = { version = "0.12.28", default-features = false, features = [
+  "blocking",
+  "http2",
+  "json",
+  "native-tls-alpn",
+  "rustls-tls",
+  "rustls-tls-native-roots",
+  "stream",
+] }
+reqwest-middleware = { version = "0.4.2", features = ["json"] }
 reqwest-websocket = "0.5.1"
 serde = "1.0.228"
 serde_with = "3.15.0"
-tauri = "2.8.5"
+tauri = "*"
 url = "2.5.7"
-utils = { version = "0.1.0", path = "../utils" }
+utils = { path = "../utils", version = "0.1.0" }

src-tauri/remote/src/auth.rs

@@ -80,7 +80,7 @@ pub async fn fetch_user() -> Result<User, RemoteAccessError> {
         let err: DropServerError = response.json().await?;
         warn!("{err:?}");
 
-        if err.status_message == "Nonce expired" {
+        if err.message == "Nonce expired" {
             return Err(RemoteAccessError::OutOfSync);
         }
 
@@ -117,9 +117,9 @@ pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
 
     if response.status() != 200 {
         let data: DropServerError = response.json()?;
-        error!("could not start handshake: {}", data.status_message);
+        error!("could not start handshake: {:?}", data);
 
-        return Err(RemoteAccessError::HandshakeFailed(data.status_message));
+        return Err(RemoteAccessError::HandshakeFailed(data.message));
     }
 
     let response = response.text()?;

src-tauri/remote/src/error.rs

@@ -15,13 +15,14 @@ use serde::Deserialize;
 pub struct DropServerError {
     pub status_code: usize,
     pub status_message: String,
-    // pub message: String,
+    pub message: String,
     // pub url: String,
 }
 
 #[derive(Debug, SerializeDisplay)]
 pub enum RemoteAccessError {
-    FetchError(Arc<reqwest::Error>),
+    FetchErrorLegacy(Arc<reqwest::Error>),
+    FetchError(Arc<reqwest_middleware::Error>),
     FetchErrorWS(Arc<reqwest_websocket::Error>),
     ParsingError(ParseError),
     InvalidEndpoint,
@@ -33,6 +34,7 @@ pub enum RemoteAccessError {
     OutOfSync,
     Cache(std::io::Error),
     CorruptedState,
+    NoDepots,
 }
 
 impl Display for RemoteAccessError {
@@ -56,6 +58,15 @@ impl Display for RemoteAccessError {
                         .unwrap_or("Unknown error".to_string())
                 )
             }
+            RemoteAccessError::FetchErrorLegacy(error) => write!(
+                f,
+                "{}: {}",
+                error,
+                error
+                    .source()
+                    .map(|v| v.to_string())
+                    .unwrap_or("Unknown error".to_string())
+            ),
             RemoteAccessError::FetchErrorWS(error) => write!(
                 f,
                 "{}: {}",
@@ -76,7 +87,7 @@ impl Display for RemoteAccessError {
             RemoteAccessError::InvalidResponse(error) => write!(
                 f,
                 "server returned an invalid response: {}, {}",
-                error.status_code, error.status_message
+                error.status_code, error.message
             ),
             RemoteAccessError::UnparseableResponse(error) => {
                 write!(f, "server returned an invalid response: {error}")
@@ -93,13 +104,19 @@ impl Display for RemoteAccessError {
                 f,
                 "Drop encountered a corrupted internal state. Please report this to the developers, with details of reproduction."
             ),
+            RemoteAccessError::NoDepots => write!(f, "There are no download depots configured on the server. Contact your server admin."),
                     }
     }
 }
 
 impl From<reqwest::Error> for RemoteAccessError {
     fn from(err: reqwest::Error) -> Self {
-        RemoteAccessError::FetchError(Arc::new(err))
+        RemoteAccessError::FetchErrorLegacy(Arc::new(err))
+    }
+}
+impl From<reqwest_middleware::Error> for RemoteAccessError {
+    fn from(value: reqwest_middleware::Error) -> Self {
+        RemoteAccessError::FetchError(Arc::new(value))
     }
 }
 impl From<reqwest_websocket::Error> for RemoteAccessError {

src-tauri/remote/src/fetch_object.rs

@@ -1,4 +1,4 @@
-use database::{DB, interface::DatabaseImpls};
+use database::{DB};
 use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
 use log::{debug, warn};
 use tauri::UriSchemeResponder;

src-tauri/remote/src/lib.rs

@@ -1,3 +1,7 @@
+#![feature(slice_concat_trait)]
+#![feature(sync_nonpoison)]
+#![feature(nonpoison_mutex)]
+
 pub mod auth;
 #[macro_use]
 pub mod cache;

src-tauri/remote/src/requests.rs

@@ -1,18 +1,17 @@
-use database::{DB, interface::DatabaseImpls};
+use database::{DB};
+use reqwest_middleware::Error;
 use url::Url;
 
 use crate::{
     auth::generate_authorization_header, error::RemoteAccessError, utils::DROP_CLIENT_ASYNC,
 };
 
-pub fn generate_url<T: AsRef<str>>(
+pub fn generate_url(
-    path_components: &[T],
+    path_components: &[&str],
-    query: &[(T, T)],
+    query: &[(&str, &str)],
 ) -> Result<Url, RemoteAccessError> {
-    let mut base_url = DB.fetch_base_url();
+    let path_appended = path_components.join("/");
-    for endpoint in path_components {
+    let mut base_url = DB.fetch_base_url().join(&path_appended)?;
-        base_url = base_url.join(endpoint.as_ref())?;
-    }
     {
         let mut queries = base_url.query_pairs_mut();
         for (param, val) in query {
@@ -22,7 +21,7 @@ pub fn generate_url<T: AsRef<str>>(
     Ok(base_url)
 }
 
-pub async fn make_authenticated_get(url: Url) -> Result<reqwest::Response, reqwest::Error> {
+pub async fn make_authenticated_get(url: Url) -> Result<reqwest::Response, Error> {
     DROP_CLIENT_ASYNC
         .get(url)
         .header("Authorization", generate_authorization_header())

src-tauri/remote/src/server_proto.rs

@@ -1,12 +1,11 @@
-use std::str::FromStr;
-
 use database::borrow_db_checked;
-use http::{Request, Response, StatusCode, Uri, uri::PathAndQuery};
+use http::{
+    HeaderMap, HeaderValue, Request, Response, StatusCode, Uri, header::USER_AGENT,
+};
 use log::{error, warn};
 use tauri::UriSchemeResponder;
-use utils::webbrowser_open::webbrowser_open;
 
-use crate::utils::DROP_CLIENT_SYNC;
+use crate::utils::DROP_CLIENT_ASYNC;
 
 pub async fn handle_server_proto_offline_wrapper(
     request: Request<Vec<u8>>,
@@ -36,6 +35,7 @@ pub async fn handle_server_proto_wrapper(request: Request<Vec<u8>>, responder: U
                 Response::builder()
                     .status(e)
                     .body(Vec::new())
+                    .inspect_err(|v| warn!("{:?}", v))
                     .expect("Failed to build error response"),
             );
         }
@@ -43,6 +43,7 @@ pub async fn handle_server_proto_wrapper(request: Request<Vec<u8>>, responder: U
 }
 
 async fn handle_server_proto(request: Request<Vec<u8>>) -> Result<Response<Vec<u8>>, StatusCode> {
+    let (remote_uri, web_token) = {
         let db_handle = borrow_db_checked();
         let auth = match db_handle.auth.as_ref() {
             Some(auth) => auth,
@@ -52,39 +53,39 @@ async fn handle_server_proto(request: Request<Vec<u8>>) -> Result<Response<Vec<u
             }
         };
         let web_token = match &auth.web_token {
-        Some(token) => token,
+            Some(token) => token.clone(),
             None => return Err(StatusCode::UNAUTHORIZED),
         };
         let remote_uri = db_handle
             .base_url
             .parse::<Uri>()
+            .inspect_err(|v| warn!("{:?}", v))
             .expect("Failed to parse base url");
-
+        (remote_uri, web_token)
-    let path = request.uri().path();
+    };
 
     let mut new_uri = request.uri().clone().into_parts();
-    new_uri.path_and_query = Some(
-        PathAndQuery::from_str(&format!("{path}?noWrapper=true"))
-            .expect("Failed to parse request path in proto"),
-    );
     new_uri.authority = remote_uri.authority().cloned();
     new_uri.scheme = remote_uri.scheme().cloned();
     let err_msg = &format!("Failed to build new uri from parts {new_uri:?}");
-    let new_uri = Uri::from_parts(new_uri).expect(err_msg);
+    let new_uri = Uri::from_parts(new_uri)
+        .inspect_err(|v| warn!("{:?}", v))
+        .expect(err_msg);
 
-    let whitelist_prefix = ["/store", "/api", "/_", "/fonts"];
+    let mut headers = HeaderMap::new();
+    request.headers().clone_into(&mut headers);
+    headers.remove(USER_AGENT);
+    headers.append(USER_AGENT, HeaderValue::from_static("Drop Desktop Client"));
+    headers.append(
+        "Authorization",
+        HeaderValue::from_str(&format!("Bearer {web_token}")).unwrap(),
+    );
 
-    if whitelist_prefix.iter().all(|f| !path.starts_with(f)) {
+    let response = match DROP_CLIENT_ASYNC
-        webbrowser_open(new_uri.to_string());
-        return Ok(Response::new(Vec::new()));
-    }
-
-    let client = DROP_CLIENT_SYNC.clone();
-    let response = match client
         .request(request.method().clone(), new_uri.to_string())
-        .header("Authorization", format!("Bearer {web_token}"))
+        .headers(headers)
-        .headers(request.headers().clone())
         .send()
+        .await
     {
         Ok(response) => response,
         Err(e) => {
@@ -94,15 +95,26 @@ async fn handle_server_proto(request: Request<Vec<u8>>) -> Result<Response<Vec<u
     };
 
     let response_status = response.status();
-    let response_body = match response.bytes() {
+    let mut client_http_response = Response::builder()
+        .status(response_status)
+        .header("Access-Control-Allow-Origin", "*");
+
+    {
+        let client_response_headers = client_http_response.headers_mut().unwrap();
+        for (header, header_value) in response.headers() {
+            client_response_headers.insert(header, header_value.clone());
+        }
+    };
+
+    let response_body = match response.bytes().await {
         Ok(bytes) => bytes,
         Err(e) => return Err(e.status().unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)),
     };
 
-    let http_response = Response::builder()
+    let client_http_response = client_http_response
-        .status(response_status)
         .body(response_body.to_vec())
+        .inspect_err(|v| warn!("{:?}", v))
         .expect("Failed to build server proto response");
 
-    Ok(http_response)
+    Ok(client_http_response)
 }

src-tauri/remote/src/utils.rs

@@ -2,12 +2,20 @@ use std::{
     fs::{self, File},
     io::Read,
     sync::LazyLock,
+    time::Duration,
 };
 
+use client::{app_state::AppState, app_status::AppStatus};
 use database::db::DATA_ROOT_DIR;
+use http::Extensions;
 use log::{debug, info, warn};
 use reqwest::Certificate;
+use reqwest_middleware::{
+    ClientBuilder, ClientWithMiddleware, Error, Middleware, Next, Result,
+    reqwest::{Request, Response},
+};
 use serde::Deserialize;
+use tauri::{AppHandle, Emitter, Manager, async_runtime::Mutex};
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -21,9 +29,65 @@ impl DropHealthcheck {
 }
 static DROP_CERT_BUNDLE: LazyLock<Vec<Certificate>> = LazyLock::new(fetch_certificates);
 pub static DROP_CLIENT_SYNC: LazyLock<reqwest::blocking::Client> = LazyLock::new(get_client_sync);
-pub static DROP_CLIENT_ASYNC: LazyLock<reqwest::Client> = LazyLock::new(get_client_async);
+pub static DROP_CLIENT_ASYNC: LazyLock<ClientWithMiddleware> = LazyLock::new(get_client_async);
 pub static DROP_CLIENT_WS_CLIENT: LazyLock<reqwest::Client> = LazyLock::new(get_client_ws);
 
+pub static DROP_APP_HANDLE: LazyLock<Mutex<Option<AppHandle>>> = LazyLock::new(|| Mutex::new(None));
+
+struct AutoOfflineMiddleware;
+
+#[async_trait::async_trait]
+impl Middleware for AutoOfflineMiddleware {
+    async fn handle(
+        &self,
+        req: Request,
+        extensions: &mut Extensions,
+        next: Next<'_>,
+    ) -> Result<Response> {
+        let res = next.run(req, extensions).await;
+        match res {
+            Ok(res) => {
+                tauri::async_runtime::spawn(async move {
+                    let lock = DROP_APP_HANDLE.lock().await;
+                    if let Some(app_handle) = &*lock {
+                        let state = app_handle.state::<std::sync::nonpoison::Mutex<AppState>>();
+                        let mut state_lock = state.lock();
+                        if state_lock.status == AppStatus::Offline {
+                            state_lock.status = AppStatus::SignedIn;
+                            app_handle
+                                .emit("update_state", &*state_lock)
+                                .expect("failed to emit state update");
+                        }
+                    };
+                });
+
+                Ok(res)
+            }
+            Err(err) => match err {
+                Error::Middleware(error) => Err(Error::Middleware(error)),
+                Error::Reqwest(error) => {
+                    if error.is_connect() {
+                        // Spawn to defer this action - the state will most likely be locked
+                        tauri::async_runtime::spawn(async move {
+                            let lock = DROP_APP_HANDLE.lock().await;
+                            if let Some(app_handle) = &*lock {
+                                let state =
+                                    app_handle.state::<std::sync::nonpoison::Mutex<AppState>>();
+                                let mut state_lock = state.lock();
+                                state_lock.status = AppStatus::Offline;
+                                app_handle
+                                    .emit("update_state", &*state_lock)
+                                    .expect("failed to emit state update");
+                            };
+                        });
+                    };
+                    Err(Error::Reqwest(error))
+                }
+            },
+        }
+    }
+}
+
 fn fetch_certificates() -> Vec<Certificate> {
     let certificate_dir = DATA_ROOT_DIR.join("certificates");
 
@@ -91,19 +155,26 @@ pub fn get_client_sync() -> reqwest::blocking::Client {
     }
     client
         .use_rustls_tls()
+        .user_agent("Drop Desktop Client")
+        .connect_timeout(Duration::from_millis(1500))
         .build()
         .expect("Failed to build synchronous client")
 }
-pub fn get_client_async() -> reqwest::Client {
+pub fn get_client_async() -> ClientWithMiddleware {
     let mut client = reqwest::ClientBuilder::new();
 
     for cert in DROP_CERT_BUNDLE.iter() {
         client = client.add_root_certificate(cert.clone());
     }
-    client
+    let normal_client = client
         .use_rustls_tls()
+        .user_agent("Drop Desktop Client")
+        .build()
+        .expect("Failed to build asynchronous client");
+
+    ClientBuilder::new(normal_client)
+        .with(AutoOfflineMiddleware)
         .build()
-        .expect("Failed to build asynchronous client")
 }
 pub fn get_client_ws() -> reqwest::Client {
     let mut client = reqwest::ClientBuilder::new();
@@ -113,6 +184,7 @@ pub fn get_client_ws() -> reqwest::Client {
     }
     client
         .use_rustls_tls()
+        .user_agent("Drop Desktop Client")
         .http1_only()
         .build()
         .expect("Failed to build websocket client")

src-tauri/src/client.rs

@@ -3,6 +3,7 @@ use std::sync::nonpoison::Mutex;
 use database::{borrow_db_checked, borrow_db_mut_checked};
 use download_manager::DOWNLOAD_MANAGER;
 use log::{debug, error};
+use remote::requests::{generate_url, make_authenticated_get};
 use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;
 use tauri_plugin_opener::OpenerExt;
@@ -18,18 +19,15 @@ pub fn fetch_state(state: tauri::State<'_, Mutex<AppState>>) -> Result<String, S
 }
 
 #[tauri::command]
-pub fn quit(app: tauri::AppHandle) {
+pub async fn quit(app: tauri::AppHandle) {
-    cleanup_and_exit(&app);
+    cleanup_and_exit(&app).await;
 }
 
-pub fn cleanup_and_exit(app: &AppHandle) {
+pub async fn cleanup_and_exit(app: &AppHandle) {
     debug!("cleaning up and exiting application");
-    match DOWNLOAD_MANAGER.ensure_terminated() {
+    match DOWNLOAD_MANAGER.ensure_terminated().await {
-        Ok(res) => match res {
         Ok(()) => debug!("download manager terminated correctly"),
-            Err(()) => error!("download manager failed to terminate correctly"),
+        Err(_) => error!("download manager failed to terminate correctly"),
-        },
-        Err(e) => panic!("{e:?}"),
     }
 
     app.exit(0);
@@ -76,7 +74,12 @@ pub fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autost
 
 #[tauri::command]
 pub fn open_fs(path: String, app_handle: AppHandle) -> Result<(), tauri_plugin_opener::Error> {
-    app_handle
+    app_handle.opener().open_path(path, None::<&str>)
-        .opener()
+}
-        .open_path(path, None::<&str>)
+
+
+#[tauri::command]
+pub async fn check_online() -> Result<bool, ()> {
+    let online = make_authenticated_get(generate_url(&["/api/v1/"], &[]).unwrap()).await.is_ok();
+    Ok(online)
 }

src-tauri/src/collections.rs

@@ -1,15 +1,29 @@
-use games::collections::collection::{Collection, Collections};
+use std::sync::nonpoison::Mutex;
+
+use client::app_state::AppState;
+use database::{GameDownloadStatus, borrow_db_checked};
+use games::collections::collection::Collections;
 use remote::{
-    auth::generate_authorization_header,
     cache::{cache_object, get_cached_object},
     error::RemoteAccessError,
+    offline,
     requests::{generate_url, make_authenticated_get},
-    utils::DROP_CLIENT_ASYNC,
 };
-use serde_json::json;
 
-#[tauri::command]
 pub async fn fetch_collections(
+    state: tauri::State<'_, Mutex<AppState>>,
+    hard_refresh: Option<bool>,
+) -> Result<Collections, RemoteAccessError> {
+    offline!(
+        state,
+        fetch_collections_online,
+        fetch_collections_offline,
+        hard_refresh
+    )
+    .await
+}
+
+pub async fn fetch_collections_online(
     hard_refresh: Option<bool>,
 ) -> Result<Collections, RemoteAccessError> {
     let do_hard_refresh = hard_refresh.unwrap_or(false);
@@ -28,79 +42,25 @@ pub async fn fetch_collections(
     Ok(collections)
 }
 
-#[tauri::command]
+pub async fn fetch_collections_offline(
-pub async fn fetch_collection(collection_id: String) -> Result<Collection, RemoteAccessError> {
+    _hard_refresh: Option<bool>,
-    let response = make_authenticated_get(generate_url(
+) -> Result<Collections, RemoteAccessError> {
-        &["/api/v1/client/collection/", &collection_id],
+    let mut cached = get_cached_object::<Collections>("collections")?;
-        &[],
-    )?)
-    .await?;
 
-    Ok(response.json().await?)
+    let db_handle = borrow_db_checked();
+
+    for collection in cached.iter_mut() {
+        collection.entries.retain(|v| {
+            matches!(
+                &db_handle
+                    .applications
+                    .game_statuses
+                    .get(&v.game_id)
+                    .unwrap_or(&GameDownloadStatus::Remote {}),
+                GameDownloadStatus::Installed { .. } | GameDownloadStatus::SetupRequired { .. }
+            )
+        });
     }
 
-#[tauri::command]
+    Ok(cached)
-pub async fn create_collection(name: String) -> Result<Collection, RemoteAccessError> {
-    let client = DROP_CLIENT_ASYNC.clone();
-    let url = generate_url(&["/api/v1/client/collection"], &[])?;
-
-    let response = client
-        .post(url)
-        .header("Authorization", generate_authorization_header())
-        .json(&json!({"name": name}))
-        .send()
-        .await?;
-
-    Ok(response.json().await?)
-}
-
-#[tauri::command]
-pub async fn add_game_to_collection(
-    collection_id: String,
-    game_id: String,
-) -> Result<(), RemoteAccessError> {
-    let client = DROP_CLIENT_ASYNC.clone();
-
-    let url = generate_url(&["/api/v1/client/collection", &collection_id, "entry"], &[])?;
-
-    client
-        .post(url)
-        .header("Authorization", generate_authorization_header())
-        .json(&json!({"id": game_id}))
-        .send()
-        .await?;
-    Ok(())
-}
-
-#[tauri::command]
-pub async fn delete_collection(collection_id: String) -> Result<bool, RemoteAccessError> {
-    let client = DROP_CLIENT_ASYNC.clone();
-
-    let url = generate_url(&["/api/v1/client/collection", &collection_id], &[])?;
-
-    let response = client
-        .delete(url)
-        .header("Authorization", generate_authorization_header())
-        .send()
-        .await?;
-
-    Ok(response.json().await?)
-}
-#[tauri::command]
-pub async fn delete_game_in_collection(
-    collection_id: String,
-    game_id: String,
-) -> Result<(), RemoteAccessError> {
-    let client = DROP_CLIENT_ASYNC.clone();
-
-    let url = generate_url(&["/api/v1/client/collection", &collection_id, "entry"], &[])?;
-
-    client
-        .delete(url)
-        .header("Authorization", generate_authorization_header())
-        .json(&json!({"id": game_id}))
-        .send()
-        .await?;
-
-    Ok(())
 }

src-tauri/src/download_manager.rs

@@ -2,21 +2,21 @@ use database::DownloadableMetadata;
 use download_manager::DOWNLOAD_MANAGER;
 
 #[tauri::command]
-pub fn pause_downloads() {
+pub async fn pause_downloads() {
-    DOWNLOAD_MANAGER.pause_downloads();
+    DOWNLOAD_MANAGER.pause_downloads().await;
 }
 
 #[tauri::command]
-pub fn resume_downloads() {
+pub async fn resume_downloads() {
-    DOWNLOAD_MANAGER.resume_downloads();
+    DOWNLOAD_MANAGER.resume_downloads().await;
 }
 
 #[tauri::command]
-pub fn move_download_in_queue(old_index: usize, new_index: usize) {
+pub async fn move_download_in_queue(old_index: usize, new_index: usize) {
-    DOWNLOAD_MANAGER.rearrange(old_index, new_index);
+    DOWNLOAD_MANAGER.rearrange(old_index, new_index).await;
 }
 
 #[tauri::command]
-pub fn cancel_game(meta: DownloadableMetadata) {
+pub async fn cancel_game(meta: DownloadableMetadata) {
-    DOWNLOAD_MANAGER.cancel(meta);
+    DOWNLOAD_MANAGER.cancel(meta).await;
 }

src-tauri/src/downloads.rs

@@ -1,6 +1,8 @@
 use std::{path::PathBuf, sync::Arc};
 
-use database::{GameDownloadStatus, borrow_db_checked};
+use database::{
+    DownloadType, DownloadableMetadata, GameDownloadStatus, borrow_db_checked, platform::Platform,
+};
 use download_manager::{
     DOWNLOAD_MANAGER, downloadable::Downloadable, error::ApplicationDownloadError,
 };
@@ -9,16 +11,37 @@ use games::downloads::download_agent::GameDownloadAgent;
 #[tauri::command]
 pub async fn download_game(
     game_id: String,
-    game_version: String,
+    version_id: String,
+    target_platform: Platform,
     install_dir: usize,
 ) -> Result<(), ApplicationDownloadError> {
+    {
+        let db = borrow_db_checked();
+        let status = db
+            .applications
+            .game_statuses
+            .get(&game_id)
+            .unwrap_or(&GameDownloadStatus::Remote {});
+
+        if matches!(status, GameDownloadStatus::Installed { .. }) {
+            return Ok(());
+        }
+    };
+
     let sender = { DOWNLOAD_MANAGER.get_sender().clone() };
 
+    let meta = DownloadableMetadata {
+        id: game_id,
+        version: version_id,
+        target_platform,
+        download_type: DownloadType::Game,
+    };
+
     let game_download_agent = GameDownloadAgent::new_from_index(
-        game_id.clone(),
+        meta,
-        game_version.clone(),
         install_dir,
         sender,
+        DOWNLOAD_MANAGER.clone_depot_manager(),
     )
     .await?;
 
@@ -27,6 +50,7 @@ pub async fn download_game(
 
     DOWNLOAD_MANAGER
         .queue_download(game_download_agent.clone())
+        .await
         .unwrap();
 
     Ok(())
@@ -34,43 +58,53 @@ pub async fn download_game(
 
 #[tauri::command]
 pub async fn resume_download(game_id: String) -> Result<(), ApplicationDownloadError> {
-    let s = borrow_db_checked()
+    let (meta, install_dir) = {
+        let db_lock = borrow_db_checked();
+        let status = db_lock
             .applications
             .game_statuses
             .get(&game_id)
-        .unwrap()
+            .ok_or(ApplicationDownloadError::InvalidCommand)?
             .clone();
 
-    let (version_name, install_dir) = match s {
+        let meta = db_lock
-        GameDownloadStatus::Remote {} => unreachable!(),
+            .applications
-        GameDownloadStatus::SetupRequired { .. } => unreachable!(),
+            .installed_game_version
-        GameDownloadStatus::Installed { .. } => unreachable!(),
+            .get(&game_id)
-        GameDownloadStatus::PartiallyInstalled {
+            .ok_or(ApplicationDownloadError::InvalidCommand)?
-            version_name,
+            .clone();
-            install_dir,
+
-        } => (version_name, install_dir),
+        let install_dir = match status {
+            GameDownloadStatus::Remote {} => Err(ApplicationDownloadError::InvalidCommand),
+            GameDownloadStatus::SetupRequired { .. } => {
+                Err(ApplicationDownloadError::InvalidCommand)
+            }
+            GameDownloadStatus::Installed { .. } => Err(ApplicationDownloadError::InvalidCommand),
+            GameDownloadStatus::PartiallyInstalled { install_dir, .. } => Ok(install_dir),
+        }?;
+        (meta, install_dir)
     };
 
     let sender = DOWNLOAD_MANAGER.get_sender();
-    let parent_dir: PathBuf = install_dir.into();
+
+    let install_dir = PathBuf::from(install_dir);
+    let install_dir = install_dir
+        .parent()
+        .expect("game somehow installed at root");
 
     let game_download_agent = Arc::new(Box::new(
         GameDownloadAgent::new(
-            game_id,
+            meta,
-            version_name.clone(),
+            install_dir.to_path_buf(),
-            parent_dir
-                .parent()
-                .unwrap_or_else(|| {
-                    panic!("Failed to get parent directry of {}", parent_dir.display())
-                })
-                .to_path_buf(),
             sender,
+            DOWNLOAD_MANAGER.clone_depot_manager(),
         )
         .await?,
     ) as Box<dyn Downloadable + Send + Sync>);
 
     DOWNLOAD_MANAGER
         .queue_download(game_download_agent)
+        .await
         .unwrap();
     Ok(())
 }

src-tauri/src/games.rs

@@ -1,7 +1,12 @@
 use std::sync::nonpoison::Mutex;
 
-use database::{GameDownloadStatus, GameVersion, borrow_db_checked, borrow_db_mut_checked};
+use bitcode::{Decode, Encode};
+use database::{
+    DownloadableMetadata, GameDownloadStatus, borrow_db_checked,
+    borrow_db_mut_checked, platform::Platform,
+};
 use games::{
+    collections::collection::Collection,
     downloads::error::LibraryError,
     library::{FetchGameStruct, FrontendGameOptions, Game, get_current_meta, uninstall_game_logic},
     state::{GameStatusManager, GameStatusWithTransient},
@@ -10,35 +15,46 @@ use log::warn;
 use process::PROCESS_MANAGER;
 use remote::{
     auth::generate_authorization_header,
-    cache::{cache_object, cache_object_db, get_cached_object, get_cached_object_db},
+    cache::{cache_object, cache_object_db, get_cached_object},
     error::{DropServerError, RemoteAccessError},
     offline,
     requests::generate_url,
     utils::DROP_CLIENT_ASYNC,
 };
+use serde::{Deserialize, Serialize};
 use tauri::AppHandle;
 
-use crate::AppState;
+use crate::{AppState, collections::fetch_collections};
 
 #[tauri::command]
 pub async fn fetch_library(
     state: tauri::State<'_, Mutex<AppState>>,
+    app_handle: AppHandle,
     hard_refresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
+) -> Result<FetchLibraryResponse, RemoteAccessError> {
     offline!(
         state,
         fetch_library_logic,
         fetch_library_logic_offline,
         state,
+        app_handle,
         hard_refresh
     )
     .await
 }
 
+#[derive(Encode, Decode, Serialize)]
+pub struct FetchLibraryResponse {
+    library: Vec<Game>,
+    collections: Vec<Collection>,
+    other: Vec<Game>,
+}
+
 pub async fn fetch_library_logic(
     state: tauri::State<'_, Mutex<AppState>>,
+    app_handle: AppHandle,
     hard_fresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
+) -> Result<FetchLibraryResponse, RemoteAccessError> {
     let do_hard_refresh = hard_fresh.unwrap_or(false);
     if !do_hard_refresh && let Ok(library) = get_cached_object("library") {
         return Ok(library);
@@ -55,63 +71,90 @@ pub async fn fetch_library_logic(
     if response.status() != 200 {
         let err = response.json().await.unwrap_or(DropServerError {
             status_code: 500,
-            status_message: "Invalid response from server.".to_owned(),
+            status_message: "Server Error".to_owned(),
+            message: "Invalid response from server.".to_owned(),
         });
         warn!("{err:?}");
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let mut games: Vec<Game> = response.json().await?;
+    let library: Vec<Game> = response.json().await?;
+    let collections = fetch_collections(state, hard_fresh).await?;
 
-    let mut handle = state.lock();
+    let mut all_games = library.clone();
+    all_games.extend(
+        collections
+            .iter()
+            .flat_map(|v| v.entries.iter().map(|v| v.game.clone())),
+    );
 
+    let installed_metas = {
         let mut db_handle = borrow_db_mut_checked();
 
-    for game in &games {
+        for game in &all_games {
-        handle.games.insert(game.id().clone(), game.clone());
             if !db_handle.applications.game_statuses.contains_key(game.id()) {
                 db_handle
                     .applications
                     .game_statuses
                     .insert(game.id().clone(), GameDownloadStatus::Remote {});
             }
+            cache_object_db(&format!("game/{}", game.id), game, &db_handle)?;
         }
 
+        db_handle
+            .applications
+            .installed_game_version
+            .values()
+            .cloned()
+            .collect::<Vec<DownloadableMetadata>>()
+    };
+
     // Add games that are installed but no longer in library
-    for meta in db_handle.applications.installed_game_version.values() {
+    let mut other = Vec::new();
-        if games.iter().any(|e| *e.id() == meta.id) {
+    for meta in installed_metas {
+        if all_games.iter().any(|e| *e.id() == meta.id) {
             continue;
         }
         // We should always have a cache of the object
         // Pass db_handle because otherwise we get a gridlock
-        let game = match get_cached_object_db::<Game>(&meta.id.clone(), &db_handle) {
+        let game = match get_cached_object::<Game>(&meta.id.clone()) {
             Ok(game) => game,
             Err(err) => {
                 warn!(
                     "{} is installed, but encountered error fetching its error: {}.",
                     meta.id, err
                 );
+                /*
+                 * We can't return a dummy object here because it needs to be in the cache to work
+                 * So we uninstall the game so we don't "lose" it
+                 */
+                uninstall_game_logic(meta.clone(), &app_handle);
                 continue;
             }
         };
-        games.push(game);
+        other.push(game);
     }
 
-    drop(handle);
+    let response = FetchLibraryResponse {
-    drop(db_handle);
+        library,
-    cache_object("library", &games)?;
+        collections,
+        other,
+    };
 
-    Ok(games)
+    cache_object("library", &response)?;
+
+    Ok(response)
 }
 pub async fn fetch_library_logic_offline(
     _state: tauri::State<'_, Mutex<AppState>>,
+    _app_handle: AppHandle,
     _hard_refresh: Option<bool>,
-) -> Result<Vec<Game>, RemoteAccessError> {
+) -> Result<FetchLibraryResponse, RemoteAccessError> {
-    let mut games: Vec<Game> = get_cached_object("library")?;
+    let mut response: FetchLibraryResponse = get_cached_object("library")?;
 
     let db_handle = borrow_db_checked();
 
-    games.retain(|game| {
+    let retain_filter = |game: &Game| {
         matches!(
             &db_handle
                 .applications
@@ -120,46 +163,50 @@ pub async fn fetch_library_logic_offline(
                 .unwrap_or(&GameDownloadStatus::Remote {}),
             GameDownloadStatus::Installed { .. } | GameDownloadStatus::SetupRequired { .. }
         )
+    };
+
+    response.library.retain(retain_filter);
+    response.other.retain(retain_filter);
+    response.collections.iter_mut().for_each(|k| {
+        k.entries.retain(|object| {
+            matches!(
+                &db_handle
+                    .applications
+                    .game_statuses
+                    .get(object.game.id())
+                    .unwrap_or(&GameDownloadStatus::Remote {}),
+                GameDownloadStatus::Installed { .. } | GameDownloadStatus::SetupRequired { .. }
+            )
+        })
     });
 
-    Ok(games)
+    Ok(response)
 }
 pub async fn fetch_game_logic(
     id: String,
     state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
     let version = {
-        let state_handle = state.lock();
-
         let db_lock = borrow_db_checked();
 
         let metadata_option = db_lock.applications.installed_game_version.get(&id);
-        let version = match metadata_option {
+        
+
+        match metadata_option {
             None => None,
             Some(metadata) => db_lock
                 .applications
                 .game_versions
-                .get(&metadata.id)
+                .get(&metadata.version)
-                .map(|v| v.get(metadata.version.as_ref().unwrap()).unwrap())
                 .cloned(),
-        };
-
-        let game = state_handle.games.get(&id);
-        if let Some(game) = game {
-            let status = GameStatusManager::fetch_state(&id, &db_lock);
-
-            let data = FetchGameStruct::new(game.clone(), status, version);
-
-            cache_object_db(&id, game, &db_lock)?;
-
-            return Ok(data);
         }
-
-        version
     };
 
+    let game = match get_cached_object::<Game>(&format!("game/{}", id)) {
+        Ok(value) => value,
+        Err(_) => {
             let client = DROP_CLIENT_ASYNC.clone();
-    let response = generate_url(&["/api/v1/client/game/", &id], &[])?;
+            let response = generate_url(&["/api/v1/client/game", &id], &[])?;
             let response = client
                 .get(response)
                 .header("Authorization", generate_authorization_header())
@@ -181,9 +228,9 @@ pub async fn fetch_game_logic(
             }
 
             let game: Game = response.json().await?;
-
+            game
-    let mut state_handle = state.lock();
+        }
-    state_handle.games.insert(id.clone(), game.clone());
+    };
 
     let mut db_handle = borrow_db_mut_checked();
 
@@ -204,10 +251,31 @@ pub async fn fetch_game_logic(
     Ok(data)
 }
 
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct VersionDownloadOptionRequiredContent {
+    version_id: String,
+    name: String,
+    icon_object_id: String,
+    short_description: String,
+    size: usize,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VersionDownloadOption {
+    version_id: String,
+    display_name: Option<String>,
+    version_path: String,
+    platform: Platform,
+    size: usize,
+    required_content: Vec<VersionDownloadOptionRequiredContent>,
+}
+
 pub async fn fetch_game_version_options_logic(
     game_id: String,
     state: tauri::State<'_, Mutex<AppState>>,
-) -> Result<Vec<GameVersion>, RemoteAccessError> {
+) -> Result<Vec<VersionDownloadOption>, RemoteAccessError> {
     let client = DROP_CLIENT_ASYNC.clone();
 
     let response = generate_url(&["/api/v1/client/game/versions"], &[("id", &game_id)])?;
@@ -223,14 +291,15 @@ pub async fn fetch_game_version_options_logic(
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let data: Vec<GameVersion> = response.json().await?;
+    let data: Vec<VersionDownloadOption> = response.json().await?;
 
     let state_lock = state.lock();
     let process_manager_lock = PROCESS_MANAGER.lock();
-    let data: Vec<GameVersion> = data
+    let data = data
         .into_iter()
         .filter(|v| process_manager_lock.valid_platform(&v.platform))
         .collect();
+    //data.dedup_by_key(|v| v.platform);
     drop(process_manager_lock);
     drop(state_lock);
 
@@ -248,8 +317,7 @@ pub async fn fetch_game_logic_offline(
         Some(metadata) => db_handle
             .applications
             .game_versions
-            .get(&metadata.id)
+            .get(&metadata.version)
-            .map(|v| v.get(metadata.version.as_ref().unwrap()).unwrap())
             .cloned(),
     };
 
@@ -297,7 +365,7 @@ pub fn uninstall_game(game_id: String, app_handle: AppHandle) -> Result<(), Libr
 pub async fn fetch_game_version_options(
     game_id: String,
     state: tauri::State<'_, Mutex<AppState>>,
-) -> Result<Vec<GameVersion>, RemoteAccessError> {
+) -> Result<Vec<VersionDownloadOption>, RemoteAccessError> {
     fetch_game_version_options_logic(game_id, state).await
 }
 
@@ -313,31 +381,24 @@ pub fn update_game_configuration(
         .get(&game_id)
         .ok_or(LibraryError::MetaNotFound(game_id))?;
 
-    let id = installed_version.id.clone();
+    let _id = installed_version.id.clone();
-    let version = installed_version
+    let version = installed_version.version.clone();
-        .version
-        .clone()
-        .ok_or(LibraryError::VersionNotFound(id.clone()))?;
 
     let mut existing_configuration = handle
         .applications
         .game_versions
-        .get(&id)
-        .unwrap()
         .get(&version)
         .unwrap()
         .clone();
 
     // Add more options in here
-    existing_configuration.launch_command_template = options.launch_string().clone();
+    existing_configuration.launch_template = options.launch_string().clone();
 
     // Add no more options past here
 
     handle
         .applications
         .game_versions
-        .get_mut(&id)
-        .unwrap()
         .insert(version.to_string(), existing_configuration);
 
     Ok(())

src-tauri/src/lib.rs

@@ -8,26 +8,24 @@
 #![deny(clippy::all)]
 
 use std::{
-    collections::HashMap, env, fs::File, io::Write, panic::PanicHookInfo, path::Path, str::FromStr,
+    env, fs::File, io::Write, panic::PanicHookInfo, path::Path, str::FromStr,
     sync::nonpoison::Mutex, time::SystemTime,
 };
 
-use ::client::{app_status::AppStatus, autostart::sync_autostart_on_startup, user::User};
+use ::client::{app_state::AppState, app_status::AppStatus, autostart::sync_autostart_on_startup};
 use ::download_manager::DownloadManagerWrapper;
-use ::games::{library::Game, scan::scan_install_dirs};
+use ::games::scan::scan_install_dirs;
 use ::process::ProcessManagerWrapper;
 use ::remote::{
     auth::{self, HandshakeRequestBody, HandshakeResponse, generate_authorization_header},
     cache::clear_cached_object,
     error::RemoteAccessError,
     fetch_object::fetch_object_wrapper,
-    offline,
+    server_proto::handle_server_proto_wrapper,
-    server_proto::{handle_server_proto_offline_wrapper, handle_server_proto_wrapper},
+    utils::{DROP_APP_HANDLE, DROP_CLIENT_ASYNC},
-    utils::DROP_CLIENT_ASYNC,
 };
 use database::{
     DB, GameDownloadStatus, borrow_db_checked, borrow_db_mut_checked, db::DATA_ROOT_DIR,
-    interface::DatabaseImpls,
 };
 use log::{LevelFilter, debug, info, warn};
 use log4rs::{
@@ -36,9 +34,9 @@ use log4rs::{
     config::{Appender, Root},
     encode::pattern::PatternEncoder,
 };
-use serde::Serialize;
 use tauri::{
-    AppHandle, Manager, RunEvent, WindowEvent,
+    AppHandle, LogicalPosition, LogicalSize, Manager, RunEvent, WebviewBuilder, WebviewUrl,
+    WindowBuilder, WindowEvent,
     menu::{Menu, MenuItem, PredefinedMenuItem},
     tray::TrayIconBuilder,
 };
@@ -47,8 +45,6 @@ use tauri_plugin_dialog::DialogExt;
 use url::Url;
 use utils::app_emit;
 
-use crate::client::cleanup_and_exit;
-
 mod client;
 mod collections;
 mod download_manager;
@@ -59,7 +55,6 @@ mod remote;
 mod settings;
 
 use client::*;
-use collections::*;
 use download_manager::*;
 use downloads::*;
 use games::*;
@@ -67,14 +62,6 @@ use process::*;
 use remote::*;
 use settings::*;
 
-#[derive(Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AppState {
-    status: AppStatus,
-    user: Option<User>,
-    games: HashMap<String, Game>,
-}
-
 async fn setup(handle: AppHandle) -> AppState {
     let logfile = FileAppender::builder()
         .encoder(Box::new(PatternEncoder::new(
@@ -106,8 +93,6 @@ async fn setup(handle: AppHandle) -> AppState {
 
     log4rs::init_config(config).expect("Failed to initialise log4rs");
 
-    let games = HashMap::new();
-
     ProcessManagerWrapper::init(handle.clone());
     DownloadManagerWrapper::init(handle.clone());
 
@@ -120,7 +105,6 @@ async fn setup(handle: AppHandle) -> AppState {
         return AppState {
             status: AppStatus::NotConfigured,
             user: None,
-            games,
         };
     }
 
@@ -182,7 +166,6 @@ async fn setup(handle: AppHandle) -> AppState {
     AppState {
         status: app_status,
         user,
-        games,
     }
 }
 
@@ -204,6 +187,8 @@ pub fn custom_panic_handler(e: &PanicHookInfo) -> Option<()> {
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    // let global_span = span!(Level::TRACE, "global_span");
+    // let _enter = global_span.enter();
     std::panic::set_hook(Box::new(|e| {
         let _ = custom_panic_handler(e);
         println!("{e}");
@@ -243,6 +228,7 @@ pub fn run() {
             use_remote,
             gen_drop_url,
             fetch_drop_object,
+            check_online,
             // Library
             fetch_library,
             fetch_game,
@@ -252,13 +238,6 @@ pub fn run() {
             fetch_game_status,
             fetch_game_version_options,
             update_game_configuration,
-            // Collections
-            fetch_collections,
-            fetch_collection,
-            create_collection,
-            add_game_to_collection,
-            delete_collection,
-            delete_game_in_collection,
             // Downloads
             download_game,
             resume_download,
@@ -272,7 +251,8 @@ pub fn run() {
             kill_game,
             toggle_autostart,
             get_autostart_enabled,
-            open_process_logs
+            open_process_logs,
+            get_launch_options
         ])
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_dialog::init())
@@ -284,10 +264,16 @@ pub fn run() {
             let handle = app.handle().clone();
 
             tauri::async_runtime::block_on(async move {
-                let state = setup(handle).await;
+                let state = setup(handle.clone()).await;
                 info!("initialized drop client");
                 app.manage(Mutex::new(state));
 
+                let global_app_handle = handle;
+                {
+                    let mut app_handle_lock = DROP_APP_HANDLE.lock().await;
+                    app_handle_lock.replace(global_app_handle);
+                };
+
                 {
                     use tauri_plugin_deep_link::DeepLinkExt;
                     let _ = app.deep_link().register_all();
@@ -296,19 +282,26 @@ pub fn run() {
 
                 let handle = app.handle().clone();
 
-                let _main_window = tauri::WebviewWindowBuilder::new(
+                let width = 1536.0;
-                    &handle,
+                let height = 864.0;
-                    "main", // BTW this is not the name of the window, just the label. Keep this 'main', there are permissions & configs that depend on it
+
-                    tauri::WebviewUrl::App("main".into()),
+                let main_window = WindowBuilder::new(&handle, "main")
-                )
                     .title("Drop Desktop App")
                     .min_inner_size(1000.0, 500.0)
-                .inner_size(1536.0, 864.0)
+                    .inner_size(width, height)
                     .decorations(false)
                     .shadow(false)
-                .data_directory(DATA_ROOT_DIR.join(".webview"))
                     .build()
-                .expect("Failed to build main window");
+                    .expect("failed to build main window");
+
+                main_window
+                    .add_child(
+                        WebviewBuilder::new("frontned", WebviewUrl::App("main".into()))
+                            .auto_resize(),
+                        LogicalPosition::new(0., 0.),
+                        LogicalSize::new(width, height),
+                    )
+                    .expect("failed to create frontend webview");
 
                 app.deep_link().on_open_url(move |event| {
                     debug!("handling drop:// url");
@@ -368,7 +361,7 @@ pub fn run() {
                                     .expect("Failed to show window");
                             }
                             "quit" => {
-                                cleanup_and_exit(app);
+                                app.exit(0);
                             }
 
                             _ => {
@@ -408,20 +401,9 @@ pub fn run() {
                 fetch_object_wrapper(request, responder).await;
             });
         })
-        .register_asynchronous_uri_scheme_protocol("server", |ctx, request, responder| {
+        .register_asynchronous_uri_scheme_protocol("server", |_ctx, request, responder| {
-            tauri::async_runtime::block_on(async move {
+            tauri::async_runtime::spawn(async move {
-                let state = ctx
+                handle_server_proto_wrapper(request, responder).await;
-                    .app_handle()
-                    .state::<tauri::State<'_, Mutex<AppState>>>();
-
-                offline!(
-                    state,
-                    handle_server_proto_wrapper,
-                    handle_server_proto_offline_wrapper,
-                    request,
-                    responder
-                )
-                .await;
             });
         })
         .on_window_event(|window, event| {

src-tauri/src/process.rs

@@ -1,41 +1,53 @@
-use std::sync::nonpoison::Mutex;
+use std::sync::Arc;
 
-use process::{PROCESS_MANAGER, error::ProcessError};
+use process::{
+    PROCESS_MANAGER,
+    error::ProcessError,
+    process_manager::{LaunchOption, ProcessManager},
+};
+use serde::Serialize;
 use tauri::AppHandle;
 use tauri_plugin_opener::OpenerExt;
 
-use crate::AppState;
-
 #[tauri::command]
-pub fn launch_game(
+pub fn get_launch_options(id: String) -> Result<Vec<LaunchOption>, ProcessError> {
-    id: String,
+    let launch_options = ProcessManager::get_launch_options(id)?;
-    state: tauri::State<'_, Mutex<AppState>>,
-) -> Result<(), ProcessError> {
-    let state_lock = state.lock();
-    let mut process_manager_lock = PROCESS_MANAGER.lock();
-    //let meta = DownloadableMetadata {
-    //    id,
-    //    version: Some(version),
-    //    download_type: DownloadType::Game,
-    //};
 
-    match process_manager_lock.launch_process(id) {
+    Ok(launch_options)
-        Ok(()) => {}
-        Err(e) => return Err(e),
 }
 
-    drop(process_manager_lock);
+#[derive(Serialize)]
-    drop(state_lock);
+#[serde(tag = "result", content = "data")]
+pub enum LaunchResult {
+    Success,
+    InstallRequired(String, String),
+}
 
-    Ok(())
+#[tauri::command]
+pub fn launch_game(id: String, index: usize) -> Result<LaunchResult, ProcessError> {
+    let result = {
+        let mut process_manager_lock = PROCESS_MANAGER.lock();
+
+        process_manager_lock.launch_process(id, index)
+    };
+
+    if let Err(err) = &result
+        && let ProcessError::RequiredDependency(game_id, version_id) = err
+    {
+        return Ok(LaunchResult::InstallRequired(
+            game_id.to_string(),
+            version_id.to_string(),
+        ));
+    }
+
+    result?;
+
+    Ok(LaunchResult::Success)
 }
 
 #[tauri::command]
 pub fn kill_game(game_id: String) -> Result<(), ProcessError> {
-    PROCESS_MANAGER
+    Ok(PROCESS_MANAGER.lock().kill_game(game_id)?)
-        .lock()
-        .kill_game(game_id)
-        .map_err(ProcessError::IOError)
 }
 
 #[tauri::command]
@@ -46,5 +58,5 @@ pub fn open_process_logs(game_id: String, app_handle: AppHandle) -> Result<(), P
     app_handle
         .opener()
         .open_path(dir.display().to_string(), None::<&str>)
-        .map_err(ProcessError::OpenerError)
+        .map_err(|v| ProcessError::OpenerError(Arc::new(v)))
 }

src-tauri/tauri.conf.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://schema.tauri.app/config/2.0.0",
   "productName": "Drop Desktop Client",
-  "version": "0.3.4",
+  "version": "0.4.0",
-  "identifier": "dev.drop.client",
+  "identifier": "org.droposs.client",
   "build": {
     "beforeDevCommand": "pnpm run -C main dev --port 1432",
     "devUrl": "http://localhost:1432/",

src-tauri/utils/src/download_manager_send.rs

@@ -1,7 +1,7 @@
 #[macro_export]
 macro_rules! send {
     ($download_manager:expr, $signal:expr) => {
-        $download_manager.send($signal).unwrap_or_else(|_| {
+        $download_manager.send($signal).await.unwrap_or_else(|_| {
             panic!(
                 "Failed to send signal {} to the download manager",
                 stringify!(signal)