release: v3.3.55

lib/config-store.js

@@ -277,7 +277,12 @@ class ConfigStore {
             if (fs.existsSync(this.filePath)) {
               const existing = fs.readFileSync(this.filePath, 'utf-8');
               if (existing && existing.trim().length > 2) {
-                fs.writeFileSync(backupPath, existing, 'utf-8');
+                let isValid = false;
+                try {
+                  const parsed = JSON.parse(existing);
+                  isValid = parsed && typeof parsed === 'object' && (parsed.hosters || parsed.hosterSettings || parsed.globalSettings);
+                } catch {}
+                if (isValid) fs.writeFileSync(backupPath, existing, 'utf-8');
               }
             }
           } catch {}

lib/hosters.js

@@ -499,24 +499,27 @@ async function _resolveDoodstreamUploadByName(apiKey, fileName, baselineCodes, s
   return null;
 }
 
-async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, throttle) {
+async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, throttle, opts) {
   const config = HOSTER_CONFIGS[hosterName];
   if (!config) throw new Error(`Unbekannter Hoster: ${hosterName}`);
 
-  // For byse: snapshot the current file-code list so the post-upload poller
-  // can identify new arrivals even when the initial POST response has an
-  // empty filecode.
   let byseBaseline = null;
   if (hosterName === 'byse.sx') {
-    const baseline = await _fetchByseFileList(apiKey, signal);
-    byseBaseline = new Set(baseline.map(f => f.file_code));
+    if (opts && opts.byseBaseline instanceof Set) {
+      byseBaseline = opts.byseBaseline;
+    } else {
+      const baseline = await _fetchByseFileList(apiKey, signal);
+      byseBaseline = new Set(baseline.map(f => f.file_code));
+    }
   }
-  // Doodstream: same snapshot so a codeless upload response can be recovered by
-  // matching a newly-appeared file in the account by name (see below).
   let doodBaseline = null;
   if (hosterName === 'doodstream.com') {
-    const baseline = await _fetchDoodstreamFileList(apiKey, signal);
-    doodBaseline = new Set(baseline.map(f => f.file_code));
+    if (opts && opts.doodBaseline instanceof Set) {
+      doodBaseline = opts.doodBaseline;
+    } else {
+      const baseline = await _fetchDoodstreamFileList(apiKey, signal);
+      doodBaseline = new Set(baseline.map(f => f.file_code));
+    }
   }
 
   // Step 1: Get upload server
@@ -647,8 +650,23 @@ async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, thro
   throw new Error(msg);
 }
 
