Merge branch 'main' into Fix/Pixeldrain

src/main/services/cloud-sync.ts

@@ -0,0 +1,112 @@
+import { levelKeys, gamesSublevel, db } from "@main/level";
+import { app } from "electron";
+import path from "node:path";
+import * as tar from "tar";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import type { GameShop, User } from "@types";
+import { backupsPath } from "@main/constants";
+import { HydraApi } from "./hydra-api";
+import { normalizePath } from "@main/helpers";
+import { logger } from "./logger";
+import { WindowManager } from "./window-manager";
+import axios from "axios";
+import { Ludusavi } from "./ludusavi";
+import { isFuture, isToday } from "date-fns";
+import { SubscriptionRequiredError } from "@shared";
+
+export class CloudSync {
+  private static async bundleBackup(
+    shop: GameShop,
+    objectId: string,
+    winePrefix: string | null
+  ) {
+    const backupPath = path.join(backupsPath, `${shop}-${objectId}`);
+
+    // Remove existing backup
+    if (fs.existsSync(backupPath)) {
+      fs.rmSync(backupPath, { recursive: true });
+    }
+
+    await Ludusavi.backupGame(shop, objectId, backupPath, winePrefix);
+
+    const tarLocation = path.join(backupsPath, `${crypto.randomUUID()}.tar`);
+
+    await tar.create(
+      {
+        gzip: false,
+        file: tarLocation,
+        cwd: backupPath,
+      },
+      ["."]
+    );
+
+    return tarLocation;
+  }
+
+  public static async uploadSaveGame(
+    objectId: string,
+    shop: GameShop,
+    downloadOptionTitle: string | null,
+    label?: string
+  ) {
+    const hasActiveSubscription = await db
+      .get<string, User>(levelKeys.user, { valueEncoding: "json" })
+      .then((user) => {
+        const expiresAt = user?.subscription?.expiresAt;
+        return expiresAt && (isFuture(expiresAt) || isToday(expiresAt));
+      });
+
+    if (!hasActiveSubscription) {
+      throw new SubscriptionRequiredError();
+    }
+
+    const game = await gamesSublevel.get(levelKeys.game(shop, objectId));
+
+    const bundleLocation = await this.bundleBackup(
+      shop,
+      objectId,
+      game?.winePrefixPath ?? null
+    );
+
+    const stat = await fs.promises.stat(bundleLocation);
+
+    const { uploadUrl } = await HydraApi.post<{
+      id: string;
+      uploadUrl: string;
+    }>("/profile/games/artifacts", {
+      artifactLengthInBytes: stat.size,
+      shop,
+      objectId,
+      hostname: os.hostname(),
+      homeDir: normalizePath(app.getPath("home")),
+      downloadOptionTitle,
+      platform: os.platform(),
+      label,
+    });
+
+    const fileBuffer = await fs.promises.readFile(bundleLocation);
+
+    await axios.put(uploadUrl, fileBuffer, {
+      headers: {
+        "Content-Type": "application/tar",
+      },
+      onUploadProgress: (progressEvent) => {
+        logger.log(progressEvent);
+      },
+    });
+
+    WindowManager.mainWindow?.webContents.send(
+      `on-upload-complete-${objectId}-${shop}`,
+      true
+    );
+
+    fs.rm(bundleLocation, (err) => {
+      if (err) {
+        logger.error("Failed to remove tar file", err);
+        throw err;
+      }
+    });
+  }
+}

src/main/services/download/torbox.ts

@@ -6,6 +6,7 @@ import type {
   TorBoxAddTorrentRequest,
   TorBoxRequestLinkRequest,
 } from "@types";
+import { appVersion } from "@main/constants";
 
 export class TorBoxClient {
   private static instance: AxiosInstance;
@@ -18,6 +19,7 @@ export class TorBoxClient {
       baseURL: this.baseURL,
       headers: {
         Authorization: `Bearer ${apiToken}`,
+        "User-Agent": `Hydra/${appVersion}`,
       },
     });
   }

src/main/services/hosters/datanodes.ts

@@ -1,47 +1,74 @@
 import axios, { AxiosResponse } from "axios";
