From a7d0523186132e0d28a30d291d00234ff32eb6b1 Mon Sep 17 00:00:00 2001
From: Fazri Gading <fazrigading@gmail.com>
Date: Sun, 25 Jan 2026 01:36:20 +0800
Subject: [PATCH] feat: auto-resume download process & auto-retry if
 disconnected (#143)

---
 GUI/index.html                  |  39 +--
 GUI/js/ui.js                    | 357 ++++++++++++++++++++++---
 GUI/style.css                   | 249 +++++++++++++++++-
 backend/managers/gameManager.js | 329 ++++++++++++++++++++---
 backend/utils/fileManager.js    | 446 ++++++++++++++++++++++++++++----
 main.js                         | 320 ++++++++++++++++-------
 preload.js                      |  10 +-
 7 files changed, 1503 insertions(+), 247 deletions(-)

diff --git a/GUI/index.html b/GUI/index.html
index 0cb2785..2cb204b 100644
--- a/GUI/index.html
+++ b/GUI/index.html
@@ -602,21 +602,30 @@
         </div>
     </div>
 
-    <div id="progressOverlay" class="progress-overlay" style="display: none;">
-        <div class="progress-content">
-            <div class="progress-info">
-                <span id="progressText" data-i18n="progress.initializing">Initializing...</span>
-                <span id="progressPercent">0%</span>
-            </div>
-            <div class="progress-bar-container">
-                <div id="progressBarFill" class="progress-bar-fill"></div>
-            </div>
-            <div class="progress-details">
-                <span id="progressSpeed"></span>
-                <span id="progressSize"></span>
-            </div>
-        </div>
-    </div>
+<div id="progressOverlay" class="progress-overlay" style="display: none;">
+        <div class="progress-content">
+            <div class="progress-info">
+                <span id="progressText" data-i18n="progress.initializing">Initializing...</span>
+                <span id="progressPercent">0%</span>
+            </div>
+            <div class="progress-bar-container">
+                <div id="progressBarFill" class="progress-bar-fill"></div>
+            </div>
+            <div class="progress-details">
+                <span id="progressSpeed"></span>
+                <span id="progressSize"></span>
+            </div>
+            <div id="progressErrorContainer" class="progress-error-container" style="display: none;">
+                <div id="progressErrorMessage" class="progress-error-message"></div>
+                <div class="progress-retry-section">
+                    <span id="progressRetryInfo" class="progress-retry-info"></span>
+                    <button id="progressRetryBtn" class="progress-retry-btn" style="display: none;">
+                        🔄 Retry Download
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
 
     <div id="chatUsernameModal" class="chat-username-modal" style="display: none;">
         <div class="chat-username-modal-content">
diff --git a/GUI/js/ui.js b/GUI/js/ui.js
index 5e47283..4e7131b 100644
--- a/GUI/js/ui.js
+++ b/GUI/js/ui.js
@@ -1,11 +1,27 @@
 
-let progressOverlay;
-let progressBar;
-let progressBarFill;
-let progressText;
-let progressPercent;
-let progressSpeed;
-let progressSize;
+let progressOverlay;
+let progressBar;
+let progressBarFill;
+let progressText;
+let progressPercent;
+let progressSpeed;
+let progressSize;
+let progressErrorContainer;
+let progressErrorMessage;
+let progressRetryInfo;
+let progressRetryBtn;
+
+// Download retry state
+let currentDownloadState = {
+    isDownloading: false,
+    canRetry: false,
+    retryData: null,
+    lastError: null,
+    errorType: null,
+    branch: null,
+    fileName: null,
+    cacheDir: null
+};
 
 function showPage(pageId) {
   const pages = document.querySelectorAll('.page');
@@ -143,26 +159,108 @@ function hideProgress() {
   }
 }
 
-function updateProgress(data) {
-  if (data.message && progressText) {
-    progressText.textContent = data.message;
-  }
-
-  if (data.percent !== null && data.percent !== undefined) {
-    const percent = Math.min(100, Math.max(0, Math.round(data.percent)));
-    if (progressPercent) progressPercent.textContent = `${percent}%`;
-    if (progressBarFill) progressBarFill.style.width = `${percent}%`;
-    if (progressBar) progressBar.style.width = `${percent}%`;
-  }
-
-  if (data.speed && data.downloaded && data.total) {
-    const speedMB = (data.speed / 1024 / 1024).toFixed(2);
-    const downloadedMB = (data.downloaded / 1024 / 1024).toFixed(2);
-    const totalMB = (data.total / 1024 / 1024).toFixed(2);
-    if (progressSpeed) progressSpeed.textContent = `${speedMB} MB/s`;
-    if (progressSize) progressSize.textContent = `${downloadedMB} / ${totalMB} MB`;
-  }
-}
+function updateProgress(data) {
+  // Handle retry state
+  if (data.retryState) {
+    currentDownloadState.retryData = data.retryState;
+    updateRetryState(data.retryState);
+  }
+
+  if (data.message && progressText) {
+    progressText.textContent = data.message;
+  }
+
+  if (data.percent !== null && data.percent !== undefined) {
+    const percent = Math.min(100, Math.max(0, Math.round(data.percent)));
+    if (progressPercent) progressPercent.textContent = `${percent}%`;
+    if (progressBarFill) progressBarFill.style.width = `${percent}%`;
+    if (progressBar) progressBar.style.width = `${percent}%`;
+  }
+
+  if (data.speed && data.downloaded && data.total) {
+    const speedMB = (data.speed / 1024 / 1024).toFixed(2);
+    const downloadedMB = (data.downloaded / 1024 / 1024).toFixed(2);
+    const totalMB = (data.total / 1024 / 1024).toFixed(2);
+    if (progressSpeed) progressSpeed.textContent = `${speedMB} MB/s`;
+    if (progressSize) progressSize.textContent = `${downloadedMB} / ${totalMB} MB`;
+  }
+
+  // Handle error states with enhanced categorization
+  // Don't show error during automatic retries - let the retry message display instead
+  if ((data.error || (data.message && data.message.includes('failed'))) && 
+      !(data.retryState && data.retryState.isAutomaticRetry)) {
+    const errorType = categorizeError(data.message);
+    showDownloadError(data.message, data.canRetry, errorType);
+  } else if (data.percent === 100) {
+    hideDownloadError();
+  } else if (data.retryState && data.retryState.isAutomaticRetry) {
+    // Hide any existing error during automatic retries
+    hideDownloadError();
+  }
+}
+
+function updateRetryState(retryState) {
+  if (!progressRetryInfo) return;
+
+  if (retryState.isAutomaticRetry && retryState.automaticStallRetries > 0) {
+    // Show automatic stall retry count
+    progressRetryInfo.textContent = `Auto-retry ${retryState.automaticStallRetries}/3`;
+    progressRetryInfo.style.display = 'block';
+    progressRetryInfo.style.background = 'rgba(255, 193, 7, 0.2)'; // Light orange background for auto-retries
+    progressRetryInfo.style.color = '#ff9800'; // Orange text for auto-retries
+  } else if (retryState.attempts > 1) {
+    // Show manual retry count
+    progressRetryInfo.textContent = `Attempt ${retryState.attempts}/${retryState.maxRetries}`;
+    progressRetryInfo.style.display = 'block';
+    progressRetryInfo.style.background = ''; // Reset background
+    progressRetryInfo.style.color = ''; // Reset color
+  } else {
+    progressRetryInfo.style.display = 'none';
+    progressRetryInfo.style.background = ''; // Reset background
+    progressRetryInfo.style.color = ''; // Reset color
+  }
+}
+
+function showDownloadError(errorMessage, canRetry = true, errorType = 'general') {
+  if (!progressErrorContainer || !progressErrorMessage || !progressRetryBtn) return;
+
+  currentDownloadState.lastError = errorMessage;
+  currentDownloadState.canRetry = canRetry;
+  currentDownloadState.errorType = errorType;
+  
+  // Update retry context if available
+  if (data && data.retryData) {
+    currentDownloadState.branch = data.retryData.branch;
+    currentDownloadState.fileName = data.retryData.fileName;
+    currentDownloadState.cacheDir = data.retryData.cacheDir;
+  }
+
+  // User-friendly error messages
+  const userMessage = getErrorMessage(errorMessage, errorType);
+  progressErrorMessage.textContent = userMessage;
+  progressErrorContainer.style.display = 'block';
+  progressRetryBtn.style.display = canRetry ? 'block' : 'none';
+
+  // Add visual indicators based on error type
+  progressErrorContainer.className = `progress-error-container error-${errorType}`;
+
+  if (progressOverlay) {
+    progressOverlay.classList.add('error-state');
+  }
+}
+
+function hideDownloadError() {
+  if (!progressErrorContainer) return;
+
+  progressErrorContainer.style.display = 'none';
+  currentDownloadState.canRetry = false;
+  currentDownloadState.lastError = null;
+  currentDownloadState.errorType = null;
+
+  if (progressOverlay) {
+    progressOverlay.classList.remove('error-state');
+  }
+}
 
 function setupAnimations() {
   document.body.style.opacity = '0';
@@ -470,17 +568,24 @@ function showNotification(message, type = 'info') {
   }, 5000);
 }
 