+async function prefetchBaseline(hosterName, apiKey, signal) {
+  try {
+    if (hosterName === 'byse.sx') {
+      const baseline = await _fetchByseFileList(apiKey, signal);
+      return new Set(baseline.map(f => f.file_code));
+    }
+    if (hosterName === 'doodstream.com') {
+      const baseline = await _fetchDoodstreamFileList(apiKey, signal);
+      return new Set(baseline.map(f => f.file_code));
+    }
+  } catch { /* leave caller to fall back to per-job fetch */ }
+  return null;
+}
+
 module.exports = {
   uploadFile,
+  prefetchBaseline,
   HOSTER_CONFIGS,
   __test: {
     extractUploadServerUrl,

lib/updater.js

@@ -233,7 +233,20 @@ async function installUpdate(onProgress) {
     // Stage: done
     if (onProgress) onProgress({ stage: 'done', percent: 100 });
 
-    setTimeout(() => app.quit(), 900);
+    const _doQuit = () => setTimeout(() => app.quit(), 900);
+    const _getActive = () => {
+      try { return globalThis._mhuUploadManagerRef && globalThis._mhuUploadManagerRef.getActiveJobCount ? globalThis._mhuUploadManagerRef.getActiveJobCount() : 0; }
+      catch { return 0; }
+    };
+    if (_getActive() > 0) {
+      const POLL_MS = 3000;
+      const poller = setInterval(() => {
+        if (_getActive() === 0) { clearInterval(poller); _doQuit(); }
+      }, POLL_MS);
+      setTimeout(() => { try { clearInterval(poller); } catch {} _doQuit(); }, 30 * 60 * 1000);
+    } else {
+      _doQuit();
+    }
 
   } catch (err) {
     if (onProgress) onProgress({ stage: 'error', error: err.message });

lib/upload-manager.js

@@ -2,7 +2,7 @@ const { EventEmitter } = require('events');
 const path = require('path');
 const fs = require('fs');
 const crypto = require('crypto');
-const { uploadFile } = require('./hosters');
+const { uploadFile, prefetchBaseline } = require('./hosters');
 const VidmolyUploader = require('./vidmoly-upload');
 const VoeUploader = require('./voe-upload');
 const DoodstreamUploader = require('./doodstream-upload');
@@ -42,6 +42,7 @@ class UploadManager extends EventEmitter {
     this._failedAccounts = new Map(); // hoster -> Set of failed accountIds
     this._accountOverrides = new Map(); // hoster -> fallback account object
     this._doodApiKeyCache = new Map(); // accountId/username -> derived doodstream API key ('' = tried, none)
+    this._baselineCache = new Map(); // hoster:apiKey -> Promise<Set<file_code>> (one fetch shared across all jobs in batch)
   }
 
   switchAccount(hoster, fallbackAccount) {
@@ -66,6 +67,10 @@ class UploadManager extends EventEmitter {
     return this._accountOverrides.get(hoster) || null;
   }
 
+  getActiveJobCount() {
+    return this.activeJobs.size;
+  }
+
   clearFailedAccount(hoster, accountId) {
     return this._failedAccounts.delete(`${hoster}:${accountId}`);
   }
@@ -278,6 +283,7 @@ class UploadManager extends EventEmitter {
     this.jobAbortControllers.clear();
     this.cancelledJobIds.clear();
     this._doodApiKeyCache.clear(); // re-derive doodstream keys fresh each batch
+    this._baselineCache.clear(); // re-fetch baselines per batch (a long batch could outlast remote-side relevance)
     this.semaphores = {};
     this.globalSemaphore = null;
     this.globalThrottle = null;
@@ -308,18 +314,32 @@ class UploadManager extends EventEmitter {
     this._batchResults = results;
     this._additionalPromises = []; // Track jobs added mid-batch via addJobs()
 
-    for (const task of tasks) {
-      const fileName = path.basename(task.file);
-      if (!results.has(task.file)) {
-        let size = 0;
-        try { size = fs.statSync(task.file).size; } catch {}
-        results.set(task.file, { name: fileName, size, results: [] });
+    const DEDUP_CHUNK = 200;
+    for (let i = 0; i < tasks.length; i += DEDUP_CHUNK) {
+      if (signal.aborted) break;
+      const end = Math.min(i + DEDUP_CHUNK, tasks.length);
+      for (let j = i; j < end; j++) {
+        const task = tasks[j];
+        if (!results.has(task.file)) {
+          const fileName = path.basename(task.file);
+          let size = 0;
+          try { size = fs.statSync(task.file).size; } catch {}
+          results.set(task.file, { name: fileName, size, results: [] });
+        }
       }
+      if (end < tasks.length) await new Promise(setImmediate);
     }
 
     this._startStatsTimer();
 
-    const promises = tasks.map((task) => this._runJob(task, results, signal));
+    const SPAWN_CHUNK = 100;
+    const promises = [];
+    for (let i = 0; i < tasks.length; i += SPAWN_CHUNK) {
+      if (signal.aborted) break;
+      const end = Math.min(i + SPAWN_CHUNK, tasks.length);
+      for (let j = i; j < end; j++) promises.push(this._runJob(tasks[j], results, signal));
+      if (end < tasks.length) await new Promise(setImmediate);
+    }
     await Promise.allSettled(promises);
     // Wait for any jobs added mid-batch via addJobs()
     while (this._additionalPromises.length > 0) {
@@ -540,14 +560,16 @@ class UploadManager extends EventEmitter {
             speedAbort = new AbortController();
             uploadSignalBundle = this._combineManySignals([signal, speedAbort.signal]);
             speedMonitor = setInterval(() => {
-              if (currentSpeedKbs > 0 && currentSpeedKbs < settings.restartBelowKbs) {
-                if (!lowSpeedSince) lowSpeedSince = Date.now();
-                if (Date.now() - lowSpeedSince > 6000) {
-                  speedAbort.abort();
+              try {
+                if (currentSpeedKbs > 0 && currentSpeedKbs < settings.restartBelowKbs) {
+                  if (!lowSpeedSince) lowSpeedSince = Date.now();
+                  if (Date.now() - lowSpeedSince > 6000) {
+                    speedAbort.abort();
+                  }
+                } else {
+                  lowSpeedSince = 0;
                 }
-              } else {
-                lowSpeedSince = 0;
-              }
+              } catch (e) { this._rotLog('speed-monitor-error', { jobId, error: e && e.message }); }
             }, 2000);
           }
 
@@ -561,41 +583,42 @@ class UploadManager extends EventEmitter {
           const PROGRESS_EMIT_INTERVAL = 250; // ms – throttle UI updates
 
           const progressCb = (bytesUploaded, bytesTotal) => {
-            const now = Date.now();
-            const elapsed = Math.round((now - jobStart) / 1000);
-            const timeDelta = (now - lastSpeedTime) / 1000;
-            if (timeDelta >= 1) {
-              const bytesDelta = bytesUploaded - lastBytes;
-              currentSpeedKbs = Math.round(bytesDelta / timeDelta / 1024);
-              lastBytes = bytesUploaded;
-              lastSpeedTime = now;
-            }
+            try {
+              const now = Date.now();
+              const elapsed = Math.round((now - jobStart) / 1000);
+              const timeDelta = (now - lastSpeedTime) / 1000;
+              if (Number.isFinite(timeDelta) && timeDelta >= 1) {
+                const bytesDelta = bytesUploaded - lastBytes;
+                currentSpeedKbs = Math.round(bytesDelta / timeDelta / 1024);
+                lastBytes = bytesUploaded;
+                lastSpeedTime = now;
+              }
 
-            activeEntry.speedKbs = currentSpeedKbs;
-            activeEntry.bytesUploaded = bytesUploaded;
+              activeEntry.speedKbs = currentSpeedKbs;
+              activeEntry.bytesUploaded = bytesUploaded;
 
-            // Throttle progress emissions to reduce IPC + rendering overhead
-            if (now - lastEmitTime < PROGRESS_EMIT_INTERVAL) return;
-            lastEmitTime = now;
+              if (now - lastEmitTime < PROGRESS_EMIT_INTERVAL) return;
+              lastEmitTime = now;
 
-            const remaining = currentSpeedKbs > 0
-              ? Math.round((bytesTotal - bytesUploaded) / (currentSpeedKbs * 1024))
-              : 0;
+              const remaining = currentSpeedKbs > 0
+                ? Math.round((bytesTotal - bytesUploaded) / (currentSpeedKbs * 1024))
+                : 0;
 
-            this._emitProgress(uploadId, fileName, task.hoster, { accountId: task.accountId,
-              jobId,
-              status: 'uploading',
-              progress: bytesTotal > 0 ? Math.min(1, bytesUploaded / bytesTotal) : 0,
-              bytesUploaded,
-              bytesTotal,
-              speedKbs: currentSpeedKbs,
-              elapsed,
-              remaining,
-              error: null,
-              result: null,
-              attempt,
-              maxAttempts
-            });
+              this._emitProgress(uploadId, fileName, task.hoster, { accountId: task.accountId,
+                jobId,
+                status: 'uploading',
+                progress: bytesTotal > 0 ? Math.min(1, bytesUploaded / bytesTotal) : 0,
+                bytesUploaded,
+                bytesTotal,
+                speedKbs: currentSpeedKbs,
+                elapsed,
+                remaining,
+                error: null,
+                result: null,
+                attempt,
+                maxAttempts
+              });
+            } catch { /* progress callbacks must never throw — swallowing is correct, the stream keeps going */ }
           };
 
           const result = await this._executeUpload(task, progressCb, uploadSignalBundle.signal, throttle);
@@ -919,7 +942,9 @@ class UploadManager extends EventEmitter {
       const apiKey = await this._resolveDoodstreamApiKey(task);
       if (apiKey) {
         this._rotLog('doodstream-via-api', { accountId: task.accountId, fileName: path.basename(task.file) });
-        return uploadFile('doodstream.com', task.file, apiKey, progressCb, signal, throttle);
+        return uploadFile('doodstream.com', task.file, apiKey, progressCb, signal, throttle, {
+          doodBaseline: await this._getBaseline('doodstream.com', apiKey, signal)
+        });
       }
       this._rotLog('doodstream-via-web', { accountId: task.accountId, fileName: path.basename(task.file) });
       const dood = new DoodstreamUploader();
@@ -929,10 +954,23 @@ class UploadManager extends EventEmitter {
       const clouddrop = new ClouddropUploader(task.apiKey);
       return clouddrop.upload(task.file, progressCb, signal, throttle);
     } else {
-      return uploadFile(task.hoster, task.file, task.apiKey, progressCb, signal, throttle);
+      const baselineOpts = {};
+      if (task.hoster === 'byse.sx') baselineOpts.byseBaseline = await this._getBaseline('byse.sx', task.apiKey, signal);
+      if (task.hoster === 'doodstream.com') baselineOpts.doodBaseline = await this._getBaseline('doodstream.com', task.apiKey, signal);
+      return uploadFile(task.hoster, task.file, task.apiKey, progressCb, signal, throttle, baselineOpts);
     }
   }
 
+  _getBaseline(hosterName, apiKey, signal) {
+    if (!apiKey) return Promise.resolve(null);
+    const key = `${hosterName}:${apiKey}`;
+    let pending = this._baselineCache.get(key);
+    if (pending) return pending;
+    pending = prefetchBaseline(hosterName, apiKey, signal);
+    this._baselineCache.set(key, pending);
+    return pending;
+  }
+
   // Resolve (and cache per batch) the doodstream API key for a login-only
   // account by logging in once and scraping+validating it from the session.
   // Returns the key string, or '' when none could be derived (cached either way
@@ -962,7 +1000,7 @@ class UploadManager extends EventEmitter {
   _startStatsTimer() {
     if (this.statsInterval) clearInterval(this.statsInterval);
     this.statsInterval = setInterval(() => {
-      // Single pass over active jobs instead of two.
+      try {
       let globalSpeedKbs = 0;
       let activeCount = 0;
       let inProgressBytes = 0;
@@ -982,6 +1020,7 @@ class UploadManager extends EventEmitter {
         activeJobs: activeCount,
         pendingJobs: Object.values(this.semaphores).reduce((sum, semaphore) => sum + semaphore.pending, 0)
       });
+      } catch { /* never let a stats tick crash the timer + caller */ }
     }, 1000);
   }
 

lib/vidmoly-upload.js

@@ -382,7 +382,7 @@ class VidmolyUploader {
           }
         }
 
-        if (best && (bestScore > 0 || newFiles.length === 1)) {
+        if (best && bestScore > 0) {
           return this._buildUrlsFromCode(best.file_code);
         }
       }

main.js

@@ -208,6 +208,7 @@ function getAllLogPaths() {
     debug: debugPath,
     accountRotation: rot,
     doodstreamDebug: path.join(dir, 'doodstream-debug.log'),
+    crashLog: path.join(dir, 'crash.log'),
     logDir: dir
   };
 }
@@ -216,23 +217,10 @@ function rotLog(msg, ts) {
   try {
     const iso = new Date(ts || Date.now()).toISOString();
     const line = `[${iso}] ${msg}\n`;
-    // Write synchronously. Rotation events are rare (a handful per batch) so
-    // the batching optimization from debugLog doesn't buy us anything, and
-    // syncing guarantees the user can refresh the file and see fresh entries
-    // without waiting on a flush timer.
-    const candidates = [
-      getRotLogPath(),
-      path.join(app.getPath('desktop') || app.getPath('userData'), 'account-rotation.log'),
-      path.join(app.getPath('userData'), 'account-rotation.log')
-    ];
-    for (const target of candidates) {
-      try {
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        fs.appendFileSync(target, line, 'utf-8');
-        break;
-      } catch {}
+    _rotLogBuffer.push(line);
+    if (!_rotLogFlushTimer) {
+      _rotLogFlushTimer = setTimeout(() => { _rotLogFlushTimer = null; _flushRotLog(); }, 500);
     }
-    // Mirror into the main debug log for single-file-grep convenience.
     _debugLogBuffer.push(`[${iso}] [ROT] ${msg}\n`);
     if (!_debugLogFlushTimer) {
       _debugLogFlushTimer = setTimeout(() => { _debugLogFlushTimer = null; _flushDebugLog(); }, 500);
@@ -240,11 +228,62 @@ function rotLog(msg, ts) {
   } catch {}
 }
 
-// Catch unhandled rejections from fire-and-forget async calls
+function safeSend(channel, data) {
+  if (!mainWindow || mainWindow.isDestroyed()) return false;
+  try {
+    mainWindow.webContents.send(channel, data);
+    return true;
+  } catch (err) {
+    debugLog(`safeSend(${channel}) failed: ${err && err.message ? err.message : err}`);
+    return false;
+  }
+}
+
+function _writeCrashLog(prefix, err, extra) {
+  try {
+    const ts = new Date().toISOString();
+    const line = `[${ts}] ${prefix} ${err && err.stack ? err.stack : (err && err.message) || String(err)}${extra ? ' :: ' + JSON.stringify(extra) : ''}\n`;
+    try {
+      const target = getDebugLogPath();
+      fs.appendFileSync(target, line, 'utf-8');
+    } catch {}
+    try {
+      const crashDir = path.dirname(getDebugLogPath());
+      fs.appendFileSync(path.join(crashDir, 'crash.log'), line, 'utf-8');
+    } catch {}
+  } catch {}
+}
+
 process.on('unhandledRejection', (reason) => {
   debugLog(`UNHANDLED REJECTION: ${reason && reason.stack ? reason.stack : reason}`);
+  _writeCrashLog('UNHANDLED REJECTION', reason);
 });
 
+process.on('uncaughtException', (err, origin) => {
+  _writeCrashLog('UNCAUGHT EXCEPTION (' + origin + ')', err);
+  debugLog(`UNCAUGHT EXCEPTION (${origin}): ${err && err.stack ? err.stack : err}`);
+});
+
+process.on('exit', (code) => {
+  try { _writeCrashLog('PROCESS EXIT', new Error('code=' + code)); } catch {}
+});
+
+process.on('warning', (warning) => {
+  debugLog(`PROCESS WARNING: ${warning.name} ${warning.message}`);
+});
+
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGBREAK']) {
+  try {
+    process.on(sig, () => {
+      _writeCrashLog('SIGNAL ' + sig, new Error('process received ' + sig));
+      try {
+        if (_debugLogBuffer.length) fs.appendFileSync(getDebugLogPath(), _debugLogBuffer.join(''), 'utf-8');
+      } catch {}
+      process.exit(0);
+    });
+  } catch {}
+}
+
 function withTimeout(promise, timeoutMs, label) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
@@ -444,9 +483,7 @@ function _flushUploadLog() {
       // next session writes here directly (no more fallback ladder) and
       // the Settings input reflects reality.
       _persistFallbackLogPath(target.path);
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.send('upload-log-fallback', { fallbackPath: target.path });
-      }
+      safeSend('upload-log-fallback', { fallbackPath: target.path });
     }
     if (_uploadLogBuffer.length && !_uploadLogFlushTimer) setImmediate(_flushUploadLog);
   });
@@ -474,9 +511,7 @@ function _persistFallbackLogPath(workingPath) {
     cfg.globalSettings = gs;
     configStore.save({ globalSettings: gs }).catch(() => {});
     _invalidateUploadLogTargetCache();
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('log-path-auto-updated', { logFilePath: toSave });
-    }
+    safeSend('log-path-auto-updated', { logFilePath: toSave });
   } catch (err) {
     debugLog(`persist fallback logpath failed: ${err.message}`);
   }
@@ -960,6 +995,51 @@ function createWindow() {
   });
 
   mainWindow.webContents.setBackgroundThrottling(false);
+
+  mainWindow.webContents.on('render-process-gone', (_event, details) => {
+    _writeCrashLog('RENDER PROCESS GONE', new Error(details.reason || 'unknown'), details);
+    debugLog(`RENDER PROCESS GONE: reason=${details.reason} exitCode=${details.exitCode}`);
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      try {
+        const choice = dialog.showMessageBoxSync(mainWindow, {
+          type: 'error',
+          title: 'Renderer abgestürzt',
+          message: `Der Renderer-Prozess ist abgestürzt (${details.reason}).`,
+          detail: 'Bitte Diagnose-Paket exportieren und einsenden. Klick "Neu laden" um die UI wiederherzustellen — laufende Uploads im Main-Process bleiben aktiv.',
+          buttons: ['Neu laden', 'Beenden'],
+          defaultId: 0,
+          cancelId: 1
+        });
+        if (choice === 0) {
+          mainWindow.webContents.reload();
+        } else {
+          app.exit(1);
+        }
+      } catch {
+        try { mainWindow.webContents.reload(); } catch {}
+      }
+    }
+  });
+
+  mainWindow.webContents.on('unresponsive', () => {
+    _writeCrashLog('RENDERER UNRESPONSIVE', new Error('webContents unresponsive'));
+    debugLog('RENDERER UNRESPONSIVE');
+  });
+
+  mainWindow.webContents.on('responsive', () => {
+    debugLog('RENDERER RESPONSIVE AGAIN');
+  });
+
+  mainWindow.webContents.on('did-fail-load', (_event, errorCode, errorDescription, validatedURL) => {
+    _writeCrashLog('DID-FAIL-LOAD', new Error(errorDescription), { errorCode, validatedURL });
+    debugLog(`DID-FAIL-LOAD: ${errorCode} ${errorDescription} url=${validatedURL}`);
+  });
+
+  app.on('child-process-gone', (_event, details) => {
+    _writeCrashLog('CHILD PROCESS GONE', new Error(details.reason || 'unknown'), details);
+    debugLog(`CHILD PROCESS GONE: type=${details.type} reason=${details.reason} exitCode=${details.exitCode}`);
+  });
+
   mainWindow.loadFile(path.join(__dirname, 'renderer', 'index.html'));
 }
 
@@ -1053,7 +1133,7 @@ app.whenReady().then(() => {
       logInfo(`update-check: available=${result && result.available}, remote=${result && result.remoteVersion}`);
       logDebug(`update-check result: ${JSON.stringify(result)}`);
       if (result && result.available && mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.send('app:update-available', result);
+        safeSend('app:update-available', result);
       }
     } catch (err) {
       logError('update-check failed', err);
@@ -1062,6 +1142,9 @@ app.whenReady().then(() => {
 });
 
 app.on('window-all-closed', () => {
+  const activeJobs = uploadManager && typeof uploadManager.getActiveJobCount === 'function' ? uploadManager.getActiveJobCount() : 0;
+  debugLog(`window-all-closed: activeJobs=${activeJobs}, uploadManager=${!!uploadManager}`);
+  _writeCrashLog('WINDOW-ALL-CLOSED', new Error('all windows closed'), { activeJobs, uploadManager: !!uploadManager });
   app.quit();
 });
 
@@ -1072,7 +1155,8 @@ app.on('before-quit', () => {
     if (remoteServer) { remoteServer.stop(); remoteServer = null; }
     destroyCaptureWindow();
   } catch {}
-  destroyDropTargetWindow();
+  try { destroyDropTargetWindow(); } catch {}
+  try { if (tray && !tray.isDestroyed()) { tray.destroy(); tray = null; } } catch {}
   // Flush pending log buffers synchronously so no lines are lost.
   try {
     if (_debugLogBuffer.length) {
@@ -1133,11 +1217,9 @@ ipcMain.handle('save-config', async (_event, config) => {
           rotLog(`main: config-updated → late fallback ${fallback.id} for ${hoster} (was stuck on ${failedAccountId})`);
           uploadManager.switchAccount(hoster, fallback);
           _sessionAccountOverrides.set(hoster, fallback);
-          if (mainWindow && !mainWindow.isDestroyed()) {
-            mainWindow.webContents.send('account-switched', {
+          safeSend('account-switched', {
               hoster, fromAccountId: failedAccountId, toAccountId: fallback.id
             });
-          }
         }
       }
     } catch (err) {
@@ -1297,36 +1379,62 @@ ipcMain.handle('select-folder', async () => {
   });
   if (result.canceled || !result.filePaths.length) return null;
 
-  // Recursively collect all files from selected folders
   const files = [];
-  const walk = (dir) => {
-    try {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) walk(full);
-        else if (entry.isFile()) files.push(full);
-      }
-    } catch {}
-  };
-  for (const folder of result.filePaths) walk(folder);
+  for (const folder of result.filePaths) await walkFolderAsync(folder, files);
+  return files.length > 0 ? files.map(f => f.path) : null;
+});
+
+ipcMain.handle('select-folder-with-sizes', async () => {
+  const result = await dialog.showOpenDialog(mainWindow, {
+    properties: ['openDirectory', 'multiSelections']
+  });
+  if (result.canceled || !result.filePaths.length) return null;
+
+  const files = [];
+  for (const folder of result.filePaths) await walkFolderAsync(folder, files);
   return files.length > 0 ? files : null;
 });
 
+async function walkFolderAsync(rootDir, outFiles) {
+  const fsp = fs.promises;
+  const stack = [rootDir];
+  let scanned = 0;
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = await fsp.readdir(dir, { withFileTypes: true }); }
+    catch { continue; }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.isFile()) {
+        let size = 0;
+        try { size = (await fsp.stat(full)).size; } catch {}
+        outFiles.push({ path: full, name: entry.name, size });
+      }
+    }
+    if ((++scanned % 8) === 0) await new Promise(setImmediate);
+  }
+}
+
 ipcMain.handle('resolve-folder-files', async (_event, folderPath) => {
   const files = [];
-  const walk = (dir) => {
-    try {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) walk(full);
-        else if (entry.isFile()) files.push(full);
-      }
-    } catch {}
-  };
-  walk(folderPath);
+  await walkFolderAsync(folderPath, files);
   return files;
 });
 
+ipcMain.handle('get-file-sizes', async (_event, paths) => {
+  if (!Array.isArray(paths)) return {};
+  const fsp = fs.promises;
+  const out = {};
+  let i = 0;
+  for (const p of paths) {
+    try { out[p] = (await fsp.stat(p)).size; } catch { out[p] = 0; }
+    if ((++i % 32) === 0) await new Promise(setImmediate);
+  }
+  return out;
+});
+
 ipcMain.handle('start-upload', (_event, payload) => {
   const config = configStore.load();
   const files = payload && Array.isArray(payload.files) ? payload.files : [];
@@ -1382,9 +1490,29 @@ ipcMain.handle('start-upload', (_event, payload) => {
 
   // Pass hoster settings to the upload manager
   uploadManager = new UploadManager(config.hosterSettings || {}, config.globalSettings || {});
+  globalThis._mhuUploadManagerRef = uploadManager;
+
+  const _progressByJob = new Map();
+  const _progressTerminalQueue = [];
+  let _progressFlushTimer = null;
+  const PROGRESS_BATCH_INTERVAL_MS = 100;
+  function _scheduleProgressFlush() {
+    if (_progressFlushTimer) return;
+    _progressFlushTimer = setTimeout(() => {
+      _progressFlushTimer = null;
+      if (!mainWindow || mainWindow.isDestroyed()) {
+        _progressByJob.clear();
+        _progressTerminalQueue.length = 0;
+        return;
+      }
+      const batch = _progressTerminalQueue.splice(0);
+      for (const v of _progressByJob.values()) batch.push(v);
+      _progressByJob.clear();
+      if (batch.length) safeSend('upload-progress-batch', batch);
+    }, PROGRESS_BATCH_INTERVAL_MS);
+  }
 
   uploadManager.on('progress', (data) => {
-    // Only log state changes, not continuous progress updates
     if (data.status !== 'uploading') {
       debugLog(`progress: ${data.fileName} ${data.hoster} ${data.status} ${data.error || ''}`);
       _appendJobLog(data.jobId, {
@@ -1393,10 +1521,6 @@ ipcMain.handle('start-upload', (_event, payload) => {
         error: data.error || null, attempt: data.attempt || 0, maxAttempts: data.maxAttempts || 0
       });
     }
-    // Write to fileuploader.log immediately when a single upload finishes —
-    // unless the user disabled logging for this hoster (per-hoster toggle).
-    // Read from the live uploadManager.hosterSettings so a mid-batch toggle
-    // (which calls updateSettings) takes effect immediately.
     if (data.status === 'done' && data.result) {
       const link = data.result.download_url || data.result.embed_url || data.result.file_code || '';
       if (link) {
@@ -1409,22 +1533,29 @@ ipcMain.handle('start-upload', (_event, payload) => {
         debugLog(`WARNING: done but no link for ${data.fileName} @ ${data.hoster}: ${JSON.stringify(data.result)}`);
       }
     }
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('upload-progress', data);
+    const isTerminal = data.status === 'done' || data.status === 'error' || data.status === 'aborted' || data.status === 'skipped';
+    if (isTerminal) {
+      if (data.jobId) _progressByJob.delete(data.jobId);
+      _progressTerminalQueue.push(data);
+    } else if (data.jobId) {
+      _progressByJob.set(data.jobId, data);
+    } else {
+      _progressTerminalQueue.push(data);
     }
+    _scheduleProgressFlush();
   });
 
   uploadManager.on('stats', (data) => {
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('upload-stats', data);
-    }
-    // Update tray tooltip with upload progress
-    if (data.state === 'uploading' && data.activeJobs > 0) {
-      const speedMb = ((data.globalSpeedKbs || 0) / 1024).toFixed(1);
-      updateTrayTooltip(`Upload: ${data.activeJobs} aktiv - ${speedMb} MB/s`);
-    } else {
-      updateTrayTooltip('Multi-Hoster-Upload');
-    }
+    try {
+      if (!data || typeof data !== 'object') return;
+      safeSend('upload-stats', data);
+      if (data.state === 'uploading' && data.activeJobs > 0) {
+        const speedMb = ((Number(data.globalSpeedKbs) || 0) / 1024).toFixed(1);
+        updateTrayTooltip(`Upload: ${data.activeJobs} aktiv - ${speedMb} MB/s`);
+      } else {
+        updateTrayTooltip('Multi-Hoster-Upload');
+      }
+    } catch (e) { debugLog(`stats listener error: ${e && e.message}`); }
   });
 
   uploadManager.on('account-failed', ({ hoster, accountId }) => {
@@ -1437,9 +1568,7 @@ ipcMain.handle('start-upload', (_event, payload) => {
       rotLog(`main: account-failed ${hoster} ${accountId} → resolved fallback ${fallback.id}`);
       uploadManager.switchAccount(hoster, fallback);
       _sessionAccountOverrides.set(hoster, fallback);
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.send('account-switched', { hoster, fromAccountId: accountId, toAccountId: fallback.id });
-      }
+      safeSend('account-switched', { hoster, fromAccountId: accountId, toAccountId: fallback.id });
     } else {
       rotLog(`main: account-failed ${hoster} ${accountId} → NO fallback available (end of chain)`);
     }
@@ -1455,17 +1584,25 @@ ipcMain.handle('start-upload', (_event, payload) => {
     'doodstream-via-web'
   ]);
   uploadManager.on('rot-log', (entry) => {
-    const { ts, event, ...rest } = entry;
-    const pairs = Object.entries(rest)
-      .map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`)
-      .join(' ');
-    rotLog(`[${event}] ${pairs}`, ts);
-    if (entry.jobId) {
-      _appendJobLog(entry.jobId, { ts: ts || Date.now(), kind: 'rot', event, ...rest });
-    }
-    if (mainWindow && !mainWindow.isDestroyed() && ROT_LOG_RENDERER_EVENTS.has(event)) {
-      mainWindow.webContents.send('account-rotation-log', entry);
-    }
+    try {
+      if (!entry || typeof entry !== 'object') return;
+      const { ts, event, ...rest } = entry;
+      const pairs = Object.entries(rest)
+        .map(([k, v]) => {
+          let sv;
+          try { sv = typeof v === 'string' ? v : JSON.stringify(v); }
+          catch { sv = '<unserializable>'; }
+          return `${k}=${sv}`;
+        })
+        .join(' ');
+      rotLog(`[${event}] ${pairs}`, ts);
+      if (entry.jobId) {
+        _appendJobLog(entry.jobId, { ts: ts || Date.now(), kind: 'rot', event, ...rest });
+      }
+      if (ROT_LOG_RENDERER_EVENTS.has(event)) {
+        safeSend('account-rotation-log', entry);
+      }
+    } catch (e) { debugLog(`rot-log listener error: ${e && e.message}`); }
   });
 
   // Capture the manager identity at listener-registration time so the post-
@@ -1482,13 +1619,11 @@ ipcMain.handle('start-upload', (_event, payload) => {
     try { await configStore.appendHistory(summary); } catch (err) {
       debugLog(`appendHistory failed: ${err.message}`);
     }
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('upload-batch-done', summary);
-    }
+    safeSend('upload-batch-done', summary);
 
     // Shutdown after finish
     handleShutdownAfterFinish();
-    if (uploadManager === _thisManager) uploadManager = null;
+    if (uploadManager === _thisManager) { uploadManager = null; globalThis._mhuUploadManagerRef = null; }
     else debugLog('batch-done: skipping uploadManager null-out — a newer manager replaced this one mid-await');
   });
 
@@ -1504,8 +1639,7 @@ ipcMain.handle('start-upload', (_event, payload) => {
     }).catch((err) => {
       debugLog(`startBatch REJECTED: ${err && err.stack ? err.stack : err}`);
       // Forward error to renderer as batch-done with failure
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.send('upload-batch-done', {
+      safeSend('upload-batch-done', {
           id: 'error',
           timestamp: new Date().toISOString(),
           total: tasks.length,
@@ -1514,7 +1648,6 @@ ipcMain.handle('start-upload', (_event, payload) => {
           files: [],
           error: err ? err.message : 'Unbekannter Fehler'
         });
-      }
     });
   });
 
@@ -1701,6 +1834,7 @@ ipcMain.handle('create-support-bundle', async () => {
         { label: 'debug.log (last 5 MB)', path: paths.debug, maxBytes: 5 * 1024 * 1024 },
         { label: 'account-rotation.log (last 2 MB)', path: paths.accountRotation, maxBytes: 2 * 1024 * 1024 },
         { label: 'doodstream-debug.log (last 2 MB)', path: paths.doodstreamDebug, maxBytes: 2 * 1024 * 1024 },
+        { label: 'crash.log', path: path.join(paths.logDir || path.dirname(paths.debug), 'crash.log'), maxBytes: 1 * 1024 * 1024 },
         { label: 'fileuploader.log (last 1 MB)', path: paths.fileuploader, maxBytes: 1 * 1024 * 1024 }
       ]
     });
@@ -1742,12 +1876,19 @@ ipcMain.handle('export-backup', async () => {
   const { canceled, filePath } = await dialog.showSaveDialog(mainWindow, {
     title: 'Backup exportieren',
     defaultPath: `multi-hoster-backup-${new Date().toISOString().slice(0, 10)}.mhu`,
-    filters: [{ name: 'Multi-Hoster Backup', extensions: ['mhu'] }]
+    filters: [
+      { name: 'Multi-Hoster Backup (verschlüsselt)', extensions: ['mhu'] },
+      { name: 'Multi-Hoster Backup (Klartext JSON)', extensions: ['json'] }
+    ]
   });
   if (canceled || !filePath) return { ok: false, canceled: true };
   const config = configStore.load();
-  const encrypted = backupCrypto.encrypt(config);
-  fs.writeFileSync(filePath, encrypted);
+  if (filePath.toLowerCase().endsWith('.json')) {
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+  } else {
+    const encrypted = backupCrypto.encrypt(config);
+    fs.writeFileSync(filePath, encrypted);
+  }
   return { ok: true, path: filePath };
 });
 
@@ -1759,7 +1900,11 @@ ipcMain.handle('import-backup', async (_event, legacyPassword) => {
   } else {
     const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
       title: 'Backup importieren',
-      filters: [{ name: 'Multi-Hoster Backup', extensions: ['mhu'] }],
+      filters: [
+        { name: 'Multi-Hoster Backup', extensions: ['mhu', 'json'] },
+        { name: 'Verschlüsselt (.mhu)', extensions: ['mhu'] },
+        { name: 'Klartext (.json)', extensions: ['json'] }
+      ],
       properties: ['openFile']
     });
     if (canceled || !filePaths.length) return { ok: false, canceled: true };
@@ -1768,14 +1913,25 @@ ipcMain.handle('import-backup', async (_event, legacyPassword) => {
     _lastImportPath = sourcePath;
   }
   let imported;
-  try {
-    imported = backupCrypto.decrypt(buffer, legacyPassword);
-  } catch (err) {
-    if (err && err.needsPassword) {
-      return { ok: false, needsPassword: true };
+  const looksLikeJson = buffer.length >= 1 && (buffer[0] === 0x7B || buffer[0] === 0x20 || buffer[0] === 0x0A || buffer[0] === 0x0D || buffer[0] === 0x09 || buffer[0] === 0xEF);
+  if (looksLikeJson) {
+    try {
+      const text = buffer.toString('utf-8').replace(/^\uFEFF/, '');
+      imported = JSON.parse(text);
+    } catch (err) {
+      _lastImportPath = null;
+      return { ok: false, error: 'Klartext-Backup ist kein gültiges JSON: ' + (err.message || err) };
+    }
+  } else {
+    try {
+      imported = backupCrypto.decrypt(buffer, legacyPassword);
+    } catch (err) {
+      if (err && err.needsPassword) {
+        return { ok: false, needsPassword: true, hint: 'Falls dieses Backup mit der aktuellen Version erzeugt wurde, ist die Datei vermutlich beim Transfer beschädigt worden (z. B. FTP-Text-Modus). Versuch es mit einem Klartext-JSON-Export.' };
+      }
+      _lastImportPath = null;
+      throw err;
     }
-    _lastImportPath = null;
-    throw err;
   }
   _lastImportPath = null;
   // Validate imported data has required structure
@@ -1893,13 +2049,9 @@ ipcMain.handle('app:check-updates', async () => {
 
 ipcMain.handle('app:install-update', () => {
   installUpdate((progress) => {
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('app:update-progress', progress);
-    }
+    safeSend('app:update-progress', progress);
   }).catch((err) => {
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('app:update-progress', { stage: 'error', error: err.message });
-    }
+    safeSend('app:update-progress', { stage: 'error', error: err.message });
   });
   return { started: true };
 });
@@ -1978,9 +2130,7 @@ function startFolderMonitor(settings) {
     folderMonitor.removeAllListeners();
     folderMonitor.on('new-files', (files) => {
       debugLog(`folder-monitor: ${files.length} new file(s)`);
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.send('folder-monitor:new-files', files);
-      }
+      safeSend('folder-monitor:new-files', files);
     });
     folderMonitor.on('error', (err) => {
       debugLog(`folder-monitor error: ${err.message}`);
@@ -2224,9 +2374,7 @@ ipcMain.handle('remote:get-capture-source-id', async () => {
 
 // IPC: Client count updates from capture window
 ipcMain.on('remote:client-count', (_event, count) => {
-  if (mainWindow && !mainWindow.isDestroyed()) {
-    mainWindow.webContents.send('remote:client-count', count);
-  }
+  safeSend('remote:client-count', count);
 });
 
 // IPC: Remote settings
@@ -2331,7 +2479,7 @@ ipcMain.on('drop-target:files', (_event, paths) => {
       mainWindow.show();
       mainWindow.focus();
     }
-    mainWindow.webContents.send('drop-target:files', paths);
+    safeSend('drop-target:files', paths);
   }
 });
 
@@ -2368,9 +2516,7 @@ function handleShutdownAfterFinish() {
   const { exec } = require('child_process');
 
   // Notify renderer
-  if (mainWindow && !mainWindow.isDestroyed()) {
-    mainWindow.webContents.send('shutdown-countdown', { mode: shutdownMode, seconds: 60 });
-  }
+  safeSend('shutdown-countdown', { mode: shutdownMode, seconds: 60 });
 
   // Clear any previous countdown to prevent orphaned timers
   if (shutdownTimer) clearTimeout(shutdownTimer);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-hoster-uploader",
-  "version": "3.3.46",
+  "version": "3.3.55",
   "description": "Upload files to doodstream, voe, vidmoly, byse simultaneously",
   "main": "main.js",
   "scripts": {

preload.js

@@ -30,7 +30,9 @@ contextBridge.exposeInMainWorld('api', {
   // File selection
   selectFiles: () => ipcRenderer.invoke('select-files'),
   selectFolder: () => ipcRenderer.invoke('select-folder'),
+  selectFolderWithSizes: () => ipcRenderer.invoke('select-folder-with-sizes'),
   resolveFolderFiles: (folderPath) => ipcRenderer.invoke('resolve-folder-files', folderPath),
+  getFileSizes: (paths) => ipcRenderer.invoke('get-file-sizes', paths),
 
   // Upload control
   startUpload: (payload) => ipcRenderer.invoke('start-upload', payload),
@@ -93,6 +95,9 @@ contextBridge.exposeInMainWorld('api', {
   onUploadProgress: (callback) => {
     ipcRenderer.on('upload-progress', (_event, data) => callback(data));
   },
+  onUploadProgressBatch: (callback) => {
+    ipcRenderer.on('upload-progress-batch', (_event, batch) => callback(batch));
+  },
   onUploadBatchDone: (callback) => {
     ipcRenderer.on('upload-batch-done', (_event, data) => callback(data));
   },

renderer/app.js

@@ -63,10 +63,12 @@ const queueSortState = { key: 'filename', direction: 'asc' };
 // History state
 let historyRowsData = [];
 let historySortState = { key: 'date', direction: 'desc' };
+let _historySortClicked = false;
 
 // Session-specific files for the "Files" panel (resets each session)
 let sessionFilesData = [];
 const recentSortState = { key: 'date', direction: 'desc' };
+let _recentSortClicked = false;
 const selectedRecentIds = new Set();
 // Maintained incrementally — avoids O(n) filter() scans every 250ms in the status bar.
 let _sessionDoneCount = 0;
@@ -75,6 +77,19 @@ let _sessionErrorCount = 0;
 // Huge with thousands of rows × thousands of incoming results.
 const _sessionFileKeys = new Set();
 
+window.addEventListener('error', (e) => {
+  try {
+    const msg = `RENDERER ERROR: ${e.message} at ${e.filename}:${e.lineno}:${e.colno}${e.error && e.error.stack ? '\n' + e.error.stack : ''}`;
+    if (window.api && window.api.debugLog) window.api.debugLog(msg);
+  } catch {}
+});
+window.addEventListener('unhandledrejection', (e) => {
+  try {
+    const reason = e.reason && e.reason.stack ? e.reason.stack : (e.reason && e.reason.message) || String(e.reason);
+    if (window.api && window.api.debugLog) window.api.debugLog(`RENDERER UNHANDLED REJECTION: ${reason}`);
+  } catch {}
+});
+
 // --- Init ---
 async function init() {
   config = await window.api.getConfig();
@@ -111,6 +126,12 @@ async function init() {
   window.api.onUploadProgress((data) => {
     handleProgress(data);
   });
+  if (window.api.onUploadProgressBatch) {
+    window.api.onUploadProgressBatch((batch) => {
+      if (!Array.isArray(batch)) return;
+      for (let i = 0; i < batch.length; i++) handleProgress(batch[i]);
+    });
+  }
   window.api.onUploadBatchDone((data) => {
     handleBatchDone(data);
   });
@@ -674,11 +695,12 @@ async function addDroppedFiles(fileList) {
           const folderFiles = await window.api.resolveFolderFiles(filePath);
           if (folderFiles && folderFiles.length > 0) {
             for (const fp of folderFiles) {
-              if (!existingPaths.has(fp)) {
-                const name = fp.split('\\').pop().split('/').pop();
-                newFiles.push({ path: fp, name, size: null });
-                existingPaths.add(fp);
-              }
+              const p = typeof fp === 'string' ? fp : (fp && fp.path);
+              if (!p || existingPaths.has(p)) continue;
+              const name = typeof fp === 'string' ? p.split('\\').pop().split('/').pop() : (fp.name || p.split('\\').pop().split('/').pop());
+              const size = typeof fp === 'string' ? null : (fp.size || 0);
+              newFiles.push({ path: p, name, size });
+              existingPaths.add(p);
             }
             continue;
           }
@@ -709,28 +731,52 @@ async function pickFiles() {
 }
 
 async function pickFolder() {
+  const richFiles = window.api.selectFolderWithSizes ? await window.api.selectFolderWithSizes() : null;
+  if (richFiles && Array.isArray(richFiles)) { addPathsToQueue(richFiles); return; }
   const paths = await window.api.selectFolder();
   if (!paths) return;
   addPathsToQueue(paths);
 }
 
 function addPathsToQueue(paths) {
-  // Build path-Set once so dedup is O(1) per candidate instead of O(n+m).
-  // Matters when the user picks a folder with thousands of files.
   const existing = new Set();
   for (const f of selectedFiles) existing.add(f.path);
   for (const f of _pendingFiles) existing.add(f.path);
 
   const newFiles = [];
-  for (const p of paths) {
-    if (existing.has(p)) continue;
+  const pendingSizeFetch = [];
+  for (const entry of paths) {
+    const p = typeof entry === 'string' ? entry : (entry && entry.path);
+    if (!p || existing.has(p)) continue;
     existing.add(p);
-    const name = p.split('\\').pop().split('/').pop();
-    newFiles.push({ path: p, name, size: null });
+    const name = typeof entry === 'string' ? p.split('\\').pop().split('/').pop() : (entry.name || p.split('\\').pop().split('/').pop());
+    const size = typeof entry === 'string' ? null : (entry.size || 0);
+    newFiles.push({ path: p, name, size });
+    if (size === null || size === undefined || size === 0) pendingSizeFetch.push(p);
   }
   if (newFiles.length > 0) {
     _pendingFiles.push(...newFiles);
     openHosterModal();
+    if (pendingSizeFetch.length > 0 && window.api.getFileSizes) {
+      window.api.getFileSizes(pendingSizeFetch).then((sizeMap) => {
+        if (!sizeMap || typeof sizeMap !== 'object') return;
+        let changed = false;
+        for (const f of _pendingFiles) {
+          if (sizeMap[f.path] && (!f.size || f.size === 0)) { f.size = sizeMap[f.path]; changed = true; }
+        }
+        for (const f of selectedFiles) {
+          if (sizeMap[f.path] && (!f.size || f.size === 0)) { f.size = sizeMap[f.path]; changed = true; }
+        }
+        for (const j of queueJobs) {
+          if (sizeMap[j.file] && (!j.bytesTotal || j.bytesTotal === 0)) { j.bytesTotal = sizeMap[j.file]; changed = true; }
+        }
+        if (changed) {
+          _queueStatsCache = null;
+          if (typeof renderQueueTable === 'function') renderQueueTable();
+          if (typeof updateStatusBar === 'function') updateStatusBar();
+        }
+      }).catch(() => {});
+    }
   }
 }
 
@@ -1437,7 +1483,7 @@ async function doBackupExport() {
   }
 }
 
-function askLegacyBackupPassword() {
+function askLegacyBackupPassword(hint) {
   return new Promise((resolve) => {
     const overlay = document.createElement('div');
     overlay.className = 'modal-overlay';
@@ -1450,7 +1496,7 @@ function askLegacyBackupPassword() {
     const header = document.createElement('div');
     header.className = 'modal-header';
     const h3 = document.createElement('h3');
-    h3.textContent = 'Passwort erforderlich';
+    h3.textContent = 'Backup nicht entschlüsselbar';
     header.appendChild(h3);
 
     const body = document.createElement('div');
@@ -1458,7 +1504,15 @@ function askLegacyBackupPassword() {
     const p = document.createElement('p');
     p.style.margin = '0 0 10px';
     p.style.fontSize = '13px';
-    p.textContent = 'Dieses Backup wurde mit einem Passwort verschlüsselt.';
+    p.textContent = 'Wenn das Backup mit der alten Passwort-Option (vor v3.0) erstellt wurde, hier eingeben.';
+    if (hint) {
+      const p2 = document.createElement('p');
+      p2.style.margin = '0 0 10px';
+      p2.style.fontSize = '12px';
+      p2.style.color = 'var(--text-dim)';
+      p2.textContent = hint;
+      body.appendChild(p2);
+    }
     const input = document.createElement('input');
     input.type = 'password';
     input.className = 'key-input';
@@ -1502,7 +1556,7 @@ async function doBackupImport(legacyPassword) {
     const result = await window.api.importBackup(pw);
     if (!result || result.canceled) return;
     if (result.needsPassword) {
-      const entered = await askLegacyBackupPassword();
+      const entered = await askLegacyBackupPassword(result.hint);
       if (entered) doBackupImport(entered);
       return;
     }
@@ -1867,6 +1921,14 @@ async function cancelUpload() {
 
 // --- Progress handling ---
 function handleProgress(data) {
+  try {
+    if (!data || typeof data !== 'object') return;
+    _handleProgressImpl(data);
+  } catch (err) {
+    if (window.api && window.api.debugLog) window.api.debugLog(`handleProgress error: ${err && err.stack ? err.stack : err}`);
+  }
+}
+function _handleProgressImpl(data) {
   let job = data.jobId ? _jobIndexById.get(data.jobId) : null;
   if (!job && data.uploadId) job = _jobIndexByUploadId.get(data.uploadId);
   if (!job) {
@@ -2128,6 +2190,14 @@ function _retryFailedFromBuckets(buckets, transientOnly) {
 }
 
 function handleStats(data) {
+  try {
+    if (!data || typeof data !== 'object') return;
+    _handleStatsImpl(data);
+  } catch (err) {
+    if (window.api && window.api.debugLog) window.api.debugLog(`handleStats error: ${err && err.stack ? err.stack : err}`);
+  }
+}
+function _handleStatsImpl(data) {
   lastUploadStats = {
     state: data.state || 'idle',
     globalSpeedKbs: data.globalSpeedKbs || 0,
@@ -2455,7 +2525,7 @@ function _computeQueueStats() {
   }
 
   _queueStatsCache = { total, remaining, inProgress, done, errors, bytesRemaining, totalSize, remainingSize, inProgressBytes };
-  queueMicrotask(() => { _queueStatsCache = null; });
+  (typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn))(() => { _queueStatsCache = null; });
   return _queueStatsCache;
 }
 
@@ -2516,8 +2586,10 @@ async function executeHealthCheck(hosters, _mode) {
 }
 
 async function runHealthCheck(mode = 'manual', requestedHosters = null) {
-  if (healthCheckRunning || (uploading && mode === 'manual')) return [];
-  // Build check list: all enabled accounts with creds
+  if (healthCheckRunning) {
+    if (mode === 'manual') showCopyToast('Account-Check läuft bereits.');
+    return [];
+  }
   let hosters;
   if (Array.isArray(requestedHosters) && requestedHosters.length > 0) {
     hosters = requestedHosters;
@@ -3644,7 +3716,10 @@ async function deleteAccount(accountId) {
   // Fire-and-forget the persist. The earlier `await getConfig()` round-trip
   // was redundant (we already have the truth in memory) and was the main
   // source of perceived lag on add/delete.
-  window.api.saveConfig({ hosters: config.hosters }).catch(() => {});
+  window.api.saveConfig({ hosters: config.hosters }).catch((err) => {
+    if (window.api && window.api.debugLog) window.api.debugLog(`deleteAccount saveConfig failed: ${err && err.message ? err.message : err}`);
+    showCopyToast('Account-Löschung konnte nicht persistiert werden — bitte erneut versuchen.');
+  });
 }
 
 function readAccountCredsFromModal(authType) {
@@ -3850,6 +3925,15 @@ async function _commitAccount(ctx, creds, validatedStatus, validatedMessage) {
     const idx = config.hosters[ctx.hosterName].findIndex(a => a.id === accountId);
     if (idx >= 0) {
       config.hosters[ctx.hosterName][idx] = { ...config.hosters[ctx.hosterName][idx], ...creds };
+    } else {
+      _accountModalBusy = false;
+      const _sb = document.getElementById('saveAccountBtn'); if (_sb) _sb.disabled = false;
+      const _st = document.getElementById('accountModalStatus');
+      if (_st) {
+        _st.textContent = 'Account nicht mehr in der Config — wurde extern gelöscht. Modal schließen und neu anlegen.';
+        _st.className = 'account-modal-status error';
+      }
+      return;
     }
   } else {
     accountId = `${ctx.hosterName}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@@ -4097,17 +4181,32 @@ function renderHistoryTable(container) {
     ${headerCell('date', 'Date')}${headerCell('filename', 'Filename')}${headerCell('host', 'Host')}${headerCell('link', 'Link')}
   </tr></thead><tbody>`;
 
-  rows.forEach(row => {
-    html += `<tr class="history-row${row.isError ? ' error' : ''}" data-link="${escapeAttr(row.link)}">
-      <td class="col-date">${escapeHtml(row.date)}</td>
-      <td class="col-filename">${escapeHtml(row.filename)}</td>
-      <td class="col-host">${escapeHtml(row.host)}</td>
-      <td class="col-link">${escapeHtml(row.link)}</td>
-    </tr>`;
-  });
-
-  html += '</tbody></table>';
-  container.innerHTML = html;
+  const parts = [html];
+  const len = rows.length;
+  for (let i = 0; i < len; i++) {
+    const row = rows[i];
+    const link = row.link || '';
+    const date = escapeHtml(row.date);
+    const filename = escapeHtml(row.filename);
+    const host = escapeHtml(row.host);
+    const linkHtml = escapeHtml(link);
+    const linkAttr = escapeAttr(link);
+    parts.push('<tr class="history-row');
+    if (row.isError) parts.push(' error');
+    parts.push('" data-link="');
+    parts.push(linkAttr);
+    parts.push('"><td class="col-date">');
+    parts.push(date);
+    parts.push('</td><td class="col-filename">');
+    parts.push(filename);
+    parts.push('</td><td class="col-host">');
+    parts.push(host);
+    parts.push('</td><td class="col-link">');
+    parts.push(linkHtml);
+    parts.push('</td></tr>');
+  }
+  parts.push('</tbody></table>');
+  container.innerHTML = parts.join('');
 
   // Delegated listeners: bind once per render-target instead of once per
   // row/header. With a 5000-row history the per-row bind path was a
@@ -4119,8 +4218,14 @@ function renderHistoryTable(container) {
       const th = e.target.closest('th.sortable');
       if (th && container.contains(th)) {
         const key = th.dataset.historySort;
-        if (historySortState.key === key) historySortState.direction = historySortState.direction === 'asc' ? 'desc' : 'asc';
-        else { historySortState.key = key; historySortState.direction = key === 'date' ? 'desc' : 'asc'; }
+        const defaultDir = key === 'date' ? 'desc' : 'asc';
+        if (!_historySortClicked || historySortState.key !== key) {
+          _historySortClicked = true;
+          historySortState.key = key;
+          historySortState.direction = defaultDir;
+        } else {
+          historySortState.direction = historySortState.direction === 'asc' ? 'desc' : 'asc';
+        }
         renderHistoryTable(container);
         return;
       }
@@ -4176,11 +4281,13 @@ function setupListeners() {
     const th = e.target.closest('th[data-recent-sort]');
     if (!th) return;
     const key = th.dataset.recentSort;
-    if (recentSortState.key === key) {
-      recentSortState.direction = recentSortState.direction === 'desc' ? 'asc' : 'desc';
-    } else {
+    const defaultDir = key === 'date' ? 'desc' : 'asc';
+    if (!_recentSortClicked || recentSortState.key !== key) {
+      _recentSortClicked = true;
       recentSortState.key = key;
-      recentSortState.direction = key === 'date' ? 'desc' : 'asc';
+      recentSortState.direction = defaultDir;
+    } else {
+      recentSortState.direction = recentSortState.direction === 'desc' ? 'asc' : 'desc';
     }
     renderRecentUploadsPanel();
   });
@@ -4774,4 +4881,15 @@ function updateStatsPanel() {
 }
 
 // --- Start ---
-init();
+init().catch((err) => {
+  try {
+    if (window.api && window.api.debugLog) window.api.debugLog(`init failed: ${err && err.stack ? err.stack : err}`);
+    const root = document.getElementById('app') || document.body;
+    if (root) {
+      const banner = document.createElement('div');
+      banner.style.cssText = 'position:fixed;top:0;left:0;right:0;background:#5a1e1e;color:#fff;padding:8px;z-index:99999;font-family:sans-serif;font-size:13px';
+      banner.textContent = 'Initialisierung fehlgeschlagen: ' + (err && err.message ? err.message : err) + ' — bitte Diagnose-Paket exportieren oder Programm neu starten.';
+      root.appendChild(banner);
+    }
+  } catch {}
+});

tests/upload-manager.test.js

@@ -31,6 +31,7 @@ describe('UploadManager', () => {
     const origRequire = module.constructor.prototype.require;
     const hosters = require('../lib/hosters');
     hosters.uploadFile = mockUploadFile;
+    hosters.prefetchBaseline = async () => null;
 
     // Mock fs.statSync for test file paths
     const fs = require('fs');