Add proxy client and route downloads through it

backend/utils/clientPatcher.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { getProxyDownloadStream } = require('./proxyClient');
 
 // Domain configuration
 const ORIGINAL_DOMAIN = 'hytale.com';
@@ -605,9 +606,6 @@ class ClientPatcher {
     console.log('Downloading pre-patched HytaleServer.jar...');
 
     try {
-      const https = require('https');
-      
-      // Use different URL for pre-release vs release
       let url;
       if (branch === 'pre-release') {
         url = 'https://patcher.authbp.xyz/download/patched_prerelease';
@@ -617,41 +615,28 @@ class ClientPatcher {
         console.log('  Using release patched server from:', url);
       }
 
+      const file = fs.createWriteStream(serverPath);
+      let totalSize = 0;
+      let downloaded = 0;
+
+      const stream = await getProxyDownloadStream(url, (chunk, downloadedBytes, total) => {
+        downloaded = downloadedBytes;
+        totalSize = total;
+        if (progressCallback && totalSize) {
+          const percent = 30 + Math.floor((downloaded / totalSize) * 60);
+          progressCallback(`Downloading... ${(downloaded / 1024 / 1024).toFixed(2)} MB`, percent);
+        }
+      });
+
+      stream.pipe(file);
+
       await new Promise((resolve, reject) => {
-        const handleResponse = (response) => {
-          if (response.statusCode === 302 || response.statusCode === 301) {
-            https.get(response.headers.location, handleResponse).on('error', reject);
-            return;
-          }
-
-          if (response.statusCode !== 200) {
-            reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
-            return;
-          }
-
-          const file = fs.createWriteStream(serverPath);
-          const totalSize = parseInt(response.headers['content-length'], 10);
-          let downloaded = 0;
-
-          response.on('data', (chunk) => {
-            downloaded += chunk.length;
-            if (progressCallback && totalSize) {
-              const percent = 30 + Math.floor((downloaded / totalSize) * 60);
-              progressCallback(`Downloading... ${(downloaded / 1024 / 1024).toFixed(2)} MB`, percent);
-            }
-          });
-
-          response.pipe(file);
-          file.on('finish', () => {
-            file.close();
-            resolve();
-          });
-        };
-
-        https.get(url, handleResponse).on('error', (err) => {
-          fs.unlink(serverPath, () => {});
-          reject(err);
+        file.on('finish', () => {
+          file.close();
+          resolve();
         });
+        file.on('error', reject);
+        stream.on('error', reject);
       });
 
       console.log('  Download successful');

backend/utils/proxyClient.js

@@ -0,0 +1,96 @@
+const crypto = require('crypto');
+const axios = require('axios');
+const https = require('https');
+
+const PROXY_URL = process.env.HF2P_PROXY_URL || 'your_proxy_url_here';
+const SECRET_KEY = process.env.HF2P_SECRET_KEY || 'your_secret_key_here_for_jwt';
+
+function generateToken() {
+  const timestamp = Date.now().toString();
+  const hash = crypto
+    .createHmac('sha256', SECRET_KEY)
+    .update(timestamp)
+    .digest('hex');
+  return `${timestamp}:${hash}`;
+}
+
+async function proxyRequest(url, options = {}) {
+  const token = generateToken();
+  const urlObj = new URL(url);
+  const targetUrl = `${urlObj.protocol}//${urlObj.host}`;
+
+  const config = {
+    method: options.method || 'GET',
+    url: `${PROXY_URL}/proxy${urlObj.pathname}${urlObj.search}`,
+    headers: {
+      'X-Auth-Token': token,
+      'X-Target-URL': targetUrl,
+      ...(options.headers || {})
+    },
+    timeout: options.timeout || 30000,
+    responseType: options.responseType
+  };
+
+  return axios(config);
+}
+
+function getProxyDownloadStream(url, onData) {
+  return new Promise((resolve, reject) => {
+    const token = generateToken();
+    const urlObj = new URL(url);
+    const targetUrl = `${urlObj.protocol}//${urlObj.host}`;
+
+    const proxyUrl = new URL(PROXY_URL);
+    const requestPath = `/proxy${urlObj.pathname}${urlObj.search}`;
+
+    const options = {
+      hostname: proxyUrl.hostname,
+      port: proxyUrl.port || (proxyUrl.protocol === 'https:' ? 443 : 80),
+      path: requestPath,
+      method: 'GET',
+      headers: {
+        'X-Auth-Token': token,
+        'X-Target-URL': targetUrl
+      }
+    };
+
+    const protocol = proxyUrl.protocol === 'https:' ? https : require('http');
+
+    const handleResponse = (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        const redirectUrl = response.headers.location;
+        if (redirectUrl.startsWith('http')) {
+          getProxyDownloadStream(redirectUrl, onData).then(resolve).catch(reject);
+        } else {
+          reject(new Error(`Invalid redirect: ${redirectUrl}`));
+        }
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`HTTP ${response.statusCode}`));
+        return;
+      }
+
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloaded = 0;
+
+      response.on('data', (chunk) => {
+        downloaded += chunk.length;
+        if (onData) {
+          onData(chunk, downloaded, totalSize);
+        }
+      });
+
+      resolve(response);
+    };
+
+    protocol.get(options, handleResponse).on('error', reject);
+  });
+}
+
+module.exports = {
+  proxyRequest,
+  getProxyDownloadStream,
+  generateToken
+};