chore: Add test.yml workflow

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

.github/workflows/release.yml

@@ -0,0 +1,70 @@
+name: 'publish'
+
+on:
+  workflow_dispatch: {}
+  release:
+    types: [published]
+  # This can be used to automatically publish nightlies at UTC nighttime
+#  schedule:
+#    - cron: "0 2 * * *" # run at 2 AM UTC
+
+# This workflow will trigger on each push to the `release` branch to create or update a GitHub release, build your app, and upload the artifacts to the release.
+
+jobs:
+  publish-tauri:
+    permissions:
+      contents: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: 'macos-latest' # for Arm based macs (M1 and above).
+            args: '--target aarch64-apple-darwin'
+          - platform: 'macos-latest' # for Intel based macs.
+            args: '--target x86_64-apple-darwin'
+          - platform: 'ubuntu-24.04' # for Tauri v1 you could replace this with ubuntu-20.04.
+            args: ''
+          - platform: 'ubuntu-24.04-arm'
+            args: '--target aarch64-unknown-linux-gnu'
+          - platform: 'windows-latest'
+            args: ''
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+
+      - name: install Rust nightly
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          # Those targets are only used on macos runners so it's in an `if` to slightly speed up windows and linux builds.
+          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
+
+      - name: install dependencies (ubuntu only)
+        if: matrix.platform == 'ubuntu-22.04' # This must match the platform value defined above.
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.0-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libgtk2.0-dev libsoup3.0-dev
+        # webkitgtk 4.0 is for Tauri v1 - webkitgtk 4.1 is for Tauri v2.
+        # You can remove the one that doesn't apply to your app to speed up the workflow a bit.
+
+      - name: install frontend dependencies
+        run: yarn install # change this to npm, pnpm or bun depending on which one you use.
+
+      - uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tagName: v__VERSION__ # the action automatically replaces \_\_VERSION\_\_ with the app version.
+          releaseName: 'Auto-release v__VERSION__'
+          releaseBody: 'See the assets to download this version and install. This release was created automatically.'
+          releaseDraft: false
+          prerelease: true
+          args: ${{ matrix.args }}

.github/workflows/test.yml

@@ -0,0 +1,69 @@
+name: 'test'
+
+on:
+  workflow_dispatch: {}
+
+  # This can be used to automatically publish nightlies at UTC nighttime
+#  schedule:
+#    - cron: "0 2 * * *" # run at 2 AM UTC
+
+# This workflow will trigger on each push to the `release` branch to create or update a GitHub release, build your app, and upload the artifacts to the release.
+
+jobs:
+  publish-tauri:
+    permissions:
+      contents: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: 'macos-latest' # for Arm based macs (M1 and above).
+            args: '--target aarch64-apple-darwin'
+          - platform: 'macos-latest' # for Intel based macs.
+            args: '--target x86_64-apple-darwin'
+          - platform: 'ubuntu-24.04' # for Tauri v1 you could replace this with ubuntu-20.04.
+            args: ''
+          - platform: 'ubuntu-24.04-arm'
+            args: '--target aarch64-unknown-linux-gnu'
+          - platform: 'windows-latest'
+            args: ''
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+
+      - name: install Rust nightly
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          # Those targets are only used on macos runners so it's in an `if` to slightly speed up windows and linux builds.
+          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
+
+      - name: install dependencies (ubuntu only)
+        if: matrix.platform == 'ubuntu-22.04' # This must match the platform value defined above.
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libgtk2.0-dev libsoup3.0-dev
+        # webkitgtk 4.0 is for Tauri v1 - webkitgtk 4.1 is for Tauri v2.
+        # You can remove the one that doesn't apply to your app to speed up the workflow a bit.
+
+      - name: install frontend dependencies
+        run: yarn install # change this to npm, pnpm or bun depending on which one you use.
+
+      - uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tagName: v__VERSION__ # the action automatically replaces \_\_VERSION\_\_ with the app version.
+          releaseName: 'Auto testing release'
+          releaseBody: 'See the assets to download this version and install. This release was created automatically.'
+          releaseDraft: false
+          prerelease: true
+          args: ${{ matrix.args }}

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "drop-base"]
+	path = drop-base
+	url = https://github.com/drop-oss/drop-base
+[submodule "src-tauri/tailscale/libtailscale"]
+	path = src-tauri/tailscale/libtailscale
+	url = https://github.com/tailscale/libtailscale.git
+[submodule "src-tauri/umu/umu-launcher"]
+	path = src-tauri/umu/umu-launcher
+	url = https://github.com/Open-Wine-Components/umu-launcher.git

components/GameOptions/Launch.vue

@@ -0,0 +1,31 @@
+<template>
+  <div>
+    <label for="launch" class="block text-sm/6 font-medium text-zinc-100"
+      >Launch string template</label
+    >
+    <div class="mt-2">
+      <input
+        type="text"
+        name="launch"
+        id="launch"
+        class="block w-full rounded-md bg-zinc-800 px-3 py-1.5 text-base text-zinc-100 outline-1 -outline-offset-1 outline-zinc-800 placeholder:text-zinc-400 focus:outline-2 focus:-outline-offset-2 focus:outline-blue-600 sm:text-sm/6"
+        placeholder="{}"
+        aria-describedby="launch-description"
+        v-model="model!!.launchString"
+      />
+    </div>
+    <p class="mt-2 text-sm text-zinc-400" id="launch-description">
+      Override the launch string. Passed to system's default shell, and replaces
+      "{}" with the command to start the game.
+      <span class="font-semibold text-zinc-200"
+        >Leaving it blank will cause the game not to start.</span
+      >
+    </p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { FrontendGameConfiguration } from "~/composables/game";
+
+const model = defineModel<FrontendGameConfiguration>();
+</script>

components/GameOptionsModal.vue

@@ -0,0 +1,122 @@
+<template>
+  <ModalTemplate size-class="max-w-4xl" v-model="open">
+    <template #default>
+      <div class="flex flex-row gap-x-4">
+        <nav class="flex flex-1 flex-col" aria-label="Sidebar">
+          <ul role="list" class="-mx-2 space-y-1">
+            <li v-for="(tab, tabIdx) in tabs" :key="tab.name">
+              <button
+                @click="() => (currentTabIndex = tabIdx)"
+                :class="[
+                  tabIdx == currentTabIndex
+                    ? 'bg-zinc-800 text-zinc-100'
+                    : 'text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100',
+                  'transition w-full group flex gap-x-3 rounded-md p-2 text-sm/6 font-semibold',
+                ]"
+              >
+                <component
+                  :is="tab.icon"
+                  :class="[
+                    tabIdx == currentTabIndex
+                      ? 'text-zinc-100'
+                      : 'text-gray-400 group-hover:text-zinc-100',
+                    'size-6 shrink-0',
+                  ]"
+                  aria-hidden="true"
+                />
+                {{ tab.name }}
+              </button>
+            </li>
+          </ul>
+        </nav>
+        <div class="border-l-2 border-zinc-800 w-full grow pl-4">
+          <component
+            v-model="configuration"
+            :is="tabs[currentTabIndex]?.page"
+          />
+        </div>
+      </div>
+      <div v-if="saveError" class="mt-5 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">
+              {{ saveError }}
+            </h3>
+          </div>
+        </div>
+      </div>
+    </template>
+    <template #buttons>
+      <LoadingButton
+        @click="() => save()"
+        :loading="saveLoading"
+        type="submit"
+        class="ml-2 w-full sm:w-fit"
+      >
+        Save
+      </LoadingButton>
+      <button
+        @click="() => (open = false)"
+        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"
+        ref="cancelButtonRef"
+      >
+        Cancel
+      </button>
+    </template>
+  </ModalTemplate>
+</template>
+
+<script setup lang="ts">
+import type { Component } from "vue";
+import {
+  RocketLaunchIcon,
+  ServerIcon,
+  TrashIcon,
+  XCircleIcon,
+} from "@heroicons/vue/20/solid";
+import Launch from "./GameOptions/Launch.vue";
+import type { FrontendGameConfiguration } from "~/composables/game";
+import { invoke } from "@tauri-apps/api/core";
+
+const open = defineModel<boolean>();
+const props = defineProps<{ gameId: string }>();
+const game = await useGame(props.gameId);
+
+const configuration: Ref<FrontendGameConfiguration> = ref({
+  launchString: game.version!!.launchCommandTemplate,
+});
+
+const tabs: Array<{ name: string; icon: Component; page: Component }> = [
+  {
+    name: "Launch",
+    icon: RocketLaunchIcon,
+    page: Launch,
+  },
+  {
+    name: "Storage",
+    icon: ServerIcon,
+    page: h("div"),
+  },
+];
+const currentTabIndex = ref(0);
+
+const saveLoading = ref(false);
+const saveError = ref<undefined | string>();
+async function save() {
+  saveLoading.value = true;
+  try {
+    await invoke("update_game_configuration", {
+      gameId: game.game.id,
+      options: configuration.value,
+    });
+    open.value = false;
+  } catch (e) {
+    saveError.value = (e as unknown as string).toString();
+  }
+  saveLoading.value = false;
+}
+</script>

components/GameStatusButton.vue

@@ -1,32 +1,76 @@
 <template>
+  <!-- Do not add scale animations to this: https://stackoverflow.com/a/35683068 -->
   <div class="inline-flex divide-x divide-zinc-900">
-    <button type="button" @click="() => buttonActions[props.status.type]()" :class="[
+    <button
+      type="button"
+      @click="() => buttonActions[props.status.type]()"
+      :class="[
         styles[props.status.type],
         showDropdown ? 'rounded-l-md' : 'rounded-md',
         'inline-flex uppercase font-display items-center gap-x-2 px-4 py-3 text-md font-semibold shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
-    ]">
+      ]"
-      <component :is="buttonIcons[props.status.type]" class="-mr-0.5 size-5" aria-hidden="true" />
+    >
+      <component
+        :is="buttonIcons[props.status.type]"
+        class="-mr-0.5 size-5"
+        aria-hidden="true"
+      />
       {{ buttonNames[props.status.type] }}
     </button>
-    <Menu v-if="showDropdown" as="div" class="relative inline-block text-left grow">
+    <Menu
+      v-if="showDropdown"
+      as="div"
+      class="relative inline-block text-left grow"
+    >
       <div class="h-full">
-        <MenuButton :class="[
+        <MenuButton
+          :class="[
             styles[props.status.type],
-          'inline-flex w-full h-full justify-center items-center rounded-r-md px-1 py-2 text-sm font-semibold shadow-sm'
+            'inline-flex w-full h-full justify-center items-center rounded-r-md px-1 py-2 text-sm font-semibold shadow-sm group',
-        ]">
+            'focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
+          ]"
+        >
           <ChevronDownIcon class="size-5" aria-hidden="true" />
         </MenuButton>
       </div>
 
-      <transition enter-active-class="transition ease-out duration-100" enter-from-class="transform opacity-0 scale-95"
+      <transition
-        enter-to-class="transform opacity-100 scale-100" leave-active-class="transition ease-in duration-75"
+        enter-active-class="transition ease-out duration-100"
-        leave-from-class="transform opacity-100 scale-100" leave-to-class="transform opacity-0 scale-95">
+        enter-from-class="transform opacity-0 scale-95"
+        enter-to-class="transform opacity-100 scale-100"
+        leave-active-class="transition ease-in duration-75"
+        leave-from-class="transform opacity-100 scale-100"
+        leave-to-class="transform opacity-0 scale-95"
+      >
         <MenuItems
-          class="absolute right-0 z-50 mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none">
+          class="absolute right-0 z-[500] mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none"
+        >
           <div class="py-1">
             <MenuItem v-slot="{ active }">
-            <button @click="() => emit('uninstall')"
+              <button
-              :class="[active ? 'bg-zinc-800 text-zinc-100 outline-none' : 'text-zinc-400', 'w-full block px-4 py-2 text-sm inline-flex justify-between']">Uninstall
+                @click="() => emit('options')"
+                :class="[
+                  active
+                    ? 'bg-zinc-800 text-zinc-100 outline-none'
+                    : 'text-zinc-400',
+                  'w-full block px-4 py-2 text-sm inline-flex justify-between',
+                ]"
+              >
+                Options
+                <Cog6ToothIcon class="size-5" />
+              </button>
+            </MenuItem>
+            <MenuItem v-slot="{ active }">
+              <button
+                @click="() => emit('uninstall')"
+                :class="[
+                  active
+                    ? 'bg-zinc-800 text-zinc-100 outline-none'
+                    : 'text-zinc-400',
+                  'w-full block px-4 py-2 text-sm inline-flex justify-between',
+                ]"
+              >
+                Uninstall
                 <TrashIcon class="size-5" />
               </button>
             </MenuItem>
@@ -43,13 +87,13 @@ import {
   ChevronDownIcon,
   PlayIcon,
   QueueListIcon,
-  TrashIcon,
   WrenchIcon,
 } from "@heroicons/vue/20/solid";
 
 import type { Component } from "vue";
 import { GameStatusEnum, type GameStatus } from "~/types.js";
-import { Menu, MenuButton, MenuItem, MenuItems } from '@headlessui/vue'
+import { Menu, MenuButton, MenuItem, MenuItems } from "@headlessui/vue";
+import { Cog6ToothIcon, TrashIcon } from "@heroicons/vue/24/outline";
 
 const props = defineProps<{ status: GameStatus }>();
 const emit = defineEmits<{
@@ -58,19 +102,32 @@ const emit = defineEmits<{
   (e: "queue"): void;
   (e: "uninstall"): void;
   (e: "kill"): void;
+  (e: "options"): void;
 }>();
 
-const showDropdown = computed(() => props.status.type === GameStatusEnum.Installed || props.status.type === GameStatusEnum.SetupRequired);
+const showDropdown = computed(
+  () =>
+    props.status.type === GameStatusEnum.Installed ||
+    props.status.type === GameStatusEnum.SetupRequired
+);
 
 const styles: { [key in GameStatusEnum]: string } = {
-  [GameStatusEnum.Remote]: "bg-blue-600 text-white hover:bg-blue-500 focus-visible:outline-blue-600",
+  [GameStatusEnum.Remote]:
-  [GameStatusEnum.Queued]: "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700",
+    "bg-blue-600 text-white hover:bg-blue-500 focus-visible:outline-blue-600 hover:bg-blue-500",
-  [GameStatusEnum.Downloading]: "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700",
+  [GameStatusEnum.Queued]:
-  [GameStatusEnum.SetupRequired]: "bg-yellow-600 text-white hover:bg-yellow-500 focus-visible:outline-yellow-600",
+    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
-  [GameStatusEnum.Installed]: "bg-green-600 text-white hover:bg-green-500 focus-visible:outline-green-600",
+  [GameStatusEnum.Downloading]:
-  [GameStatusEnum.Updating]: "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700",
+    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
-  [GameStatusEnum.Uninstalling]: "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700",
+  [GameStatusEnum.SetupRequired]:
-  [GameStatusEnum.Running]: "bg-zinc-800 text-white focus-visible:outline-zinc-700"
+    "bg-yellow-600 text-white hover:bg-yellow-500 focus-visible:outline-yellow-600 hover:bg-yellow-500",
+  [GameStatusEnum.Installed]:
+    "bg-green-600 text-white hover:bg-green-500 focus-visible:outline-green-600 hover:bg-green-500",
+  [GameStatusEnum.Updating]:
+    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
+  [GameStatusEnum.Uninstalling]:
+    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
+  [GameStatusEnum.Running]:
+    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
 };
 
 const buttonNames: { [key in GameStatusEnum]: string } = {
@@ -81,7 +138,7 @@ const buttonNames: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Installed]: "Play",
   [GameStatusEnum.Updating]: "Updating",
   [GameStatusEnum.Uninstalling]: "Uninstalling",
-  [GameStatusEnum.Running]: "Stop"
+  [GameStatusEnum.Running]: "Stop",
 };
 
 const buttonIcons: { [key in GameStatusEnum]: Component } = {
@@ -92,7 +149,7 @@ const buttonIcons: { [key in GameStatusEnum]: Component } = {
   [GameStatusEnum.Installed]: PlayIcon,
   [GameStatusEnum.Updating]: ArrowDownTrayIcon,
   [GameStatusEnum.Uninstalling]: TrashIcon,
-  [GameStatusEnum.Running]: PlayIcon
+  [GameStatusEnum.Running]: PlayIcon,
 };
 
 const buttonActions: { [key in GameStatusEnum]: () => void } = {
@@ -102,7 +159,7 @@ const buttonActions: { [key in GameStatusEnum]: () => void } = {
   [GameStatusEnum.SetupRequired]: () => emit("launch"),
   [GameStatusEnum.Installed]: () => emit("launch"),
   [GameStatusEnum.Updating]: () => emit("queue"),
-  [GameStatusEnum.Uninstalling]: () => { },
+  [GameStatusEnum.Uninstalling]: () => {},
-  [GameStatusEnum.Running]: () => emit("kill")
+  [GameStatusEnum.Running]: () => emit("kill"),
 };
 </script>

components/Header.vue

@@ -11,7 +11,7 @@
               v-for="(nav, navIdx) in navigation"
               :class="[
                 'transition  uppercase font-display font-semibold text-md',
-                navIdx === currentPageIndex
+                navIdx === currentNavigation
                   ? 'text-zinc-100'
                   : 'text-zinc-400 hover:text-zinc-200',
               ]"
@@ -28,9 +28,7 @@
       />
       <div class="inline-flex items-center">
         <ol class="inline-flex gap-3">
-          <HeaderQueueWidget
+          <HeaderQueueWidget :object="currentQueueObject" />
-            :object="currentQueueObject"
-          />
           <li v-for="(item, itemIdx) in quickActions">
             <HeaderWidget
               @click="item.action"
@@ -39,21 +37,23 @@
               <component class="h-5" :is="item.icon" />
             </HeaderWidget>
           </li>
+          <OfflineHeaderWidget v-if="state.status === AppStatus.Offline" />
           <HeaderUserWidget />
         </ol>
       </div>
     </div>
-    <WindowControl class="h-16 w-16 p-4" />
+    <WindowControl  />
   </div>
 </template>
 
 <script setup lang="ts">
 import { BellIcon, UserGroupIcon } from "@heroicons/vue/16/solid";
-import type { NavigationItem, QuickActionNav } from "../types";
+import { AppStatus, type NavigationItem, type QuickActionNav } from "../types";
 import HeaderWidget from "./HeaderWidget.vue";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 
 const window = getCurrentWindow();
+const state = useAppState();
 
 const navigation: Array<NavigationItem> = [
   {
@@ -78,7 +78,7 @@ const navigation: Array<NavigationItem> = [
   },
 ];
 
-const currentPageIndex = useCurrentNavigationIndex(navigation);
+const { currentNavigation } = useCurrentNavigationIndex(navigation);
 
 const quickActions: Array<QuickActionNav> = [
   {

components/HeaderButton.vue

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

components/HeaderUserWidget.vue

@@ -49,7 +49,10 @@
                 Admin Dashboard
               </a>
             </MenuItem>
-            <MenuItem v-for="(nav, navIdx) in navigation" v-slot="{ active, close }">
+            <MenuItem
+              v-for="(nav, navIdx) in navigation"
+              v-slot="{ active, close }"
+            >
               <button
                 @click="() => navigate(close, nav)"
                 :href="nav.route"
@@ -58,8 +61,8 @@
                   'transition text-left block px-4 py-2 text-sm',
                 ]"
               >
-                {{ nav.label }}</button
+                {{ nav.label }}
-              >
+              </button>
             </MenuItem>
           </div>
         </PanelWidget>
@@ -80,27 +83,22 @@ const open = ref(false);
 const router = useRouter();
 router.afterEach(() => {
   open.value = false;
-})
+});
 
 const state = useAppState();
-const profilePictureUrl: string = await invoke("gen_drop_url", {
+const profilePictureUrl: string = await useObject(
-  path: `/api/v1/object/${state.value.user?.profilePicture}`,
+  state.value.user?.profilePictureObjectId ?? ""
-});
+);
 const adminUrl: string = await invoke("gen_drop_url", {
   path: "/admin",
 });
 
-function navigate(close: () => any, to: NavigationItem){
+function navigate(close: () => any, to: NavigationItem) {
   close();
   router.push(to.route);
 }
 
 const navigation: NavigationItem[] = [
-  {
-    label: "Account settings",
-    route: "/account",
-    prefix: "",
-  },
   {
     label: "App settings",
     route: "/settings",
@@ -110,6 +108,6 @@ const navigation: NavigationItem[] = [
     label: "Quit Drop",
     route: "/quit",
     prefix: "",
-  }
+  },
-]
+];
 </script>

components/InitiateAuthModule.vue

@@ -126,6 +126,7 @@ import { invoke } from "@tauri-apps/api/core";
 const loading = ref(false);
 const error = ref<string | undefined>();
 
+let offerManualTimeout: NodeJS.Timeout | undefined;
 const offerManual = ref(false);
 const manualToken = ref("");
 const manualLoading = ref(false);
@@ -135,14 +136,16 @@ async function auth() {
 }
 
 function authWrapper_wrapper() {
+  error.value = undefined;
   loading.value = true;
   auth().catch((e) => {
     loading.value = false;
     error.value = e;
+    if (offerManualTimeout) clearTimeout(offerManualTimeout);
   });
-  setTimeout(() => {
+  offerManualTimeout = setTimeout(() => {
     offerManual.value = true;
-  }, 10000);
+  }, 2000);
 }
 
 async function continueManual() {

components/LibrarySearch.vue

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

components/OfflineHeaderWidget.vue

@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import { ArrowDownTrayIcon, CloudIcon } from "@heroicons/vue/20/solid";
+</script>
+
+<template>
+  <div
+    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">
+      <CloudIcon class="h-5 z-50 text-zinc-500" />
+      <div
+        class="absolute rounded-full left-1/2 top-1/2 -translate-y-[45%] -translate-x-1/2 w-[2px] h-6 rotate-[45deg] bg-zinc-400 z-50"
+      />
+    </div>
+    Offline
+  </div>
+</template>

components/WindowControl.vue

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

composables/current-page-engine.ts

@@ -26,5 +26,7 @@ export const useCurrentNavigationIndex = (
     currentNavigation.value = calculateCurrentNavIndex(to);
   });
 
-  return currentNavigation;
+  return {currentNavigation, recalculateNavigation: () => {
+    currentNavigation.value = calculateCurrentNavIndex(route);
+  }};
 };

composables/game.ts

@@ -1,8 +1,9 @@
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
-import type { Game, GameStatus, GameStatusEnum } from "~/types";
+import type { Game, GameStatus, GameStatusEnum, GameVersion } from "~/types";
 
-const gameRegistry: { [key: string]: Game } = {};
+const gameRegistry: { [key: string]: { game: Game; version?: GameVersion } } =
+  {};
 
 const gameStatusRegistry: { [key: string]: Ref<GameStatus> } = {};
 