-function setupUI() {
-  progressOverlay = document.getElementById('progressOverlay');
-  progressBar = document.getElementById('progressBar');
-  progressBarFill = document.getElementById('progressBarFill');
-  progressText = document.getElementById('progressText');
-  progressPercent = document.getElementById('progressPercent');
-  progressSpeed = document.getElementById('progressSpeed');
-  progressSize = document.getElementById('progressSize');
-
-  // Setup draggable progress bar
-  setupProgressDrag();
+function setupUI() {
+  progressOverlay = document.getElementById('progressOverlay');
+  progressBar = document.getElementById('progressBar');
+  progressBarFill = document.getElementById('progressBarFill');
+  progressText = document.getElementById('progressText');
+  progressPercent = document.getElementById('progressPercent');
+  progressSpeed = document.getElementById('progressSpeed');
+  progressSize = document.getElementById('progressSize');
+  progressErrorContainer = document.getElementById('progressErrorContainer');
+  progressErrorMessage = document.getElementById('progressErrorMessage');
+  progressRetryInfo = document.getElementById('progressRetryInfo');
+  progressRetryBtn = document.getElementById('progressRetryBtn');
+
+  // Setup draggable progress bar
+  setupProgressDrag();
+
+  // Setup retry button
+  setupRetryButton();
 
   lockPlayButton(true);
 
@@ -648,7 +753,175 @@ function toggleMaximize() {
   }
 }
 
-// Make toggleMaximize globally available
-window.toggleMaximize = toggleMaximize;
-
-document.addEventListener('DOMContentLoaded', setupUI);
+// Error categorization and user-friendly messages
+function categorizeError(message) {
+  const msg = message.toLowerCase();
+  
+  if (msg.includes('network') || msg.includes('connection') || msg.includes('offline')) {
+    return 'network';
+  } else if (msg.includes('stalled') || msg.includes('timeout')) {
+    return 'stall';
+  } else if (msg.includes('file') || msg.includes('disk')) {
+    return 'file';
+  } else if (msg.includes('permission') || msg.includes('access')) {
+    return 'permission';
+  } else if (msg.includes('server') || msg.includes('5')) {
+    return 'server';
+  } else if (msg.includes('corrupted') || msg.includes('pwr file') || msg.includes('unexpected eof')) {
+    return 'corruption';
+  } else if (msg.includes('butler') || msg.includes('patch installation')) {
+    return 'butler';
+  } else if (msg.includes('space') || msg.includes('full') || msg.includes('device full')) {
+    return 'space';
+  } else if (msg.includes('conflict') || msg.includes('already exists')) {
+    return 'conflict';
+  } else {
+    return 'general';
+  }
+}
+
+function getErrorMessage(technicalMessage, errorType) {
+  // Technical errors go to console, user gets friendly messages
+  console.error(`Download error [${errorType}]:`, technicalMessage);
+  
+  switch (errorType) {
+    case 'network':
+      return 'Network connection lost. Please check your internet connection and retry.';
+    case 'stall':
+      return 'Download stalled due to slow connection. Please retry.';
+    case 'file':
+      return 'Unable to save file. Check disk space and permissions. Please retry.';
+    case 'permission':
+      return 'Permission denied. Check if launcher has write access. Please retry.';
+    case 'server':
+      return 'Server error. Please wait a moment and retry.';
+    case 'corruption':
+      return 'Corrupted PWR file detected. File deleted and will retry.';
+    case 'butler':
+      return 'Patch installation failed. Please retry.';
+    case 'space':
+      return 'Insufficient disk space. Free up space and retry.';
+    case 'conflict':
+      return 'Installation directory conflict. Please retry.';
+    default:
+      return 'Download failed. Please retry.';
+  }
+}
+
+// Connection quality indicator (simplified)
+function updateConnectionQuality(quality) {
+  if (!progressSize) return;
+  
+  const qualityColors = {
+    'Good': '#10b981',
+    'Fair': '#fbbf24', 
+    'Poor': '#f87171'
+  };
+  
+  const color = qualityColors[quality] || '#6b7280';
+  progressSize.style.color = color;
+  
+  // Add subtle quality indicator
+  if (progressSize.dataset.quality !== quality) {
+    progressSize.dataset.quality = quality;
+    progressSize.style.transition = 'color 0.5s ease';
+  }
+}
+
+// Enhanced retry button setup
+function setupRetryButton() {
+  if (!progressRetryBtn) return;
+
+  progressRetryBtn.addEventListener('click', async () => {
+    if (!currentDownloadState.canRetry || currentDownloadState.isDownloading) {
+      return;
+    }
+
+    // Disable retry button during retry
+    progressRetryBtn.disabled = true;
+    progressRetryBtn.textContent = '🔄 Retrying...';
+    progressRetryBtn.classList.add('retrying');
+    currentDownloadState.isDownloading = true;
+
+    try {
+      // Hide error state during retry
+      hideDownloadError();
+      
+      // Reset retry info styling for manual retries
+      if (progressRetryInfo) {
+        progressRetryInfo.style.background = '';
+        progressRetryInfo.style.color = '';
+      }
+      
+      // Update progress text with context-aware message
+      if (progressText) {
+        const contextMessage = getRetryContextMessage();
+        progressText.textContent = contextMessage;
+      }
+
+      // Ensure retry data exists, create defaults if null
+      if (!currentDownloadState.retryData) {
+        currentDownloadState.retryData = {
+          branch: 'release',
+          fileName: '4.pwr'
+        };
+        console.log('[UI] Created default retry data:', currentDownloadState.retryData);
+      }
+
+      // Send retry request to backend
+      if (window.electronAPI && window.electronAPI.retryDownload) {
+        const result = await window.electronAPI.retryDownload(currentDownloadState.retryData);
+        
+        if (!result.success) {
+          throw new Error(result.error || 'Retry failed');
+        }
+      } else {
+        // Fallback for development/testing
+        console.warn('electronAPI.retryDownload not available, simulating retry...');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        throw new Error('Retry API not available');
+      }
+
+    } catch (error) {
+      console.error('Retry failed:', error);
+      const errorType = categorizeError(error.message);
+      showDownloadError(`Retry failed: ${error.message}`, true, errorType);
+      
+      // Reset retry button
+      progressRetryBtn.disabled = false;
+      progressRetryBtn.textContent = '🔄 Retry Download';
+      progressRetryBtn.classList.remove('retrying');
+      currentDownloadState.isDownloading = false;
+    }
+  });
+}
+
+function getRetryContextMessage() {
+  const errorType = currentDownloadState.errorType;
+  
+  switch (errorType) {
+    case 'network':
+      return 'Reconnecting and retrying download...';
+    case 'stall':
+      return 'Resuming stalled download...';
+    case 'server':
+      return 'Waiting for server and retrying...';
+    case 'corruption':
+      return 'Re-downloading corrupted PWR file...';
+    case 'butler':
+      return 'Re-attempting patch installation...';
+    case 'space':
+      return 'Retrying after clearing disk space...';
+    case 'permission':
+      return 'Retrying with corrected permissions...';
+    case 'conflict':
+      return 'Retrying after resolving conflicts...';
+    default:
+      return 'Initiating retry download...';
+  }
+}
+
+// Make toggleMaximize globally available
+window.toggleMaximize = toggleMaximize;
+
+document.addEventListener('DOMContentLoaded', setupUI);
diff --git a/GUI/style.css b/GUI/style.css
index acdc079..8e492f1 100644
--- a/GUI/style.css
+++ b/GUI/style.css
@@ -1770,15 +1770,246 @@ body {
     animation: shimmer 2s infinite;
 }
 
-@keyframes shimmer {
-    0% {
-        left: -100%;
-    }
-
-    100% {
-        left: 100%;
-    }
-}
+@keyframes shimmer {
+    0% {
+        left: -100%;
+    }
+
+    100% {
+        left: 100%;
+    }
+}
+
+/* Progress Error and Retry Styles */
+.progress-error-container {
+    margin-top: 0.75rem;
+    padding-top: 0.75rem;
+    border-top: 1px solid rgba(239, 68, 68, 0.3);
+    animation: errorSlideIn 0.3s ease-out;
+}
+
+@keyframes errorSlideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.progress-error-message {
+    color: #f87171;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 0.75rem;
+    margin-bottom: 0.5rem;
+    text-shadow: 0 0 8px rgba(248, 113, 113, 0.4);
+    line-height: 1.4;
+}
+
+.progress-retry-section {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.progress-retry-info {
+    color: #fbbf24;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 0.7rem;
+    flex: 1;
+}
+
+.progress-retry-btn {
+    background: linear-gradient(135deg, #dc2626, #ef4444);
+    color: white;
+    border: none;
+    padding: 0.5rem 1rem;
+    border-radius: 6px;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 0.75rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    box-shadow: 0 2px 8px rgba(220, 38, 38, 0.3);
+    white-space: nowrap;
+    min-width: 120px;
+}
+
+.progress-retry-btn:hover {
+    background: linear-gradient(135deg, #b91c1c, #dc2626);
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(220, 38, 38, 0.4);
+}
+
+.progress-retry-btn:active {
+    transform: translateY(0);
+    box-shadow: 0 2px 6px rgba(220, 38, 38, 0.3);
+}
+
+.progress-retry-btn:disabled {
+    background: linear-gradient(135deg, #4b5563, #6b7280);
+    cursor: not-allowed;
+    transform: none;
+    box-shadow: none;
+    opacity: 0.6;
+}
+
+/* Progress overlay error state */
+.progress-overlay.error-state {
+    border-color: rgba(239, 68, 68, 0.5);
+    box-shadow:
+        0 4px 16px rgba(0, 0, 0, 0.5),
+        0 0 30px rgba(239, 68, 68, 0.2),
+        inset 0 1px 0 rgba(255, 255, 255, 0.05);
+}
+
+.progress-overlay.error-state #progressBarFill {
+    background: linear-gradient(90deg, #dc2626, #ef4444);
+    animation: errorPulse 1.5s ease-in-out infinite;
+}
+
+@keyframes errorPulse {
+    0%, 100% {
+        opacity: 0.8;
+    }
+    50% {
+        opacity: 1;
+    }
+}
+
+/* Error type specific styling */
+.progress-error-container.error-network {
+    border-top-color: rgba(59, 130, 246, 0.5);
+}
+
+.progress-error-container.error-network .progress-error-message {
+    color: #60a5fa;
+    text-shadow: 0 0 8px rgba(96, 165, 250, 0.4);
+}
+
+.progress-error-container.error-stall {
+    border-top-color: rgba(245, 158, 11, 0.5);
+}
+
+.progress-error-container.error-stall .progress-error-message {
+    color: #fbbf24;
+    text-shadow: 0 0 8px rgba(251, 191, 36, 0.4);
+}
+
+.progress-error-container.error-file {
+    border-top-color: rgba(239, 68, 68, 0.5);
+}
+
+.progress-error-container.error-file .progress-error-message {
+    color: #f87171;
+    text-shadow: 0 0 8px rgba(248, 113, 113, 0.4);
+}
+
+.progress-error-container.error-permission {
+    border-top-color: rgba(168, 85, 247, 0.5);
+}
+
+.progress-error-container.error-permission .progress-error-message {
+    color: #a855f7;
+    text-shadow: 0 0 8px rgba(168, 85, 247, 0.4);
+}
+
+.progress-error-container.error-server {
+    border-top-color: rgba(236, 72, 153, 0.5);
+}
+
+.progress-error-container.error-server .progress-error-message {
+    color: #ec4899;
+    text-shadow: 0 0 8px rgba(236, 72, 153, 0.4);
+}
+
+.progress-error-container.error-corruption {
+    border-top-color: rgba(220, 38, 38, 0.8);
+}
+
+.progress-error-container.error-corruption .progress-error-message {
+    color: #dc2626;
+    text-shadow: 0 0 8px rgba(220, 38, 38, 0.6);
+    font-weight: 600;
+}
+
+.progress-error-container.error-butler {
+    border-top-color: rgba(245, 158, 11, 0.5);
+}
+
+.progress-error-container.error-butler .progress-error-message {
+    color: #f59e0b;
+    text-shadow: 0 0 8px rgba(245, 158, 11, 0.4);
+}
+
+.progress-error-container.error-space {
+    border-top-color: rgba(168, 85, 247, 0.5);
+}
+
+.progress-error-container.error-space .progress-error-message {
+    color: #a855f7;
+    text-shadow: 0 0 8px rgba(168, 85, 247, 0.4);
+}
+
+.progress-error-container.error-conflict {
+    border-top-color: rgba(6, 182, 212, 0.5);
+}
+
+.progress-error-container.error-conflict .progress-error-message {
+    color: #06b6d4;
+    text-shadow: 0 0 8px rgba(6, 182, 212, 0.4);
+}
+
+/* Connection quality indicators */
+.progress-details {
+    transition: all 0.3s ease;
+}
+
+.progress-details #progressSize {
+    transition: color 0.5s ease;
+}
+
+/* Enhanced retry button states */
+.progress-retry-btn.retrying {
+    background: linear-gradient(135deg, #059669, #10b981);
+    animation: retryingPulse 1s ease-in-out infinite;
+}
+
+@keyframes retryingPulse {
+    0%, 100% {
+        transform: scale(1);
+        box-shadow: 0 2px 8px rgba(5, 150, 105, 0.3);
+    }
+    50% {
+        transform: scale(1.05);
+        box-shadow: 0 4px 12px rgba(5, 150, 105, 0.4);
+    }
+}
+
+/* Network status indicator (optional future enhancement) */
+.network-status {
+    position: absolute;
+    top: 5px;
+    right: 5px;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: #10b981;
+    box-shadow: 0 0 6px rgba(16, 185, 129, 0.6);
+}
+
+.network-status.poor {
+    background: #f87171;
+    box-shadow: 0 0 6px rgba(248, 113, 113, 0.6);
+}
+
+.network-status.fair {
+    background: #fbbf24;
+    box-shadow: 0 0 6px rgba(251, 191, 36, 0.6);
+}
 
 .progress-bar-fill {
     height: 100%;
diff --git a/backend/managers/gameManager.js b/backend/managers/gameManager.js
index 5c64e77..d58e8c3 100644
--- a/backend/managers/gameManager.js
+++ b/backend/managers/gameManager.js
@@ -3,15 +3,15 @@ const path = require('path');
 const { execFile } = require('child_process');
 const { getResolvedAppDir, findClientPath, findUserDataPath, findUserDataRecursive, GAME_DIR, CACHE_DIR, TOOLS_DIR } = require('../core/paths');
 const { getOS, getArch } = require('../utils/platformUtils');
-const { downloadFile } = require('../utils/fileManager');
-const { getLatestClientVersion } = require('../services/versionManager');
+const { downloadFile, retryDownload, retryStalledDownload, MAX_AUTOMATIC_STALL_RETRIES } = require('../utils/fileManager');
+const { getLatestClientVersion, getInstalledClientVersion } = require('../services/versionManager');
 const { installButler } = require('./butlerManager');
 const { downloadAndReplaceHomePageUI, downloadAndReplaceLogo } = require('./uiFileManager');
 const { saveUsername, saveInstallPath, loadJavaPath, CONFIG_FILE, loadConfig, loadVersionBranch, saveVersionClient, loadVersionClient } = require('../core/config');
 const { resolveJavaPath, detectSystemJava, downloadJRE, getJavaExec, getBundledJavaPath } = require('./javaManager');
 const userDataBackup = require('../utils/userDataBackup');
 
-async function downloadPWR(branch = 'release', fileName = '4.pwr', progressCallback, cacheDir = CACHE_DIR) {
+async function downloadPWR(branch = 'release', fileName = '4.pwr', progressCallback, cacheDir = CACHE_DIR, manualRetry = false) {
   const osName = getOS();
   const arch = getArch();
 
@@ -20,42 +20,142 @@ async function downloadPWR(branch = 'release', fileName = '4.pwr', progressCallb
   }
 
   const url = `https://game-patches.hytale.com/patches/${osName}/${arch}/${branch}/0/${fileName}`;
-
   const dest = path.join(cacheDir, `${branch}_${fileName}`);
 
   // Check if file exists and validate it
-  if (fs.existsSync(dest)) {
+  if (fs.existsSync(dest) && !manualRetry) {
     console.log('PWR file found in cache:', dest);
     
-    // Validate file size (PWR files should be > 1MB)
+    // Validate file size (PWR files should be > 1MB and >= 1.5GB for complete downloads)
     const stats = fs.statSync(dest);
     if (stats.size < 1024 * 1024) {
-      console.log('Cached PWR file seems corrupted (too small), re-downloading...');
-      fs.unlinkSync(dest);
-    } else {
-      return dest;
+      return false;
+    }
+    
+    // Check if file is under 1.5 GB (incomplete download)
+    const sizeInMB = stats.size / 1024 / 1024;
+    if (sizeInMB < 1500) {
+      console.log(`[PWR Validation] File appears incomplete: ${sizeInMB.toFixed(2)} MB < 1.5 GB`);
+      return false;
     }
   }
 
   console.log('Fetching PWR patch file:', url);
-  await downloadFile(url, dest, progressCallback);
   
-  // Validate downloaded file
+  try {
+    if (manualRetry) {
+      await retryDownload(url, dest, progressCallback);
+    } else {
+      await downloadFile(url, dest, progressCallback);
+    }
+  } catch (error) {
+    // Check for automatic stall retry conditions (only for stall errors, not manual retries)
+    if (!manualRetry && 
+        error.message && 
+        error.message.includes('stalled') && 
+        error.canRetry !== false && // Explicitly check it's not false
+        (!error.retryState || error.retryState.automaticStallRetries < MAX_AUTOMATIC_STALL_RETRIES)) {
+      
+      console.log(`[PWR] Automatic stall retry triggered (${(error.retryState && error.retryState.automaticStallRetries || 0) + 1}/${MAX_AUTOMATIC_STALL_RETRIES})`);
+      
+      try {
+        await retryStalledDownload(url, dest, progressCallback, error);
+        console.log('[PWR] Automatic stall retry successful');
+        
+        // After successful automatic retry, continue with normal flow - the file should be valid now
+        const retryStats = fs.statSync(dest);
+        console.log(`PWR file downloaded (auto-retry), size: ${(retryStats.size / 1024 / 1024).toFixed(2)} MB`);
+        
+        if (!validatePWRFile(dest)) {
+          console.log(`[PWR Validation] PWR file validation failed after auto-retry, deleting corrupted file: ${dest}`);
+          fs.unlinkSync(dest);
+          throw new Error('Downloaded PWR file is corrupted or invalid after automatic retry. Please retry manually');
+        }
+
+        
+      } catch (retryError) {
+        console.error('[PWR] Automatic stall retry failed:', retryError.message);
+        
+        // Create enhanced error with updated retry state
+        const enhancedError = new Error(`PWR download failed after automatic retries: ${retryError.message}`);
+        enhancedError.originalError = retryError;
+        enhancedError.retryState = retryError.retryState || error.retryState || null;
+        enhancedError.canRetry = true; // Still allow manual retry
+        enhancedError.pwrUrl = url;
+        enhancedError.pwrDest = dest;
+        enhancedError.branch = branch;
+        enhancedError.fileName = fileName;
+        enhancedError.cacheDir = cacheDir;
+        enhancedError.automaticRetriesExhausted = true;
+        throw enhancedError;
+      }
+    }
+    
+    // Enhanced error handling for retry UI (non-stall errors or exhausted automatic retries)
+    const enhancedError = new Error(`PWR download failed: ${error.message}`);
+    enhancedError.originalError = error;
+    enhancedError.retryState = error.retryState || null;
+    enhancedError.canRetry = error.isConnectionLost ? false : (error.canRetry !== false); // Don't allow retry for connection lost
+    enhancedError.pwrUrl = url;
+    enhancedError.pwrDest = dest;
+    enhancedError.branch = branch;
+    enhancedError.fileName = fileName;
+    enhancedError.cacheDir = cacheDir;
+    enhancedError.isConnectionLost = error.isConnectionLost || false;
+    
+    console.log(`[PWR] Error handling:`, {
+      message: enhancedError.message,
+      isConnectionLost: enhancedError.isConnectionLost,
+      canRetry: enhancedError.canRetry,
+      retryState: enhancedError.retryState
+    });
+    
+    throw enhancedError;
+  }
+  
+  // Enhanced PWR file validation
   const stats = fs.statSync(dest);
   console.log(`PWR file downloaded, size: ${(stats.size / 1024 / 1024).toFixed(2)} MB`);
   
-  if (stats.size < 1024 * 1024) {
+  if (!validatePWRFile(dest)) {
+    console.log(`[PWR Validation] PWR file validation failed, deleting corrupted file: ${dest}`);
     fs.unlinkSync(dest);
-    throw new Error('Downloaded PWR file is corrupted (file too small)');
+    throw new Error('Downloaded PWR file is corrupted or invalid. Please retry');
   }
   
   console.log('PWR saved to:', dest);
+  console.log(`[PWR Validation] PWR file validation passed: ${dest}`);
 
   return dest;
 }
 
-async function applyPWR(pwrFile, progressCallback, gameDir = GAME_DIR, toolsDir = TOOLS_DIR) {
+// Manual retry function for PWR downloads
+async function retryPWRDownload(branch, fileName, progressCallback, cacheDir = CACHE_DIR) {
+  console.log('Initiating manual PWR retry...');
+  return await downloadPWR(branch, fileName, progressCallback, cacheDir, true);
+}
+
+async function applyPWR(pwrFile, progressCallback, gameDir = GAME_DIR, toolsDir = TOOLS_DIR, branch = 'release', cacheDir = CACHE_DIR) {
+  console.log(`[Butler] Starting PWR application with:`);
+  console.log(`[Butler] - PWR file: ${pwrFile}`);
+  console.log(`[Butler] - Staging dir: ${path.join(gameDir, 'staging-temp')}`);
+  console.log(`[Butler] - Game dir: ${gameDir}`);
+  console.log(`[Butler] - Branch: ${branch}`);
+  console.log(`[Butler] - Cache dir: ${cacheDir}`);
+  
+  // Validate PWR file exists and get diagnostic info
+  if (!pwrFile || typeof pwrFile !== 'string' || !fs.existsSync(pwrFile)) {
+    throw new Error(`PWR file not found: ${pwrFile || 'undefined'}. Please retry download.`);
+  }
+  
+  const pwrStats = fs.statSync(pwrFile);
+  console.log(`[Butler] PWR file size: ${(pwrStats.size / 1024 / 1024).toFixed(2)} MB`);
+  console.log(`[Butler] PWR file exists: ${fs.existsSync(pwrFile)}`);
+  
   const butlerPath = await installButler(toolsDir);
+  console.log(`[Butler] Butler path: ${butlerPath}`);
+  console.log(`[Butler] Butler executable: ${fs.existsSync(butlerPath)}`);
+  
   const gameLatest = gameDir;
   const stagingDir = path.join(gameLatest, 'staging-temp');
 
@@ -66,12 +166,11 @@ async function applyPWR(pwrFile, progressCallback, gameDir = GAME_DIR, toolsDir
     return;
   }
 
-  if (!fs.existsSync(gameLatest)) {
-    fs.mkdirSync(gameLatest, { recursive: true });
-  }
-  if (!fs.existsSync(stagingDir)) {
-    fs.mkdirSync(stagingDir, { recursive: true });
-  }
+  // Validate and prepare directories
+  validateGameDirectory(gameLatest, stagingDir);
+  
+  console.log(`[Butler] Game directory validated: ${gameLatest}`);
+  console.log(`[Butler] Staging directory validated: ${stagingDir}`);
 
   if (progressCallback) {
     progressCallback('Installing game patch...', null, null, null, null);
@@ -95,6 +194,8 @@ async function applyPWR(pwrFile, progressCallback, gameDir = GAME_DIR, toolsDir
     gameLatest
   ];
 
+  console.log(`[Butler] Executing command: ${butlerPath} ${args.join(' ')}`);
+
   try {
     await new Promise((resolve, reject) => {
       const child = execFile(butlerPath, args, {
@@ -102,32 +203,97 @@ async function applyPWR(pwrFile, progressCallback, gameDir = GAME_DIR, toolsDir
         timeout: 600000
       }, (error, stdout, stderr) => {
         if (error) {
-          console.error('Butler stderr:', stderr);
-          console.error('Butler stdout:', stdout);
+          console.error('[Butler] stderr:', stderr);
+          console.error('[Butler] stdout:', stdout);
+          console.error('[Butler] error code:', error.code);
+          console.error('[Butler] error signal:', error.signal);
           
-          // Check for EOF error (corrupted PWR file)
-          if (stderr && stderr.includes('unexpected EOF')) {
-            // Delete corrupted PWR file
-            console.log('Corrupted PWR file detected, deleting:', pwrFile);
+          // Enhanced error pattern detection
+          const errorPatterns = {
+            'unexpected EOF': {
+              message: 'Corrupted PWR file detected and deleted. Please try launching the game again.',
+              shouldDeletePWR: true
+            },
+            'permission denied': {
+              message: 'Permission denied. Check file permissions and try again.',
+              shouldDeletePWR: false
+            },
+            'no space left': {
+              message: 'Insufficient disk space. Free up space and try again.',
+              shouldDeletePWR: false
+            },
+            'device full': {
+              message: 'Insufficient disk space. Free up space and try again.',
+              shouldDeletePWR: false
+            },
+            'already exists': {
+              message: 'Installation directory conflict. Clean directories and retry.',
+              shouldDeletePWR: false
+            },
+            'network error': {
+              message: 'Network error during patch installation. Please retry.',
+              shouldDeletePWR: false
+            },
+            'connection refused': {
+              message: 'Connection refused. Check network and retry.',
+              shouldDeletePWR: false
+            }
+          };
+          
+          let enhancedMessage = `Patch installation failed: ${error.message}${stderr ? '\n' + stderr : ''}`;
+          let shouldDeletePWR = false;
+          
+          // Check error patterns
+          const errorText = (stderr + ' ' + error.message).toLowerCase();
+          for (const [pattern, config] of Object.entries(errorPatterns)) {
+            if (errorText.includes(pattern)) {
+              enhancedMessage = config.message;
+              shouldDeletePWR = config.shouldDeletePWR;
+              console.log(`[Butler] Pattern matched: ${pattern}`);
+              break;
+            }
+          }
+          
+          // Delete corrupted PWR file if needed
+          if (shouldDeletePWR) {
             try {
               if (fs.existsSync(pwrFile)) {
                 fs.unlinkSync(pwrFile);
-                console.log('Corrupted PWR file deleted. Please try again to re-download.');
+                console.log('[Butler] Corrupted PWR file deleted:', pwrFile);
               }
             } catch (delErr) {
-              console.error('Failed to delete corrupted PWR file:', delErr);
+              console.error('[Butler] Failed to delete corrupted PWR file:', delErr);
             }
-            reject(new Error(`Corrupted PWR file detected and deleted. Please try launching the game again.`));
-          } else {
-            reject(new Error(`Patch installation failed: ${error.message}${stderr ? '\n' + stderr : ''}`));
           }
+          
+          // Enhanced error with retry context
+          const enhancedError = new Error(enhancedMessage);
+          enhancedError.canRetry = true;
+          enhancedError.branch = branch;
+          enhancedError.fileName = path.basename(pwrFile);
+          enhancedError.cacheDir = cacheDir;
+          enhancedError.butlerError = true;
+          enhancedError.errorCode = error.code;
+          enhancedError.stderr = stderr;
+          enhancedError.stdout = stdout;
+          
+          console.log('[Butler] Enhanced error created with retry context');
+          reject(enhancedError);
         } else {
+          console.log('[Butler] Patch installation completed successfully');
           resolve();
         }
       });
     });
   } catch (error) {
-    throw error;
+    console.error('[Butler] Exception during Butler execution:', error);
+    const enhancedError = new Error(`Butler execution failed: ${error.message}`);
+    enhancedError.canRetry = true;
+    enhancedError.branch = branch;
+    enhancedError.fileName = path.basename(pwrFile);
+    enhancedError.cacheDir = cacheDir;
+    enhancedError.butlerError = true;
+    throw enhancedError;
   }
 
   if (fs.existsSync(stagingDir)) {
@@ -191,7 +357,7 @@ async function updateGameFiles(newVersion, progressCallback, gameDir = GAME_DIR,
       progressCallback('Extracting new files...', 60, null, null, null);
     }
 
-    await applyPWR(pwrFile, progressCallback, tempUpdateDir, toolsDir);
+    await applyPWR(pwrFile, progressCallback, tempUpdateDir, toolsDir, branch, cacheDir);
 
     if (progressCallback) {
       progressCallback('Replacing game files...', 80, null, null, null);
@@ -369,8 +535,28 @@ async function installGame(playerName = 'Player', progressCallback, javaPathOver
   console.log(`Installing game files for branch: ${branch}...`);
 
   const latestVersion = await getLatestClientVersion(branch);
-  const pwrFile = await downloadPWR(branch, latestVersion, progressCallback, customCacheDir);
-  await applyPWR(pwrFile, progressCallback, customGameDir, customToolsDir);
+  let pwrFile;
+  try {
+    pwrFile = await downloadPWR(branch, latestVersion, progressCallback, customCacheDir);
+    
+    // If downloadPWR returns false, it means the file doesn't exist or is invalid
+    // We should retry the download with a manual retry flag
+    if (!pwrFile) {
+      console.log('[Install] PWR file not found or invalid, attempting retry...');
+      pwrFile = await retryPWRDownload(branch, latestVersion, progressCallback, customCacheDir);
+    }
+    
+    // Double-check we have a valid file path
+    if (!pwrFile || typeof pwrFile !== 'string') {
+      throw new Error(`PWR file download failed: received invalid path ${pwrFile}. Please retry download.`);
+    }
+    
+  } catch (downloadError) {
+    console.error('[Install] PWR download failed:', downloadError.message);
+    throw downloadError; // Re-throw to be handled by the main installGame error handler
+  }
+  
+  await applyPWR(pwrFile, progressCallback, customGameDir, customToolsDir, branch, customCacheDir);
 
   // Save the installed version and branch to config
   saveVersionClient(latestVersion);
@@ -546,8 +732,79 @@ async function repairGame(progressCallback, branchOverride = null) {
   return { success: true, repaired: true };
 }
 
+// Directory validation and cleanup function
+function validateGameDirectory(gameDir, stagingDir) {
+  try {
+    // Ensure game directory exists and is writable
+    if (!fs.existsSync(gameDir)) {
+      fs.mkdirSync(gameDir, { recursive: true });
+      console.log(`[Butler] Created game directory: ${gameDir}`);
+    }
+    
+    // Test write permissions
+    const testFile = path.join(gameDir, '.permission_test');
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    console.log(`[Butler] Game directory is writable: ${gameDir}`);
+    
+    // Clean and ensure staging directory
+    if (fs.existsSync(stagingDir)) {
+      console.log(`[Butler] Cleaning existing staging directory: ${stagingDir}`);
+      fs.rmSync(stagingDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(stagingDir, { recursive: true });
+    console.log(`[Butler] Created clean staging directory: ${stagingDir}`);
+    
+    // Check disk space (basic check)
+    const freeSpace = fs.statSync(gameDir);
+    console.log(`[Butler] Directory validation completed successfully`);
+    
+  } catch (error) {
+    throw new Error(`Directory validation failed: ${error.message}. Please check permissions and disk space.`);
+  }
+}
+
+// Enhanced PWR file validation
+function validatePWRFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+    
+    const stats = fs.statSync(filePath);
+    const sizeInMB = stats.size / 1024 / 1024;
+    
+    if (stats.size < 1024 * 1024) {
+      return false;
+    }
+    
+    // Check if file is under 1.5 GB (incomplete download)
+    if (sizeInMB < 1500) {
+      console.log(`[PWR Validation] File appears incomplete: ${sizeInMB.toFixed(2)} MB < 1.5 GB`);
+      return false;
+    }
+    
+    // Basic file header validation (PWR files should have specific headers)
+    const buffer = fs.readFileSync(filePath, { start: 0, end: 20 });
+    if (buffer.length < 10) {
+      return false;
+    }
+    
+    // Check for common PWR magic bytes or patterns
+    // This is a basic check - could be enhanced with actual PWR format specification
+    const header = buffer.toString('hex', 0, 10);
+    console.log(`[PWR Validation] File header: ${header}`);
+    
+    return true;
+  } catch (error) {
+    console.error(`[PWR Validation] Error:`, error.message);
+    return false;
+  }
+}
+
 module.exports = {
   downloadPWR,
+  retryPWRDownload,
   applyPWR,
   updateGameFiles,
   isGameInstalled,
diff --git a/backend/utils/fileManager.js b/backend/utils/fileManager.js
index 6eb5455..a736565 100644
--- a/backend/utils/fileManager.js
+++ b/backend/utils/fileManager.js
@@ -2,16 +2,116 @@ const fs = require('fs');
 const path = require('path');
 const axios = require('axios');
 
-async function downloadFile(url, dest, progressCallback, maxRetries = 3) {
+// Automatic stall retry constants
+const MAX_AUTOMATIC_STALL_RETRIES = 3;
+const AUTOMATIC_STALL_RETRY_DELAY = 3000; // 3 seconds in milliseconds
+
+// Network monitoring utilities using Node.js built-in methods
+function checkNetworkConnection() {
+  return new Promise((resolve) => {
+    const { lookup } = require('dns');
+    const http = require('http');
+    
+    // Try DNS lookup first (faster) - using callback version
+    lookup('8.8.8.8', (err) => {
+      if (err) {
+        resolve(false);
+        return;
+      }
+      
+      // Try HTTP request to confirm internet connectivity
+      const req = http.get('http://www.google.com', { timeout: 3000 }, (res) => {
+        resolve(true);
+        res.destroy();
+      });
+      
+      req.on('error', () => {
+        resolve(false);
+      });
+      
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+    });
+  });
+}
+
+
+
+async function downloadFile(url, dest, progressCallback, maxRetries = 5) {
   let lastError = null;
+  let retryState = {
+    attempts: 0,
+    maxRetries: maxRetries,
+    canRetry: true,
+    lastError: null,
+    automaticStallRetries: 0,
+    isAutomaticRetry: false
+  };
+  let downloadStalled = false;
+  let streamCompleted = false;
 
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {
+      retryState.attempts = attempt + 1;
       console.log(`Download attempt ${attempt + 1}/${maxRetries} for ${url}`);
 
       if (attempt > 0 && progressCallback) {
-        progressCallback(`Retry ${attempt}/${maxRetries - 1}...`, null, null, null, null);
-        await new Promise(resolve => setTimeout(resolve, 2000 * attempt)); // Délai progressif
+        // Exponential backoff with jitter
+        const baseDelay = 2000;
+        const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+        const jitter = Math.random() * 1000;
+        const delay = Math.min(exponentialDelay + jitter, 30000);
+        
+        progressCallback(`Retry ${attempt}/${maxRetries - 1}...`, null, null, null, null, retryState);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+
+      // Create AbortController for proper stream control
+      const controller = new AbortController();
+      let hasReceivedData = false;
+      
+      // Smart overall timeout - only trigger if no progress for extended period
+      const overallTimeout = setInterval(() => {
+        const now = Date.now();
+        const timeSinceLastProgress = now - lastProgressTime;
+        
+        // Only timeout if no data received for 5 minutes (300 seconds)
+        if (timeSinceLastProgress > 300000 && hasReceivedData) {
+          console.log('Download stalled for 5 minutes, aborting...');
+          console.log(`Download had progress before stall: ${(downloaded / 1024 / 1024).toFixed(2)} MB`);
+          controller.abort();
+        }
+      }, 60000); // Check every minute
+
+      // Check if we can resume existing download
+      let startByte = 0;
+      if (fs.existsSync(dest)) {
+        const existingStats = fs.statSync(dest);
+        
+        // Only resume if file exists and is substantial (> 1MB)
+        if (existingStats.size > 1024 * 1024) {
+          startByte = existingStats.size;
+          console.log(`Resuming download from byte ${startByte} (${(existingStats.size / 1024 / 1024).toFixed(2)} MB already downloaded)`);
+        } else {
+          // File too small, start fresh
+          fs.unlinkSync(dest);
+          console.log('Existing file too small, starting fresh download');
+        }
+      }
+
+      const headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': '*/*',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Referer': 'https://launcher.hytale.com/',
+        'Connection': 'keep-alive'
+      };
+      
+      // Add Range header for resume capability
+      if (startByte > 0) {
+        headers['Range'] = `bytes=${startByte}-`;
       }
 
       const response = await axios({
@@ -19,16 +119,12 @@ async function downloadFile(url, dest, progressCallback, maxRetries = 3) {
         url: url,
         responseType: 'stream',
         timeout: 60000, // 60 secondes timeout
-        headers: {
-          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-          'Accept': '*/*',
-          'Accept-Language': 'en-US,en;q=0.9',
-          'Referer': 'https://launcher.hytale.com/',
-          'Connection': 'keep-alive'
-        },
+        signal: controller.signal,
+        headers: headers,
         // Configuration Axios pour la robustesse réseau
         validateStatus: function (status) {
-          return status >= 200 && status < 300;
+          // Accept both 200 (full download) and 206 (partial content for resume)
+          return (status >= 200 && status < 300) || status === 206;
         },
         // Retry configuration
         maxRedirects: 5,
@@ -36,117 +132,313 @@ async function downloadFile(url, dest, progressCallback, maxRetries = 3) {
         family: 4 // Force IPv4
       });
 
-      const totalSize = parseInt(response.headers['content-length'], 10);
-      let downloaded = 0;
+      const contentLength = response.headers['content-length'];
+      const totalSize = contentLength ? parseInt(contentLength, 10) + startByte : 0; // Adjust for resume
+      let downloaded = startByte; // Start with existing bytes
       let lastProgressTime = Date.now();
       const startTime = Date.now();
 
-      // Nettoyer le fichier de destination s'il existe
-      if (fs.existsSync(dest)) {
-        fs.unlinkSync(dest);
+      // Check network status before attempting download
+      try {
+        const isNetworkOnline = await checkNetworkConnection();
+        if (!isNetworkOnline) {
+          throw new Error('Network connection unavailable. Please check your connection and retry.');
+        }
+      } catch (networkError) {
+        console.error('[Network] Network check failed, proceeding anyway:', networkError.message);
+        // Continue with download attempt - network check failure shouldn't block
       }
 
-      const writer = fs.createWriteStream(dest);
-      let downloadStalled = false;
+      const writer = fs.createWriteStream(dest, { 
+        flags: startByte > 0 ? 'a' : 'w', // 'a' for append (resume), 'w' for write (fresh)
+        start: startByte > 0 ? startByte : 0
+      });
+      let streamError = null;
       let stalledTimeout = null;
+      
+      // Reset state for this attempt
+      downloadStalled = false;
+      streamCompleted = false;
 
+      // Enhanced stream event handling
       response.data.on('data', (chunk) => {
         downloaded += chunk.length;
         const now = Date.now();
+        hasReceivedData = true; // Mark that we've received data
 
-        // Reset stalled timer on data received
+        // Reset simple stall timer on data received
         if (stalledTimeout) {
           clearTimeout(stalledTimeout);
         }
 
-        // Set new stalled timer (30 seconds without data = stalled)
-        stalledTimeout = setTimeout(() => {
+        // Set new stall timer (30 seconds without data = stalled)
+        stalledTimeout = setTimeout(async () => {
+          console.log('Download stalled - checking network connectivity...');
+          
+          // Check if network is actually available before retrying
+          try {
+            const isNetworkOnline = await checkNetworkConnection();
+            if (!isNetworkOnline) {
+              console.log('Network connection lost - stopping download and showing error');
+              downloadStalled = true;
+              streamError = new Error('Network connection lost. Please check your internet connection and retry.');
+              streamError.isConnectionLost = true;
+              streamError.canRetry = false;
+              controller.abort();
+              writer.destroy();
+              response.data.destroy();
+              // Immediately reject the promise to prevent hanging
+              setTimeout(() => promiseReject(streamError), 100);
+              return;
+            }
+          } catch (networkError) {
+            console.error('Network check failed during stall detection:', networkError.message);
+          }
+          
+          console.log('Network available - download stalled due to slow connection, aborting for retry...');
           downloadStalled = true;
+          streamError = new Error('Download stalled due to slow network connection. Please retry.');
+          controller.abort();
           writer.destroy();
           response.data.destroy();
+          // Immediately reject the promise to prevent hanging
+          setTimeout(() => promiseReject(streamError), 100);
         }, 30000);
 
         if (progressCallback && totalSize > 0 && (now - lastProgressTime > 100)) { // Update every 100ms max
           const percent = Math.min(100, Math.max(0, (downloaded / totalSize) * 100));
           const elapsed = (now - startTime) / 1000;
           const speed = elapsed > 0 ? downloaded / elapsed : 0;
-          progressCallback(null, percent, speed, downloaded, totalSize);
+          
+          progressCallback(null, percent, speed, downloaded, totalSize, retryState);
           lastProgressTime = now;
         }
       });
 
+      // Enhanced stream error handling
       response.data.on('error', (error) => {
+        // Ignore errors if it was intentionally cancelled or already handled
+        if (downloadStalled || streamCompleted || controller.signal.aborted) {
+          console.log(`Ignoring stream error after cancellation: ${error.code || error.message}`);
+          return;
+        }
+        
+        if (!streamError) {
+          streamError = new Error(`Stream error: ${error.code || error.message}. Please retry.`);
+          // Check for connection lost indicators
+          if (error.code === 'ERR_NETWORK_CHANGED' || 
+              error.code === 'ERR_INTERNET_DISCONNECTED' ||
+              error.code === 'ERR_CONNECTION_LOST') {
+            streamError.isConnectionLost = true;
+            streamError.canRetry = false;
+          }
+          console.error(`Stream error on attempt ${attempt + 1}:`, error.code || error.message);
+        }
         if (stalledTimeout) {
           clearTimeout(stalledTimeout);
         }
-        console.error(`Stream error on attempt ${attempt + 1}:`, error.code || error.message);
+        if (overallTimeout) {
+          clearInterval(overallTimeout);
+        }
         writer.destroy();
       });
 
+      response.data.on('close', () => {
+        // Only treat as error if not already handled by cancellation and writer didn't complete
+        if (!streamError && !streamCompleted && !downloadStalled && !controller.signal.aborted) {
+          // Check if writer actually completed but stream close came first
+          setTimeout(() => {
+            if (!streamCompleted) {
+              streamError = new Error('Stream closed unexpectedly. Please retry.');
+              console.log('Stream closed unexpectedly on attempt', attempt + 1);
+            }
+          }, 500); // Small delay to check if writer completes
+        }
+        if (stalledTimeout) {
+          clearTimeout(stalledTimeout);
+        }
+        if (overallTimeout) {
+          clearInterval(overallTimeout);
+        }
+      });
+
+      response.data.on('abort', () => {
+        // Only treat as error if not already handled by stall detection
+        if (!streamError && !streamCompleted && !downloadStalled) {
+          streamError = new Error('Download aborted due to network issue. Please retry.');
+          console.log('Stream aborted on attempt', attempt + 1);
+        }
+        if (stalledTimeout) {
+          clearTimeout(stalledTimeout);
+        }
+      });
+
       response.data.pipe(writer);
 
+      let promiseReject = null;
       await new Promise((resolve, reject) => {
+        // Store promise reject function for immediate use by stall timeout
+        promiseReject = reject;
         writer.on('finish', () => {
+          streamCompleted = true;
+          console.log(`Writer finished on attempt ${attempt + 1}, downloaded: ${(downloaded / 1024 / 1024).toFixed(2)} MB`);
+          
+          // Clear ALL timeouts to prevent them from firing after completion
           if (stalledTimeout) {
             clearTimeout(stalledTimeout);
+            console.log('Cleared stall timeout after writer finished');
           }
+          if (overallTimeout) {
+            clearInterval(overallTimeout);
+            console.log('Cleared overall timeout after writer finished');
+          }
+          
+          // Download is successful if writer finished - regardless of stream state
           if (!downloadStalled) {
             console.log(`Download completed successfully on attempt ${attempt + 1}`);
             resolve();
           } else {
-            reject(new Error('Download stalled'));
+            // Don't reject here if we already rejected due to network loss - prevents duplicate rejection
+            console.log('Writer finished after stall detection, ignoring...');
           }
         });
 
         writer.on('error', (error) => {
+          // Ignore write errors if stream was intentionally cancelled
+          if (downloadStalled || controller.signal.aborted) {
+            console.log(`Ignoring writer error after cancellation: ${error.code || error.message}`);
+            return;
+          }
+          
+          if (!streamError) {
+            streamError = new Error(`File write error: ${error.code || error.message}. Please retry.`);
+            console.error(`Writer error on attempt ${attempt + 1}:`, error.code || error.message);
+          }
           if (stalledTimeout) {
             clearTimeout(stalledTimeout);
           }
-          reject(error);
+          if (overallTimeout) {
+            clearInterval(overallTimeout);
+          }
+          reject(streamError);
         });
 
-        response.data.on('error', (error) => {
-          if (stalledTimeout) {
-            clearTimeout(stalledTimeout);
+        // Handle case where stream ends without finishing writer
+        response.data.on('end', () => {
+          if (!streamCompleted && !downloadStalled && !streamError) {
+            // Give a small delay for writer to finish - this is normal behavior
+            setTimeout(() => {
+              if (!streamCompleted) {
+                console.log('Stream ended but writer not finished - waiting longer...');
+                // Give more time for writer to finish - this might be slow disk I/O
+                setTimeout(() => {
+                  if (!streamCompleted) {
+                    streamError = new Error('Download incomplete. Please retry.');
+                    reject(streamError);
+                  }
+                }, 2000);
+              }
+            }, 1000);
           }
-          reject(error);
         });
       });
 
       // Si on arrive ici, le téléchargement a réussi
       return;
 
-    } catch (error) {
-      lastError = error;
-      console.error(`Download attempt ${attempt + 1} failed:`, error.code || error.message);
+  } catch (error) {
+    lastError = error;
+    retryState.lastError = error;
+    console.error(`Download attempt ${attempt + 1} failed:`, error.code || error.message);
+    console.error(`Error details:`, { 
+      isConnectionLost: error.isConnectionLost, 
+      canRetry: error.canRetry,
+      message: error.message,
+      downloadStalled: downloadStalled,
+      streamCompleted: streamCompleted
+    });
+    
+    // Check if download actually completed successfully despite the error
+    if (fs.existsSync(dest)) {
+      const stats = fs.statSync(dest);
+      const sizeInMB = stats.size / 1024 / 1024;
+      console.log(`File size after error: ${sizeInMB.toFixed(2)} MB`);
+      
+      // If file is substantial size (> 1.5GB), treat as success and break
+      if (sizeInMB >= 1500) {
+        console.log('File appears to be complete despite error, treating as success');
+        return; // Exit the retry loop successfully
+      }
+    }
 
-      // Nettoyer le fichier partiel en cas d'erreur
-      if (fs.existsSync(dest)) {
-        try {
+    // Enhanced file cleanup with validation
+    if (fs.existsSync(dest)) {
+      try {
+        // Check if file is corrupted (small or invalid) or if error is non-resumable
+        const partialStats = fs.statSync(dest);
+        const isResumableError = error.message && (
+          error.message.includes('stalled') ||
+          error.message.includes('timeout') ||
+          error.message.includes('network') ||
+          error.message.includes('aborted')
+        );
+        
+        // Check if download appears to be complete (close to expected PWR size)
+        const isPossiblyComplete = partialStats.size >= 1500 * 1024 * 1024; // >= 1.5GB
+        
+        if (partialStats.size < 1024 * 1024 || (!isResumableError && !isPossiblyComplete)) {
+          // Delete if file is too small OR error is non-resumable AND not possibly complete
+          console.log(`[Cleanup] Removing PWR file (${!isResumableError && !isPossiblyComplete ? 'non-resumable error' : 'too small'}): ${(partialStats.size / 1024 / 1024).toFixed(2)} MB`);
           fs.unlinkSync(dest);
-        } catch (cleanupError) {
-          console.warn('Could not cleanup partial file:', cleanupError.message);
+        } else {
+          // Keep the file for resume on resumable errors or if possibly complete
+          console.log(`[Resume] Keeping PWR file (${isPossiblyComplete ? 'possibly complete' : 'for resume'}): ${(partialStats.size / 1024 / 1024).toFixed(2)} MB`);
         }
+      } catch (cleanupError) {
+        console.warn('Could not handle partial file:', cleanupError.message);
       }
+    }
 
-      // Vérifier si c'est une erreur réseau que l'on peut retry
-      const retryableErrors = ['ECONNRESET', 'ENOTFOUND', 'ECONNREFUSED', 'ETIMEDOUT', 'ESOCKETTIMEDOUT', 'EPROTO'];
-      const isRetryable = retryableErrors.includes(error.code) ||
-        error.message.includes('timeout') ||
-        error.message.includes('stalled') ||
-        (error.response && error.response.status >= 500);
+    // Expanded retryable error codes for better network detection
+    const retryableErrors = [
+      'ECONNRESET', 'ENOTFOUND', 'ECONNREFUSED', 'ETIMEDOUT', 
+      'ESOCKETTIMEDOUT', 'EPROTO', 'ENETDOWN', 'EHOSTUNREACH',
+      'ERR_NETWORK', 'ERR_INTERNET_DISCONNECTED', 'ERR_CONNECTION_RESET',
+      'ERR_CONNECTION_TIMED_OUT', 'ERR_NAME_NOT_RESOLVED'
+    ];
+    
+    const isRetryable = retryableErrors.includes(error.code) ||
+      error.message.includes('timeout') ||
+      error.message.includes('stalled') ||
+      error.message.includes('aborted') ||
+      error.message.includes('network') ||
+      error.message.includes('connection') ||
+      error.message.includes('Please retry') ||
+      error.message.includes('corrupted') ||
+      error.message.includes('invalid') ||
+      (error.response && error.response.status >= 500);
 
-      if (!isRetryable || attempt === maxRetries - 1) {
-        console.error(`Non-retryable error or max retries reached: ${error.code || error.message}`);
+    // Respect error's canRetry property if set
+    const canRetry = (error.canRetry === false) ? false : isRetryable;
 
-        break;
-      }
+    if (!canRetry || attempt === maxRetries - 1) {
+      retryState.canRetry = false;
+      console.error(`Non-retryable error or max retries reached: ${error.code || error.message}`);
+      break;
+    }
 
-      console.log(`Retryable error detected, will retry in ${2000 * (attempt + 1)}ms...`);
+    console.log(`Retryable error detected, will retry...`);
     }
   }
 
-  throw new Error(`Download failed after ${maxRetries} attempts. Last error: ${lastError?.code || lastError?.message || 'Unknown error'}`);
+  // Enhanced error with retry state and user-friendly message
+  const detailedError = lastError?.code || lastError?.message || 'Unknown error';
+  const errorMessage = `Download failed after ${maxRetries} attempts. Last error: ${detailedError}. Please retry`;
+  const enhancedError = new Error(errorMessage);
+  enhancedError.retryState = retryState;
+  enhancedError.lastError = lastError;
+  enhancedError.detailedError = detailedError;
+  throw enhancedError;
 }
 
 function findHomePageUIPath(gameLatest) {
@@ -205,8 +497,64 @@ function findLogoPath(gameLatest) {
   return searchDirectory(gameLatest);
 }
 
+// Automatic stall retry function for network stalls
+async function retryStalledDownload(url, dest, progressCallback, previousError = null) {
+  console.log('Automatic stall retry initiated for:', url);
+  
+  // Wait before retry to allow network recovery
+  console.log(`Waiting ${AUTOMATIC_STALL_RETRY_DELAY/1000} seconds before automatic retry...`);
+  await new Promise(resolve => setTimeout(resolve, AUTOMATIC_STALL_RETRY_DELAY));
+  
+  try {
+    // Create new retryState for automatic retry
+    const automaticRetryState = {
+      attempts: 1,
+      maxRetries: 1,
+      canRetry: true,
+      lastError: null,
+      automaticStallRetries: (previousError && previousError.retryState) ? previousError.retryState.automaticStallRetries + 1 : 1,
+      isAutomaticRetry: true
+    };
+    
+    // Update progress callback with automatic retry info
+    if (progressCallback) {
+      progressCallback(
+        `Automatic stall retry ${automaticRetryState.automaticStallRetries}/${MAX_AUTOMATIC_STALL_RETRIES}...`,
+        null, null, null, null, automaticRetryState
+      );
+    }
+    
+    await downloadFile(url, dest, progressCallback, 1);
+    console.log('Automatic stall retry successful');
+  } catch (error) {
+    console.error('Automatic stall retry failed:', error.message);
+    throw error;
+  }
+}
+
+// Manual retry function for user-initiated retries
+async function retryDownload(url, dest, progressCallback, previousError = null) {
+  console.log('Manual retry initiated for:', url);
+  
+  // If we have a previous error with retry state, continue from there
+  let additionalRetries = 3; // Allow 3 additional manual retries
+  if (previousError && previousError.retryState) {
+    additionalRetries = Math.max(2, 5 - previousError.retryState.attempts);
+  }
+  
+  try {
+    await downloadFile(url, dest, progressCallback, additionalRetries);
+    console.log('Manual retry successful');
+  } catch (error) {
+    console.error('Manual retry failed:', error.message);
+    throw error;
+  }
+}
+
 module.exports = {
   downloadFile,
+  retryDownload,
+  retryStalledDownload,
   findHomePageUIPath,
   findLogoPath
 };
diff --git a/main.js b/main.js
index 891f594..7b1cf60 100644
--- a/main.js
+++ b/main.js
@@ -255,11 +255,11 @@ app.whenReady().then(async () => {
         mainWindow.webContents.send('lock-play-button', true);
       }
 
-      const progressCallback = (message, percent, speed, downloaded, total) => {
-        if (mainWindow && !mainWindow.isDestroyed()) {
-          mainWindow.webContents.send('first-launch-progress', { message, percent, speed, downloaded, total });
-        }
-      };
+      const progressCallback = (message, percent, speed, downloaded, total, retryState) => {
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send('first-launch-progress', { message, percent, speed, downloaded, total, retryState });
+        }
+      };
 
       const firstLaunchResult = await Promise.race([
         handleFirstLaunchCheck(progressCallback),
@@ -346,20 +346,21 @@ app.on('window-all-closed', () => {
 });
 
 
-ipcMain.handle('launch-game', async (event, playerName, javaPath, installPath, gpuPreference) => {
-  try {
-    const progressCallback = (message, percent, speed, downloaded, total) => {
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        const data = {
-          message: message || null,
-          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
-          speed: speed !== null && speed !== undefined ? speed : null,
-          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
-          total: total !== null && total !== undefined ? total : null
-        };
-        mainWindow.webContents.send('progress-update', data);
-      }
-    };
+ipcMain.handle('launch-game', async (event, playerName, javaPath, installPath, gpuPreference) => {
+  try {
+    const progressCallback = (message, percent, speed, downloaded, total, retryState) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        const data = {
+          message: message || null,
+          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
+          speed: speed !== null && speed !== undefined ? speed : null,
+          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
+          total: total !== null && total !== undefined ? total : null,
+          retryState: retryState || null
+        };
+        mainWindow.webContents.send('progress-update', data);
+      }
+    };
 
     const result = await launchGameWithVersionCheck(playerName, progressCallback, javaPath, installPath, gpuPreference);
 
@@ -389,47 +390,108 @@ ipcMain.handle('launch-game', async (event, playerName, javaPath, installPath, g
   }
 });
 
-ipcMain.handle('install-game', async (event, playerName, javaPath, installPath, branch) => {
-  try {
-    console.log(`[IPC] install-game called with branch: ${branch || 'default'}`);
-    
-    // Signal installation start
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('installation-start');
-    }
-
-    const progressCallback = (message, percent, speed, downloaded, total) => {
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        const data = {
-          message: message || null,
-          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
-          speed: speed !== null && speed !== undefined ? speed : null,
-          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
-          total: total !== null && total !== undefined ? total : null
-        };
-        mainWindow.webContents.send('progress-update', data);
-      }
-    };
-
-    const result = await installGame(playerName, progressCallback, javaPath, installPath, branch);
-
-    // Signal installation end
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('installation-end');
-    }
-
-    return result;
-  } catch (error) {
-    console.error('Install error:', error);
-    const errorMessage = error.message || error.toString();
-
-    // Signal installation end on error too
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('installation-end');
-    }
-
-    return { success: false, error: errorMessage };
-  }
+ipcMain.handle('install-game', async (event, playerName, javaPath, installPath, branch) => {
+  try {
+    console.log(`[IPC] install-game called with branch: ${branch || 'default'}`);
+    
+    // Signal installation start
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.webContents.send('installation-start');
+    }
+
+    const progressCallback = (message, percent, speed, downloaded, total, retryState) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        const data = {
+          message: message || null,
+          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
+          speed: speed !== null && speed !== undefined ? speed : null,
+          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
+          total: total !== null && total !== undefined ? total : null,
+          retryState: retryState || null
+        };
+        mainWindow.webContents.send('progress-update', data);
+      }
+    };
+
+    const result = await installGame(playerName, progressCallback, javaPath, installPath, branch);
+
+    // Signal installation end
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.webContents.send('installation-end');
+    }
+
+    // Ensure we always return a result for the IPC handler
+    const successResponse = result || { success: true };
+    console.log('[Main] Returning success response for install-game:', successResponse);
+    return successResponse;
+  } catch (error) {
+    console.error('Install error:', error);
+    const errorMessage = error.message || error.toString();
+
+    // Enhanced error data extraction for both download and Butler errors
+    let errorData = {
+      message: errorMessage,
+      error: true,
+      canRetry: true,
+      retryData: null
+    };
+
+    // Handle Butler-specific errors
+    if (error.butlerError) {
+      console.log('[Main] Processing Butler error with retry context');
+      errorData.retryData = {
+        branch: error.branch || 'release',
+        fileName: error.fileName || '4.pwr',
+        cacheDir: error.cacheDir
+      };
+      errorData.canRetry = error.canRetry !== undefined ? error.canRetry : true;
+      
+      // Add Butler-specific error details
+      if (error.stderr) {
+        console.error('[Main] Butler stderr:', error.stderr);
+      }
+      if (error.stdout) {
+        console.log('[Main] Butler stdout:', error.stdout);
+      }
+      if (error.errorCode) {
+        console.log('[Main] Butler error code:', error.errorCode);
+      }
+    }
+    // Handle PWR download errors
+    else if (error.branch && error.fileName) {
+      console.log('[Main] Processing PWR download error with retry context');
+      errorData.retryData = {
+        branch: error.branch,
+        fileName: error.fileName,
+        cacheDir: error.cacheDir
+      };
+      errorData.canRetry = error.canRetry !== undefined ? error.canRetry : true;
+    }
+    // Default fallback for other errors
+    else {
+      console.log('[Main] Processing generic error, creating default retry data');
+      errorData.retryData = {
+        branch: 'release',
+        fileName: '4.pwr'
+      };
+    }
+
+    // Send enhanced error info for retry UI
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      console.log('[Main] Sending error data to renderer:', errorData);
+      mainWindow.webContents.send('progress-update', errorData);
+    }
+
+    // Signal installation end on error too
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.webContents.send('installation-end');
+    }
+
+    // Always return a proper response to prevent timeout
+    const errorResponse = { success: false, error: errorMessage };
+    console.log('[Main] Returning error response for install-game:', errorResponse);
+    return errorResponse;
+  }
 });
 
 ipcMain.handle('save-username', (event, username) => {
@@ -519,18 +581,19 @@ ipcMain.handle('select-install-path', async () => {
 
 ipcMain.handle('accept-first-launch-update', async (event, existingGame) => {
   try {
-    const progressCallback = (message, percent, speed, downloaded, total) => {
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        const data = {
-          message: message || null,
-          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
-          speed: speed !== null && speed !== undefined ? speed : null,
-          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
-          total: total !== null && total !== undefined ? total : null
-        };
-        mainWindow.webContents.send('first-launch-progress', data);
-      }
-    };
+    const progressCallback = (message, percent, speed, downloaded, total, retryState) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        const data = {
+          message: message || null,
+          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
+          speed: speed !== null && speed !== undefined ? speed : null,
+          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
+          total: total !== null && total !== undefined ? total : null,
+          retryState: retryState || null
+        };
+        mainWindow.webContents.send('first-launch-progress', data);
+      }
+    };
 
     const result = await proposeGameUpdate(existingGame, progressCallback);
 
@@ -573,28 +636,94 @@ ipcMain.handle('uninstall-game', async () => {
   }
 });
 
-ipcMain.handle('repair-game', async () => {
-  try {
-    const progressCallback = (message, percent, speed, downloaded, total) => {
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        const data = {
-          message: message || null,
-          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
-          speed: speed !== null && speed !== undefined ? speed : null,
-          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
-          total: total !== null && total !== undefined ? total : null
-        };
-        mainWindow.webContents.send('progress-update', data);
-      }
-    };
-
-    const result = await repairGame(progressCallback);
-    return result;
-  } catch (error) {
-    console.error('Repair error:', error);
-    return { success: false, error: error.message };
-  }
-});
+ipcMain.handle('repair-game', async () => {
+  try {
+    const progressCallback = (message, percent, speed, downloaded, total, retryState) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        const data = {
+          message: message || null,
+          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
+          speed: speed !== null && speed !== undefined ? speed : null,
+          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
+          total: total !== null && total !== undefined ? total : null,
+          retryState: retryState || null
+        };
+        mainWindow.webContents.send('progress-update', data);
+      }
+    };
+
+    const result = await repairGame(progressCallback);
+    return result;
+  } catch (error) {
+    console.error('Repair error:', error);
+    const errorMessage = error.message || error.toString();
+    return { success: false, error: errorMessage };
+  }
+});
+
+ipcMain.handle('retry-download', async (event, retryData) => {
+  try {
+    console.log('[IPC] retry-download called with data:', retryData);
+    
+    // Handle null retry data gracefully
+    if (!retryData || !retryData.branch || !retryData.fileName) {
+      console.log('[IPC] Invalid retry data, using defaults');
+      retryData = {
+        branch: 'release',
+        fileName: '4.pwr'
+      };
+    }
+    
+    const progressCallback = (message, percent, speed, downloaded, total, retryState) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        const data = {
+          message: message || null,
+          percent: percent !== null && percent !== undefined ? Math.min(100, Math.max(0, percent)) : null,
+          speed: speed !== null && speed !== undefined ? speed : null,
+          downloaded: downloaded !== null && downloaded !== undefined ? downloaded : null,
+          total: total !== null && total !== undefined ? total : null,
+          retryState: retryState || null
+        };
+        mainWindow.webContents.send('progress-update', data);
+      }
+    };
+
+    // Extract PWR download info from retryData
+    const branch = retryData.branch;
+    const fileName = retryData.fileName;
+    const cacheDir = retryData.cacheDir;
+    
+    console.log(`[IPC] Retrying PWR download: branch=${branch}, fileName=${fileName}`);
+    
+    // Perform the retry with enhanced context
+    await retryPWRDownload(branch, fileName, progressCallback, cacheDir);
+    
+    return { success: true };
+  } catch (error) {
+    console.error('Retry download error:', error);
+    const errorMessage = error.message || error.toString();
+    
+    // Send error update to frontend with context
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      const data = {
+        message: errorMessage,
+        error: true,
+        canRetry: true,
+        retryData: {
+          branch: retryData?.branch || 'release',
+          fileName: retryData?.fileName || '4.pwr',
+          cacheDir: retryData?.cacheDir
+        }
+      };
+      mainWindow.webContents.send('progress-update', data);
+    }
+    
+    // Always return a proper response to prevent timeout
+    const errorResponse = { success: false, error: errorMessage };
+    console.log('[Main] Returning error response for retry-download:', errorResponse);
+    return errorResponse;
+  }
+});
 
 ipcMain.handle('get-hytale-news', async () => {
   try {
@@ -710,7 +839,8 @@ ipcMain.handle('load-settings', async () => {
   }
 });
 
-const { getModsPath, loadInstalledMods, downloadMod, uninstallMod, toggleMod, getCurrentUuid, getAllUuidMappings, setUuidForUser, generateNewUuid, deleteUuidForUser, resetCurrentUserUuid } = require('./backend/launcher');
+const { getModsPath, loadInstalledMods, downloadMod, uninstallMod, toggleMod, getCurrentUuid, getAllUuidMappings, setUuidForUser, generateNewUuid, deleteUuidForUser, resetCurrentUserUuid } = require('./backend/launcher');
+const { retryPWRDownload } = require('./backend/managers/gameManager');
 const os = require('os');
 
 ipcMain.handle('get-local-app-data', async () => {
diff --git a/preload.js b/preload.js
index b431f1a..cb88bc0 100644
--- a/preload.js
+++ b/preload.js
@@ -28,6 +28,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
   isGameInstalled: () => ipcRenderer.invoke('is-game-installed'),
   uninstallGame: () => ipcRenderer.invoke('uninstall-game'),
   repairGame: () => ipcRenderer.invoke('repair-game'),
+  retryDownload: (retryData) => ipcRenderer.invoke('retry-download', retryData),
   getHytaleNews: () => ipcRenderer.invoke('get-hytale-news'),
   openExternal: (url) => ipcRenderer.invoke('open-external', url),
   openExternalLink: (url) => ipcRenderer.invoke('openExternalLink', url),
@@ -44,7 +45,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
   selectModFiles: () => ipcRenderer.invoke('select-mod-files'),
   copyModFile: (sourcePath, modsPath) => ipcRenderer.invoke('copy-mod-file', sourcePath, modsPath),
   onProgressUpdate: (callback) => {
-    ipcRenderer.on('progress-update', (event, data) => callback(data));
+    ipcRenderer.on('progress-update', (event, data) => {
+      // Ensure data includes retry state if available
+      if (data && typeof data === 'object') {
+        callback(data);
+      } else {
+        callback(data);
+      }
+    });
   },
   onProgressComplete: (callback) => {
     ipcRenderer.on('progress-complete', () => callback());