+import { wrapper } from "axios-cookiejar-support";
+import { CookieJar } from "tough-cookie";
 
 export class DatanodesApi {
-  private static readonly session = axios.create({});
+  private static readonly jar = new CookieJar();
+
+  private static readonly session = wrapper(
+    axios.create({
+      jar: DatanodesApi.jar,
+      withCredentials: true,
+    })
+  );
 
   public static async getDownloadUrl(downloadUrl: string): Promise<string> {
-    const parsedUrl = new URL(downloadUrl);
-    const pathSegments = parsedUrl.pathname.split("/");
+    try {
+      const parsedUrl = new URL(downloadUrl);
+      const pathSegments = parsedUrl.pathname.split("/").filter(Boolean);
+      const fileCode = pathSegments[0];
 
-    const fileCode = decodeURIComponent(pathSegments[1]);
-    const fileName = decodeURIComponent(pathSegments[pathSegments.length - 1]);
+      await this.jar.setCookie(
+        "lang=english;",
+        "https://datanodes.to"
+      );
 
-    const payload = new URLSearchParams({
-      op: "download2",
-      id: fileCode,
-      rand: "",
-      referer: "https://datanodes.to/download",
-      method_free: "Free Download >>",
-      method_premium: "",
-      adblock_detected: "",
-    });
+      const payload = new URLSearchParams({
+        op: "download2",
+        id: fileCode,
+        method_free: "Free Download >>",
+        dl: "1",
+      });
 
-    const response: AxiosResponse = await this.session.post(
-      "https://datanodes.to/download",
-      payload,
-      {
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Cookie: `lang=english; file_name=${fileName}; file_code=${fileCode};`,
-          Host: "datanodes.to",
-          Origin: "https://datanodes.to",
-          Referer: "https://datanodes.to/download",
-          "User-Agent":
-            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-        },
-        maxRedirects: 0,
-        validateStatus: (status: number) => status === 302 || status < 400,
+      const response: AxiosResponse = await this.session.post(
+        "https://datanodes.to/download",
+        payload,
+        {
+          headers: {
+            "User-Agent":
+              "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0",
+            Referer: "https://datanodes.to/download",
+            Origin: "https://datanodes.to",
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+          maxRedirects: 0,
+          validateStatus: (status: number) => status === 302 || status < 400,
+        }
+      );
+
+      if (response.status === 302) {
+        return response.headers["location"];
       }
-    );
 
-    if (response.status === 302) {
-      return response.headers["location"];
+      if (typeof response.data === "object" && response.data.url) {
+        return decodeURIComponent(response.data.url);
+      }
+
+      const htmlContent = String(response.data);
+      if (!htmlContent) {
+        throw new Error("Empty response received");
+      }
+
+      const downloadLinkRegex = /href=["'](https:\/\/[^"']+)["']/;
+      const downloadLinkMatch = downloadLinkRegex.exec(htmlContent);
+      if (downloadLinkMatch) {
+        return downloadLinkMatch[1];
+      }
+
+      throw new Error("Failed to get the download link");
+    } catch (error) {
+      console.error("Error fetching download URL:", error);
+      throw error;
     }
-
-    return "";
   }
 }

src/main/services/index.ts

@@ -7,3 +7,4 @@ export * from "./process-watcher";
 export * from "./main-loop";
 export * from "./hydra-api";
 export * from "./ludusavi";
+export * from "./cloud-sync";

src/main/services/process-watcher.ts

@@ -6,6 +6,9 @@ import axios from "axios";
 import { exec } from "child_process";
 import { ProcessPayload } from "./download/types";
 import { gamesSublevel, levelKeys } from "@main/level";
+import { t } from "i18next";
+import { CloudSync } from "./cloud-sync";
+import { format } from "date-fns";
 
 const commands = {
   findWineDir: `lsof -c wine 2>/dev/null | grep '/drive_c/windows$' | head -n 1 | awk '{for(i=9;i<=NF;i++) printf "%s ", $i; print ""}'`,
@@ -225,6 +228,18 @@ function onOpenGame(game: Game) {
 
   if (game.remoteId) {
     updateGamePlaytime(game, 0, new Date()).catch(() => {});
+
+    if (game.automaticCloudSync) {
+      CloudSync.uploadSaveGame(
+        game.objectId,
+        game.shop,
+        null,
+        t("automatic_backup_from", {
+          ns: "game_details",
+          date: format(new Date(), "dd/MM/yyyy"),
+        })
+      );
+    }
   } else {
     createGame({ ...game, lastTimePlayed: new Date() }).catch(() => {});
   }
@@ -287,6 +302,18 @@ const onCloseGame = (game: Game) => {
       performance.now() - gamePlaytime.lastSyncTick,
       game.lastTimePlayed!
     ).catch(() => {});
+
+    if (game.automaticCloudSync) {
+      CloudSync.uploadSaveGame(
+        game.objectId,
+        game.shop,
+        null,
+        t("automatic_backup_from", {
+          ns: "game_details",
+          date: format(new Date(), "dd/MM/yyyy"),
+        })
+      );
+    }
   } else {
     createGame(game).catch(() => {});
   }