@@ -31,27 +32,44 @@ export const parseStatus = (status: SerializedGameStatus): GameStatus => {
 
 export const useGame = async (gameId: string) => {
   if (!gameRegistry[gameId]) {
-    const data: { game: Game; status: SerializedGameStatus } = await invoke(
+    const data: {
-      "fetch_game",
+      game: Game;
-      {
+      status: SerializedGameStatus;
+      version?: GameVersion;
+    } = await invoke("fetch_game", {
       gameId,
-      }
+    });
-    );
+    gameRegistry[gameId] = { game: data.game, version: data.version };
-    gameRegistry[gameId] = data.game;
     if (!gameStatusRegistry[gameId]) {
       gameStatusRegistry[gameId] = ref(parseStatus(data.status));
 
       listen(`update_game/${gameId}`, (event) => {
         const payload: {
           status: SerializedGameStatus;
+          version?: GameVersion;
         } = event.payload as any;
         console.log(payload.status);
         gameStatusRegistry[gameId].value = parseStatus(payload.status);
+        
+        /**
+         * I am not super happy about this.
+         * 
+         * This will mean that we will still have a version assigned if we have a game installed then uninstall it.
+         * It is necessary because a flag to check if we should overwrite seems excessive, and this function gets called
+         * on transient state updates. 
+         */
+        if (payload.version) {
+          gameRegistry[gameId].version = payload.version;
+        }
       });
     }
   }
 
   const game = gameRegistry[gameId];
   const status = gameStatusRegistry[gameId];
-  return { game, status };
+  return { ...game, status };
+};
+
+export type FrontendGameConfiguration = {
+  launchString: string;
 };

error.vue

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

layouts/default.vue

@@ -1,9 +1,79 @@
 <template>
-  <div class="flex flex-col bg-zinc-900 overflow-hidden">
+  <div class="flex flex-col bg-zinc-900 overflow-hidden h-screen">
+    <NuxtErrorBoundary>
       <Header class="select-none" />
       <div class="relative grow overflow-y-auto">
         <slot />
       </div>
+      <template #error="{ error }">
+        <MiniHeader />
+        <div class="relative grow overflow-y-auto bg-zinc-950">
+          <div
+            class="grid min-h-full grid-cols-1 grid-rows-[1fr,auto,1fr] lg:grid-cols-[max(50%,36rem),1fr]"
+          >
+            <header
+              class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
+            >
+              <Logo class="h-10 w-auto sm:h-12" />
+            </header>
+            <main
+              class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"
+            >
+              <div class="max-w-lg">
+                <h1
+                  class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
+                >
+                  Unrecoverable error
+                </h1>
+                <p class="mt-6 text-base leading-7 text-zinc-400">
+                  Drop encountered an error that it couldn't handle. Please
+                  restart the application and file a bug report.
+                </p>
+                <p class="mt-3 text-sm font-monospace text-zinc-500">
+                  Error: {{ error }}
+                </p>
+              </div>
+            </main>
+            <footer
+              class="self-end lg:col-span-2 lg:col-start-1 lg:row-start-3"
+            >
+              <div class="border-t border-blue-600 bg-zinc-900 py-10">
+                <nav
+                  class="mx-auto flex w-full max-w-7xl items-center gap-x-4 px-6 text-sm leading-7 text-zinc-400 lg:px-8"
+                >
+                  <a href="#">Documentation</a>
+                  <svg
+                    viewBox="0 0 2 2"
+                    aria-hidden="true"
+                    class="h-0.5 w-0.5 fill-zinc-700"
+                  >
+                    <circle cx="1" cy="1" r="1" />
+                  </svg>
+                  <a href="#">Troubleshooting</a>
+                  <svg
+                    viewBox="0 0 2 2"
+                    aria-hidden="true"
+                    class="h-0.5 w-0.5 fill-zinc-700"
+                  >
+                    <circle cx="1" cy="1" r="1" />
+                  </svg>
+                  <NuxtLink to="/setup/server">Switch instance</NuxtLink>
+                </nav>
+              </div>
+            </footer>
+            <div
+              class="hidden lg:relative lg:col-start-2 lg:row-start-1 lg:row-end-4 lg:block"
+            >
+              <img
+                src="@/assets/wallpaper.jpg"
+                alt=""
+                class="absolute inset-0 h-full w-full object-cover"
+              />
+            </div>
+          </div>
+        </div>
+      </template>
+    </NuxtErrorBoundary>
   </div>
 </template>
 

layouts/mini.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="flex flex-col bg-zinc-950 overflow-hidden">
+  <div class="flex flex-col bg-zinc-950 overflow-hidden h-screen">
     <MiniHeader />
     <div class="relative grow overflow-y-auto">
       <slot />

nuxt.config.ts

@@ -13,5 +13,5 @@ export default defineNuxtConfig({
 
   ssr: false,
 
-  extends: [["github:drop-oss/drop-base"]],
+  extends: [["./drop-base"]],
 });

package.json

@@ -1,7 +1,7 @@
 {
   "name": "drop-app",
   "private": true,
-  "version": "0.2.0-beta",
+  "version": "0.3.0-rc-3",
   "type": "module",
   "scripts": {
     "build": "nuxt build",
@@ -19,9 +19,11 @@
     "@tauri-apps/plugin-deep-link": "~2",
     "@tauri-apps/plugin-dialog": "^2.0.1",
     "@tauri-apps/plugin-os": "~2",
-    "@tauri-apps/plugin-shell": ">=2.0.0",
+    "@tauri-apps/plugin-shell": "^2.2.1",
+    "koa": "^2.16.1",
     "markdown-it": "^14.1.0",
-    "nuxt": "^3.13.0",
+    "micromark": "^4.0.1",
+    "nuxt": "^3.16.0",
     "scss": "^0.2.4",
     "vue": "latest",
     "vue-router": "latest",
@@ -35,7 +37,9 @@
     "autoprefixer": "^10.4.20",
     "postcss": "^8.4.47",
     "sass-embedded": "^1.79.4",
-    "tailwindcss": "^3.4.13"
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.8.3",
+    "vue-tsc": "^2.2.10"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

pages/account.vue

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

pages/error/index.vue

@@ -1,66 +0,0 @@
-<template>
-  <div
-    class="grid min-h-full grid-cols-1 grid-rows-[1fr,auto,1fr] lg:grid-cols-[max(50%,36rem),1fr]"
-  >
-    <header
-      class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
-    >
-      <Logo class="h-10 w-auto sm:h-12" />
-    </header>
-    <main
-      class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"
-    >
-      <div class="max-w-lg">
-        <h1
-          class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
-        >
-          Unrecoverable error
-        </h1>
-        <p class="mt-6 text-base leading-7 text-zinc-400">
-          Drop encountered an error that it couldn't handle. Please restart the
-          application and file a bug report.
-        </p>
-      </div>
-    </main>
-    <footer class="self-end lg:col-span-2 lg:col-start-1 lg:row-start-3">
-      <div class="border-t border-blue-600 bg-zinc-900 py-10">
-        <nav
-          class="mx-auto flex w-full max-w-7xl items-center gap-x-4 px-6 text-sm leading-7 text-zinc-400 lg:px-8"
-        >
-          <a href="#">Documentation</a>
-          <svg
-            viewBox="0 0 2 2"
-            aria-hidden="true"
-            class="h-0.5 w-0.5 fill-zinc-700"
-          >
-            <circle cx="1" cy="1" r="1" />
-          </svg>
-          <a href="#">Troubleshooting</a>
-          <svg
-            viewBox="0 0 2 2"
-            aria-hidden="true"
-            class="h-0.5 w-0.5 fill-zinc-700"
-          >
-            <circle cx="1" cy="1" r="1" />
-          </svg>
-          <NuxtLink to="/setup/server">Switch instance</NuxtLink>
-        </nav>
-      </div>
-    </footer>
-    <div
-      class="hidden lg:relative lg:col-start-2 lg:row-start-1 lg:row-end-4 lg:block"
-    >
-      <img
-        src="@/assets/wallpaper.jpg"
-        alt=""
-        class="absolute inset-0 h-full w-full object-cover"
-      />
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-definePageMeta({
-  layout: "mini",
-});
-</script>

pages/library.vue

@@ -1,78 +1,52 @@
 <template>
   <div class="flex flex-row h-full">
+    <!-- Sidebar -->
     <div
-      class="flex-none max-h-full overflow-y-auto w-64 bg-zinc-950 px-2 py-1"
+      class="flex-none max-h-full overflow-y-auto w-72 bg-zinc-950/50 backdrop-blur-xl px-4 py-3 border-r border-zinc-800/50"
     >
-      <ul class="flex flex-col gap-y-1">
+      <LibrarySearch />
-        <NuxtLink
-          v-for="(nav, navIdx) in navigation"
-          :key="nav.route"
-          :class="[
-            'transition-all duration-200 rounded-lg flex items-center py-1.5 px-3',
-            navIdx === currentNavigationIndex
-              ? 'bg-zinc-800 text-zinc-100'
-              : nav.isInstalled.value
-              ? 'text-zinc-300 hover:bg-zinc-800/90 hover:text-zinc-200'
-              : 'text-zinc-500 hover:bg-zinc-800/70 hover:text-zinc-300',
-          ]"
-          :href="nav.route"
-        >
-          <div class="flex items-center w-full gap-x-3">
-            <img
-              class="size-6 flex-none object-cover bg-zinc-900 rounded"
-              :src="icons[navIdx]"
-              alt=""
-            />
-            <p class="truncate text-sm font-display leading-6 flex-1">
-              {{ nav.label }}
-            </p>
-          </div>
-        </NuxtLink>
-      </ul>
     </div>
     <div class="grow overflow-y-auto">
-      <NuxtPage :libraryDownloadError = "libraryDownloadError" />
+      <NuxtErrorBoundary>
+        <NuxtPage />
+        <template #error="{ error }">
+          <main
+            class="grid min-h-full w-full place-items-center px-6 py-24 sm:py-32 lg:px-8"
+          >
+            <div class="text-center">
+              <p class="text-base font-semibold text-blue-600">Error</p>
+              <h1
+                class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
+              >
+                Failed to load library
+              </h1>
+              <p class="mt-6 text-base leading-7 text-zinc-400">
+                Drop couldn't load your library: "{{ error }}".
+              </p>
+            </div>
+          </main>
+        </template>
+      </NuxtErrorBoundary>
     </div>
   </div>
 </template>
 
-<script setup lang="ts">
+<script setup lang="ts"></script>
-import { invoke } from "@tauri-apps/api/core";
-import { GameStatusEnum, type Game, type NavigationItem } from "~/types";
 
-let libraryDownloadError = false;
+<style scoped>
-
+.list-move,
-async function calculateGames(): Promise<Game[]> {
+.list-enter-active,
-  try {
+.list-leave-active {
-    return await invoke("fetch_library");
+  transition: all 0.3s ease;
-  }
-  catch(e) {
-    libraryDownloadError = true;
-    return new Array();
-  }
 }
 
-const rawGames: Array<Game> = await calculateGames();
+.list-enter-from,
-const games = await Promise.all(rawGames.map((e) => useGame(e.id)));
+.list-leave-to {
-const icons = await Promise.all(
+  opacity: 0;
-  games.map(({ game, status }) => useObject(game.mIconId))
+  transform: translateX(-30px);
-);
+}
 
-const navigation = games.map(({ game, status }) => {
+.list-leave-active {
-  const isInstalled = computed(
+  position: absolute;
-    () =>
+}
-      status.value.type == GameStatusEnum.Installed ||
+</style>
-      status.value.type == GameStatusEnum.SetupRequired
-  );
-
-  const item = {
-    label: game.mName,
-    route: `/library/${game.id}`,
-    prefix: `/library/${game.id}`,
-    isInstalled,
-  };
-  return item;
-});
-
-const currentNavigationIndex = useCurrentNavigationIndex(navigation);
-</script>

pages/library/[id]/index.vue

@@ -1,52 +1,164 @@
 <template>
   <div
-    class="mx-auto w-full relative flex flex-col justify-center pt-64 z-10 overflow-hidden"
+    class="mx-auto w-full relative flex flex-col justify-center pt-72 overflow-hidden"
   >
-    <!-- banner image -->
+    <div class="absolute inset-0 z-0">
-    <div class="absolute flex top-0 h-fit inset-x-0 z-[-20]">
+      <img
-      <img :src="bannerUrl" class="w-full h-auto object-cover" />
+        :src="bannerUrl"
+        class="w-full h-[24rem] object-cover blur-sm scale-105"
+      />
+      <div
+        class="absolute inset-0 bg-gradient-to-t from-zinc-900 via-zinc-900/80 to-transparent opacity-90"
+      />
+      <div
+        class="absolute inset-0 bg-gradient-to-r from-zinc-900/95 via-zinc-900/80 to-transparent opacity-90"
+      />
+    </div>
+
+    <div class="relative z-10">
+      <div class="px-8 pb-4">
         <h1
-        class="absolute inset-x-0 w-fit mx-auto text-center top-32 -translate-y-[50%] text-4xl text-zinc-100 font-bold font-display z-50 p-4 shadow-xl bg-zinc-900/80 rounded-xl"
+          class="text-5xl text-zinc-100 font-bold font-display drop-shadow-lg mb-8"
         >
           {{ game.mName }}
         </h1>
-      <div
+
-        class="absolute inset-0 bg-gradient-to-b from-transparent to-50% to-zinc-900"
+        <div class="flex flex-row gap-x-4 items-stretch mb-8">
-      />
+          <!-- Do not add scale animations to this: https://stackoverflow.com/a/35683068 -->
-    </div>
-    <!-- main page -->
-    <div class="w-full min-h-screen mx-auto bg-zinc-900 px-5 py-6">
-      <!-- game toolbar -->
-      <div class="h-full flex flex-row gap-x-4 items-stretch">
           <GameStatusButton
             @install="() => installFlow()"
             @launch="() => launch()"
             @queue="() => queue()"
             @uninstall="() => uninstall()"
             @kill="() => kill()"
+            @options="() => (configureModalOpen = true)"
             :status="status"
           />
           <a
             :href="remoteUrl"
             target="_blank"
             type="button"
-          class="inline-flex items-center rounded-md bg-zinc-800/50 px-4 font-semibold text-white shadow-sm hover:bg-zinc-800/80 uppercase font-display"
+            class="transition-transform duration-300 hover:scale-105 active:scale-95 inline-flex items-center rounded-md bg-zinc-800/50 px-6 font-semibold text-white shadow-xl backdrop-blur-sm hover:bg-zinc-800/80 uppercase font-display"
           >
             <BuildingStorefrontIcon class="mr-2 size-5" aria-hidden="true" />
-
             Store
           </a>
         </div>
       </div>
+
+      <!-- Main content -->
+      <div class="w-full bg-zinc-900 px-8 py-6">
+        <div class="grid grid-cols-[2fr,1fr] gap-8">
+          <div class="space-y-6">
+            <div class="bg-zinc-800/50 rounded-xl p-6 backdrop-blur-sm">
+              <div
+                v-html="htmlDescription"
+                class="prose prose-invert prose-blue overflow-y-auto custom-scrollbar max-w-none"
+              ></div>
+            </div>
+          </div>
+
+          <div class="space-y-6">
+            <div class="bg-zinc-800/50 rounded-xl p-6 backdrop-blur-sm">
+              <h2 class="text-xl font-display font-semibold text-zinc-100 mb-4">
+                Game Images
+              </h2>
+              <div class="relative">
+                <div v-if="mediaUrls.length > 0">
+                  <div
+                    class="relative aspect-video rounded-lg overflow-hidden cursor-pointer group"
+                  >
+                    <div
+                      class="absolute inset-0"
+                      @click="fullscreenImage = mediaUrls[currentImageIndex]"
+                    >
+                      <TransitionGroup name="slide" tag="div" class="h-full">
+                        <img
+                          v-for="(url, index) in mediaUrls"
+                          :key="url"
+                          :src="url"
+                          class="absolute inset-0 w-full h-full object-cover"
+                          v-show="index === currentImageIndex"
+                        />
+                      </TransitionGroup>
+                    </div>
+
+                    <div
+                      class="absolute inset-0 flex items-center justify-between px-4 opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none"
+                    >
+                      <div class="pointer-events-auto">
+                        <button
+                          v-if="mediaUrls.length > 1"
+                          @click.stop="previousImage()"
+                          class="p-2 rounded-full bg-zinc-900/50 text-zinc-100 hover:bg-zinc-900/80 transition-all duration-300 hover:scale-110"
+                        >
+                          <ChevronLeftIcon class="size-5" />
+                        </button>
+                      </div>
+                      <div class="pointer-events-auto">
+                        <button
+                          v-if="mediaUrls.length > 1"
+                          @click.stop="nextImage()"
+                          class="p-2 rounded-full bg-zinc-900/50 text-zinc-100 hover:bg-zinc-900/80 transition-all duration-300 hover:scale-110"
+                        >
+                          <ChevronRightIcon class="size-5" />
+                        </button>
+                      </div>
+                    </div>
+
+                    <div
+                      class="absolute inset-0 bg-gradient-to-t from-black/50 to-transparent opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none"
+                    />
+                    <div
+                      class="absolute bottom-4 right-4 flex items-center gap-x-2 text-white opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none"
+                    >
+                      <ArrowsPointingOutIcon class="size-5" />
+                      <span class="text-sm font-medium">View Fullscreen</span>
+                    </div>
+                  </div>
+
+                  <div
+                    class="absolute -bottom-2 left-1/2 -translate-x-1/2 flex gap-x-2"
+                  >
+                    <button
+                      v-for="(_, index) in mediaUrls"
+                      :key="index"
+                      @click.stop="currentImageIndex = index"
+                      class="w-1.5 h-1.5 rounded-full transition-all"
+                      :class="[
+                        currentImageIndex === index
+                          ? 'bg-zinc-100 scale-125'
+                          : 'bg-zinc-600 hover:bg-zinc-500',
+                      ]"
+                    />
+                  </div>
+                </div>
+
+                <div
+                  v-else
+                  class="aspect-video rounded-lg overflow-hidden bg-zinc-900/50 flex flex-col items-center justify-center text-center px-4"
+                >
+                  <PhotoIcon class="size-12 text-zinc-500 mb-2" />
+                  <p class="text-zinc-400 font-medium">No images available</p>
+                  <p class="text-zinc-500 text-sm">
+                    Game screenshots will appear here when available
+                  </p>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
   </div>
 
   <ModalTemplate v-model="installFlowOpen">
     <template #default>
       <div class="sm:flex sm:items-start">
         <div class="mt-3 text-center sm:mt-0 sm:text-left">
-          <DialogTitle as="h3" class="text-base font-semibold text-zinc-100"
+          <h3 class="text-base font-semibold text-zinc-100"
             >Install {{ game.mName }}?
-          </DialogTitle>
+          </h3>
           <div class="mt-2">
             <p class="text-sm text-zinc-400">
               Drop will add {{ game.mName }} to the queue to be downloaded.
@@ -238,7 +350,7 @@
       <LoadingButton
         @click="() => install()"
         :disabled="
-          !(versionOptions && versionOptions.length > 0 && !installDir)
+          !(versionOptions && versionOptions.length > 0)
         "
         :loading="installLoading"
         type="submit"
@@ -256,6 +368,74 @@
       </button>
     </template>
   </ModalTemplate>
+
+  <GameOptionsModal v-if="status.type === GameStatusEnum.Installed" v-model="configureModalOpen" :game-id="game.id" />
+
+  <Transition
+    enter="transition ease-out duration-300"
+    enter-from="opacity-0"
+    enter-to="opacity-100"
+    leave="transition ease-in duration-200"
+    leave-from="opacity-100"
+    leave-to="opacity-0"
+  >
+    <div
+      v-if="fullscreenImage"
+      class="fixed inset-0 z-50 bg-black/95 flex items-center justify-center"
+      @click="fullscreenImage = null"
+    >
+      <div
+        class="relative w-full h-full flex items-center justify-center"
+        @click.stop
+      >
+        <button
+          class="absolute top-4 right-4 p-2 rounded-full bg-zinc-900/50 text-zinc-100 hover:bg-zinc-900 transition-colors"
+          @click.stop="fullscreenImage = null"
+        >
+          <XMarkIcon class="size-6" />
+        </button>
+
+        <button
+          v-if="mediaUrls.length > 1"
+          @click.stop="previousImage()"
+          class="absolute left-4 p-3 rounded-full bg-zinc-900/50 text-zinc-100 hover:bg-zinc-900 transition-colors"
+        >
+          <ChevronLeftIcon class="size-6" />
+        </button>
+        <button
+          v-if="mediaUrls.length > 1"
+          @click.stop="nextImage()"
+          class="absolute right-4 p-3 rounded-full bg-zinc-900/50 text-zinc-100 hover:bg-zinc-900 transition-colors"
+        >
+          <ChevronRightIcon class="size-6" />
+        </button>
+
+        <TransitionGroup
+          name="slide"
+          tag="div"
+          class="w-full h-full flex items-center justify-center"
+          @click.stop
+        >
+          <img
+            v-for="(url, index) in mediaUrls"
+            v-show="currentImageIndex === index"
+            :key="url"
+            :src="url"
+            class="max-h-[90vh] max-w-[90vw] object-contain"
+            :alt="`${game.mName} screenshot ${index + 1}`"
+          />
+        </TransitionGroup>
+
+        <div
+          class="absolute bottom-4 left-1/2 -translate-x-1/2 px-4 py-2 rounded-full bg-zinc-900/50 backdrop-blur-sm"
+        >
+          <p class="text-zinc-100 text-sm font-medium">
+            {{ currentImageIndex + 1 }} / {{ mediaUrls.length }}
+          </p>
+        </div>
+      </div>
+    </div>
+  </Transition>
 </template>
 
 <script setup lang="ts">
@@ -274,10 +454,17 @@ import {
   CheckIcon,
   ChevronUpDownIcon,
   WrenchIcon,
+  ChevronLeftIcon,
+  ChevronRightIcon,
+  XMarkIcon,
+  ArrowsPointingOutIcon,
+  PhotoIcon,
 } from "@heroicons/vue/20/solid";
 import { BuildingStorefrontIcon } from "@heroicons/vue/24/outline";
 import { XCircleIcon } from "@heroicons/vue/24/solid";
 import { invoke } from "@tauri-apps/api/core";
+import { micromark } from "micromark";
+import { GameStatusEnum } from "~/types";
 
 const route = useRoute();
 const router = useRouter();
@@ -290,13 +477,24 @@ const remoteUrl: string = await invoke("gen_drop_url", {
   path: `/store/${game.value.id}`,
 });
 
-const bannerUrl = await useObject(game.value.mBannerId);
+const bannerUrl = await useObject(game.value.mBannerObjectId);
+
+// Get all available images
+const mediaUrls = await Promise.all(
+  game.value.mImageCarouselObjectIds.map((id) => useObject(id))
+);
+
+const htmlDescription = micromark(game.value.mDescription);
 
 const installFlowOpen = ref(false);
 const versionOptions = ref<
   undefined | Array<{ versionName: string; platform: string }>
 >();
 const installDirs = ref<undefined | Array<string>>();
+const currentImageIndex = ref(0);
+
+const configureModalOpen = ref(false);
+
 async function installFlow() {
   installFlowOpen.value = true;
   versionOptions.value = undefined;
@@ -319,8 +517,7 @@ const installVersionIndex = ref(0);
 const installDir = ref(0);
 async function install() {
   try {
-    if (!versionOptions.value)
+    if (!versionOptions.value) throw new Error("Versions have not been loaded");
-      throw new Error("Versions have not been loaded");
     installLoading.value = true;
     await invoke("download_game", {
       gameId: game.value.id,
@@ -376,4 +573,61 @@ async function kill() {
     console.error(e);
   }
 }
+
+function nextImage() {
+  currentImageIndex.value = (currentImageIndex.value + 1) % mediaUrls.length;
+}
+
+function previousImage() {
+  currentImageIndex.value =
+    (currentImageIndex.value - 1 + mediaUrls.length) % mediaUrls.length;
+}
+
+const fullscreenImage = ref<string | null>(null);
 </script>
+
+<style scoped>
+.fade-enter-active,
+.fade-leave-active {
+  transition: opacity 0.3s ease;
+}
+
+.fade-enter-from,
+.fade-leave-to {
+  opacity: 0;
+}
+
+.slide-enter-active,
+.slide-leave-active {
+  transition: all 0.3s ease;
+  position: absolute;
+}
+
+.slide-enter-from {
+  opacity: 0;
+  transform: translateX(100%);
+}
+
+.slide-leave-to {
+  opacity: 0;
+  transform: translateX(-100%);
+}
+
+.custom-scrollbar {
+  scrollbar-width: thin;
+  scrollbar-color: rgb(82 82 91) transparent;
+}
+
+.custom-scrollbar::-webkit-scrollbar {
+  width: 6px;
+}
+
+.custom-scrollbar::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.custom-scrollbar::-webkit-scrollbar-thumb {
+  background-color: rgb(82 82 91);
+  border-radius: 3px;
+}
+</style>

pages/library/index.vue

@@ -1,9 +1,19 @@
-<script setup lang="ts">
-const props = defineProps<{ libraryDownloadError: boolean }>();
-</script>
 <template>
-    <div v-if="libraryDownloadError" class="mx-auto pt-10 text-center text-gray-500">
-        Library Failed to update
-    </div>
 
+    <div class="h-full flex flex-col items-center justify-center">
+        <div class="text-center">
+            <div class="flex flex-col items-center gap-y-4">
+                <div class="p-4 rounded-xl bg-zinc-700/50 backdrop-blur-sm">
+                    <RocketLaunchIcon class="size-12 text-zinc-400" />
+                </div>
+                <div>
+                    <h3 class="text-xl font-display font-semibold text-zinc-100">Select a game</h3>
+                    <p class="mt-1 text-sm text-zinc-400">Choose a game from your library to view details</p>
+                </div>
+            </div>
+        </div>
+    </div>
 </template>
+<script setup lang="ts">
+import { RocketLaunchIcon } from '@heroicons/vue/24/outline';
+</script>

pages/queue.vue

@@ -158,7 +158,7 @@ function loadGamesForQueue(v: typeof queue.value) {
     if (games.value[id]) return;
     (async () => {
       const gameData = await useGame(id);
-      const cover = await useObject(gameData.game.mCoverId);
+      const cover = await useObject(gameData.game.mCoverObjectId);
       games.value[id] = { ...gameData, cover };
     })();
   }
@@ -167,7 +167,7 @@ function loadGamesForQueue(v: typeof queue.value) {
 loadGamesForQueue(queue.value);
 
 async function onEnd(event: { oldIndex: number; newIndex: number }) {
-  await invoke("move_game_in_queue", {
+  await invoke("move_download_in_queue", {
     oldIndex: event.oldIndex,
     newIndex: event.newIndex,
   });

pages/settings.vue

@@ -10,13 +10,13 @@
         <ul role="list" class="-mx-2 space-y-1">
           <li v-for="(item, itemIdx) in navigation" :key="item.prefix">
             <NuxtLink :href="item.route" :class="[
-              itemIdx === currentPageIndex
+              itemIdx === currentNavigation
                 ? 'bg-zinc-800/50 text-zinc-100'
                 : 'text-zinc-400 hover:bg-zinc-800/30 hover:text-zinc-200',
               'transition group flex gap-x-3 rounded-md p-2 pr-12 text-sm font-semibold leading-6',
             ]">
               <component :is="item.icon" :class="[
-                itemIdx === currentPageIndex
+                itemIdx === currentNavigation
                   ? 'text-zinc-100'
                   : 'text-zinc-400 group-hover:text-zinc-200',
                 'transition h-6 w-6 shrink-0',
@@ -45,6 +45,7 @@ import type { Component } from "vue";
 import type { NavigationItem } from "~/types";
 import { platform } from '@tauri-apps/plugin-os';
 import { invoke } from "@tauri-apps/api/core";
+import { UserIcon } from "@heroicons/vue/20/solid";
 
 const systemData = await invoke<{
   clientId: string;
@@ -101,6 +102,12 @@ const navigation = computed(() => [
     prefix: "/settings/downloads",
     icon: ArrowDownTrayIcon,
   },
+  {
+    label: "Account",
+    route: "/settings/account",
+    prefix: "/settings/account",
+    icon: UserIcon
+  },
   ...(isDebugMode.value ? [{
     label: "Debug Info",
     route: "/settings/debug", 
@@ -112,10 +119,10 @@ const navigation = computed(() => [
 const currentPlatform = platform();
 
 // Use .value to unwrap the computed ref
-const currentPageIndex = useCurrentNavigationIndex(navigation.value);
+const {currentNavigation} = useCurrentNavigationIndex(navigation.value);
 
 // Watch for navigation changes and update currentPageIndex
 watch(navigation, (newNav) => {
-  currentPageIndex.value = useCurrentNavigationIndex(newNav).value;
+  currentNavigation.value = useCurrentNavigationIndex(newNav).currentNavigation.value;
 });
 </script>

pages/settings/account.vue

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

pages/settings/downloads.vue

@@ -1,10 +1,15 @@
 <template>
-  <div>
+  <div class="border-b border-zinc-700 py-5">
-    <div class="border-b border-zinc-600 py-2 px-1">
+    <h3 class="text-base font-semibold font-display leading-6 text-zinc-100">
-      <div
+      Downloads
-        class="-ml-4 -mt-2 flex flex-wrap items-center justify-between sm:flex-nowrap"
+    </h3>
-      >
+  </div>
-        <div class="ml-4 mt-2">
+
+
+  <div class="mt-5">
+    <div class="border-b border-zinc-600">
+      <div class="-ml-4 -mt-2 flex flex-wrap items-center justify-between sm:flex-nowrap">
+        <div class="ml-4 mt-2 pb-4">
           <h3 class="text-base font-display font-semibold text-zinc-100">
             Install directories
           </h3>
@@ -15,27 +20,17 @@
           </p>
         </div>
         <div class="ml-4 mt-2 shrink-0">
-          <button
+          <button @click="() => (open = true)" type="button"
-            @click="() => (open = true)"
+            class="relative inline-flex items-center rounded-md bg-blue-600 px-3 py-2 text-sm font-semibold text-white shadow-sm hover:bg-blue-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600">
-            type="button"
-            class="relative inline-flex items-center rounded-md bg-blue-600 px-3 py-2 text-sm font-semibold text-white shadow-sm hover:bg-blue-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600"
-          >
             Add new directory
           </button>
         </div>
       </div>
     </div>
     <ul role="list" class="divide-y divide-gray-800">
-      <li
+      <li v-for="(dir, dirIdx) in dirs" :key="dir" class="flex justify-between gap-x-6 py-5">
-        v-for="(dir, dirIdx) in dirs"
-        :key="dir"
-        class="flex justify-between gap-x-6 py-5"
-      >
         <div class="flex min-w-0 gap-x-4">
-          <FolderIcon
+          <FolderIcon class="h-6 w-6 text-blue-600 flex-none rounded-full" alt="" />
-            class="h-6 w-6 text-blue-600 flex-none rounded-full"
-            alt=""
-          />
           <div class="min-w-0 flex-auto">
             <p class="text-sm/6 text-zinc-100">
               {{ dir }}
@@ -43,16 +38,12 @@
           </div>
         </div>
         <div class="flex shrink-0 items-center gap-x-6">
-          <button
+          <button @click="() => deleteDirectory(dirIdx)" :disabled="dirs.length <= 1" :class="[
-            @click="() => deleteDirectory(dirIdx)"
-            :disabled="dirs.length <= 1"
-            :class="[
             dirs.length <= 1
               ? 'text-zinc-700'
               : 'text-zinc-400 hover:text-zinc-100',
             '-m-2.5 block p-2.5',
-            ]"
+          ]">
-          >
             <span class="sr-only">Open options</span>
             <TrashIcon class="size-5" aria-hidden="true" />
           </button>
@@ -72,37 +63,44 @@
           Maximum Download Threads
         </label>
         <div class="mt-2">
-          <input
+          <input type="number" name="threads" id="threads" min="1" max="32" v-model="downloadThreads"
-            type="number"
+            @keypress="validateNumberInput" @paste="validatePaste"
-            name="threads"
+            class="block w-full rounded-md border-0 py-1.5 text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 bg-zinc-800 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-blue-600 sm:text-sm sm:leading-6" />
-            id="threads"
-            min="1"
-            max="32"
-            v-model="downloadThreads"
-            @keypress="validateNumberInput"
-            @paste="validatePaste"
-            class="block w-full rounded-md border-0 py-1.5 text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 bg-zinc-800 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-blue-600 sm:text-sm sm:leading-6"
-          />
         </div>
         <p class="mt-2 text-sm text-zinc-400">
           The maximum number of concurrent download threads. Higher values may
           download faster but use more system resources. Default is 4.
         </p>
       </div>
+      <div class="mt-10 space-y-8">
+        <div class="flex flex-row items-center justify-between">
+          <div>
+            <h3 class="text-sm font-medium leading-6 text-zinc-100">Force Offline</h3>
+            <p class="mt-1 text-sm leading-6 text-zinc-400">
+              Drop will not make any external connections
+            </p>
+          </div>
+          <Switch v-model="forceOffline" :class="[
+            forceOffline ? 'bg-blue-600' : 'bg-zinc-700',
+            'relative inline-flex h-6 w-11 flex-shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors duration-200 ease-in-out'
+          ]">
+            <span :class="[
+              forceOffline ? 'translate-x-5' : 'translate-x-0',
+              'pointer-events-none relative inline-block h-5 w-5 transform rounded-full bg-white shadow ring-0 transition duration-200 ease-in-out'
+            ]" />
+          </Switch>
+        </div>
+      </div>
+
 
       <div class="mt-6">
-        <button
+        <button type="button" @click="saveSettings" :disabled="saveState.loading" :class="[
-          type="button"
-          @click="saveDownloadThreads"
-          :disabled="saveState.loading"
-          :class="[
           'inline-flex items-center rounded-md px-3 py-2 text-sm font-semibold text-white shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 transition-colors duration-300',
           saveState.success
             ? 'bg-green-600 hover:bg-green-500 focus-visible:outline-green-600'
             : 'bg-blue-600 hover:bg-blue-500 focus-visible:outline-blue-600',
           'disabled:bg-blue-600/50 disabled:cursor-not-allowed'
-          ]"
+        ]">
-        >
           {{ saveState.success ? 'Saved' : 'Save Changes' }}
         </button>
       </div>
@@ -110,49 +108,27 @@
   </div>
   <TransitionRoot as="template" :show="open">
     <Dialog class="relative z-50" @close="open = false">
-      <TransitionChild
+      <TransitionChild as="template" enter="ease-out duration-300" enter-from="opacity-0" enter-to="opacity-100"
-        as="template"
+        leave="ease-in duration-200" leave-from="opacity-100" leave-to="opacity-0">
-        enter="ease-out duration-300"
+        <div class="fixed inset-0 bg-zinc-950 bg-opacity-75 transition-opacity" />
-        enter-from="opacity-0"
-        enter-to="opacity-100"
-        leave="ease-in duration-200"
-        leave-from="opacity-100"
-        leave-to="opacity-0"
-      >
-        <div
-          class="fixed inset-0 bg-zinc-950 bg-opacity-75 transition-opacity"
-        />
       </TransitionChild>
 
       <div class="fixed inset-0 z-10 w-screen overflow-y-auto">
-        <div
+        <div class="flex min-h-full items-end justify-center p-4 text-center sm:items-center sm:p-0">
-          class="flex min-h-full items-end justify-center p-4 text-center sm:items-center sm:p-0"
+          <TransitionChild as="template" enter="ease-out duration-300"
-        >
-          <TransitionChild
-            as="template"
-            enter="ease-out duration-300"
             enter-from="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
-            enter-to="opacity-100 translate-y-0 sm:scale-100"
+            enter-to="opacity-100 translate-y-0 sm:scale-100" leave="ease-in duration-200"
-            leave="ease-in duration-200"
             leave-from="opacity-100 translate-y-0 sm:scale-100"
-            leave-to="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
+            leave-to="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95">
-          >
             <DialogPanel
-              class="relative transform overflow-hidden rounded-lg bg-zinc-900 px-4 pb-4 pt-5 text-left shadow-xl transition-all sm:my-8 sm:w-full sm:max-w-lg sm:p-6"
+              class="relative transform overflow-hidden rounded-lg bg-zinc-900 px-4 pb-4 pt-5 text-left shadow-xl transition-all sm:my-8 sm:w-full sm:max-w-lg sm:p-6">
-            >
               <div class="sm:flex sm:items-start">
                 <div class="mt-3 w-full sm:ml-4 sm:mt-0">
                   <div>
-                    <label
+                    <label for="dir" class="block text-sm/6 font-medium text-zinc-100">Select game directory</label>
-                      for="dir"
-                      class="block text-sm/6 font-medium text-zinc-100"
-                      >Select game directory</label
-                    >
                     <div class="mt-2">
-                      <button
+                      <button @click="() => selectDirectory()"
-                        @click="() => selectDirectory()"
+                        class="block text-left w-full rounded-md border-0 px-3 py-1.5 text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 bg-zinc-800 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-blue-600 sm:text-sm/6">
-                        class="block text-left w-full rounded-md border-0 px-3 py-1.5 text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 bg-zinc-800 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-blue-600 sm:text-sm/6"
-                      >
                         {{
                           currentDirectory ?? "Click to select a directory..."
                         }}
@@ -165,36 +141,25 @@
                 </div>
               </div>
               <div class="mt-5 sm:mt-4 sm:flex sm:flex-row-reverse">
-                <LoadingButton
+                <LoadingButton :disabled="currentDirectory == undefined" type="button" :loading="createDirectoryLoading"
-                  :disabled="currentDirectory == undefined"
+                  @click="() => submitDirectory()" :class="[
-                  type="button"
-                  :loading="createDirectoryLoading"
-                  @click="() => submitDirectory()"
-                  :class="[
                     'inline-flex w-full shadow-sm sm:ml-3 sm:w-auto',
                     currentDirectory === undefined
                       ? 'text-zinc-400 bg-blue-600/10 hover:bg-blue-600/10'
                       : 'text-white bg-blue-600 hover:bg-blue-500',
-                  ]"
+                  ]">
-                >
                   Add
                 </LoadingButton>
-                <button
+                <button type="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-800 hover:bg-zinc-900 sm:mt-0 sm:w-auto"
-                  @click="() => cancelDirectory()"
+                  @click="() => cancelDirectory()" ref="cancelButtonRef">
-                  ref="cancelButtonRef"
-                >
                   Cancel
                 </button>
               </div>
               <div v-if="error" class="mt-3 rounded-md bg-red-600/10 p-4">
                 <div class="flex">
                   <div class="flex-shrink-0">
-                    <XCircleIcon
+                    <XCircleIcon class="h-5 w-5 text-red-600" aria-hidden="true" />
-                      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">
@@ -220,6 +185,7 @@ import {
 } from "@headlessui/vue";
 import { FolderIcon, TrashIcon, XCircleIcon } from "@heroicons/vue/16/solid";
 import { invoke } from "@tauri-apps/api/core";
+import { Switch } from '@headlessui/vue'
 import { type Settings } from "~/types";
 
 const open = ref(false);
@@ -231,6 +197,7 @@ const dirs = ref<Array<string>>([]);
 
 const settings = await invoke<Settings>("fetch_settings");
 const downloadThreads = ref(settings?.maxDownloadThreads ?? 4);
+const forceOffline = ref(settings?.forceOffline ?? false);
 
 const saveState = reactive({
   loading: false,
@@ -293,11 +260,11 @@ async function deleteDirectory(index: number) {
   await updateDirs();
 }
 
-async function saveDownloadThreads() {
+async function saveSettings() {
   try {
     saveState.loading = true;
     await invoke("update_settings", {
-      newSettings: { maxDownloadThreads: downloadThreads.value },
+      newSettings: { maxDownloadThreads: downloadThreads.value, forceOffline: forceOffline.value },
     });
 
     // Show success state

pages/settings/index.vue

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

pages/store/index.vue

@@ -1,2 +1,4 @@
-<template></template>
+<template>
+  <iframe src="server://drop.local/store" class="w-full h-full" />
+</template>
 <script setup lang="ts"></script>

plugins/global-error-handler.ts

@@ -1,8 +1,11 @@
 export default defineNuxtPlugin((nuxtApp) => {
   // Also possible
+  /*
   nuxtApp.hook("vue:error", (error, instance, info) => {
+    
     console.error(error, info);
     const router = useRouter();
     router.replace(`/error`);
   });
+  */
 });

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "drop-app"
-version = "0.2.0-beta-prerelease-1"
+version = "0.3.0-rc-3"
 description = "The client application for the open-source, self-hosted game distribution platform Drop"
 authors = ["Drop OSS"]
 edition = "2021"
@@ -16,8 +16,6 @@ tauri-plugin-single-instance = { version = "2.0.0", features = ["deep-link"] }
 # 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"]
-
-[build]
 rustflags = ["-C", "target-feature=+aes,+sse2"]
 
 
@@ -25,11 +23,10 @@ rustflags = ["-C", "target-feature=+aes,+sse2"]
 tauri-build = { version = "2.0.0", features = [] }
 
 [dependencies]
-tauri-plugin-shell = "2.0.0"
+tauri-plugin-shell = "2.2.1"
 serde_json = "1"
 serde-binary = "0.5.0"
 rayon = "1.10.0"
-directories = "5.0.1"
 webbrowser = "1.0.2"
 url = "2.5.2"
 tauri-plugin-deep-link = "2"
@@ -50,12 +47,36 @@ slice-deque = "0.3.0"
 throttle_my_fn = "0.2.6"
 parking_lot = "0.12.3"
 atomic-instant-full = "0.1.0"
+cacache = "13.1.0"
+http-serde = "2.1.1"
+reqwest-middleware = "0.4.0"
+reqwest-middleware-cache = "0.1.1"
+deranged = "=0.4.0"
+droplet-rs = "0.7.3"
+gethostname = "1.0.1"
+zstd = "0.13.3"
+tar = "0.4.44"
+rand = "0.9.1"
+regex = "1.11.1"
+tempfile = "3.19.1"
+schemars = "0.8.22"
+sha1 = "0.10.6"
+dirs = "6.0.0"
+whoami = "1.6.0"
+filetime = "0.2.25"
+walkdir = "2.5.0"
+known-folders = "1.2.0"
+native_model = { version = "0.6.1", features = ["rmp_serde_1_3"] }
+# tailscale = { path = "./tailscale" }
+
+[dependencies.dynfmt]
+version = "0.1.5"
+features = ["curly"]
 
 [dependencies.tauri]
 version = "2.1.1"
 features = ["tray-icon"]
 
-
 [dependencies.tokio]
 version = "1.40.0"
 features = ["rt", "tokio-macros", "signal"]
@@ -70,23 +91,16 @@ features = ["fs"]
 
 [dependencies.uuid]
 version = "1.10.0"
-features = [
+features = ["v4", "fast-rng", "macro-diagnostics"]
-    "v4",                # Lets you generate random UUIDs
-    "fast-rng",          # Use a faster (but still sufficiently random) RNG
-    "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs
-]
-
-[dependencies.openssl]
-version = "0.10.66"
-features = ["vendored"]
 
 [dependencies.rustbreak]
 version = "2"
-features = [] # You can also use "yaml_enc" or "bin_enc"
+features = ["other_errors"] # You can also use "yaml_enc" or "bin_enc"
 
 [dependencies.reqwest]
 version = "0.12"
-features = ["json", "blocking"]
+default-features = false
+features = ["json", "http2", "blocking", "rustls-tls-webpki-roots"]
 
 [dependencies.serde]
 version = "1"

src-tauri/src/client/mod.rs

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

src-tauri/src/cloud_saves/backup_manager.rs

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

src-tauri/src/cloud_saves/conditions.rs

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

src-tauri/src/cloud_saves/metadata.rs

@@ -0,0 +1,35 @@
+use crate::database::db::GameVersion;
+
+use super::conditions::{Condition};
+
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct CloudSaveMetadata {
+    pub files: Vec<GameFile>,
+    pub game_version: GameVersion,
+    pub save_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameFile {
+    pub path: String,
+    pub id: Option<String>,
+    pub data_type: DataType,
+    pub tags: Vec<Tag>,
+    pub conditions: Vec<Condition>
+}
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
+pub enum DataType {
+    Registry,
+    File,
+    Other
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Tag {
+    Config,
+    Save,
+    #[default]
+    #[serde(other)]
+    Other,
+}

src-tauri/src/cloud_saves/mod.rs

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

src-tauri/src/cloud_saves/normalise.rs

@@ -0,0 +1,162 @@
+use std::sync::LazyLock;
+
+use regex::Regex;
+use crate::process::process_manager::Platform;
+
+use super::placeholder::*;
+
+
+pub fn normalize(path: &str, os: Platform) -> String {
+    let mut path = path.trim().trim_end_matches(['/', '\\']).replace('\\', "/");
+
+    if path == "~" || path.starts_with("~/") {
+        path = path.replacen('~', HOME, 1);
+    }
+
+    static CONSECUTIVE_SLASHES: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"/{2,}").unwrap());
+    static UNNECESSARY_DOUBLE_STAR_1: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"([^/*])\*{2,}").unwrap());
+    static UNNECESSARY_DOUBLE_STAR_2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\*{2,}([^/*])").unwrap());
+    static ENDING_WILDCARD: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\*)+$").unwrap());
+    static ENDING_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\.)$").unwrap());
+    static INTERMEDIATE_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\./)").unwrap());
+    static BLANK_SEGMENT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\s+/)").unwrap());
+    static APP_DATA: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%appdata%").unwrap());
+    static APP_DATA_ROAMING: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Roaming").unwrap());
+    static APP_DATA_LOCAL: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%localappdata%").unwrap());
+    static APP_DATA_LOCAL_2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Local/").unwrap());
+    static USER_PROFILE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%").unwrap());
+    static DOCUMENTS: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/Documents").unwrap());
+
+    for (pattern, replacement) in [
+        (&CONSECUTIVE_SLASHES, "/"),
+        (&UNNECESSARY_DOUBLE_STAR_1, "${1}*"),
+        (&UNNECESSARY_DOUBLE_STAR_2, "*${1}"),
+        (&ENDING_WILDCARD, ""),
+        (&ENDING_DOT, ""),
+        (&INTERMEDIATE_DOT, "/"),
+        (&BLANK_SEGMENT, "/"),
+        (&APP_DATA, WIN_APP_DATA),
+        (&APP_DATA_ROAMING, WIN_APP_DATA),
+        (&APP_DATA_LOCAL, WIN_LOCAL_APP_DATA),
+        (&APP_DATA_LOCAL_2, &format!("{}/", WIN_LOCAL_APP_DATA)),
+        (&USER_PROFILE, HOME),
+        (&DOCUMENTS, WIN_DOCUMENTS),
+    ] {
+        path = pattern.replace_all(&path, replacement).to_string();
+    }
+
+    if os == Platform::Windows {
+        let documents_2: Regex = Regex::new(r"(?i)<home>/Documents").unwrap();
+
+        #[allow(clippy::single_element_loop)]
+        for (pattern, replacement) in [(&documents_2, WIN_DOCUMENTS)] {
+            path = pattern.replace_all(&path, replacement).to_string();
+        }
+    }
+
+    for (pattern, replacement) in [
+        ("{64BitSteamID}", STORE_USER_ID),
+        ("{Steam3AccountID}", STORE_USER_ID),
+    ] {
+        path = path.replace(pattern, replacement);
+    }
+
+    path
+}
+
+fn too_broad(path: &str) -> bool {
+    println!("Path: {}", path);
+    use {BASE, HOME, ROOT, STORE_USER_ID, WIN_APP_DATA, WIN_DIR, WIN_DOCUMENTS, XDG_CONFIG, XDG_DATA};
+
+    let path_lower = path.to_lowercase();
+
+    for item in ALL {
+        if path == *item {
+            return true;
+        }
+    }
+
+    for item in AVOID_WILDCARDS {
+        if path.starts_with(&format!("{}/*", item)) || path.starts_with(&format!("{}/{}", item, STORE_USER_ID)) {
+            return true;
+        }
+    }
+
+    // These paths are present whether or not the game is installed.
+    // If possible, they should be narrowed down on the wiki.
+    for item in [
+        format!("{}/{}", BASE, STORE_USER_ID), // because `<storeUserId>` is handled as `*`
+        format!("{}/Documents", HOME),
+        format!("{}/Saved Games", HOME),
+        format!("{}/AppData", HOME),
+        format!("{}/AppData/Local", HOME),
+        format!("{}/AppData/Local/Packages", HOME),
+        format!("{}/AppData/LocalLow", HOME),
+        format!("{}/AppData/Roaming", HOME),
+        format!("{}/Documents/My Games", HOME),
+        format!("{}/Library/Application Support", HOME),
+        format!("{}/Library/Application Support/UserData", HOME),
+        format!("{}/Library/Preferences", HOME),
+        format!("{}/.renpy", HOME),
+        format!("{}/.renpy/persistent", HOME),
+        format!("{}/Library", HOME),
+        format!("{}/Library/RenPy", HOME),
+        format!("{}/Telltale Games", HOME),
+        format!("{}/config", ROOT),
+        format!("{}/MMFApplications", WIN_APP_DATA),
+        format!("{}/RenPy", WIN_APP_DATA),
+        format!("{}/RenPy/persistent", WIN_APP_DATA),
+        format!("{}/win.ini", WIN_DIR),
+        format!("{}/SysWOW64", WIN_DIR),
+        format!("{}/My Games", WIN_DOCUMENTS),
+        format!("{}/Telltale Games", WIN_DOCUMENTS),
+        format!("{}/unity3d", XDG_CONFIG),
+        format!("{}/unity3d", XDG_DATA),
+        "C:/Program Files".to_string(),
+        "C:/Program Files (x86)".to_string(),
+    ] {
+        let item = item.to_lowercase();
+        if path_lower == item
+            || path_lower.starts_with(&format!("{}/*", item))
+            || path_lower.starts_with(&format!("{}/{}", item, STORE_USER_ID.to_lowercase()))
+            || path_lower.starts_with(&format!("{}/savesdir", item))
+        {
+            return true;
+        }
+    }
+    
+
+    // Drive letters:
+    let drives: Regex = Regex::new(r"^[a-zA-Z]:$").unwrap();
+    if drives.is_match(path) {
+        return true;
+    }
+
+    // Colon not for a drive letter
+    if path.get(2..).is_some_and(|path| path.contains(':')) {
+        return true;
+    }
+
+    // Root:
+    if path == "/" {
+        return true;
+    }
+
+    // Relative path wildcard:
+    if path.starts_with('*') {
+        return true;
+    }
+
+    false
+}
+
+pub fn usable(path: &str) -> bool {
+    let unprintable: Regex = Regex::new(r"(\p{Cc}|\p{Cf})").unwrap();
+
+    !path.is_empty()
+        && !path.contains("{{")
+        && !path.starts_with("./")
+        && !path.starts_with("../")
+        && !too_broad(path)
+        && !unprintable.is_match(path)
+}

src-tauri/src/cloud_saves/path.rs

@@ -0,0 +1,48 @@
+use std::{path::PathBuf, sync::LazyLock};
+
+pub enum CommonPath {
+    Config,
+    Data,
+    DataLocal,
+    DataLocalLow,
+    Document,
+    Home,
+    Public,
+    SavedGames,
+}
+
+impl CommonPath {
+    pub fn get(&self) -> Option<PathBuf> {
+        static CONFIG: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::config_dir());
+        static DATA: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::data_dir());
+        static DATA_LOCAL: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::data_local_dir());
+        static DOCUMENT: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::document_dir());
+        static HOME: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::home_dir());
+        static PUBLIC: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::public_dir());
+
+        #[cfg(windows)]
+        static DATA_LOCAL_LOW: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
+            known_folders::get_known_folder_path(known_folders::KnownFolder::LocalAppDataLow)
+        });
+        #[cfg(not(windows))]
+        static DATA_LOCAL_LOW: Option<PathBuf> = None;
+
+        #[cfg(windows)]
+        static SAVED_GAMES: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
+            known_folders::get_known_folder_path(known_folders::KnownFolder::SavedGames)
+        });
+        #[cfg(not(windows))]
+        static SAVED_GAMES: Option<PathBuf> = None;
+
+        match self {
+            Self::Config => CONFIG.clone(),
+            Self::Data => DATA.clone(),
+            Self::DataLocal => DATA_LOCAL.clone(),
+            Self::DataLocalLow => DATA_LOCAL_LOW.clone(),
+            Self::Document => DOCUMENT.clone(),
+            Self::Home => HOME.clone(),
+            Self::Public => PUBLIC.clone(),
+            Self::SavedGames => SAVED_GAMES.clone(),
+        }
+    }
+}

src-tauri/src/cloud_saves/placeholder.rs

@@ -0,0 +1,51 @@
+use std::sync::LazyLock;
+
+pub const ALL: &[&str] = &[
+    ROOT,
+    GAME,
+    BASE,
+    HOME,
+    STORE_USER_ID,
+    OS_USER_NAME,
+    WIN_APP_DATA,
+    WIN_LOCAL_APP_DATA,
+    WIN_DOCUMENTS,
+    WIN_PUBLIC,
+    WIN_PROGRAM_DATA,
+    WIN_DIR,
+    XDG_DATA,
+    XDG_CONFIG,
+];
+
+/// These are paths where `<placeholder>/*/` is suspicious.
+pub const AVOID_WILDCARDS: &[&str] = &[
+    ROOT,
+    HOME,
+    WIN_APP_DATA,
+    WIN_LOCAL_APP_DATA,
+    WIN_DOCUMENTS,
+    WIN_PUBLIC,
+    WIN_PROGRAM_DATA,
+    WIN_DIR,
+    XDG_DATA,
+    XDG_CONFIG,
+];
+
+pub const ROOT: &str = "<root>"; // a directory where games are installed (configured in backup tool)
+pub const GAME: &str = "<game>"; // an installDir (if defined) or the game's canonical name in the manifest
+pub const BASE: &str = "<base>"; // shorthand for <root>/<game> (unless overridden by store-specific rules)
+pub const HOME: &str = "<home>"; // current user's home directory in the OS (~)
+pub const STORE_USER_ID: &str = "<storeUserId>"; // a store-specific id from the manifest, corresponding to the root's store type
+pub const OS_USER_NAME: &str = "<osUserName>"; // current user's ID in the game store
+pub const WIN_APP_DATA: &str = "<winAppData>"; // current user's name in the OS
+pub const WIN_LOCAL_APP_DATA: &str = "<winLocalAppData>"; // %APPDATA% on Windows
+pub const WIN_LOCAL_APP_DATA_LOW: &str = "<winLocalAppDataLow>"; // %LOCALAPPDATA% on Windows
+pub const WIN_DOCUMENTS: &str = "<winDocuments>"; // <home>/AppData/LocalLow on Windows
+pub const WIN_PUBLIC: &str = "<winPublic>"; // <home>/Documents (f.k.a. <home>/My Documents) or a localized equivalent on Windows
+pub const WIN_PROGRAM_DATA: &str = "<winProgramData>"; // %PUBLIC% on Windows
+pub const WIN_DIR: &str = "<winDir>"; // %PROGRAMDATA% on Windows
+pub const XDG_DATA: &str = "<xdgData>"; // %WINDIR% on Windows
+pub const XDG_CONFIG: &str = "<xdgConfig>"; // $XDG_DATA_HOME on Linux
+pub const SKIP: &str = "<skip>"; // $XDG_CONFIG_HOME on Linux
+
+pub static OS_USERNAME: LazyLock<String> = LazyLock::new(|| whoami::username());

src-tauri/src/cloud_saves/resolver.rs

@@ -0,0 +1,262 @@
+use std::{
+    fs::{self, create_dir_all, File},
+    io::{self, ErrorKind, Read, Write},
+    path::{Path, PathBuf},
+    thread::sleep,
+    time::Duration,
+};
+
+use super::{
+    backup_manager::BackupHandler, conditions::Condition, metadata::GameFile, placeholder::*,
+};
+use log::{debug, warn};
+use rustix::path::Arg;
+use tempfile::tempfile;
+
+use crate::{
+    database::db::GameVersion, error::backup_error::BackupError, process::process_manager::Platform,
+};
+
+use super::{backup_manager::BackupManager, metadata::CloudSaveMetadata, normalise::normalize};
+
+pub fn resolve(meta: &mut CloudSaveMetadata) -> File {
+    let f = File::create_new("save").unwrap();
+    let compressor = zstd::Encoder::new(f, 22).unwrap();
+    let mut tarball = tar::Builder::new(compressor);
+    let manager = BackupManager::new();
+    for file in meta.files.iter_mut() {
+        let id = uuid::Uuid::new_v4().to_string();
+        let os = match file
+            .conditions
+            .iter()
+            .find_map(|p| match p {
+                super::conditions::Condition::Os(os) => Some(os),
+                _ => None,
+            })
+            .cloned()
+        {
+            Some(os) => os,
+            None => {
+                warn!(
+                    "File {:?} could not be backed up because it did not provide an OS",
+                    &file
+                );
+                continue;
+            }
+        };
+        let handler = match manager.sources.get(&(manager.current_platform, os)) {
+            Some(h) => *h,
+            None => continue,
+        };
+        let t_path = PathBuf::from(normalize(&file.path, os));
+        println!("{:?}", &t_path);
+        let path = parse_path(t_path, handler, &meta.game_version).unwrap();
+        let f = std::fs::metadata(&path).unwrap(); // TODO: Fix unwrap here
+        if f.is_dir() {
+            tarball.append_dir_all(&id, path).unwrap();
+        } else if f.is_file() {
+            tarball
+                .append_file(&id, &mut File::open(path).unwrap())
+                .unwrap();
+        }
+        file.id = Some(id);
+    }
+    let binding = serde_json::to_string(meta).unwrap();
+    let serialized = binding.as_bytes();
+    let mut file = tempfile().unwrap();
+    file.write(serialized).unwrap();
+    tarball.append_file("metadata", &mut file).unwrap();
+    tarball.into_inner().unwrap().finish().unwrap()
+}
+
+pub fn extract(file: PathBuf) -> Result<(), BackupError> {
+    let tmpdir = tempfile::tempdir().unwrap();
+
+    // Reopen the file for reading
+    let file = File::open(file).unwrap();
+
+    let decompressor = zstd::Decoder::new(file).unwrap();
+    let mut f = tar::Archive::new(decompressor);
+    f.unpack(tmpdir.path()).unwrap();
+
+    let path = tmpdir.path();
+
+    let mut manifest = File::open(path.join("metadata")).unwrap();
+
+    let mut manifest_slice = Vec::new();
+    manifest.read_to_end(&mut manifest_slice).unwrap();
+
+    let manifest: CloudSaveMetadata = serde_json::from_slice(&manifest_slice).unwrap();
+
+    for file in manifest.files {
+        let current_path = path.join(file.id.as_ref().unwrap());
+
+        let manager = BackupManager::new();
+        let os = match file
+            .conditions
+            .iter()
+            .find_map(|p| match p {
+                super::conditions::Condition::Os(os) => Some(os),
+                _ => None,
+            })
+            .cloned()
+        {
+            Some(os) => os,
+            None => {
+                warn!(
+                    "File {:?} could not be replaced up because it did not provide an OS",
+                    &file
+                );
+                continue;
+            }
+        };
+        let handler = match manager.sources.get(&(manager.current_platform, os)) {
+            Some(h) => *h,
+            None => continue,
+        };
+
+        let new_path = parse_path(file.path.into(), handler, &manifest.game_version)?;
+        create_dir_all(&new_path.parent().unwrap()).unwrap();
+
+        println!(
+            "Current path {:?} copying to {:?}",
+            &current_path, &new_path
+        );
+
+        copy_item(current_path, new_path).unwrap();
+    }
+
+    Ok(())
+}
+
+pub fn copy_item<P: AsRef<Path>>(src: P, dest: P) -> io::Result<()> {
+    let src_path = src.as_ref();
+    let dest_path = dest.as_ref();
+
+    let metadata = fs::metadata(&src_path)?;
+
+    if metadata.is_file() {
+        // Ensure the parent directory of the destination exists for a file copy
+        if let Some(parent) = dest_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::copy(&src_path, &dest_path)?;
+    } else if metadata.is_dir() {
+        // For directories, we call the recursive helper function.
+        // The destination for the recursive copy is the `dest_path` itself.
+        copy_dir_recursive(&src_path, &dest_path)?;
+    } else {
+        // Handle other file types like symlinks if necessary,
+        // for now, return an error or skip.
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!("Source {:?} is neither a file nor a directory", src_path),
+        ));
+    }
+
+    Ok(())
+}
+
+fn copy_dir_recursive(src: &Path, dest: &Path) -> io::Result<()> {
+    fs::create_dir_all(&dest)?;
+
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let entry_path = entry.path();
+        let entry_file_name = match entry_path.file_name() {
+            Some(name) => name,
+            None => continue, // Skip if somehow there's no file name
+        };
+        let dest_entry_path = dest.join(entry_file_name);
+        let metadata = entry.metadata()?;
+
+        if metadata.is_file() {
+            debug!(
+                "Writing file {} to {}",
+                entry_path.display(),
+                dest_entry_path.display()
+            );
+            fs::copy(&entry_path, &dest_entry_path)?;
+        } else if metadata.is_dir() {
+            copy_dir_recursive(&entry_path, &dest_entry_path)?;
+        }
+        // Ignore other types like symlinks for this basic implementation
+    }
+
+    Ok(())
+}
+
+pub fn parse_path(
+    path: PathBuf,
+    backup_handler: &dyn BackupHandler,
+    game: &GameVersion,
+) -> Result<PathBuf, BackupError> {
+    println!("Parsing: {:?}", &path);
+    let mut s = PathBuf::new();
+    for component in path.components() {
+        match component.as_str().unwrap() {
+            ROOT => s.push(backup_handler.root_translate(&path, game)?),
+            GAME => s.push(backup_handler.game_translate(&path, game)?),
+            BASE => s.push(backup_handler.base_translate(&path, game)?),
+            HOME => s.push(backup_handler.home_translate(&path, game)?),
+            STORE_USER_ID => s.push(backup_handler.store_user_id_translate(&path, game)?),
+            OS_USER_NAME => s.push(backup_handler.os_user_name_translate(&path, game)?),
+            WIN_APP_DATA => s.push(backup_handler.win_app_data_translate(&path, game)?),
+            WIN_LOCAL_APP_DATA => s.push(backup_handler.win_local_app_data_translate(&path, game)?),
+            WIN_LOCAL_APP_DATA_LOW => {
+                s.push(backup_handler.win_local_app_data_low_translate(&path, game)?)
+            }
+            WIN_DOCUMENTS => s.push(backup_handler.win_documents_translate(&path, game)?),
+            WIN_PUBLIC => s.push(backup_handler.win_public_translate(&path, game)?),
+            WIN_PROGRAM_DATA => s.push(backup_handler.win_program_data_translate(&path, game)?),
+            WIN_DIR => s.push(backup_handler.win_dir_translate(&path, game)?),
+            XDG_DATA => s.push(backup_handler.xdg_data_translate(&path, game)?),
+            XDG_CONFIG => s.push(backup_handler.xdg_config_translate(&path, game)?),
+            SKIP => s.push(backup_handler.skip_translate(&path, game)?),
+            _ => s.push(PathBuf::from(component.as_os_str())),
+        }
+    }
+
+    println!("Final line: {:?}", &s);
+    Ok(s)
+}
+
+pub fn test() {
+    let mut meta = CloudSaveMetadata {
+        files: vec![
+            GameFile {
+                path: String::from("<home>/favicon.png"),
+                id: None,
+                data_type: super::metadata::DataType::File,
+                tags: Vec::new(),
+                conditions: vec![Condition::Os(Platform::Linux)],
+            },
+            GameFile {
+                path: String::from("<home>/Documents/Pixel Art"),
+                id: None,
+                data_type: super::metadata::DataType::File,
+                tags: Vec::new(),
+                conditions: vec![Condition::Os(Platform::Linux)],
+            },
+        ],
+        game_version: GameVersion {
+            game_id: String::new(),
+            version_name: String::new(),
+            platform: Platform::Linux,
+            launch_command: String::new(),
+            launch_args: Vec::new(),
+            launch_command_template: String::new(),
+            setup_command: String::new(),
+            setup_args: Vec::new(),
+            setup_command_template: String::new(),
+            only_setup: true,
+            version_index: 0,
+            delta: false,
+            umu_id_override: None,
+        },
+        save_id: String::from("aaaaaaa"),
+    };
+    //resolve(&mut meta);
+
+    extract("save".into()).unwrap();
+}

src-tauri/src/database/commands.rs

@@ -6,14 +6,12 @@ use std::{
 
 use serde_json::Value;
 
-use crate::{
+use crate::{database::db::borrow_db_mut_checked, error::download_manager_error::DownloadManagerError};
-    database::{db::borrow_db_mut_checked, settings::Settings},
-    download_manager::internal_error::InternalError,
-};
 
 use super::{
     db::{borrow_db_checked, save_db, DATA_ROOT_DIR},
     debug::SystemData,
+    models::data::Settings,
 };
 
 // Will, in future, return disk/remaining size
@@ -33,7 +31,7 @@ pub fn delete_download_dir(index: usize) {
 }
 
 #[tauri::command]
-pub fn add_download_dir(new_dir: PathBuf) -> Result<(), InternalError<()>> {
+pub fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>> {
     // Check the new directory is all good
     let new_dir_path = Path::new(&new_dir);
     if new_dir_path.exists() {
@@ -74,7 +72,8 @@ pub fn update_settings(new_settings: Value) {
     }
     let new_settings: Settings = serde_json::from_value(current_settings).unwrap();
     db_lock.settings = new_settings;
-    println!("new Settings: {:?}", db_lock.settings);
+    drop(db_lock);
+    save_db();
 }
 #[tauri::command]
 pub fn fetch_settings() -> Settings {

src-tauri/src/database/db.rs

@@ -1,138 +1,42 @@
 use std::{
-    collections::HashMap,
     fs::{self, create_dir_all},
-    hash::Hash,
+    path::PathBuf,
-    path::{Path, PathBuf},
     sync::{LazyLock, Mutex, RwLockReadGuard, RwLockWriteGuard},
 };
 
 use chrono::Utc;
-use directories::BaseDirs;
+use log::{debug, error, info, warn};
-use log::{debug, error, info};
+use native_model::{Decode, Encode};
 use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde::{de::DeserializeOwned, Serialize};
-use serde_with::serde_as;
-use tauri::AppHandle;
 use url::Url;
 
-use crate::{
+use crate::DB;
-    database::settings::Settings,
-    download_manager::downloadable_metadata::DownloadableMetadata,
-    games::{library::push_game_update, state::GameStatusManager},
-    process::process_manager::Platform,
-    DB,
-};
 
-#[derive(serde::Serialize, Clone, Deserialize)]
+use super::models::data::Database;
-pub struct DatabaseAuth {
-    pub private: String,
-    pub cert: String,
-    pub client_id: String,
-}
 
-// Strings are version names for a particular game
-#[derive(Serialize, Clone, Deserialize)]
-#[serde(tag = "type")]
-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)]
-pub enum ApplicationTransientStatus {
-    Downloading { version_name: String },
-    Uninstalling {},
-    Updating { version_name: String },
-    Running {},
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct GameVersion {
-    pub game_id: String,
-    pub version_name: String,
-
-    pub platform: Platform,
-
-    pub launch_command: String,
-    pub launch_args: Vec<String>,
-
-    pub setup_command: String,
-    pub setup_args: Vec<String>,
-
-    pub only_setup: bool,
-
-    pub version_index: usize,
-    pub delta: bool,
-
-    pub umu_id_override: Option<String>,
-}
-
-#[serde_as]
-#[derive(Serialize, Clone, Deserialize, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct DatabaseApplications {
-    pub install_dirs: Vec<PathBuf>,
-    // Guaranteed to exist if the game also exists in the app state map
-    pub game_statuses: HashMap<String, GameDownloadStatus>,
-    pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
-    pub installed_game_version: HashMap<String, DownloadableMetadata>,
-
-    #[serde(skip)]
-    pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
-}
-
-#[derive(Serialize, Deserialize, Clone, 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>,
-}
-impl Database {
-    fn new<T: Into<PathBuf>>(games_base_dir: T, prev_database: Option<PathBuf>) -> Self {
-        Self {
-            applications: DatabaseApplications {
-                install_dirs: vec![games_base_dir.into()],
-                game_statuses: HashMap::new(),
-                game_versions: HashMap::new(),
-                installed_game_version: HashMap::new(),
-                transient_statuses: HashMap::new(),
-            },
-            prev_database,
-            base_url: "".to_owned(),
-            auth: None,
-            settings: Settings {
-                autostart: false,
-                max_download_threads: 4,
-            },
-        }
-    }
-}
 pub static DATA_ROOT_DIR: LazyLock<Mutex<PathBuf>> =
-    LazyLock::new(|| Mutex::new(BaseDirs::new().unwrap().data_dir().join("drop")));
+    LazyLock::new(|| Mutex::new(dirs::data_dir().unwrap().join("drop")));
+
 
 // Custom JSON serializer to support everything we need
 #[derive(Debug, Default, Clone)]
 pub struct DropDatabaseSerializer;
 
-impl<T: Serialize + DeserializeOwned> DeSerializer<T> for DropDatabaseSerializer {
+impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
+    for DropDatabaseSerializer
+{
     fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
-        serde_json::to_vec(val).map_err(|e| DeSerError::Internal(e.to_string()))
+        native_model::rmp_serde_1_3::RmpSerde::encode(val).map_err(|e| DeSerError::Internal(e.to_string()))
     }
 
-    fn deserialize<R: std::io::Read>(&self, s: R) -> rustbreak::error::DeSerResult<T> {
+    fn deserialize<R: std::io::Read>(&self, mut s: R) -> rustbreak::error::DeSerResult<T> {
-        serde_json::from_reader(s).map_err(|e| DeSerError::Internal(e.to_string()))
+        let mut buf = Vec::new();
+        s.read_to_end(&mut buf)
+            .map_err(|e| rustbreak::error::DeSerError::Other(e.into()))?;
+        let val =
+            native_model::rmp_serde_1_3::RmpSerde::decode(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
+        Ok(val)
     }
 }
 
@@ -150,21 +54,25 @@ impl DatabaseImpls for DatabaseInterface {
         let db_path = data_root_dir.join("drop.db");
         let games_base_dir = data_root_dir.join("games");
         let logs_root_dir = data_root_dir.join("logs");
+        let cache_dir = data_root_dir.join("cache");
+        let pfx_dir = data_root_dir.join("pfx");
 
         debug!("creating data directory at {:?}", data_root_dir);
         create_dir_all(data_root_dir.clone()).unwrap();
-        create_dir_all(games_base_dir.clone()).unwrap();
+        create_dir_all(&games_base_dir).unwrap();
-        create_dir_all(logs_root_dir.clone()).unwrap();
+        create_dir_all(&logs_root_dir).unwrap();
+        create_dir_all(&cache_dir).unwrap();
+        create_dir_all(&pfx_dir).unwrap();
 
         let exists = fs::exists(db_path.clone()).unwrap();
 
         match exists {
             true => match PathDatabase::load_from_path(db_path.clone()) {
                 Ok(db) => db,
-                Err(e) => handle_invalid_database(e, db_path, games_base_dir),
+                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
             },
             false => {
-                let default = Database::new(games_base_dir, None);
+                let default = Database::new(games_base_dir, None, cache_dir);
                 debug!(
                     "Creating database at path {}",
                     db_path.as_os_str().to_str().unwrap()
@@ -185,26 +93,14 @@ impl DatabaseImpls for DatabaseInterface {
     }
 }
 
-pub fn set_game_status<F: FnOnce(&mut RwLockWriteGuard<'_, Database>, &DownloadableMetadata)>(
-    app_handle: &AppHandle,
-    meta: DownloadableMetadata,
-    setter: F,
-) {
-    let mut db_handle = borrow_db_mut_checked();
-    setter(&mut db_handle, &meta);
-    drop(db_handle);
-    save_db();
-
-    let status = GameStatusManager::fetch_state(&meta.id);
-
-    push_game_update(app_handle, &meta.id, status);
-}
 // TODO: Make the error relelvant rather than just assume that it's a Deserialize error
 fn handle_invalid_database(
     _e: RustbreakError,
     db_path: PathBuf,
     games_base_dir: PathBuf,
+    cache_dir: PathBuf,
 ) -> rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer> {
+    warn!("{}", _e);
     let new_path = {
         let time = Utc::now().timestamp();
         let mut base = db_path.clone();
@@ -220,6 +116,7 @@ fn handle_invalid_database(
     let db = Database::new(
         games_base_dir.into_os_string().into_string().unwrap(),
         Some(new_path),
+        cache_dir,
     );
 
     PathDatabase::create_at_path(db_path, db).expect("Database could not be created")

src-tauri/src/database/mod.rs

@@ -1,4 +1,4 @@
 pub mod commands;
 pub mod db;
 pub mod debug;
-pub mod settings;
+pub mod models;

src-tauri/src/database/models.rs

@@ -0,0 +1,240 @@
+pub mod data {
+    use native_model::{native_model, Model};
+    use serde::{Deserialize, Serialize};
+
+    pub type GameVersion = v1::GameVersion;
+    pub type Database = v2::Database;
+    pub type Settings = v1::Settings;
+    pub type DatabaseAuth = v1::DatabaseAuth;
+
+    pub type GameDownloadStatus = v1::GameDownloadStatus;
+    pub type ApplicationTransientStatus = v1::ApplicationTransientStatus;
+    pub type DownloadableMetadata = v1::DownloadableMetadata;
+    pub type DownloadType = v1::DownloadType;
+    pub type DatabaseApplications = v1::DatabaseApplications;
+    pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
+
+    pub mod v1 {
+        use crate::process::process_manager::Platform;
+        use serde_with::serde_as;
+        use std::{collections::HashMap, path::PathBuf};
+
+        use super::*;
+
+        fn default_template() -> String {
+            "{}".to_owned()
+        }
+
+        #[derive(Serialize, Deserialize, Clone, Debug)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 2, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct GameVersion {
+            pub game_id: String,
+            pub version_name: String,
+
+            pub platform: Platform,
+
+            pub launch_command: String,
+            pub launch_args: Vec<String>,
+            #[serde(default = "default_template")]
+            pub launch_command_template: String,
+
+            pub setup_command: String,
+            pub setup_args: Vec<String>,
+            #[serde(default = "default_template")]
+            pub setup_command_template: String,
+
+            pub only_setup: bool,
+
+            pub version_index: usize,
+            pub delta: bool,
+
+            pub umu_id_override: Option<String>,
+        }
+
+        #[serde_as]
+        #[derive(Serialize, Clone, Deserialize, Default)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 3, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct DatabaseApplications {
+            pub install_dirs: Vec<PathBuf>,
+            // Guaranteed to exist if the game also exists in the app state map
+            pub game_statuses: HashMap<String, GameDownloadStatus>,
+            pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
+            pub installed_game_version: HashMap<String, DownloadableMetadata>,
+
+            #[serde(skip)]
+            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+        }
+
+        #[derive(Serialize, Deserialize, Clone, Debug)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 4, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct Settings {
+            pub autostart: bool,
+            pub max_download_threads: usize,
+            pub force_offline: bool, // ... other settings ...
+        }
+        impl Default for Settings {
+            fn default() -> Self {
+                Self {
+                    autostart: false,
+                    max_download_threads: 4,
+                    force_offline: false,
+                }
+            }
+        }
+
+        // Strings are version names for a particular game
+        #[derive(Serialize, Clone, Deserialize)]
+        #[serde(tag = "type")]
+        #[native_model(id = 5, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub enum GameDownloadStatus {
+            Remote {},
+            SetupRequired {
+                version_name: String,
+                install_dir: String,
+            },
+            Installed {
+                version_name: String,
+                install_dir: String,
+            },
+        }
+
+        // Stuff that shouldn't be synced to disk
+        #[derive(Clone, Serialize, Deserialize)]
+        pub enum ApplicationTransientStatus {
+            Downloading { version_name: String },
+            Uninstalling {},
+            Updating { 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, PartialEq, Eq, PartialOrd, Ord, Hash, 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,
+        }
+    }
+
+    pub mod v2 {
+        use std::{collections::HashMap, path::PathBuf, process::Command};
+
+        use crate::process::process_manager::UMU_LAUNCHER_EXECUTABLE;
+
+        use super::*;
+
+        #[native_model(id = 1, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+        pub struct Database {
+            #[serde(default)]
+            pub settings: Settings,
+            pub auth: Option<DatabaseAuth>,
+            pub base_url: String,
+            pub applications: DatabaseApplications,
+            #[serde(skip)]
+            pub prev_database: Option<PathBuf>,
+            pub cache_dir: PathBuf,
+            pub compat_info: Option<DatabaseCompatInfo>,
+        }
+
+        #[native_model(id = 8, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+
+        pub struct DatabaseCompatInfo {
+            umu_installed: bool,
+        }
+
+        impl Database {
+            fn create_new_compat_info() -> Option<DatabaseCompatInfo> {
+                #[cfg(target_os = "windows")]
+                return None;
+
+                let has_umu_installed = Command::new(UMU_LAUNCHER_EXECUTABLE).spawn().is_ok();
+                Some(DatabaseCompatInfo {
+                    umu_installed: has_umu_installed,
+                })
+            }
+
+            pub fn new<T: Into<PathBuf>>(
+                games_base_dir: T,
+                prev_database: Option<PathBuf>,
+                cache_dir: PathBuf,
+            ) -> Self {
+                Self {
+                    applications: DatabaseApplications {
+                        install_dirs: vec![games_base_dir.into()],
+                        game_statuses: HashMap::new(),
+                        game_versions: HashMap::new(),
+                        installed_game_version: HashMap::new(),
+                        transient_statuses: HashMap::new(),
+                    },
+                    prev_database,
+                    base_url: "".to_owned(),
+                    auth: None,
+                    settings: Settings::default(),
+                    cache_dir,
+                    compat_info: Database::create_new_compat_info(),
+                }
+            }
+        }
+
+        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: Database::create_new_compat_info(),
+                }
+            }
+        }
+    }
+}

src-tauri/src/database/settings.rs

@@ -1,24 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Settings {
-    pub autostart: bool,
-    pub max_download_threads: usize,
-    // ... other settings ...
-}
-impl Default for Settings {
-    fn default() -> Self {
-        Self {
-            autostart: false,
-            max_download_threads: 4,
-        }
-    }
-}
-// Ideally use pointers instead of a macro to assign the settings
-// fn deserialize_into<T>(v: serde_json::Value, t: &mut T) -> Result<(), serde_json::Error>
-//     where T: for<'a> Deserialize<'a>
-// {
-//     *t = serde_json::from_value(v)?;
-//     Ok(())
-// }

src-tauri/src/download_manager/commands.rs

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

src-tauri/src/download_manager/download_manager.rs

@@ -12,12 +12,13 @@ use std::{
 use log::{debug, info};
 use serde::Serialize;
 
-use crate::error::application_download_error::ApplicationDownloadError;
+use crate::{
+    database::models::data::DownloadableMetadata,
+    error::application_download_error::ApplicationDownloadError,
+};
 
 use super::{
-    download_manager_builder::{CurrentProgressObject, DownloadAgent},
+    download_manager_builder::{CurrentProgressObject, DownloadAgent}, util::queue::Queue,
-    downloadable_metadata::DownloadableMetadata,
-    queue::Queue,
 };
 
 pub enum DownloadManagerSignal {
@@ -48,7 +49,7 @@ pub enum DownloadManagerSignal {
     Uninstall(DownloadableMetadata),
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum DownloadManagerStatus {
     Downloading,
     Paused,
@@ -167,6 +168,7 @@ impl DownloadManager {
         self.command_sender
             .send(DownloadManagerSignal::UpdateUIQueue)
             .unwrap();
+        self.command_sender.send(DownloadManagerSignal::Go).unwrap();
     }
     pub fn pause_downloads(&self) {
         self.command_sender

src-tauri/src/download_manager/download_manager_builder.rs

@@ -11,17 +11,14 @@ use log::{debug, error, info, warn};
 use tauri::{AppHandle, Emitter};
 
 use crate::{
+    database::models::data::DownloadableMetadata,
     error::application_download_error::ApplicationDownloadError,
     games::library::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
 };
 
 use super::{
     download_manager::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},
-    download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+    downloadable::Downloadable, util::{download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag}, progress_object::ProgressObject, queue::Queue},
-    downloadable::Downloadable,
-    downloadable_metadata::DownloadableMetadata,
-    progress_object::ProgressObject,
-    queue::Queue,
 };
 
 pub type DownloadAgent = Arc<Box<dyn Downloadable + Send + Sync>>;
@@ -209,12 +206,16 @@ impl DownloadManagerBuilder {
         }
 
         if self.current_download_agent.is_some() {
+            if self.download_queue.read().front().unwrap()
+                == &self.current_download_agent.as_ref().unwrap().metadata()
+            {
                 debug!(
                     "Current download agent: {:?}",
                     self.current_download_agent.as_ref().unwrap().metadata()
                 );
                 return;
             }
+        }
 
         debug!("current download queue: {:?}", self.download_queue.read());
 
@@ -253,7 +254,7 @@ impl DownloadManagerBuilder {
                 }
                 Err(e) => {
                     error!("download {:?} has error {}", download_agent.metadata(), &e);
-                    download_agent.on_error(&app_handle, e.clone());
+                    download_agent.on_error(&app_handle, &e);
                     sender.send(DownloadManagerSignal::Error(e)).unwrap();
                 }
             }
@@ -285,7 +286,7 @@ impl DownloadManagerBuilder {
     fn manage_error_signal(&mut self, error: ApplicationDownloadError) {
         debug!("got signal Error");
         if let Some(current_agent) = self.current_download_agent.clone() {
-            current_agent.on_error(&self.app_handle, error.clone());
+            current_agent.on_error(&self.app_handle, &error);
 
             self.stop_and_wait_current_download();
             self.remove_and_cleanup_front_download(&current_agent.metadata());

src-tauri/src/download_manager/downloadable.rs

@@ -2,11 +2,13 @@ use std::sync::Arc;
 
 use tauri::AppHandle;
 
-use crate::error::application_download_error::ApplicationDownloadError;
+use crate::{
+    database::models::data::DownloadableMetadata,
+    error::application_download_error::ApplicationDownloadError,
+};
 
 use super::{
-    download_manager::DownloadStatus, download_thread_control_flag::DownloadThreadControl,
+    download_manager::DownloadStatus, util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},
-    downloadable_metadata::DownloadableMetadata, progress_object::ProgressObject,
 };
 
 pub trait Downloadable: Send + Sync {
@@ -16,7 +18,7 @@ pub trait Downloadable: Send + Sync {
     fn status(&self) -> DownloadStatus;
     fn metadata(&self) -> DownloadableMetadata;
     fn on_initialised(&self, app_handle: &AppHandle);
-    fn on_error(&self, app_handle: &AppHandle, error: ApplicationDownloadError);
+    fn on_error(&self, app_handle: &AppHandle, error: &ApplicationDownloadError);
     fn on_complete(&self, app_handle: &AppHandle);
     fn on_incomplete(&self, app_handle: &AppHandle);
     fn on_cancelled(&self, app_handle: &AppHandle);

src-tauri/src/download_manager/downloadable_metadata.rs

@@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone, Copy)]
-pub enum DownloadType {
-    Game,
-    Tool,
-    DLC,
-    Mod,
-}
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, 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,
-        }
-    }
-}

src-tauri/src/download_manager/internal_error.rs

@@ -1,27 +0,0 @@
-use std::{fmt::Display, io, sync::mpsc::SendError};
-
-use serde_with::SerializeDisplay;
-
-#[derive(SerializeDisplay)]
-pub enum InternalError<T> {
-    IOError(io::Error),
-    SignalError(SendError<T>),
-}
-impl<T> Display for InternalError<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            InternalError::IOError(error) => write!(f, "{}", error),
-            InternalError::SignalError(send_error) => write!(f, "{}", send_error),
-        }
-    }
-}
-impl<T> From<SendError<T>> for InternalError<T> {
-    fn from(value: SendError<T>) -> Self {
-        InternalError::SignalError(value)
-    }
-}
-impl<T> From<io::Error> for InternalError<T> {
-    fn from(value: io::Error) -> Self {
-        InternalError::IOError(value)
-    }
-}

src-tauri/src/download_manager/mod.rs

@@ -1,10 +1,5 @@
 pub mod commands;
 pub mod download_manager;
 pub mod download_manager_builder;
-pub mod download_thread_control_flag;
 pub mod downloadable;
-pub mod downloadable_metadata;
+pub mod util;
-pub mod internal_error;
-pub mod progress_object;
-pub mod queue;
-pub mod rolling_progress_updates;

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

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

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

@@ -10,8 +10,10 @@ use std::{
 use atomic_instant_full::AtomicInstant;
 use throttle_my_fn::throttle;
 
+use crate::download_manager::download_manager::DownloadManagerSignal;
+
 use super::{
-    download_manager::DownloadManagerSignal, rolling_progress_updates::RollingProgressWindow,
+    rolling_progress_updates::RollingProgressWindow,
 };
 
 #[derive(Clone)]

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

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

src-tauri/src/error/application_download_error.rs

@@ -8,7 +8,7 @@ use serde_with::SerializeDisplay;
 use super::{remote_access_error::RemoteAccessError, setup_error::SetupError};
 
 // TODO: Rename / separate from downloads
-#[derive(Debug, Clone, SerializeDisplay)]
+#[derive(Debug, SerializeDisplay)]
 pub enum ApplicationDownloadError {
     Communication(RemoteAccessError),
     Checksum,

src-tauri/src/error/backup_error.rs

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

src-tauri/src/error/download_manager_error.rs

@@ -0,0 +1,27 @@
+use std::{fmt::Display, io, sync::mpsc::SendError};
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum DownloadManagerError<T> {
+    IOError(io::Error),
+    SignalError(SendError<T>),
+}
+impl<T> Display for DownloadManagerError<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DownloadManagerError::IOError(error) => write!(f, "{}", error),
+            DownloadManagerError::SignalError(send_error) => write!(f, "{}", send_error),
+        }
+    }
+}
+impl<T> From<SendError<T>> for DownloadManagerError<T> {
+    fn from(value: SendError<T>) -> Self {
+        DownloadManagerError::SignalError(value)
+    }
+}
+impl<T> From<io::Error> for DownloadManagerError<T> {
+    fn from(value: io::Error) -> Self {
+        DownloadManagerError::IOError(value)
+    }
+}

src-tauri/src/error/mod.rs

@@ -1,6 +1,8 @@
 pub mod application_download_error;
 pub mod drop_server_error;
+pub mod download_manager_error;
 pub mod library_error;
 pub mod process_error;
 pub mod remote_access_error;
 pub mod setup_error;
+pub mod backup_error;

src-tauri/src/error/process_error.rs

@@ -11,6 +11,7 @@ pub enum ProcessError {
     InvalidID,
     InvalidVersion,
     IOError(Error),
+    FormatError(String), // String errors supremacy
     InvalidPlatform,
 }
 
@@ -25,6 +26,7 @@ impl Display for ProcessError {
             ProcessError::InvalidVersion => "Invalid Game version",
             ProcessError::IOError(error) => &error.to_string(),
             ProcessError::InvalidPlatform => "This Game cannot be played on the current platform",
+            ProcessError::FormatError(e) => &format!("Failed to format template: {}", e),
         };
         write!(f, "{}", s)
     }

src-tauri/src/error/remote_access_error.rs

@@ -10,24 +10,29 @@ use url::ParseError;
 
 use super::drop_server_error::DropServerError;
 
-#[derive(Debug, Clone, SerializeDisplay)]
+#[derive(Debug, SerializeDisplay)]
 pub enum RemoteAccessError {
     FetchError(Arc<reqwest::Error>),
     ParsingError(ParseError),
     InvalidEndpoint,
     HandshakeFailed(String),
-    GameNotFound,
+    GameNotFound(String),
     InvalidResponse(DropServerError),
     InvalidRedirect,
     ManifestDownloadFailed(StatusCode, String),
     OutOfSync,
-    Generic(String),
+    Cache(cacache::Error),
 }
 
 impl Display for RemoteAccessError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            RemoteAccessError::FetchError(error) => write!(
+            RemoteAccessError::FetchError(error) => {
+                if error.is_connect() {
+                    return write!(f, "Failed to connect to Drop server. Check if you access Drop through a browser, and then try again.");
+                }
+
+                write!(
                     f,
                     "{}: {}",
                     error,
@@ -36,13 +41,14 @@ impl Display for RemoteAccessError {
                         .map(|e| e.to_string())
                         .or_else(|| Some("Unknown error".to_string()))
                         .unwrap()
-            ),
+                )
+            },
             RemoteAccessError::ParsingError(parse_error) => {
                 write!(f, "{}", parse_error)
             }
             RemoteAccessError::InvalidEndpoint => write!(f, "invalid drop endpoint"),
             RemoteAccessError::HandshakeFailed(message) => write!(f, "failed to complete handshake: {}", message),
-            RemoteAccessError::GameNotFound => write!(f, "could not find game on server"),
+            RemoteAccessError::GameNotFound(id) => write!(f, "could not find game on server: {}", id),
             RemoteAccessError::InvalidResponse(error) => write!(f, "server returned an invalid response: {} {}", error.status_code, error.status_message),
             RemoteAccessError::InvalidRedirect => write!(f, "server redirect was invalid"),
             RemoteAccessError::ManifestDownloadFailed(status, response) => write!(
@@ -51,7 +57,7 @@ impl Display for RemoteAccessError {
                 status, response
             ),
             RemoteAccessError::OutOfSync => write!(f, "server's and client's time are out of sync. Please ensure they are within at least 30 seconds of each other"),
-            RemoteAccessError::Generic(message) => write!(f, "{}", message),
+            RemoteAccessError::Cache(error) => write!(f, "Cache Error: {}", error),
         }
     }
 }

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

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+use crate::games::library::Game;
+
+pub type Collections = Vec<Collection>;
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct Collection {
+    id: String,
+    name: String,
+    is_default: bool,
+    user_id: String,
+    entries: Vec<CollectionObject>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionObject {
+    collection_id: String,
+    game_id: String,
+    game: Game,
+}

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

@@ -0,0 +1,110 @@
+use reqwest::blocking::Client;
+use serde_json::json;
+use url::Url;
+
+use crate::{
+    database::db::DatabaseImpls,
+    error::remote_access_error::RemoteAccessError,
+    remote::{auth::generate_authorization_header, requests::make_request},
+    DB,
+};
+
+use super::collection::{Collection, Collections};
+
+#[tauri::command]
+pub fn fetch_collections() -> Result<Collections, RemoteAccessError> {
+    let client = Client::new();
+    let response = make_request(&client, &["/api/v1/client/collection"], &[], |r| {
+        r.header("Authorization", generate_authorization_header())
+    })?
+    .send()?;
+
+    Ok(response.json()?)
+}
+
+#[tauri::command]
+pub fn fetch_collection(collection_id: String) -> Result<Collection, RemoteAccessError> {
+    let client = Client::new();
+    let response = make_request(
+        &client,
+        &["/api/v1/client/collection/", &collection_id],
+        &[],
+        |r| r.header("Authorization", generate_authorization_header()),
+    )?
+    .send()?;
+
+    Ok(response.json()?)
+}
+
+#[tauri::command]
+pub fn create_collection(name: String) -> Result<Collection, RemoteAccessError> {
+    let client = Client::new();
+    let base_url = DB.fetch_base_url();
+
+    let base_url = Url::parse(&format!("{}api/v1/client/collection/", base_url))?;
+
+    let response = client
+        .post(base_url)
+        .header("Authorization", generate_authorization_header())
+        .json(&json!({"name": name}))
+        .send()?;
+
+    Ok(response.json()?)
+}
+
+#[tauri::command]
+pub fn add_game_to_collection(
+    collection_id: String,
+    game_id: String,
+) -> Result<(), RemoteAccessError> {
+    let client = Client::new();
+    let url = Url::parse(&format!(
+        "{}api/v1/client/collection/{}/entry/",
+        DB.fetch_base_url(),
+        collection_id
+    ))?;
+
+    client
+        .post(url)
+        .header("Authorization", generate_authorization_header())
+        .json(&json!({"id": game_id}))
+        .send()?;
+    Ok(())
+}
+
+#[tauri::command]
+pub fn delete_collection(collection_id: String) -> Result<bool, RemoteAccessError> {
+    let client = Client::new();
+    let base_url = Url::parse(&format!(
+        "{}api/v1/client/collection/{}",
+        DB.fetch_base_url(),
+        collection_id
+    ))?;
+
+    let response = client
+        .delete(base_url)
+        .header("Authorization", generate_authorization_header())
+        .send()?;
+
+    Ok(response.json()?)
+}
+#[tauri::command]
+pub fn delete_game_in_collection(
+    collection_id: String,
+    game_id: String,
+) -> Result<(), RemoteAccessError> {
+    let client = Client::new();
+    let base_url = Url::parse(&format!(
+        "{}api/v1/client/collection/{}/entry",
+        DB.fetch_base_url(),
+        collection_id
+    ))?;
+
+    client
+        .delete(base_url)
+        .header("Authorization", generate_authorization_header())
+        .json(&json!({"id": game_id}))
+        .send()?;
+
+    Ok(())
+}

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

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

src-tauri/src/games/commands.rs

@@ -3,7 +3,13 @@ use std::sync::Mutex;
 use tauri::AppHandle;
 
 use crate::{
-    database::db::GameVersion, error::{library_error::LibraryError, remote_access_error::RemoteAccessError}, games::library::{get_current_meta, uninstall_game_logic}, AppState
+    database::models::data::GameVersion,
+    error::{library_error::LibraryError, remote_access_error::RemoteAccessError},
+    games::library::{
+        fetch_game_logic_offline, fetch_library_logic_offline, get_current_meta,
+        uninstall_game_logic,
+    },
+    offline, AppState,
 };
 
 use super::{
@@ -15,16 +21,29 @@ use super::{
 };
 
 #[tauri::command]
-pub fn fetch_library(app: AppHandle) -> Result<Vec<Game>, RemoteAccessError> {
+pub fn fetch_library(
-    fetch_library_logic(app)
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<Vec<Game>, RemoteAccessError> {
+    offline!(
+        state,
+        fetch_library_logic,
+        fetch_library_logic_offline,
+        state
+    )
 }
 
 #[tauri::command]
 pub fn fetch_game(
     game_id: String,
-    app: tauri::AppHandle,
+    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
-    fetch_game_logic(game_id, app)
+    offline!(
+        state,
+        fetch_game_logic,
+        fetch_game_logic_offline,
+        game_id,
+        state
+    )
 }
 
 #[tauri::command]
@@ -38,7 +57,6 @@ pub fn uninstall_game(game_id: String, app_handle: AppHandle) -> Result<(), Libr
         Some(data) => data,
         None => return Err(LibraryError::MetaNotFound(game_id)),
     };
-    println!("{:?}", meta);
     uninstall_game_logic(meta, &app_handle);
 
     Ok(())

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

@@ -3,9 +3,7 @@ use std::sync::{Arc, Mutex};
 use crate::{
     download_manager::{
         download_manager::DownloadManagerSignal, downloadable::Downloadable,
-        internal_error::InternalError,
+    }, error::download_manager_error::DownloadManagerError, AppState
-    },
-    AppState,
 };
 
 use super::download_agent::GameDownloadAgent;
@@ -16,7 +14,7 @@ pub fn download_game(
     game_version: String,
     install_dir: usize,
     state: tauri::State<'_, Mutex<AppState>>,
-) -> Result<(), InternalError<DownloadManagerSignal>> {
+) -> Result<(), DownloadManagerError<DownloadManagerSignal>> {
     let sender = state.lock().unwrap().download_manager.get_sender();
     let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new(
         game_id,

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

@@ -1,15 +1,12 @@
 use crate::auth::generate_authorization_header;
-use crate::database::db::{
+use crate::database::db::borrow_db_checked;
-    borrow_db_checked, set_game_status, ApplicationTransientStatus, DatabaseImpls,
+use crate::database::models::data::{
-    GameDownloadStatus,
+    ApplicationTransientStatus, DownloadType, DownloadableMetadata, GameDownloadStatus,
 };
 use crate::download_manager::download_manager::{DownloadManagerSignal, DownloadStatus};
-use crate::download_manager::download_thread_control_flag::{
-    DownloadThreadControl, DownloadThreadControlFlag,
-};
 use crate::download_manager::downloadable::Downloadable;
-use crate::download_manager::downloadable_metadata::{DownloadType, DownloadableMetadata};
+use crate::download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
-use crate::download_manager::progress_object::{ProgressHandle, ProgressObject};
+use crate::download_manager::util::progress_object::{ProgressHandle, ProgressObject};
 use crate::error::application_download_error::ApplicationDownloadError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::downloads::manifest::{DropDownloadContext, DropManifest};
@@ -25,7 +22,6 @@ use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use tauri::{AppHandle, Emitter};
-use urlencoding::encode;
 
 #[cfg(target_os = "linux")]
 use rustix::fs::{fallocate, FallocateFlags};
@@ -99,6 +95,7 @@ impl GameDownloadAgent {
         push_game_update(
             app_handle,
             &self.metadata().id,
+            None,
             (
                 None,
                 Some(ApplicationTransientStatus::Downloading {
@@ -135,7 +132,7 @@ impl GameDownloadAgent {
             &[("id", &self.id), ("version", &self.version)],
             |f| f.header("Authorization", header),
         )
-        .map_err(|e| ApplicationDownloadError::Communication(e))?
+        .map_err(ApplicationDownloadError::Communication)?
         .send()
         .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
 
@@ -250,6 +247,7 @@ impl GameDownloadAgent {
         let completed_indexes_loop_arc = completed_indexes.clone();
 
         let contexts = self.contexts.lock().unwrap();
+        debug!("{:#?}", contexts);
         pool.scope(|scope| {
             let client = &reqwest::blocking::Client::new();
             for (index, context) in contexts.iter().enumerate() {
@@ -280,9 +278,13 @@ impl GameDownloadAgent {
                 ) {
                     Ok(request) => request,
                     Err(e) => {
-                        sender.send(DownloadManagerSignal::Error(ApplicationDownloadError::Communication(e))).unwrap();
+                        sender
+                            .send(DownloadManagerSignal::Error(
+                                ApplicationDownloadError::Communication(e),
+                            ))
+                            .unwrap();
                         continue;
-                    },
+                    }
                 };
 
                 scope.spawn(move |_| {
@@ -362,7 +364,7 @@ impl Downloadable for GameDownloadAgent {
         *self.status.lock().unwrap() = DownloadStatus::Queued;
     }
 
-    fn on_error(&self, app_handle: &tauri::AppHandle, error: ApplicationDownloadError) {
+    fn on_error(&self, app_handle: &tauri::AppHandle, error: &ApplicationDownloadError) {
         *self.status.lock().unwrap() = DownloadStatus::Error;
         app_handle
             .emit("download_error", error.to_string())
@@ -370,9 +372,11 @@ impl Downloadable for GameDownloadAgent {
 
         error!("error while managing download: {}", error);
 
-        set_game_status(app_handle, self.metadata(), |db_handle, meta| {
+        let mut handle = DB.borrow_data_mut().unwrap();
-            db_handle.applications.transient_statuses.remove(meta);
+        handle
-        });
+            .applications
+            .transient_statuses
+            .remove(&self.metadata());
     }
 
     fn on_complete(&self, app_handle: &tauri::AppHandle) {
@@ -394,6 +398,7 @@ impl Downloadable for GameDownloadAgent {
                 GameUpdateEvent {
                     game_id: meta.id.clone(),
                     status: (Some(GameDownloadStatus::Remote {}), None),
+                    version: None,
                 },
             )
             .unwrap();

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

@@ -1,7 +1,5 @@
-use crate::download_manager::download_thread_control_flag::{
+use crate::download_manager::util::download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag};
-    DownloadThreadControl, DownloadThreadControlFlag,
+use crate::download_manager::util::progress_object::ProgressHandle;
-};
-use crate::download_manager::progress_object::ProgressHandle;
 use crate::error::application_download_error::ApplicationDownloadError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::downloads::manifest::DropDownloadContext;

src-tauri/src/games/library.rs

@@ -5,25 +5,29 @@ use std::thread::spawn;
 use log::{debug, error, warn};
 use serde::{Deserialize, Serialize};
 use tauri::Emitter;
-use tauri::{AppHandle, Manager};
+use tauri::AppHandle;
 
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked, save_db, GameVersion};
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked, save_db};
-use crate::database::db::{ApplicationTransientStatus, GameDownloadStatus};
+use crate::database::models::data::{
+    ApplicationTransientStatus, DownloadableMetadata, GameDownloadStatus, GameVersion,
+};
 use crate::download_manager::download_manager::DownloadStatus;
-use crate::download_manager::downloadable_metadata::DownloadableMetadata;
+use crate::error::library_error::LibraryError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::state::{GameStatusManager, GameStatusWithTransient};
 use crate::remote::auth::generate_authorization_header;
+use crate::remote::cache::{cache_object, get_cached_object, get_cached_object_db};
 use crate::remote::requests::make_request;
-use crate::AppState;
+use crate::{AppState, DB};
 
-#[derive(serde::Serialize)]
+#[derive(Serialize, Deserialize)]
 pub struct FetchGameStruct {
     game: Game,
     status: GameStatusWithTransient,
+    version: Option<GameVersion>,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct Game {
     id: String,
@@ -32,10 +36,11 @@ pub struct Game {
     m_description: String,
     // mDevelopers
     // mPublishers
-    m_icon_id: String,
+    m_icon_object_id: String,
-    m_banner_id: String,
+    m_banner_object_id: String,
-    m_cover_id: String,
+    m_cover_object_id: String,
-    m_image_library: Vec<String>,
+    m_image_library_object_ids: Vec<String>,
+    m_image_carousel_object_ids: Vec<String>,
 }
 #[derive(serde::Serialize, Clone)]
 pub struct GameUpdateEvent {
@@ -44,6 +49,7 @@ pub struct GameUpdateEvent {
         Option<GameDownloadStatus>,
         Option<ApplicationTransientStatus>,
     ),
+    pub version: Option<GameVersion>,
 }
 
 #[derive(Serialize, Clone)]
@@ -66,7 +72,9 @@ pub struct StatsUpdateEvent {
     pub time: usize,
 }
 
-pub fn fetch_library_logic(app: AppHandle) -> Result<Vec<Game>, RemoteAccessError> {
+pub fn fetch_library_logic(
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<Vec<Game>, RemoteAccessError> {
     let header = generate_authorization_header();
 
     let client = reqwest::blocking::Client::new();
@@ -81,9 +89,8 @@ pub fn fetch_library_logic(app: AppHandle) -> Result<Vec<Game>, RemoteAccessErro
         return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let games: Vec<Game> = response.json()?;
+    let mut games: Vec<Game> = response.json()?;
 
-    let state = app.state::<Mutex<AppState>>();
     let mut handle = state.lock().unwrap();
 
     let mut db_handle = borrow_db_mut_checked();
@@ -98,18 +105,63 @@ pub fn fetch_library_logic(app: AppHandle) -> Result<Vec<Game>, RemoteAccessErro
         }
     }
 
+    // Add games that are installed but no longer in library
+    for (_, meta) in &db_handle.applications.installed_game_version {
+        if games.iter().find(|e| e.id == meta.id).is_some() {
+            continue;
+        }
+        // We should always have a cache of the object
+        // Pass db_handle because otherwise we get a gridlock
+        let game = get_cached_object_db::<String, Game>(meta.id.clone(), &db_handle)?;
+        games.push(game);
+    }
+
     drop(handle);
+    drop(db_handle);
+    cache_object("library", &games)?;
 
     Ok(games)
 }
+pub fn fetch_library_logic_offline(
+    _state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<Vec<Game>, RemoteAccessError> {
+    let mut games: Vec<Game> = get_cached_object("library")?;
 
+    let db_handle = borrow_db_checked();
+
+    games.retain(|game| {
+        db_handle
+            .applications
+            .installed_game_version
+            .contains_key(&game.id)
+    });
+
+    Ok(games)
+}
 pub fn fetch_game_logic(
     id: String,
-    app: tauri::AppHandle,
+    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
-    let state = app.state::<Mutex<AppState>>();
     let mut state_handle = state.lock().unwrap();
 
+    let handle = DB.borrow_data().unwrap();
+
+    let metadata_option = handle.applications.installed_game_version.get(&id);
+    let version = match metadata_option {
+        None => None,
+        Some(metadata) => Some(
+            handle
+                .applications
+                .game_versions
+                .get(&metadata.id)
+                .unwrap()
+                .get(metadata.version.as_ref().unwrap())
+                .unwrap()
+                .clone(),
+        ),
+    };
+    drop(handle);
+
     let game = state_handle.games.get(&id);
     if let Some(game) = game {
         let status = GameStatusManager::fetch_state(&id);
@@ -117,18 +169,21 @@ pub fn fetch_game_logic(
         let data = FetchGameStruct {
             game: game.clone(),
             status,
+            version,
         };
 
+        cache_object(id, game)?;
+
         return Ok(data);
     }
     let client = reqwest::blocking::Client::new();
-    let response = make_request(&client, &["/api/v1/game/", &id], &[], |r| {
+    let response = make_request(&client, &["/api/v1/client/game/", &id], &[], |r| {
         r.header("Authorization", generate_authorization_header())
     })?
     .send()?;
 
     if response.status() == 404 {
-        return Err(RemoteAccessError::GameNotFound);
+        return Err(RemoteAccessError::GameNotFound(id));
     }
     if response.status() != 200 {
         let err = response.json().unwrap();
@@ -153,11 +208,45 @@ pub fn fetch_game_logic(
     let data = FetchGameStruct {
         game: game.clone(),
         status,
+        version,
     };
 
+    cache_object(id, &game)?;
+
     Ok(data)
 }
 
+pub fn fetch_game_logic_offline(
+    id: String,
+    _state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<FetchGameStruct, RemoteAccessError> {
+    let handle = DB.borrow_data().unwrap();
+    let metadata_option = handle.applications.installed_game_version.get(&id);
+    let version = match metadata_option {
+        None => None,
+        Some(metadata) => Some(
+            handle
+                .applications
+                .game_versions
+                .get(&metadata.id)
+                .unwrap()
+                .get(metadata.version.as_ref().unwrap())
+                .unwrap()
+                .clone(),
+        ),
+    };
+    drop(handle);
+
+    let status = GameStatusManager::fetch_state(&id);
+    let game = get_cached_object::<String, Game>(id)?;
+
+    Ok(FetchGameStruct {
+        game,
+        status,
+        version,
+    })
+}
+
 pub fn fetch_game_verion_options_logic(
     game_id: String,
     state: tauri::State<'_, Mutex<AppState>>,
@@ -193,7 +282,7 @@ pub fn fetch_game_verion_options_logic(
 }
 
 pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle) {
-    println!("triggered uninstall for agent");
+    debug!("triggered uninstall for agent");
     let mut db_handle = borrow_db_mut_checked();
     db_handle
         .applications
@@ -204,6 +293,7 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
     push_game_update(
         app_handle,
         &meta.id,
+        None,
         (None, Some(ApplicationTransientStatus::Uninstalling {})),
     );
 
@@ -213,6 +303,7 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
         return;
     }
     let previous_state = previous_state.unwrap();
+
     if let Some((_, install_dir)) = match previous_state {
         GameDownloadStatus::Installed {
             version_name,
@@ -229,6 +320,7 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
             .transient_statuses
             .entry(meta.clone())
             .and_modify(|v| *v = ApplicationTransientStatus::Uninstalling {});
+
         drop(db_handle);
 
         let app_handle = app_handle.clone();
@@ -239,6 +331,10 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
             Ok(_) => {
                 let mut db_handle = borrow_db_mut_checked();
                 db_handle.applications.transient_statuses.remove(&meta);
+                db_handle
+                    .applications
+                    .installed_game_version
+                    .remove(&meta.id);
                 db_handle
                     .applications
                     .game_statuses
@@ -248,10 +344,12 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
                 save_db();
 
                 debug!("uninstalled game id {}", &meta.id);
+                app_handle.emit("update_library", {}).unwrap();
 
                 push_game_update(
                     &app_handle,
                     &meta.id,
+                    None,
                     (Some(GameDownloadStatus::Remote {}), None),
                 );
             }
@@ -274,7 +372,7 @@ pub fn on_game_complete(
 ) -> Result<(), RemoteAccessError> {
     // Fetch game version information from remote
     if meta.version.is_none() {
-        return Err(RemoteAccessError::GameNotFound);
+        return Err(RemoteAccessError::GameNotFound(meta.id.clone()));
     }
 
     let header = generate_authorization_header();
@@ -282,7 +380,7 @@ pub fn on_game_complete(
     let client = reqwest::blocking::Client::new();
     let response = make_request(
         &client,
-        &["/api/v1/client/metadata/version"],
+        &["/api/v1/client/game/version"],
         &[
             ("id", &meta.id),
             ("version", meta.version.as_ref().unwrap()),
@@ -291,7 +389,7 @@ pub fn on_game_complete(
     )?
     .send()?;
 
-    let data: GameVersion = response.json()?;
+    let game_version: GameVersion = response.json()?;
 
     let mut handle = borrow_db_mut_checked();
     handle
@@ -299,7 +397,7 @@ pub fn on_game_complete(
         .game_versions
         .entry(meta.id.clone())
         .or_default()
-        .insert(meta.version.clone().unwrap(), data.clone());
+        .insert(meta.version.clone().unwrap(), game_version.clone());
     handle
         .applications
         .installed_game_version
@@ -308,7 +406,7 @@ pub fn on_game_complete(
     drop(handle);
     save_db();
 
-    let status = if data.setup_command.is_empty() {
+    let status = if game_version.setup_command.is_empty() {
         GameDownloadStatus::Installed {
             version_name: meta.version.clone().unwrap(),
             install_dir,
@@ -333,6 +431,7 @@ pub fn on_game_complete(
             GameUpdateEvent {
                 game_id: meta.id.clone(),
                 status: (Some(status), None),
+                version: Some(game_version),
             },
         )
         .unwrap();
@@ -340,14 +439,68 @@ pub fn on_game_complete(
     Ok(())
 }
 
-pub fn push_game_update(app_handle: &AppHandle, game_id: &String, status: GameStatusWithTransient) {
+pub fn push_game_update(
+    app_handle: &AppHandle,
+    game_id: &String,
+    version: Option<GameVersion>,
+    status: GameStatusWithTransient,
+) {
     app_handle
         .emit(
             &format!("update_game/{}", game_id),
             GameUpdateEvent {
                 game_id: game_id.clone(),
                 status,
+                version,
             },
         )
         .unwrap();
 }
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendGameOptions {
+    launch_string: String,
+}
+
+#[tauri::command]
+pub fn update_game_configuration(
+    game_id: String,
+    options: FrontendGameOptions,
+) -> Result<(), LibraryError> {
+    let mut handle = DB.borrow_data_mut().unwrap();
+    let installed_version = handle
+        .applications
+        .installed_game_version
+        .get(&game_id)
+        .ok_or(LibraryError::MetaNotFound(game_id))?;
+
+    let id = installed_version.id.clone();
+    let version = installed_version.version.clone().unwrap();
+
+    let mut existing_configuration = handle
+        .applications
+        .game_versions
+        .get(&id)
+        .unwrap()
+        .get(&version)
+        .unwrap()
+        .clone();
+
+    // Add more options in here
+    existing_configuration.launch_command_template = options.launch_string;
+
+    // Add no more options past here
+
+    handle
+        .applications
+        .game_versions
+        .get_mut(&id)
+        .unwrap()
+        .insert(version.to_string(), existing_configuration);
+
+    drop(handle);
+    save_db();
+
+    Ok(())
+}

src-tauri/src/games/mod.rs

@@ -1,3 +1,4 @@
+pub mod collections;
 pub mod commands;
 pub mod downloads;
 pub mod library;

src-tauri/src/games/state.rs

@@ -1,4 +1,7 @@
-use crate::database::db::{borrow_db_checked, ApplicationTransientStatus, GameDownloadStatus};
+use crate::database::{
+    db::borrow_db_checked,
+    models::data::{ApplicationTransientStatus, GameDownloadStatus},
+};
 
 pub type GameStatusWithTransient = (
     Option<GameDownloadStatus>,

src-tauri/src/lib.rs

@@ -1,39 +1,38 @@
-#![feature(try_trait_v2)]
-
 mod database;
 mod games;
 
-mod autostart;
+mod client;
-mod cleanup;
-mod commands;
 mod download_manager;
 mod error;
 mod process;
 mod remote;
 
 use crate::database::db::DatabaseImpls;
-use autostart::{get_autostart_enabled, toggle_autostart};
+use client::{
-use cleanup::{cleanup_and_exit, quit};
+    autostart::{get_autostart_enabled, sync_autostart_on_startup, toggle_autostart},
-use commands::fetch_state;
+    cleanup::{cleanup_and_exit, quit},
+};
+use client::commands::fetch_state;
 use database::commands::{
     add_download_dir, delete_download_dir, fetch_download_dir_stats, fetch_settings,
     fetch_system_data, update_settings,
 };
-use database::db::{
+use database::db::{borrow_db_checked, borrow_db_mut_checked, DatabaseInterface, DATA_ROOT_DIR};
-    borrow_db_checked, borrow_db_mut_checked, DatabaseInterface, GameDownloadStatus, DATA_ROOT_DIR,
+use database::models::data::GameDownloadStatus;
-};
 use download_manager::commands::{
     cancel_game, move_download_in_queue, pause_downloads, resume_downloads,
 };
 use download_manager::download_manager::DownloadManager;
 use download_manager::download_manager_builder::DownloadManagerBuilder;
+use games::collections::commands::{
+    add_game_to_collection, create_collection, delete_collection, delete_game_in_collection,
+    fetch_collection, fetch_collections,
+};
 use games::commands::{
     fetch_game, fetch_game_status, fetch_game_verion_options, fetch_library, uninstall_game,
 };
 use games::downloads::commands::download_game;
-use games::library::Game;
+use games::library::{update_game_configuration, Game};
-use http::Response;
-use http::{header::*, response::Builder as ResponseBuilder};
 use log::{debug, info, warn, LevelFilter};
 use log4rs::append::console::ConsoleAppender;
 use log4rs::append::file::FileAppender;
@@ -42,11 +41,13 @@ use log4rs::encode::pattern::PatternEncoder;
 use log4rs::Config;
 use process::commands::{kill_game, launch_game};
 use process::process_manager::ProcessManager;
-use remote::auth::{self, generate_authorization_header, recieve_handshake};
+use remote::auth::{self, recieve_handshake};
 use remote::commands::{
-    auth_initiate, gen_drop_url, manual_recieve_handshake, retry_connect, sign_out, use_remote,
+    auth_initiate, fetch_drop_object, gen_drop_url, manual_recieve_handshake, retry_connect,
+    sign_out, use_remote,
 };
-use remote::requests::make_request;
+use remote::fetch_object::{fetch_object, fetch_object_offline};
+use remote::server_proto::{handle_server_proto, handle_server_proto_offline};
 use serde::{Deserialize, Serialize};
 use std::env;
 use std::path::Path;
@@ -56,16 +57,16 @@ use std::{
     collections::HashMap,
     sync::{LazyLock, Mutex},
 };
-use tauri::ipc::IpcResponse;
 use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};
 use tauri::tray::TrayIconBuilder;
 use tauri::{AppHandle, Manager, RunEvent, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
 
-#[derive(Clone, Copy, Serialize)]
+#[derive(Clone, Copy, Serialize, Eq, PartialEq)]
 pub enum AppStatus {
     NotConfigured,
+    Offline,
     ServerError,
     SignedOut,
     SignedIn,
@@ -80,7 +81,7 @@ pub struct User {
     username: String,
     admin: bool,
     display_name: String,
-    profile_picture: String,
+    profile_picture_object_id: String,
 }
 
 #[derive(Clone, Serialize)]
@@ -154,8 +155,8 @@ fn setup(handle: AppHandle) -> AppState<'static> {
     drop(db_handle);
     for (game_id, status) in statuses.into_iter() {
         match status {
-            database::db::GameDownloadStatus::Remote {} => {}
+            GameDownloadStatus::Remote {} => {}
-            database::db::GameDownloadStatus::SetupRequired {
+            GameDownloadStatus::SetupRequired {
                 version_name: _,
                 install_dir,
             } => {
@@ -164,7 +165,7 @@ fn setup(handle: AppHandle) -> AppState<'static> {
                     missing_games.push(game_id);
                 }
             }
-            database::db::GameDownloadStatus::Installed {
+            GameDownloadStatus::Installed {
                 version_name: _,
                 install_dir,
             } => {
@@ -192,7 +193,7 @@ fn setup(handle: AppHandle) -> AppState<'static> {
     debug!("finished setup!");
 
     // Sync autostart state
-    if let Err(e) = autostart::sync_autostart_on_startup(&handle) {
+    if let Err(e) = sync_autostart_on_startup(&handle) {
         warn!("failed to sync autostart state: {}", e);
     }
 
@@ -239,6 +240,7 @@ pub fn run() {
             // Remote
             use_remote,
             gen_drop_url,
+            fetch_drop_object,
             // Library
             fetch_library,
             fetch_game,
@@ -247,6 +249,14 @@ pub fn run() {
             fetch_download_dir_stats,
             fetch_game_status,
             fetch_game_verion_options,
+            update_game_configuration,
+            // Collections
+            fetch_collections,
+            fetch_collection,
+            create_collection,
+            add_game_to_collection,
+            delete_collection,
+            delete_game_in_collection,
             // Downloads
             download_game,
             move_download_in_queue,
@@ -272,10 +282,9 @@ pub fn run() {
             debug!("initialized drop client");
             app.manage(Mutex::new(state));
 
-            #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
             {
                 use tauri_plugin_deep_link::DeepLinkExt;
-                app.deep_link().register_all()?;
+                let _ = app.deep_link().register_all();
                 debug!("registered all pre-defined deep links");
             }
 
@@ -318,6 +327,7 @@ pub fn run() {
                 ],
             )?;
 
+            run_on_tray(|| {
                 TrayIconBuilder::new()
                     .icon(app.default_window_icon().unwrap().clone())
                     .menu(&menu)
@@ -330,11 +340,12 @@ pub fn run() {
                         }
 
                         _ => {
-                        println!("menu event not handled: {:?}", event.id);
+                            warn!("menu event not handled: {:?}", event.id);
                         }
                     })
                     .build(app)
                     .expect("error while setting up tray menu");
+            });
 
             {
                 let mut db_handle = borrow_db_mut_checked();
@@ -359,40 +370,32 @@ pub fn run() {
 
             Ok(())
         })
-        .register_asynchronous_uri_scheme_protocol("object", move |_ctx, request, responder| {
+        .register_asynchronous_uri_scheme_protocol("object", move |ctx, request, responder| {
-            // Drop leading /
+            let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();
-            let object_id = &request.uri().path()[1..];
+            offline!(
-
+                state,
-            let header = generate_authorization_header();
+                fetch_object,
-            let client: reqwest::blocking::Client = reqwest::blocking::Client::new();
+                fetch_object_offline,
-            let response = make_request(&client, &["/api/v1/client/object/", object_id], &[], |f| {
+                request,
-                f.header("Authorization", header)
+                responder
+            );
         })
-            .unwrap()
+        .register_asynchronous_uri_scheme_protocol("server", move |ctx, request, responder| {
-            .send();
+            let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();
-            if response.is_err() {
+            offline!(
-                warn!(
+                state,
-                    "failed to fetch object with error: {}",
+                handle_server_proto,
-                    response.err().unwrap()
+                handle_server_proto_offline,
+                request,
+                responder
             );
-                responder.respond(Response::builder().status(500).body(Vec::new()).unwrap());
-                return;
-            }
-            let response = response.unwrap();
-
-            let resp_builder = ResponseBuilder::new().header(
-                CONTENT_TYPE,
-                response.headers().get("Content-Type").unwrap(),
-            );
-            let data = Vec::from(response.bytes().unwrap());
-            let resp = resp_builder.body(data).unwrap();
-
-            responder.respond(resp);
         })
         .on_window_event(|window, event| {
             if let WindowEvent::CloseRequested { api, .. } = event {
+                run_on_tray(|| {
                     window.hide().unwrap();
                     api.prevent_close();
+                });
             }
         })
         .build(tauri::generate_context!())
@@ -400,9 +403,20 @@ pub fn run() {
 
     app.run(|_app_handle, event| {
         if let RunEvent::ExitRequested { code, api, .. } = event {
+            run_on_tray(|| {
                 if code.is_none() {
                     api.prevent_exit();
                 }
+            });
         }
     });
 }
+
+fn run_on_tray<T: FnOnce() -> ()>(f: T) {
+    if match std::env::var("NO_TRAY_ICON") {
+        Ok(s) => s.to_lowercase() != "true",
+        Err(_) => true,
+    } {
+        (f)();
+    }
+}

src-tauri/src/process/compat.rs

@@ -1,13 +1 @@
-// Since this code isn't being used, we can either:
-// 1. Delete the entire file if compatibility features are not planned
-// 2. Or add a TODO comment if planning to implement later
 
-// Option 1: Delete the file
-// Delete src-tauri/src/process/compat.rs
-
-// Option 2: Add TODO comment
-/*
-TODO: Compatibility layer for running Windows games on Linux
-This module is currently unused but reserved for future implementation
-of Windows game compatibility features on Linux.
-*/

src-tauri/src/process/mod.rs

@@ -1,3 +1,4 @@
 pub mod commands;
+#[cfg(target_os = "linux")]
 pub mod compat;
 pub mod process_manager;

src-tauri/src/process/process_manager.rs

@@ -1,24 +1,29 @@
 use std::{
     collections::HashMap,
-    fs::{File, OpenOptions},
+    fs::OpenOptions,
-    io::{self, Error},
+    io::{self},
-    path::{Path, PathBuf},
+    path::PathBuf,
-    process::{Child, Command, ExitStatus},
+    process::{Command, ExitStatus},
+    str::FromStr,
     sync::{Arc, Mutex},
     thread::spawn,
 };
 
+use dynfmt::Format;
+use dynfmt::SimpleCurlyFormat;
 use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
 use shared_child::SharedChild;
 use tauri::{AppHandle, Manager};
-use umu_wrapper_lib::command_builder::UmuCommandBuilder;
 
 use crate::{
-    database::db::{
+    database::{
-        borrow_db_mut_checked, ApplicationTransientStatus, GameDownloadStatus, GameVersion, DATA_ROOT_DIR
+        db::{borrow_db_mut_checked, DATA_ROOT_DIR},
+        models::data::{
+            ApplicationTransientStatus, DownloadType, DownloadableMetadata, GameDownloadStatus,
+            GameVersion,
+        },
     },
-    download_manager::downloadable_metadata::{DownloadType, DownloadableMetadata},
     error::process_error::ProcessError,
     games::{library::push_game_update, state::GameStatusManager},
     AppState, DB,
@@ -39,11 +44,14 @@ impl ProcessManager<'_> {
         drop(root_dir_lock);
 
         ProcessManager {
-            current_platform: if cfg!(windows) {
+            #[cfg(target_os = "windows")]
-                Platform::Windows
+            current_platform: Platform::Windows,
-            } else {
+
-                Platform::Linux
+            #[cfg(target_os = "macos")]
-            },
+            current_platform: Platform::MacOs,
+
+            #[cfg(target_os = "linux")]
+            current_platform: Platform::Linux,
 
             app_handle,
             processes: HashMap::new(),
@@ -58,6 +66,10 @@ impl ProcessManager<'_> {
                     (Platform::Linux, Platform::Linux),
                     &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
                 ),
+                (
+                    (Platform::MacOs, Platform::MacOs),
+                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
+                ),
                 (
                     (Platform::Linux, Platform::Windows),
                     &UMULauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
@@ -66,20 +78,6 @@ impl ProcessManager<'_> {
         }
     }
 
-    fn process_command(&self, install_dir: &String, command: Vec<String>) -> (PathBuf, Vec<String>) {
-        let root = &command[0];
-
-        let install_dir = Path::new(install_dir);
-        let absolute_exe = install_dir.join(root);
-
-        /*
-        let args = command_components[1..]
-            .iter()
-            .map(|v| v.to_string())
-            .collect();
-         */
-        (absolute_exe, Vec::new())
-    }
     pub fn kill_game(&mut self, game_id: String) -> Result<(), io::Error> {
         match self.processes.get(&game_id) {
             Some(child) => {
@@ -137,7 +135,7 @@ impl ProcessManager<'_> {
 
         let status = GameStatusManager::fetch_state(&game_id);
 
-        push_game_update(&self.app_handle, &game_id, status);
+        push_game_update(&self.app_handle, &game_id, None, status);
 
         // TODO better management
     }
@@ -198,7 +196,6 @@ impl ProcessManager<'_> {
             _ => return Err(ProcessError::NotDownloaded),
         };
 
-
         let game_version = db_lock
             .applications
             .game_versions
@@ -207,37 +204,6 @@ impl ProcessManager<'_> {
             .get(version_name)
             .ok_or(ProcessError::InvalidVersion)?;
 
-        let mut command: Vec<String> = Vec::new();
-
-        match game_status {
-            GameDownloadStatus::Installed {
-                version_name: _,
-                install_dir: _,
-            } => {
-                command.extend([game_version.launch_command.clone()]);
-                command.extend(game_version.launch_args.clone());
-            },
-            GameDownloadStatus::SetupRequired {
-                version_name: _,
-                install_dir: _,
-            } => {
-                command.extend([game_version.setup_command.clone()]);
-                command.extend(game_version.setup_args.clone());
-            },
-            _ => panic!("unreachable code"),
-        };
-        info!("Command: {:?}", &command);
-
-        let (command, args) = self.process_command(install_dir, command);
-
-        let target_current_dir = command.parent().unwrap().to_str().unwrap();
-
-        info!(
-            "launching process {} in {}",
-            command.to_str().unwrap(),
-            target_current_dir
-        );
-
         let current_time = chrono::offset::Local::now();
         let log_file = OpenOptions::new()
             .write(true)
@@ -273,19 +239,58 @@ impl ProcessManager<'_> {
             .get(&(current_platform, target_platform))
             .ok_or(ProcessError::InvalidPlatform)?;
 
-        let launch_process = game_launcher
+        let (launch, args) = match game_status {
-            .launch_process(
+            GameDownloadStatus::Installed {
+                version_name: _,
+                install_dir: _,
+            } => (&game_version.launch_command, &game_version.launch_args),
+            GameDownloadStatus::SetupRequired {
+                version_name: _,
+                install_dir: _,
+            } => (&game_version.setup_command, &game_version.setup_args),
+            GameDownloadStatus::Remote {} => unreachable!("nuh uh"),
+        };
+
+        let launch = PathBuf::from_str(&install_dir).unwrap().join(launch);
+        let launch = launch.to_str().unwrap();
+
+        let launch_string = game_launcher.create_launch_process(
             &meta,
-                command.to_string_lossy().to_string(),
+            launch.to_string(),
+            args.to_vec(),
             game_version,
-                target_current_dir,
+            install_dir,
-                log_file,
+        );
-                error_file,
+
-            )
+        let launch_string = SimpleCurlyFormat
-            .map_err(ProcessError::IOError)?;
+            .format(&game_version.launch_command_template, &[launch_string])
+            .map_err(|e| ProcessError::FormatError(e.to_string()))?
+            .to_string();
+
+        #[cfg(target_os = "windows")]
+        use std::os::windows::process::CommandExt;
+
+        #[cfg(target_os = "windows")]
+        let mut command = Command::new("cmd");
+        #[cfg(target_os = "windows")]
+        command.raw_arg(format!("/C \"{}\"", &launch_string));
+
+        info!("launching (in {}): {}", install_dir, launch_string,);
+
+        #[cfg(unix)]
+        let mut command: Command = Command::new("sh");
+        #[cfg(unix)]
+        command.arg("-c").arg(launch_string);
+
+        command
+            .stderr(error_file)
+            .stdout(log_file)
+            .current_dir(install_dir);
+
+        let child = command.spawn().map_err(ProcessError::IOError)?;
 
         let launch_process_handle =
-            Arc::new(SharedChild::new(launch_process).map_err(ProcessError::IOError)?);
+            Arc::new(SharedChild::new(child).map_err(ProcessError::IOError)?);
 
         db_lock
             .applications
@@ -295,6 +300,7 @@ impl ProcessManager<'_> {
         push_game_update(
             &self.app_handle,
             &meta.id,
+            None,
             (None, Some(ApplicationTransientStatus::Running {})),
         );
 
@@ -322,66 +328,105 @@ impl ProcessManager<'_> {
     }
 }
 
-#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
 pub enum Platform {
     Windows,
     Linux,
+    MacOs,
+}
+
+impl Platform {
+    const WINDOWS: bool = cfg!(target_os = "windows");
+    const MAC: bool = cfg!(target_os = "macos");
+    const LINUX: bool = cfg!(target_os = "linux");
+    #[cfg(target_os = "windows")]
+    pub const HOST: Platform = Self::Windows;
+    #[cfg(target_os = "macos")]
+    pub const HOST: Platform = Self::MacOs;
+    #[cfg(target_os = "linux")]
+    pub const HOST: Platform = Self::Linux;
+
+
+
+    pub fn is_case_sensitive(&self) -> bool {
+        match self {
+            Self::Windows | Self::MacOs => false,
+            Self::Linux => true,
+        }
+    }
+}
+
+impl From<&str> for Platform {
+    fn from(value: &str) -> Self {
+        match value.to_lowercase().trim() {
+            "windows" => Self::Windows,
+            "linux" => Self::Linux,
+            "mac" | "macos" => Self::MacOs,
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl From<whoami::Platform> for Platform {
+    fn from(value: whoami::Platform) -> Self {
+        match value {
+            whoami::Platform::Windows => Platform::Windows,
+            whoami::Platform::Linux => Platform::Linux,
+            whoami::Platform::MacOS => Platform::MacOs,
+            _ => unimplemented!()
+        }
+    }
 }
 
 pub trait ProcessHandler: Send + 'static {
-    fn launch_process(
+    fn create_launch_process(
         &self,
         meta: &DownloadableMetadata,
         launch_command: String,
+        args: Vec<String>,
         game_version: &GameVersion,
         current_dir: &str,
-        log_file: File,
+    ) -> String;
-        error_file: File,
-    ) -> Result<Child, Error>;
 }
 
 struct NativeGameLauncher;
 impl ProcessHandler for NativeGameLauncher {
-    fn launch_process(
+    fn create_launch_process(
         &self,
         _meta: &DownloadableMetadata,
         launch_command: String,
-        game_version: &GameVersion,
+        args: Vec<String>,
-        current_dir: &str,
+        _game_version: &GameVersion,
-        log_file: File,
+        _current_dir: &str,
-        error_file: File,
+    ) -> String {
-    ) -> Result<Child, Error> {
+        format!("\"{}\" {}", launch_command, args.join(" "))
-        Command::new(PathBuf::from(launch_command))
-            .current_dir(current_dir)
-            .stdout(log_file)
-            .stderr(error_file)
-            .args(game_version.launch_args.clone())
-            .spawn()
     }
 }
 
-const UMU_LAUNCHER_EXECUTABLE: &str = "umu-run";
+pub const UMU_LAUNCHER_EXECUTABLE: &str = "umu-run";
 struct UMULauncher;
 impl ProcessHandler for UMULauncher {
-    fn launch_process(
+    fn create_launch_process(
         &self,
         _meta: &DownloadableMetadata,
         launch_command: String,
+        args: Vec<String>,
         game_version: &GameVersion,
         _current_dir: &str,
-        _log_file: File,
+    ) -> String {
-        _error_file: File,
+        debug!("Game override: \"{:?}\"", &game_version.umu_id_override);
-    ) -> Result<Child, Error> {
-        println!("Game override: .{:?}.", &game_version.umu_id_override);
         let game_id = match &game_version.umu_id_override {
-            Some(game_override) => game_override.is_empty().then_some(game_version.game_id.clone()).unwrap_or(game_override.clone()) ,
+            Some(game_override) => game_override
-            None => game_version.game_id.clone()
+                .is_empty()
+                .then_some(game_version.game_id.clone())
+                .unwrap_or(game_override.clone()),
+            None => game_version.game_id.clone(),
         };
-        info!("Game ID: {}", game_id);
+        format!(
-        UmuCommandBuilder::new(UMU_LAUNCHER_EXECUTABLE, launch_command)
+            "GAMEID={game_id} {umu} \"{launch}\" {args}",
-            .game_id(game_id)
+            umu = UMU_LAUNCHER_EXECUTABLE,
-            .launch_args(game_version.launch_args.clone())
+            launch = launch_command,
-            .build()
+            args = args.join(" ")
-            .spawn()
+        )
     }
 }

src-tauri/src/remote/auth.rs

@@ -1,27 +1,37 @@
-use std::{env, sync::Mutex};
+use std::{collections::HashMap, env};
 
 use chrono::Utc;
+use droplet_rs::ssl::sign_nonce;
+use gethostname::gethostname;
 use log::{debug, error, warn};
-use openssl::{ec::EcKey, hash::MessageDigest, pkey::PKey, sign::Signer};
 use serde::{Deserialize, Serialize};
-use tauri::{AppHandle, Emitter, Manager};
+use tauri::{AppHandle, Emitter};
 use url::Url;
 
 use crate::{
-    database::db::{
+    database::{
-        borrow_db_checked, borrow_db_mut_checked, save_db, DatabaseAuth, DatabaseImpls,
+        db::{borrow_db_checked, borrow_db_mut_checked, save_db},
+        models::data::DatabaseAuth,
     },
     error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError},
-    AppState, AppStatus, User, DB,
+    AppStatus, User,
 };
 
-use super::requests::make_request;
+use super::{
+    cache::{cache_object, get_cached_object},
+    requests::make_request,
+};
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct CapabilityConfiguration {}
 
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct InitiateRequestBody {
     name: String,
     platform: String,
+    capabilities: HashMap<String, CapabilityConfiguration>,
 }
 
 #[derive(Serialize)]
@@ -39,20 +49,6 @@ struct HandshakeResponse {
     id: String,
 }
 
-// TODO: Change return value on Err
-pub fn sign_nonce(private_key: String, nonce: String) -> Result<String, ()> {
-    let client_private_key = EcKey::private_key_from_pem(private_key.as_bytes()).unwrap();
-    let pkey_private_key = PKey::from_ec_key(client_private_key).unwrap();
-
-    let mut signer = Signer::new(MessageDigest::sha256(), &pkey_private_key).unwrap();
-    signer.update(nonce.as_bytes()).unwrap();
-    let signature = signer.sign_to_vec().unwrap();
-
-    let hex_signature = hex::encode(signature);
-
-    Ok(hex_signature)
-}
-
 pub fn generate_authorization_header() -> String {
     let certs = {
         let db = borrow_db_checked();
@@ -67,8 +63,6 @@ pub fn generate_authorization_header() -> String {
 }
 
 pub fn fetch_user() -> Result<User, RemoteAccessError> {
-    let base_url = DB.fetch_base_url();
-
     let header = generate_authorization_header();
 
     let client = reqwest::blocking::Client::new();
@@ -115,6 +109,9 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
     let client = reqwest::blocking::Client::new();
     let response = client.post(endpoint).json(&body).send()?;
     debug!("handshake responsded with {}", response.status().as_u16());
+    if !response.status().is_success() {
+        return Err(RemoteAccessError::InvalidResponse(response.json()?));
+    }
     let response_struct: HandshakeResponse = response.json()?;
 
     {
@@ -123,17 +120,28 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
             private: response_struct.private,
             cert: response_struct.certificate,
             client_id: response_struct.id,
+            web_token: None, // gets created later
         });
         drop(handle);
         save_db();
     }
 
-    {
+    let web_token = {
-        let app_state = app.state::<Mutex<AppState>>();
+        let header = generate_authorization_header();
-        let mut app_state_handle = app_state.lock().unwrap();
+        let token = client
-        app_state_handle.status = AppStatus::SignedIn;
+            .post(base_url.join("/api/v1/client/user/webtoken").unwrap())
-        app_state_handle.user = Some(fetch_user()?);
+            .header("Authorization", header)
-    }
+            .send()
+            .unwrap();
+
+        token.text().unwrap()
+    };
+
+    let mut handle = borrow_db_mut_checked();
+    let mut_auth = handle.auth.as_mut().unwrap();
+    mut_auth.web_token = Some(web_token);
+    drop(handle);
+    save_db();
 
     Ok(())
 }
@@ -158,10 +166,16 @@ pub fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
         Url::parse(&db_lock.base_url.clone())?
     };
 
+    let hostname = gethostname();
+
     let endpoint = base_url.join("/api/v1/client/auth/initiate")?;
     let body = InitiateRequestBody {
-        name: "Drop Desktop Client".to_string(),
+        name: format!("{} (Desktop)", hostname.into_string().unwrap()),
         platform: env::consts::OS.to_string(),
+        capabilities: HashMap::from([
+            ("peerAPI".to_owned(), CapabilityConfiguration {}),
+            ("cloudSaves".to_owned(), CapabilityConfiguration {}),
+        ]),
     };
 
     let client = reqwest::blocking::Client::new();
@@ -191,9 +205,13 @@ pub fn setup() -> (AppStatus, Option<User>) {
     if auth.is_some() {
         let user_result = match fetch_user() {
             Ok(data) => data,
-            Err(RemoteAccessError::FetchError(_)) => return (AppStatus::ServerUnavailable, None),
+            Err(RemoteAccessError::FetchError(_)) => {
+                let user = get_cached_object::<String, User>("user".to_owned()).unwrap();
+                return (AppStatus::Offline, Some(user));
+            }
             Err(_) => return (AppStatus::SignedInNeedsReauth, None),
         };
+        cache_object("user", &user_result).unwrap();
         return (AppStatus::SignedIn, Some(user_result));
     }
 

src-tauri/src/remote/cache.rs

@@ -0,0 +1,68 @@
+use crate::{
+    database::{db::borrow_db_checked, models::data::Database},
+    error::remote_access_error::RemoteAccessError,
+};
+use cacache::Integrity;
+use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder, Response};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_binary::binary_stream::Endian;
+
+#[macro_export]
+macro_rules! offline {
+    ($var:expr, $func1:expr, $func2:expr, $( $arg:expr ),* ) => {
+
+        if crate::borrow_db_checked().settings.force_offline || $var.lock().unwrap().status == crate::AppStatus::Offline {
+            $func2( $( $arg ), *)
+        } else {
+            $func1( $( $arg ), *)
+        }
+    }
+}
+
+pub fn cache_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
+    key: K,
+    data: &D,
+) -> Result<Integrity, RemoteAccessError> {
+    let bytes = serde_binary::to_vec(data, Endian::Little).unwrap();
+    cacache::write_sync(&borrow_db_checked().cache_dir, key, bytes)
+        .map_err(|e| RemoteAccessError::Cache(e))
+}
+pub fn get_cached_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
+    key: K,
+) -> Result<D, RemoteAccessError> {
+    get_cached_object_db::<K, D>(key, &borrow_db_checked())
+}
+pub fn get_cached_object_db<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
+    key: K,
+    db: &Database,
+) -> Result<D, RemoteAccessError> {
+    let bytes = cacache::read_sync(&db.cache_dir, key).map_err(|e| RemoteAccessError::Cache(e))?;
+    let data = serde_binary::from_slice::<D>(&bytes, Endian::Little).unwrap();
+    Ok(data)
+}
+#[derive(Serialize, Deserialize)]
+pub struct ObjectCache {
+    content_type: String,
+    body: Vec<u8>,
+}
+
+impl From<Response<Vec<u8>>> for ObjectCache {
+    fn from(value: Response<Vec<u8>>) -> Self {
+        ObjectCache {
+            content_type: value
+                .headers()
+                .get(CONTENT_TYPE)
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_owned(),
+            body: value.body().clone(),
+        }
+    }
+}
+impl From<ObjectCache> for Response<Vec<u8>> {
+    fn from(value: ObjectCache) -> Self {
+        let resp_builder = ResponseBuilder::new().header(CONTENT_TYPE, value.content_type);
+        resp_builder.body(value.body).unwrap()
+    }
+}

src-tauri/src/remote/commands.rs

@@ -1,16 +1,20 @@
 use std::sync::Mutex;
 
+use log::debug;
+use reqwest::blocking::Client;
 use tauri::{AppHandle, Emitter, Manager};
 use url::Url;
 
 use crate::{
     database::db::{borrow_db_checked, borrow_db_mut_checked, save_db},
     error::remote_access_error::RemoteAccessError,
+    remote::{auth::generate_authorization_header, requests::make_request},
     AppState, AppStatus,
 };
 
 use super::{
     auth::{auth_initiate_logic, recieve_handshake, setup},
+    cache::{cache_object, get_cached_object},
     remote::use_remote_logic,
 };
 
@@ -35,6 +39,26 @@ pub fn gen_drop_url(path: String) -> Result<String, RemoteAccessError> {
     Ok(url.to_string())
 }
 
+#[tauri::command]
+pub fn fetch_drop_object(path: String) -> Result<Vec<u8>, RemoteAccessError> {
+    let _drop_url = gen_drop_url(path.clone())?;
+    let req = make_request(&Client::new(), &[&path], &[], |r| {
+        r.header("Authorization", generate_authorization_header())
+    })?
+    .send();
+
+    match req {
+        Ok(data) => {
+            let data = data.bytes()?.to_vec();
+            cache_object(&path, &data)?;
+            Ok(data)
+        }
+        Err(e) => {
+            debug!("{}", e);
+            get_cached_object::<&str, Vec<u8>>(&path)
+        }
+    }
+}
 #[tauri::command]
 pub fn sign_out(app: AppHandle) {
     // Clear auth from database

src-tauri/src/remote/fetch_object.rs

@@ -0,0 +1,53 @@
+use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder};
+use log::warn;
+use tauri::UriSchemeResponder;
+
+use super::{
+    auth::generate_authorization_header,
+    cache::{cache_object, get_cached_object, ObjectCache},
+    requests::make_request,
+};
+
+pub fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
+    // Drop leading /
+    let object_id = &request.uri().path()[1..];
+
+    let header = generate_authorization_header();
+    let client: reqwest::blocking::Client = reqwest::blocking::Client::new();
+    let response = make_request(&client, &["/api/v1/client/object/", object_id], &[], |f| {
+        f.header("Authorization", header)
+    })
+    .unwrap()
+    .send();
+    if response.is_err() {
+        let data = get_cached_object::<&str, ObjectCache>(object_id);
+
+        match data {
+            Ok(data) => responder.respond(data.into()),
+            Err(e) => {
+                warn!("{}", e)
+            }
+        }
+        return;
+    }
+    let response = response.unwrap();
+
+    let resp_builder = ResponseBuilder::new().header(
+        CONTENT_TYPE,
+        response.headers().get("Content-Type").unwrap(),
+    );
+    let data = Vec::from(response.bytes().unwrap());
+    let resp = resp_builder.body(data).unwrap();
+    cache_object::<&str, ObjectCache>(object_id, &resp.clone().into()).unwrap();
+
+    responder.respond(resp);
+}
+pub fn fetch_object_offline(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
+    let object_id = &request.uri().path()[1..];
+    let data = get_cached_object::<&str, ObjectCache>(object_id);
+
+    match data {
+        Ok(data) => responder.respond(data.into()),
+        Err(e) => warn!("{}", e),
+    }
+}

src-tauri/src/remote/mod.rs

@@ -1,4 +1,8 @@
 pub mod auth;
+#[macro_use]
+pub mod cache;
 pub mod commands;
+pub mod fetch_object;
 pub mod remote;
 pub mod requests;
+pub mod server_proto;

src-tauri/src/remote/server_proto.rs

@@ -0,0 +1,65 @@
+use std::str::FromStr;
+
+use http::{
+    uri::PathAndQuery,
+    Request, Response, StatusCode, Uri,
+};
+use reqwest::blocking::Client;
+use tauri::UriSchemeResponder;
+
+use crate::database::db::borrow_db_checked;
+
+pub fn handle_server_proto_offline(_request: Request<Vec<u8>>, responder: UriSchemeResponder) {
+    let four_oh_four = Response::builder()
+        .status(StatusCode::NOT_FOUND)
+        .body(Vec::new())
+        .unwrap();
+    responder.respond(four_oh_four);
+}
+
+pub fn handle_server_proto(request: Request<Vec<u8>>, responder: UriSchemeResponder) {
+    let db_handle = borrow_db_checked();
+    let web_token = match &db_handle.auth.as_ref().unwrap().web_token {
+        Some(e) => e,
+        None => return,
+    };
+    let remote_uri = db_handle.base_url.parse::<Uri>().unwrap();
+
+    let path = request.uri().path();
+
+    let mut new_uri = request.uri().clone().into_parts();
+    new_uri.path_and_query =
+        Some(PathAndQuery::from_str(&format!("{}?noWrapper=true", path)).unwrap());
+    new_uri.authority = remote_uri.authority().cloned();
+    new_uri.scheme = remote_uri.scheme().cloned();
+    let new_uri = Uri::from_parts(new_uri).unwrap();
+
+    let whitelist_prefix = vec!["/store", "/api", "/_", "/fonts"];
+
+    if whitelist_prefix
+        .iter()
+        .map(|f| !path.starts_with(f))
+        .all(|f| f)
+    {
+        webbrowser::open(&new_uri.to_string()).unwrap();
+        return;
+    }
+
+    let client = Client::new();
+    let response = client
+        .request(request.method().clone(), new_uri.to_string())
+        .header("Authorization", format!("Bearer {}", web_token))
+        .headers(request.headers().clone())
+        .send()
+        .unwrap();
+
+    let response_status = response.status();
+    let response_body = response.bytes().unwrap();
+
+    let http_response = Response::builder()
+        .status(response_status)
+        .body(response_body.to_vec())
+        .unwrap();
+
+    responder.respond(http_response);
+}

src-tauri/tailscale/.gitignore

@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Generated by Tauri
+# will have schema files for capabilities auto-completion
+/gen/schemas

src-tauri/tailscale/Cargo.lock

@@ -0,0 +1,294 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "abs-file-macro"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3909701959b9fcb4d065c3cf3044fe77f6b07a85d748be4630f5214e8d7acc1"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "glob"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.172"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
+[[package]]
+name = "libloading"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a793df0d7afeac54f95b471d3af7f0d4fb975699f972341a4b76988d49cdf0c"
+dependencies = [
+ "cfg-if",
+ "windows-targets",
+]
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tailscale"
+version = "0.1.0"
+dependencies = [
+ "abs-file-macro",
+ "bindgen",
+ "libc",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "windows-targets"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1e4c7e8ceaaf9cb7d7507c974735728ab453b67ef8f18febdd7c11fe59dca8b"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"

src-tauri/tailscale/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "tailscale"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+bindgen = "*"
+abs-file-macro = "0.1.2"
+
+[dependencies]
+libc = "0.2.172"

src-tauri/tailscale/build.rs

@@ -0,0 +1,36 @@
+extern crate bindgen;
+
+use abs_file_macro::abs_file;
+use std::path::PathBuf;
+use std::process::Command;
+
+fn main() {
+    let build_folder = PathBuf::from(abs_file!());
+    let build_folder = build_folder.parent().unwrap();
+
+    let in_path = build_folder.join("libtailscale");
+    let out_path = build_folder.join("src/");
+
+    let mut make_cmd = Command::new("make");
+    make_cmd.arg("c-archive");
+    make_cmd.current_dir(in_path.clone());
+
+    make_cmd.status().expect("Make build failed");
+
+    let bindings = bindgen::Builder::default()
+        .header(in_path.join("libtailscale.h").to_str().unwrap())
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+
+    println!("cargo:rerun-if-changed=libtailscale/tailscale.go");
+    println!(
+        "cargo:rustc-link-search=native={}",
+        in_path.to_str().unwrap()
+    );
+    println!("cargo:rustc-link-lib=static={}", "tailscale");
+}

src-tauri/tailscale/src/bindings.rs

@@ -0,0 +1,363 @@
+/* automatically generated by rust-bindgen 0.71.1 */
+
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(C)]
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
+}
+pub const _ERRNO_H: u32 = 1;
+pub const _FEATURES_H: u32 = 1;
+pub const _DEFAULT_SOURCE: u32 = 1;
+pub const __GLIBC_USE_ISOC2Y: u32 = 0;
+pub const __GLIBC_USE_ISOC23: u32 = 0;
+pub const __USE_ISOC11: u32 = 1;
+pub const __USE_ISOC99: u32 = 1;
+pub const __USE_ISOC95: u32 = 1;
+pub const __USE_POSIX_IMPLICITLY: u32 = 1;
+pub const _POSIX_SOURCE: u32 = 1;
+pub const _POSIX_C_SOURCE: u32 = 200809;
+pub const __USE_POSIX: u32 = 1;
+pub const __USE_POSIX2: u32 = 1;
+pub const __USE_POSIX199309: u32 = 1;
+pub const __USE_POSIX199506: u32 = 1;
+pub const __USE_XOPEN2K: u32 = 1;
+pub const __USE_XOPEN2K8: u32 = 1;
+pub const _ATFILE_SOURCE: u32 = 1;
+pub const __WORDSIZE: u32 = 64;
+pub const __WORDSIZE_TIME64_COMPAT32: u32 = 0;
+pub const __TIMESIZE: u32 = 64;
+pub const __USE_TIME_BITS64: u32 = 1;
+pub const __USE_MISC: u32 = 1;
+pub const __USE_ATFILE: u32 = 1;
+pub const __USE_FORTIFY_LEVEL: u32 = 0;
+pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
+pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
+pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
+pub const _STDC_PREDEF_H: u32 = 1;
+pub const __STDC_IEC_559__: u32 = 1;
+pub const __STDC_IEC_60559_BFP__: u32 = 201404;
+pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
+pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
+pub const __STDC_ISO_10646__: u32 = 201706;
+pub const __GNU_LIBRARY__: u32 = 6;
+pub const __GLIBC__: u32 = 2;
+pub const __GLIBC_MINOR__: u32 = 41;
+pub const _SYS_CDEFS_H: u32 = 1;
+pub const __glibc_c99_flexarr_available: u32 = 1;
+pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
+pub const __HAVE_GENERIC_SELECTION: u32 = 1;
+pub const _BITS_ERRNO_H: u32 = 1;
+pub const EPERM: u32 = 1;
+pub const ENOENT: u32 = 2;
+pub const ESRCH: u32 = 3;
+pub const EINTR: u32 = 4;
+pub const EIO: u32 = 5;
+pub const ENXIO: u32 = 6;
+pub const E2BIG: u32 = 7;
+pub const ENOEXEC: u32 = 8;
+pub const EBADF: u32 = 9;
+pub const ECHILD: u32 = 10;
+pub const EAGAIN: u32 = 11;
+pub const ENOMEM: u32 = 12;
+pub const EACCES: u32 = 13;
+pub const EFAULT: u32 = 14;
+pub const ENOTBLK: u32 = 15;
+pub const EBUSY: u32 = 16;
+pub const EEXIST: u32 = 17;
+pub const EXDEV: u32 = 18;
+pub const ENODEV: u32 = 19;
+pub const ENOTDIR: u32 = 20;
+pub const EISDIR: u32 = 21;
+pub const EINVAL: u32 = 22;
+pub const ENFILE: u32 = 23;
+pub const EMFILE: u32 = 24;
+pub const ENOTTY: u32 = 25;
+pub const ETXTBSY: u32 = 26;
+pub const EFBIG: u32 = 27;
+pub const ENOSPC: u32 = 28;
+pub const ESPIPE: u32 = 29;
+pub const EROFS: u32 = 30;
+pub const EMLINK: u32 = 31;
+pub const EPIPE: u32 = 32;
+pub const EDOM: u32 = 33;
+pub const ERANGE: u32 = 34;
+pub const EDEADLK: u32 = 35;
+pub const ENAMETOOLONG: u32 = 36;
+pub const ENOLCK: u32 = 37;
+pub const ENOSYS: u32 = 38;
+pub const ENOTEMPTY: u32 = 39;
+pub const ELOOP: u32 = 40;
+pub const EWOULDBLOCK: u32 = 11;
+pub const ENOMSG: u32 = 42;
+pub const EIDRM: u32 = 43;
+pub const ECHRNG: u32 = 44;
+pub const EL2NSYNC: u32 = 45;
+pub const EL3HLT: u32 = 46;
+pub const EL3RST: u32 = 47;
+pub const ELNRNG: u32 = 48;
+pub const EUNATCH: u32 = 49;
+pub const ENOCSI: u32 = 50;
+pub const EL2HLT: u32 = 51;
+pub const EBADE: u32 = 52;
+pub const EBADR: u32 = 53;
+pub const EXFULL: u32 = 54;
+pub const ENOANO: u32 = 55;
+pub const EBADRQC: u32 = 56;
+pub const EBADSLT: u32 = 57;
+pub const EDEADLOCK: u32 = 35;
+pub const EBFONT: u32 = 59;
+pub const ENOSTR: u32 = 60;
+pub const ENODATA: u32 = 61;
+pub const ETIME: u32 = 62;
+pub const ENOSR: u32 = 63;
+pub const ENONET: u32 = 64;
+pub const ENOPKG: u32 = 65;
+pub const EREMOTE: u32 = 66;
+pub const ENOLINK: u32 = 67;
+pub const EADV: u32 = 68;
+pub const ESRMNT: u32 = 69;
+pub const ECOMM: u32 = 70;
+pub const EPROTO: u32 = 71;
+pub const EMULTIHOP: u32 = 72;
+pub const EDOTDOT: u32 = 73;
+pub const EBADMSG: u32 = 74;
+pub const EOVERFLOW: u32 = 75;
+pub const ENOTUNIQ: u32 = 76;
+pub const EBADFD: u32 = 77;
+pub const EREMCHG: u32 = 78;
+pub const ELIBACC: u32 = 79;
+pub const ELIBBAD: u32 = 80;
+pub const ELIBSCN: u32 = 81;
+pub const ELIBMAX: u32 = 82;
+pub const ELIBEXEC: u32 = 83;
+pub const EILSEQ: u32 = 84;
+pub const ERESTART: u32 = 85;
+pub const ESTRPIPE: u32 = 86;
+pub const EUSERS: u32 = 87;
+pub const ENOTSOCK: u32 = 88;
+pub const EDESTADDRREQ: u32 = 89;
+pub const EMSGSIZE: u32 = 90;
+pub const EPROTOTYPE: u32 = 91;
+pub const ENOPROTOOPT: u32 = 92;
+pub const EPROTONOSUPPORT: u32 = 93;
+pub const ESOCKTNOSUPPORT: u32 = 94;
+pub const EOPNOTSUPP: u32 = 95;
+pub const EPFNOSUPPORT: u32 = 96;
+pub const EAFNOSUPPORT: u32 = 97;
+pub const EADDRINUSE: u32 = 98;
+pub const EADDRNOTAVAIL: u32 = 99;
+pub const ENETDOWN: u32 = 100;
+pub const ENETUNREACH: u32 = 101;
+pub const ENETRESET: u32 = 102;
+pub const ECONNABORTED: u32 = 103;
+pub const ECONNRESET: u32 = 104;
+pub const ENOBUFS: u32 = 105;
+pub const EISCONN: u32 = 106;
+pub const ENOTCONN: u32 = 107;
+pub const ESHUTDOWN: u32 = 108;
+pub const ETOOMANYREFS: u32 = 109;
+pub const ETIMEDOUT: u32 = 110;
+pub const ECONNREFUSED: u32 = 111;
+pub const EHOSTDOWN: u32 = 112;
+pub const EHOSTUNREACH: u32 = 113;
+pub const EALREADY: u32 = 114;
+pub const EINPROGRESS: u32 = 115;
+pub const ESTALE: u32 = 116;
+pub const EUCLEAN: u32 = 117;
+pub const ENOTNAM: u32 = 118;
+pub const ENAVAIL: u32 = 119;
+pub const EISNAM: u32 = 120;
+pub const EREMOTEIO: u32 = 121;
+pub const EDQUOT: u32 = 122;
+pub const ENOMEDIUM: u32 = 123;
+pub const EMEDIUMTYPE: u32 = 124;
+pub const ECANCELED: u32 = 125;
+pub const ENOKEY: u32 = 126;
+pub const EKEYEXPIRED: u32 = 127;
+pub const EKEYREVOKED: u32 = 128;
+pub const EKEYREJECTED: u32 = 129;
+pub const EOWNERDEAD: u32 = 130;
+pub const ENOTRECOVERABLE: u32 = 131;
+pub const ERFKILL: u32 = 132;
+pub const EHWPOISON: u32 = 133;
+pub const ENOTSUP: u32 = 95;
+pub type wchar_t = ::std::os::raw::c_uint;
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Copy, Clone)]
+pub struct max_align_t {
+    pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
+    pub __bindgen_padding_0: u64,
+    pub __clang_max_align_nonce2: u128,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of max_align_t"][::std::mem::size_of::<max_align_t>() - 32usize];
+    ["Alignment of max_align_t"][::std::mem::align_of::<max_align_t>() - 16usize];
+    ["Offset of field: max_align_t::__clang_max_align_nonce1"]
+        [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize];
+    ["Offset of field: max_align_t::__clang_max_align_nonce2"]
+        [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 16usize];
+};
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _GoString_ {
+    pub p: *const ::std::os::raw::c_char,
+    pub n: isize,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _GoString_"][::std::mem::size_of::<_GoString_>() - 16usize];
+    ["Alignment of _GoString_"][::std::mem::align_of::<_GoString_>() - 8usize];
+    ["Offset of field: _GoString_::p"][::std::mem::offset_of!(_GoString_, p) - 0usize];
+    ["Offset of field: _GoString_::n"][::std::mem::offset_of!(_GoString_, n) - 8usize];
+};
+unsafe extern "C" {
+    pub fn __errno_location() -> *mut ::std::os::raw::c_int;
+}
+pub type GoInt8 = ::std::os::raw::c_schar;
+pub type GoUint8 = ::std::os::raw::c_uchar;
+pub type GoInt16 = ::std::os::raw::c_short;
+pub type GoUint16 = ::std::os::raw::c_ushort;
+pub type GoInt32 = ::std::os::raw::c_int;
+pub type GoUint32 = ::std::os::raw::c_uint;
+pub type GoInt64 = ::std::os::raw::c_longlong;
+pub type GoUint64 = ::std::os::raw::c_ulonglong;
+pub type GoInt = GoInt64;
+pub type GoUint = GoUint64;
+pub type GoUintptr = usize;
+pub type GoFloat32 = f32;
+pub type GoFloat64 = f64;
+pub type GoComplex64 = __BindgenComplex<f32>;
+pub type GoComplex128 = __BindgenComplex<f64>;
+pub type _check_for_64_bit_pointer_matching_GoInt = [::std::os::raw::c_char; 1usize];
+pub type GoString = _GoString_;
+pub type GoMap = *mut ::std::os::raw::c_void;
+pub type GoChan = *mut ::std::os::raw::c_void;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct GoInterface {
+    pub t: *mut ::std::os::raw::c_void,
+    pub v: *mut ::std::os::raw::c_void,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of GoInterface"][::std::mem::size_of::<GoInterface>() - 16usize];
+    ["Alignment of GoInterface"][::std::mem::align_of::<GoInterface>() - 8usize];
+    ["Offset of field: GoInterface::t"][::std::mem::offset_of!(GoInterface, t) - 0usize];
+    ["Offset of field: GoInterface::v"][::std::mem::offset_of!(GoInterface, v) - 8usize];
+};
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct GoSlice {
+    pub data: *mut ::std::os::raw::c_void,
+    pub len: GoInt,
+    pub cap: GoInt,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of GoSlice"][::std::mem::size_of::<GoSlice>() - 24usize];
+    ["Alignment of GoSlice"][::std::mem::align_of::<GoSlice>() - 8usize];
+    ["Offset of field: GoSlice::data"][::std::mem::offset_of!(GoSlice, data) - 0usize];
+    ["Offset of field: GoSlice::len"][::std::mem::offset_of!(GoSlice, len) - 8usize];
+    ["Offset of field: GoSlice::cap"][::std::mem::offset_of!(GoSlice, cap) - 16usize];
+};
+unsafe extern "C" {
+    pub fn TsnetNewServer() -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetStart(sd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetUp(sd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetClose(sd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetGetIps(
+        sd: ::std::os::raw::c_int,
+        buf: *mut ::std::os::raw::c_char,
+        buflen: usize,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetErrmsg(
+        sd: ::std::os::raw::c_int,
+        buf: *mut ::std::os::raw::c_char,
+        buflen: usize,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetListen(
+        sd: ::std::os::raw::c_int,
+        network: *mut ::std::os::raw::c_char,
+        addr: *mut ::std::os::raw::c_char,
+        listenerOut: *mut ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetGetRemoteAddr(
+        listener: ::std::os::raw::c_int,
+        conn: ::std::os::raw::c_int,
+        buf: *mut ::std::os::raw::c_char,
+        buflen: usize,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetDial(
+        sd: ::std::os::raw::c_int,
+        network: *mut ::std::os::raw::c_char,
+        addr: *mut ::std::os::raw::c_char,
+        connOut: *mut ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetSetDir(
+        sd: ::std::os::raw::c_int,
+        str_: *mut ::std::os::raw::c_char,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetSetHostname(
+        sd: ::std::os::raw::c_int,
+        str_: *mut ::std::os::raw::c_char,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetSetAuthKey(
+        sd: ::std::os::raw::c_int,
+        str_: *mut ::std::os::raw::c_char,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetSetControlURL(
+        sd: ::std::os::raw::c_int,
+        str_: *mut ::std::os::raw::c_char,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetSetEphemeral(sd: ::std::os::raw::c_int, e: GoInt) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetSetLogFD(
+        sd: ::std::os::raw::c_int,
+        fd: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetLoopback(
+        sd: ::std::os::raw::c_int,
+        addrOut: *mut ::std::os::raw::c_char,
+        addrLen: usize,
+        proxyOut: *mut ::std::os::raw::c_char,
+        localOut: *mut ::std::os::raw::c_char,
+    ) -> ::std::os::raw::c_int;
+}
+unsafe extern "C" {
+    pub fn TsnetEnableFunnelToLocalhostPlaintextHttp1(
+        sd: ::std::os::raw::c_int,
+        localhostPort: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}

src-tauri/tailscale/src/lib.rs

@@ -0,0 +1,350 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+use std::ffi::{CStr, CString};
+use std::io::{Read, Write};
+#[cfg(not(target_os = "windows"))]
+use std::os::fd::{AsRawFd, RawFd};
+#[cfg(target_os = "windows")]
+use std::os::windows::io::{AsRawHandle, RawHandle};
+use std::os::raw::{c_char, c_int};
+mod bindings;
+#[cfg(test)]
+mod test;
+
+type GoInt = i64;
+
+use bindings::*;
+use libc;
+
+#[derive(Debug)]
+pub enum TailscaleError {
+    ApiError(c_int, String),
+    BadFileDescriptor,
+    BufferTooSmall,
+    NulError(std::ffi::NulError),
+    InvalidUtf8(std::str::Utf8Error),
+    IoError(std::io::Error),
+    InvalidHandle,
+}
+
+impl From<std::ffi::NulError> for TailscaleError {
+    fn from(err: std::ffi::NulError) -> Self {
+        TailscaleError::NulError(err)
+    }
+}
+
+impl From<std::str::Utf8Error> for TailscaleError {
+    fn from(err: std::str::Utf8Error) -> Self {
+        TailscaleError::InvalidUtf8(err)
+    }
+}
+
+impl From<std::io::Error> for TailscaleError {
+    fn from(err: std::io::Error) -> Self {
+        TailscaleError::IoError(err)
+    }
+}
+
+// Helper function to get error message from the server handle
+// This helper is needed because TsnetErrmsg requires the server handle (sd)
+fn get_tsnet_errmsg(sd: c_int) -> String {
+    let mut buf = [0u8; 256]; // Choose a reasonable buffer size
+    let message = unsafe { TsnetErrmsg(sd, buf.as_mut_ptr() as *mut c_char, buf.len()) };
+
+    if message == 0 {
+        let c_str = unsafe { CStr::from_ptr(buf.as_ptr() as *const c_char) };
+        c_str.to_string_lossy().into_owned()
+    } else {
+        format!(
+            "(Failed to get error message, TsnetErrmsg returned {})",
+            message
+        )
+    }
+}
+
+fn parse_tsnet_result(sd: c_int, ret: c_int) -> Result<(), TailscaleError> {
+    match ret {
+        0 => Ok(()),
+        code if code == libc::EBADF => Err(TailscaleError::BadFileDescriptor),
+        code if code == libc::ERANGE => Err(TailscaleError::BufferTooSmall),
+        _ => {
+            let message = get_tsnet_errmsg(sd);
+            Err(TailscaleError::ApiError(ret, message))
+        }
+    }
+}
+
+pub struct Tailscale(c_int);
+
+// A TailscaleListener is a socket on the tailnet listening for connections.
+//
+// It is much like allocating a system socket(2) and calling listen(2).
+// Accept connections with tailscale_accept and close the listener  with close.
+//
+// Under the hood, a tailscale_listener is one half of a socketpair itself,
+// used to move the connection fd from Go to C. This means you can use epoll
+// or its equivalent on a tailscale_listener to know if there is a connection
+// read to accept.
+pub struct TailscaleListener(c_int);
+
+// A TailscaleConn is a connection to an address on the tailnet.
+//
+// It is a pipe(2) on which you can use read(2), write(2), and close(2).
+// For extra control over the connection, see the tailscale_conn_* functions.
+pub struct TailscaleConn(c_int);
+
+// NEEDS REVIEW. CANNOT BE BADLY DONE
+impl Drop for Tailscale {
+    fn drop(&mut self) {
+        let ret = unsafe { TsnetClose(self.0) };
+        if ret != 0 && ret != libc::EBADF {
+            eprintln!("Error closing Tailscale server {}: {}", self.0, ret);
+        }
+    }
+}
+
+impl Drop for TailscaleListener {
+    fn drop(&mut self) {
+        // TailscaleListener is treated like a file descriptor.
+        let ret = unsafe { libc::close(self.0) };
+         if ret != 0 && ret != libc::EBADF {
+             eprintln!("Error closing Tailscale listener {}: {}", self.0, ret);
+        }
+    }
+}
+
+impl Drop for TailscaleConn {
+    fn drop(&mut self) {
+        // TailscaleConn is treated like a file descriptor (pipe).
+        let ret = unsafe { libc::close(self.0) };
+         if ret != 0 && ret != libc::EBADF {
+             eprintln!("Error closing Tailscale connection {}: {}", self.0, ret);
+        }
+    }
+}
+
+impl Tailscale {
+    pub fn new() -> Self {
+        Tailscale(unsafe { TsnetNewServer() })
+    }
+
+    pub fn start(&self) -> Result<(), TailscaleError> {
+        let ret = unsafe { TsnetStart(self.0) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn up(&self) -> Result<(), TailscaleError> {
+        let ret = unsafe { TsnetUp(self.0) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn close(&self) -> Result<(), TailscaleError> {
+        let ret = unsafe { TsnetClose(self.0) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn set_dir(&self, dir: &str) -> Result<(), TailscaleError> {
+        let c_dir = CString::new(dir)?;
+        let ret = unsafe { TsnetSetDir(self.0, c_dir.as_ptr() as *mut c_char) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn set_hostname<T: AsRef<str>>(&self, hostname: T) -> Result<(), TailscaleError> {
+        let c_hostname = CString::new(hostname.as_ref())?;
+        let ret = unsafe { TsnetSetHostname(self.0, c_hostname.as_ptr() as *mut c_char) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn set_authkey(&self, authkey: &str) -> Result<(), TailscaleError> {
+        let c_authkey = CString::new(authkey)?;
+        let ret = unsafe { TsnetSetAuthKey(self.0, c_authkey.as_ptr() as *mut c_char) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn set_control_url(&self, control_url: &str) -> Result<(), TailscaleError> {
+        let c_control_url = CString::new(control_url)?;
+        let ret = unsafe { TsnetSetControlURL(self.0, c_control_url.as_ptr() as *mut c_char) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn set_ephemeral(&self, ephemeral: bool) -> Result<(), TailscaleError> {
+        let e: GoInt = if ephemeral { 1 } else { 0 };
+        // Use GoInt (i64) based on bindgen output
+        let ret = unsafe { TsnetSetEphemeral(self.0, e) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn set_log_fd(&self, fd: i32) -> Result<(), TailscaleError> {
+        let ret = unsafe { TsnetSetLogFD(self.0, fd) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn get_ips<'a>(&self, buf: &'a mut [u8]) -> Result<&'a str, TailscaleError> {
+        let ret = unsafe { TsnetGetIps(self.0, buf.as_mut_ptr() as *mut c_char, buf.len()) };
+        match ret {
+            0 => {
+                let c_str = unsafe { CStr::from_ptr(buf.as_ptr() as *const c_char) };
+                c_str.to_str().map_err(TailscaleError::from) // Convert Utf8Error
+            }
+            code if code == libc::EBADF => Err(TailscaleError::BadFileDescriptor),
+            code if code == libc::ERANGE => Err(TailscaleError::BufferTooSmall),
+            _ => {
+                let err_msg = get_tsnet_errmsg(self.0);
+                Err(TailscaleError::ApiError(ret, err_msg))
+            }
+        }
+    }
+
+    pub fn loopback(
+        &self,
+        addr_buf: &mut [u8],
+        proxy_buf: &mut [u8],
+        local_buf: &mut [u8],
+    ) -> Result<(), TailscaleError> {
+        // C header says proxy_out and local_out must hold 33 bytes.
+        if proxy_buf.len() < 33 || local_buf.len() < 33 {
+            return Err(TailscaleError::BufferTooSmall); // Custom check based on docs
+        }
+
+        let ret = unsafe {
+            TsnetLoopback(
+                self.0,
+                addr_buf.as_mut_ptr() as *mut c_char,
+                addr_buf.len(),
+                proxy_buf.as_mut_ptr() as *mut c_char,
+                local_buf.as_mut_ptr() as *mut c_char,
+            )
+        };
+
+        parse_tsnet_result(self.0, ret)
+    }
+    pub fn dial(&self, network: &str, addr: &str) -> Result<TailscaleConn, TailscaleError> {
+        let c_network = CString::new(network)?;
+        let c_addr = CString::new(addr)?;
+        let mut conn_out: c_int = -1;
+        let ret = unsafe {
+            TsnetDial(
+                self.0,
+                c_network.as_ptr() as *mut c_char,
+                c_addr.as_ptr() as *mut c_char,
+                &mut conn_out,
+            )
+        };
+
+        parse_tsnet_result(self.0, ret)?;
+
+        if ret == 0 && conn_out != -1 {
+            Ok(TailscaleConn(conn_out))
+        } else if ret == 0 {
+            Err(TailscaleError::InvalidHandle)
+        } else {
+            unreachable!();
+        }
+    }
+    pub fn listen(&self, network: &str, addr: &str) -> Result<TailscaleListener, TailscaleError> {
+        let c_network = CString::new(network)?;
+        let c_addr = CString::new(addr)?;
+        let mut listener_out: c_int = -1; // Use c_int for the output pointer
+        let ret = unsafe {
+            TsnetListen(
+                self.0,
+                c_network.as_ptr() as *mut c_char,
+                c_addr.as_ptr() as *mut c_char,
+                &mut listener_out,
+            )
+        };
+
+        parse_tsnet_result(self.0, ret)?;
+
+        if ret == 0 && listener_out != -1 {
+            Ok(TailscaleListener(listener_out))
+        } else if ret == 0 {
+            Err(TailscaleError::InvalidHandle)
+        } else {
+            unreachable!();
+        }
+    }
+
+    pub fn enable_funnel_to_localhost_plaintext_http1(
+        &self,
+        localhost_port: i32,
+    ) -> Result<(), TailscaleError> {
+        let ret =
+            unsafe { TsnetEnableFunnelToLocalhostPlaintextHttp1(self.0, localhost_port as c_int) };
+        parse_tsnet_result(self.0, ret)
+    }
+
+    pub fn get_last_error_message<'a>(&self, buf: &'a mut [u8]) -> Result<&'a str, TailscaleError> {
+        let ret = unsafe { TsnetErrmsg(self.0, buf.as_mut_ptr() as *mut c_char, buf.len()) };
+        match ret {
+            0 => {
+                let c_str = unsafe { CStr::from_ptr(buf.as_ptr() as *const c_char) };
+                c_str.to_str().map_err(TailscaleError::from) // Convert Utf8Error
+            }
+            code if code == libc::EBADF => Err(TailscaleError::BadFileDescriptor),
+            code if code == libc::ERANGE => Err(TailscaleError::BufferTooSmall),
+            // TsnetErrmsg should ideally not return other codes, but handle defensively
+            _ => Err(TailscaleError::ApiError(
+                ret,
+                format!("TsnetErrmsg returned unknown code {}", ret),
+            )),
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+// Requires the connection handle to behave like a raw file descriptor.
+impl AsRawFd for TailscaleConn {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0
+    }
+}
+#[cfg(target_os = "windows")]
+impl AsRawHandle for TailscaleConn {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.0
+    }
+}
+
+impl Read for TailscaleConn {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        #[cfg(not(target_os = "windows"))]
+        let fd = self.as_raw_fd();
+        #[cfg(target_os = "windows")]
+        let fd = self.as_raw_handle();
+        // Safety: Calling libc::read on a valid file descriptor.
+        // The caller must ensure the handle is valid for reading (it is after successful dial/accept).
+        let n = unsafe {
+            libc::read(fd, buf.as_mut_ptr() as *mut libc::c_void, buf.len())
+        };
+        if n < 0 {
+            Err(std::io::Error::last_os_error())
+        } else {
+            Ok(n as usize)
+        }
+    }
+}
+
+impl Write for TailscaleConn {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        
+        let fd = self.as_raw_fd();
+        // Safety: Calling libc::write on a valid file descriptor.
+        // The caller must ensure the handle is valid for writing (it is after successful dial/accept).
+        let n = unsafe {
+            libc::write(fd, buf.as_ptr() as *const libc::c_void, buf.len())
+        };
+        if n < 0 {
+            Err(std::io::Error::last_os_error())
+        } else {
+            Ok(n as usize)
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        // For a pipe/socket, flush is often a no-op after write.
+        Ok(())
+    }
+}

src-tauri/tailscale/src/test.rs

@@ -0,0 +1,30 @@
+use std::error::Error;
+
+use crate::{Tailscale, TailscaleError};
+
+#[test]
+fn start_listener() -> Result<(), TailscaleError> {
+    println!("Creating server");
+    // Create a new server
+    let ts = Tailscale::new();
+
+    // Configure it
+    println!("Configuring directory");
+    ts.set_dir("/tmp/tailscale-rust-test")?;
+    println!("Configuring hostname");
+    ts.set_hostname("my-rust-node")?;
+    println!("Setting ephemeral");
+    //ts.set_authkey("tskey-...")?; // Set authkey if needed for auto-registration
+    ts.set_ephemeral(true)?;
+
+    // Bring the server up
+    println!("Starting Tailscale...");
+    ts.up()?;
+    println!("Tailscale started!");
+
+    // Get IPs
+    let mut ip_buf = [0u8; 256];
+    let ips = ts.get_ips(&mut ip_buf)?;
+    println!("Tailscale IPs: {}", ips);
+    Ok(())
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2.0.0",
   "productName": "Drop Desktop Client",
-  "version": "0.2.0-beta",
+  "version": "0.3.0-rc-3",
   "identifier": "dev.drop.app",
   "build": {
     "beforeDevCommand": "yarn dev --port 1432",