New hosters

src/main/events/torrenting/start-game-download.ts

@@ -82,7 +82,6 @@ const startGameDownload = async (
     queued: true,
     extracting: false,
     automaticallyExtract,
-    extractionProgress: 0,
   };
 
   try {
@@ -124,6 +123,42 @@ const startGameDownload = async (
     }
 
     if (err instanceof Error) {
+      if (downloader === Downloader.Buzzheavier) {
+        if (err.message.includes("Rate limit")) {
+          return {
+            ok: false,
+            error: "Buzzheavier: Rate limit exceeded",
+          };
+        }
+        if (
+          err.message.includes("not found") ||
+          err.message.includes("deleted")
+        ) {
+          return {
+            ok: false,
+            error: "Buzzheavier: File not found",
+          };
+        }
+      }
+
+      if (downloader === Downloader.FuckingFast) {
+        if (err.message.includes("Rate limit")) {
+          return {
+            ok: false,
+            error: "FuckingFast: Rate limit exceeded",
+          };
+        }
+        if (
+          err.message.includes("not found") ||
+          err.message.includes("deleted")
+        ) {
+          return {
+            ok: false,
+            error: "FuckingFast: File not found",
+          };
+        }
+      }
+
       return { ok: false, error: err.message };
     }
 

src/main/services/download/download-manager.ts

@@ -20,14 +20,47 @@ import { RealDebridClient } from "./real-debrid";
 import path from "path";
 import { logger } from "../logger";
 import { db, downloadsSublevel, gamesSublevel, levelKeys } from "@main/level";
-import { orderBy } from "lodash-es";
+import { sortBy } from "lodash-es";
 import { TorBoxClient } from "./torbox";
 import { GameFilesManager } from "../game-files-manager";
 import { HydraDebridClient } from "./hydra-debrid";
+import { BuzzheavierApi, FuckingFastApi } from "@main/services/hosters";
 
 export class DownloadManager {
   private static downloadingGameId: string | null = null;
 
+  private static extractFilename(url: string, originalUrl?: string): string | undefined {
+    if (originalUrl && originalUrl.includes('#')) {
+      const hashPart = originalUrl.split('#')[1];
+      if (hashPart && !hashPart.startsWith('http')) {
+        return hashPart;
+      }
+    }
+
+    if (url.includes('#')) {
+      const hashPart = url.split('#')[1];
+      if (hashPart && !hashPart.startsWith('http')) {
+        return hashPart;
+      }
+    }
+
+    try {
+      const urlObj = new URL(url);
+      const pathname = urlObj.pathname;
+      const filename = pathname.split('/').pop();
+      if (filename && filename.length > 0) {
+        return filename;
+      }
+    } catch {
+    }
+
+    return undefined;
+  }
+
+  private static sanitizeFilename(filename: string): string {
+    return filename.replace(/[<>:"/\\|?*]/g, '_');
+  }
+
   public static async startRPC(
     download?: Download,
     downloadsToSeed?: Download[]
@@ -126,10 +159,21 @@ export class DownloadManager {
         }
       );
 
+      if (WindowManager.mainWindow && download) {
+        WindowManager.mainWindow.setProgressBar(progress === 1 ? -1 : progress);
+        WindowManager.mainWindow.webContents.send(
+          "on-download-progress",
+          JSON.parse(
+            JSON.stringify({
+              ...status,
+              game,
+            })
+          )
+        );
+      }
+
       const shouldExtract = download.automaticallyExtract;
 
-      // Handle download completion BEFORE sending progress to renderer
-      // This ensures extraction starts and DB is updated before UI reacts
       if (progress === 1 && download) {
         publishDownloadCompleteNotification(game);
 
@@ -143,7 +187,6 @@ export class DownloadManager {
             shouldSeed: true,
             queued: false,
             extracting: shouldExtract,
-            extractionProgress: shouldExtract ? 0 : download.extractionProgress,
           });
         } else {
           await downloadsSublevel.put(gameId, {
@@ -152,22 +195,12 @@ export class DownloadManager {
             shouldSeed: false,
             queued: false,
             extracting: shouldExtract,
-            extractionProgress: shouldExtract ? 0 : download.extractionProgress,
           });
 
           this.cancelDownload(gameId);
         }
 
         if (shouldExtract) {
-          // Send initial extraction progress BEFORE download progress
-          // This ensures the UI shows extraction immediately
-          WindowManager.mainWindow?.webContents.send(
-            "on-extraction-progress",
-            game.shop,
-            game.objectId,
-            0
-          );
-
           const gameFilesManager = new GameFilesManager(
             game.shop,
             game.objectId
@@ -194,10 +227,10 @@ export class DownloadManager {
           .values()
           .all()
           .then((games) => {
-            return orderBy(
+            return sortBy(
               games.filter((game) => game.status === "paused" && game.queued),
               "timestamp",
-              "desc"
+              "DESC"
             );
           });
 
@@ -209,18 +242,6 @@ export class DownloadManager {
           this.downloadingGameId = null;
         }
       }
-
-      // Send progress to renderer after completion handling
-      if (WindowManager.mainWindow && download) {
-        WindowManager.mainWindow.setProgressBar(progress === 1 ? -1 : progress);
-        WindowManager.mainWindow.webContents.send(
-          "on-download-progress",
-          structuredClone({
-            ...status,
-            game,
-          })
-        );
-      }
     }
   }
 
@@ -360,6 +381,58 @@ export class DownloadManager {
           save_path: download.downloadPath,
         };
       }
+      case Downloader.Buzzheavier: {
+        logger.log(`[DownloadManager] Processing Buzzheavier download for URI: ${download.uri}`);
+        try {
+          const directUrl = await BuzzheavierApi.getDirectLink(download.uri);
+          logger.log(`[DownloadManager] Buzzheavier direct URL obtained`);
+
+          const filename = this.extractFilename(directUrl, download.uri);
+          const sanitizedFilename = filename ? this.sanitizeFilename(filename) : undefined;
+          
+          if (sanitizedFilename) {
+            logger.log(`[DownloadManager] Using filename: ${sanitizedFilename}`);
+          }
+
+          return {
+            action: "start",
+            game_id: downloadId,
+            url: directUrl,
+            save_path: download.downloadPath,
+            out: sanitizedFilename,
+            allow_multiple_connections: true,
+          };
+        } catch (error) {
+          logger.error(`[DownloadManager] Error processing Buzzheavier download:`, error);
+          throw error;
+        }
+      }
+      case Downloader.FuckingFast: {
+        logger.log(`[DownloadManager] Processing FuckingFast download for URI: ${download.uri}`);
+        try {
+          const directUrl = await FuckingFastApi.getDirectLink(download.uri);
+          logger.log(`[DownloadManager] FuckingFast direct URL obtained`);
+
+          const filename = this.extractFilename(directUrl, download.uri);
+          const sanitizedFilename = filename ? this.sanitizeFilename(filename) : undefined;
+          
+          if (sanitizedFilename) {
+            logger.log(`[DownloadManager] Using filename: ${sanitizedFilename}`);
+          }
+
+          return {
+            action: "start",
+            game_id: downloadId,
+            url: directUrl,
+            save_path: download.downloadPath,
+            out: sanitizedFilename,
+            allow_multiple_connections: true,
+          };
+        } catch (error) {
+          logger.error(`[DownloadManager] Error processing FuckingFast download:`, error);
+          throw error;
+        }
+      }
       case Downloader.Mediafire: {
         const downloadUrl = await MediafireApi.getDownloadUrl(download.uri);
 

src/main/services/hosters/buzzheavier.ts

@@ -0,0 +1,82 @@
+import axios from "axios";
+import {
+  HOSTER_USER_AGENT,
+  extractHosterFilename,
+  handleHosterError,
+} from "./fuckingfast";
+import { logger } from "@main/services";
+
+export class BuzzheavierApi {
+  private static readonly BUZZHEAVIER_DOMAINS = [
+    "buzzheavier.com",
+    "bzzhr.co",
+    "fuckingfast.net",
+  ];
+
+  private static isSupportedDomain(url: string): boolean {
+    const lowerUrl = url.toLowerCase();
+    return this.BUZZHEAVIER_DOMAINS.some((domain) => lowerUrl.includes(domain));
+  }
+
+  private static async getBuzzheavierDirectLink(url: string): Promise<string> {
+    try {
+      const baseUrl = url.split("#")[0];
+      logger.log(`[Buzzheavier] Starting download link extraction for: ${baseUrl}`);
+
+      await axios.get(baseUrl, {
+        headers: { "User-Agent": HOSTER_USER_AGENT },
+        timeout: 30000,
+      });
+
+      const downloadUrl = `${baseUrl}/download`;
+      logger.log(`[Buzzheavier] Making HEAD request to: ${downloadUrl}`);
+      const headResponse = await axios.head(downloadUrl, {
+        headers: {
+          "hx-current-url": baseUrl,
+          "hx-request": "true",
+          referer: baseUrl,
+          "User-Agent": HOSTER_USER_AGENT,
+        },
+        maxRedirects: 0,
+        validateStatus: (status) =>
+          status === 200 || status === 204 || status === 301 || status === 302,
+        timeout: 30000,
+      });
+
+      const hxRedirect = headResponse.headers["hx-redirect"];
+      logger.log(`[Buzzheavier] Received hx-redirect header: ${hxRedirect}`);
+      if (!hxRedirect) {
+        logger.error(`[Buzzheavier] No hx-redirect header found. Status: ${headResponse.status}`);
+        throw new Error(
+          "Could not extract download link. File may be deleted or is a directory."
+        );
+      }
+
+      const domain = new URL(baseUrl).hostname;
+      const directLink = hxRedirect.startsWith("/dl/")
+        ? `https://${domain}${hxRedirect}`
+        : hxRedirect;
+      logger.log(`[Buzzheavier] Extracted direct link`);
+      return directLink;
+    } catch (error) {
+      logger.error(`[Buzzheavier] Error in getBuzzheavierDirectLink:`, error);
+      handleHosterError(error);
+    }
+  }
+
+  public static async getDirectLink(url: string): Promise<string> {
+    if (!this.isSupportedDomain(url)) {
+      throw new Error(
+        `Unsupported domain. Supported domains: ${this.BUZZHEAVIER_DOMAINS.join(", ")}`
+      );
+    }
+    return this.getBuzzheavierDirectLink(url);
+  }
+
+  public static async getFilename(
+    url: string,
+    directUrl?: string
+  ): Promise<string> {
+    return extractHosterFilename(url, directUrl);
+  }
+}

src/main/services/hosters/fuckingfast.ts

@@ -0,0 +1,129 @@
+import axios from "axios";
+import { logger } from "@main/services";
+
+export const HOSTER_USER_AGENT =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:144.0) Gecko/20100101 Firefox/144.0";
+
+export async function extractHosterFilename(
+  url: string,
+  directUrl?: string
+): Promise<string> {
+  if (url.includes("#")) {
+    const fragment = url.split("#")[1];
+    if (fragment && !fragment.startsWith("http")) {
+      return fragment;
+    }
+  }
+
+  if (directUrl) {
+    try {
+      const response = await axios.head(directUrl, {
+        timeout: 10000,
+        headers: { "User-Agent": HOSTER_USER_AGENT },
+      });
+
+      const contentDisposition = response.headers["content-disposition"];
+      if (contentDisposition) {
+        const filenameMatch = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(
+          contentDisposition
+        );
+        if (filenameMatch && filenameMatch[1]) {
+          return filenameMatch[1].replace(/['"]/g, "");
+        }
+      }
+    } catch {
+      // Ignore errors
+    }
+
+    const urlPath = new URL(directUrl).pathname;
+    const filename = urlPath.split("/").pop()?.split("?")[0];
+    if (filename) {
+      return filename;
+    }
+  }
+
+  return "downloaded_file";
+}
+
+export function handleHosterError(error: unknown): never {
+  if (axios.isAxiosError(error)) {
+    if (error.response?.status === 404) {
+      throw new Error("File not found");
+    }
+    if (error.response?.status === 429) {
+      throw new Error("Rate limit exceeded. Please try again later.");
+    }
+    if (error.response?.status === 403) {
+      throw new Error("Access denied. File may be private or deleted.");
+    }
+    throw new Error(`Network error: ${error.response?.status || "Unknown"}`);
+  }
+  throw error;
+}
+
+// ============================================
+// FuckingFast API Class
+// ============================================
+export class FuckingFastApi {
+  private static readonly FUCKINGFAST_DOMAINS = ["fuckingfast.co"];
+
+  private static readonly FUCKINGFAST_REGEX =
+    /window\.open\("(https:\/\/fuckingfast\.co\/dl\/[^"]*)"\)/;
+
+  private static isSupportedDomain(url: string): boolean {
+    const lowerUrl = url.toLowerCase();
+    return this.FUCKINGFAST_DOMAINS.some((domain) => lowerUrl.includes(domain));
+  }
+
+  private static async getFuckingFastDirectLink(url: string): Promise<string> {
+    try {
+      logger.log(`[FuckingFast] Starting download link extraction for: ${url}`);
+      const response = await axios.get(url, {
+        headers: { "User-Agent": HOSTER_USER_AGENT },
+        timeout: 30000,
+      });
+
+      const html = response.data;
+
+      if (html.toLowerCase().includes("rate limit")) {
+        logger.error(`[FuckingFast] Rate limit detected`);
+        throw new Error(
+          "Rate limit exceeded. Please wait a few minutes and try again."
+        );
+      }
+
+      if (html.includes("File Not Found Or Deleted")) {
+        logger.error(`[FuckingFast] File not found or deleted`);
+        throw new Error("File not found or deleted");
+      }
+
+      const match = this.FUCKINGFAST_REGEX.exec(html);
+      if (!match || !match[1]) {
+        logger.error(`[FuckingFast] Could not extract download link`);
+        throw new Error("Could not extract download link from page");
+      }
+
+      logger.log(`[FuckingFast] Successfully extracted direct link`);
+      return match[1];
+    } catch (error) {
+      logger.error(`[FuckingFast] Error:`, error);
+      handleHosterError(error);
+    }
+  }
+
+  public static async getDirectLink(url: string): Promise<string> {
+    if (!this.isSupportedDomain(url)) {
+      throw new Error(
+        `Unsupported domain. Supported domains: ${this.FUCKINGFAST_DOMAINS.join(", ")}`
+      );
+    }
+    return this.getFuckingFastDirectLink(url);
+  }
+
+  public static async getFilename(
+    url: string,
+    directUrl?: string
+  ): Promise<string> {
+    return extractHosterFilename(url, directUrl);
+  }
+}

src/main/services/hosters/index.ts

@@ -3,3 +3,5 @@ export * from "./qiwi";
 export * from "./datanodes";
 export * from "./mediafire";
 export * from "./pixeldrain";
+export * from "./buzzheavier";
+export * from "./fuckingfast";

src/renderer/src/constants.ts

@@ -10,6 +10,8 @@ export const DOWNLOADER_NAME = {
   [Downloader.Qiwi]: "Qiwi",
   [Downloader.Datanodes]: "Datanodes",
   [Downloader.Mediafire]: "Mediafire",
+  [Downloader.Buzzheavier]: "Buzzheavier",
+  [Downloader.FuckingFast]: "FuckingFast",
   [Downloader.TorBox]: "TorBox",
   [Downloader.Hydra]: "Nimbus",
 };

src/shared/constants.ts

@@ -8,6 +8,8 @@ export enum Downloader {
   Mediafire,
   TorBox,
   Hydra,
+  Buzzheavier,
+  FuckingFast,
 }
 
 export enum DownloadSourceStatus {

src/shared/index.ts

@@ -114,6 +114,16 @@ export const getDownloadersForUri = (uri: string) => {
   if (uri.startsWith("https://datanodes.to")) return [Downloader.Datanodes];
   if (uri.startsWith("https://www.mediafire.com"))
     return [Downloader.Mediafire];
+  if (
+    uri.startsWith("https://buzzheavier.com") ||
+    uri.startsWith("https://bzzhr.co") ||
+    uri.startsWith("https://fuckingfast.net")
+  ) {
+    return [Downloader.Buzzheavier];
+  }
+  if (uri.startsWith("https://fuckingfast.co")) {
+    return [Downloader.FuckingFast];
+  }
 
   if (realDebridHosts.some((host) => uri.startsWith(host)))
     return [Downloader.RealDebrid];