.gitignore

@@ -19,6 +19,7 @@ apply_update.cmd
 
 .claude/
 .github/
+docs/plans/
 CHANGELOG.md
 
 node_modules/
@@ -28,6 +29,7 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
+# Forgejo deployment runtime files
 deploy/forgejo/.env
 deploy/forgejo/forgejo/
 deploy/forgejo/postgres/
@@ -36,14 +38,3 @@ deploy/forgejo/caddy/config/
 deploy/forgejo/caddy/logs/
 deploy/forgejo/backups/
 .secrets
-
-*.log.old
-*.bak
-
-rust-postprocess/
-electron-postprocess/
-python-postprocess/
-scripts/*.py
-scripts/*.ps1
-scripts/*.md
-scripts/fix-library-renames.mjs

README.md

@@ -36,8 +36,7 @@ Desktop downloader for Windows with package-based queue management, multi-provid
 - Package-based queue with item status, retries, ETA, speed, provider, and account label.
 - Start, pause, stop, cancel, reset, rename, and delete for packages and items.
 - Ctrl+Click multi-select and bulk actions.
-- Queue backup import/export as JSON.
+- Queue import/export.
-- Context-menu export for selected packages or selected items as structured TXT re-import files.
 - Duplicate handling when adding links: keep, skip, or overwrite.
 - Optional start scheduling for a specific time.
 - Session recovery after restart with optional auto-resume.
@@ -46,10 +45,9 @@ Desktop downloader for Windows with package-based queue management, multi-provid
 ### Link collection
 
 - Paste links directly into the collector.
-- Import `.txt` export files that preserve package names and optional per-file names.
 - Clipboard watcher with automatic link detection.
 - `.dlc` import via file picker and drag-and-drop.
-- Drag-and-drop of plain links, `.txt` export files, and supported container files.
+- Drag-and-drop of plain links and supported container files.
 
 ### Provider routing and fallback
 
@@ -165,29 +163,6 @@ npm run dev
 5. Start the queue and monitor downloads, extraction, and provider status.
 6. Review history and statistics after completion.
 
-## Link export format
-
-Selected packages or items can be exported from the context menu as a structured text file. Re-importing that file restores the original package grouping, even if it only contains a subset of items from a larger package.
-
-Example:
-
-```txt
-# rd-link-export: 1
-# package: Dave Staffel 1
-# file: Dave.S01E01.rar
-https://example.com/e01
-# file: Dave.S01E02.rar
-https://example.com/e02
-```
-
-Supported import sources:
-
-- collector text input
-- `Datei importieren`
-- drag-and-drop of `.txt` and `.json`
-
-The optional `# file:` marker preserves the original item name so the imported subset can be rebuilt with the same package name and per-item filename hints.
-
 ## Project structure
 
 - `src/main` - Electron main process, download engine, provider clients, updater, storage
@@ -206,89 +181,6 @@ Runtime files are stored in Electron's `userData` directory, including:
 - `rd_session_state.json`
 - `rd_history.json`
 - `rd_downloader.log`
-- `audit.log`
-- `rename.log`
-- `debug_ai_manifest.json`
-- `trace.log`
-- `trace_config.json`
-- `session-logs/session_*.txt`
-- `package-logs/package_*.txt`
-- `item-logs/item_*.txt`
-
-`audit.log`, `rename.log`, and `trace.log` are rotated automatically. The current file is kept plus one `.old` backup, and outdated backups are purged automatically.
-
-### Remote debug server
-
-For headless or server-style troubleshooting, the app can expose a small authenticated HTTP debug API with live status and log tails.
-
-Enable it by creating these files in the same runtime folder that contains `rd_downloader.log`:
-
-- `debug_token.txt`
-  Example: a long random token such as `rd-debug-please-change-me`
-- `debug_port.txt`
-  Example: `9868`
-- `debug_host.txt` (optional)
-  Default is `127.0.0.1`. Set `0.0.0.0` only if you really want remote access and protect it with firewall, VPN, or reverse proxy.
-
-After startup, the app also writes `debug_ai_manifest.json` into the same runtime folder. This file is meant for support tooling and AI agents: it lists all available endpoints, the auth method, the related runtime files, and the one remaining external value the assistant may still need from you for remote access: the server IP or DNS name.
-
-If you want extra support detail during a flaky or hard-to-reproduce issue, the app also maintains a `trace.log` plus `trace_config.json`. You can enable or disable the support trace from the app menu or remotely via the debug API. By default, the support trace now auto-disables again after 2 hours so it does not stay enabled forever by accident.
-
-The app menu under `Hilfe` also includes a `Debug-Setup prüfen` action. It verifies the current host/port/token/AI-manifest/trace setup locally and now also reports free disk space, current support-log sizes, and an estimated support-bundle size.
-
-Available endpoints after restart:
-
-- `GET /health`
-- `GET /meta`
-- `GET /debug/setup`
-- `GET /self-check`
-- `GET /host/diagnostics`
-- `GET /status`
-- `GET /settings`
-- `GET /accounts`
-- `GET /stats`
-- `GET /history?limit=50&status=completed`
-- `GET /packages?package=Release&includeItems=1`
-- `GET /items?status=downloading&package=Release`
-- `GET /session?package=Release`
-- `GET /log?lines=100&grep=keyword`
-- `GET /logs/main?lines=100&grep=keyword`
-- `GET /logs/audit?lines=100&grep=keyword`
-- `GET /logs/rename?lines=100&grep=keyword`
-- `GET /logs/trace?lines=100&grep=keyword`
-- `GET /logs/session?lines=100&grep=keyword`
-- `GET /logs/package?package=Release&lines=100&grep=keyword`
-- `GET /logs/item?item=episode.part2.rar&lines=100&grep=keyword`
-- `GET /trace/config?enable=1&note=support&durationMinutes=120`
-- `GET /support/bundle`
-- `GET /diagnostics?package=Release&lines=150`
-
-Authentication works with either:
-
-- header: `Authorization: Bearer <token>`
-- query param: `?token=<token>`
-
-Example from PowerShell:
-
-```powershell
-Invoke-RestMethod "http://SERVER:9868/diagnostics?token=YOUR_TOKEN&package=Release"
-Invoke-RestMethod "http://SERVER:9868/settings?token=YOUR_TOKEN"
-Invoke-RestMethod "http://SERVER:9868/accounts?token=YOUR_TOKEN"
-Invoke-RestMethod "http://SERVER:9868/stats?token=YOUR_TOKEN"
-Invoke-RestMethod "http://SERVER:9868/history?token=YOUR_TOKEN&limit=20"
-Invoke-RestMethod "http://SERVER:9868/debug/setup?token=YOUR_TOKEN"
-Invoke-RestMethod "http://SERVER:9868/self-check?token=YOUR_TOKEN"
-Invoke-RestMethod "http://SERVER:9868/logs/audit?token=YOUR_TOKEN&lines=200"
-Invoke-RestMethod "http://SERVER:9868/logs/rename?token=YOUR_TOKEN&lines=200"
-Invoke-RestMethod "http://SERVER:9868/logs/trace?token=YOUR_TOKEN&lines=200"
-Invoke-RestMethod "http://SERVER:9868/trace/config?token=YOUR_TOKEN&enable=1&note=support&durationMinutes=120"
-Invoke-RestMethod "http://SERVER:9868/logs/package?token=YOUR_TOKEN&package=Release&lines=200"
-Invoke-RestMethod "http://SERVER:9868/logs/item?token=YOUR_TOKEN&item=episode.part2.rar&lines=200"
-Invoke-RestMethod "http://SERVER:9868/host/diagnostics?token=YOUR_TOKEN"
-Invoke-WebRequest "http://SERVER:9868/support/bundle?token=YOUR_TOKEN" -OutFile ".\\rd-support-bundle.zip"
-```
-
-This makes it easy to share one URL plus token during support, so current package status, session state, history, redacted account/settings state, audit actions, rename/MKV move traces, trace data, package/session/item logs, host-side Windows crash hints, disk space, support-log volume, support-bundle size estimates, and even a full ZIP support bundle can be inspected remotely.
 
 ## Troubleshooting
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "real-debrid-downloader",
-  "version": "1.7.190",
+  "version": "1.7.66",
   "description": "Desktop downloader",
   "main": "build/main/main/main.js",
   "author": "Sucukdeluxe",

resources/extractor-jvm/src/com/sucukdeluxe/extractor/JBindExtractorMain.java

@@ -98,12 +98,13 @@ public final class JBindExtractorMain {
                 System.out.flush();
             }
         } catch (IOException ignored) {
-
+            // stdin closed — parent process exited
         }
     }
 
     private static ExtractionRequest parseDaemonRequest(String jsonLine) {
-
+        // Minimal JSON parsing without external dependencies.
+        // Expected format: {"archive":"...","target":"...","conflict":"...","backend":"...","passwords":["...","..."]}
         ExtractionRequest request = new ExtractionRequest();
         request.archiveFile = new File(extractJsonString(jsonLine, "archive"));
         request.targetDir = new File(extractJsonString(jsonLine, "target"));
@@ -115,7 +116,7 @@ public final class JBindExtractorMain {
         if (backend.length() > 0) {
             request.backend = Backend.fromValue(backend);
         }
-
+        // Parse passwords array
         int pwStart = jsonLine.indexOf("\"passwords\"");
         if (pwStart >= 0) {
             int arrStart = jsonLine.indexOf('[', pwStart);
@@ -160,7 +161,7 @@ public final class JBindExtractorMain {
         for (int i = from; i < s.length(); i++) {
             char c = s.charAt(i);
             if (c == '\\') {
-                i++;
+                i++; // skip escaped character
                 continue;
             }
             if (c == '"') return i;
@@ -366,6 +367,7 @@ public final class JBindExtractorMain {
                 throw new IOException("Archiv enthalt keine Eintrage oder konnte nicht gelesen werden: " + request.archiveFile.getAbsolutePath());
             }
 
+            // Pre-scan: collect file indices, sizes, output paths, and detect encryption
             long totalUnits = 0;
             boolean encrypted = false;
             List<Integer> fileIndices = new ArrayList<Integer>();
@@ -389,7 +391,7 @@ public final class JBindExtractorMain {
                     Boolean isEncrypted = (Boolean) archive.getProperty(i, PropID.ENCRYPTED);
                     encrypted = encrypted || Boolean.TRUE.equals(isEncrypted);
                 } catch (Throwable ignored) {
-
+                    // ignore encrypted flag read issues
                 }
 
                 Long rawSize = (Long) archive.getProperty(i, PropID.SIZE);
@@ -398,12 +400,12 @@ public final class JBindExtractorMain {
 
                 File output = resolveOutputFile(request.targetDir, entryName, request.conflictMode, reserved);
                 fileIndices.add(i);
-                outputFiles.add(output);
+                outputFiles.add(output); // null if skipped
                 fileSizes.add(itemSize);
             }
 
             if (fileIndices.isEmpty()) {
-
+                // All items are folders or skipped
                 ProgressTracker progress = new ProgressTracker(1);
                 progress.emitStart();
                 progress.emitDone();
@@ -413,16 +415,19 @@ public final class JBindExtractorMain {
             ProgressTracker progress = new ProgressTracker(totalUnits);
             progress.emitStart();
 
+            // Build index array for bulk extract
             int[] indices = new int[fileIndices.size()];
             for (int i = 0; i < fileIndices.size(); i++) {
                 indices[i] = fileIndices.get(i);
             }
 
+            // Map from archive index to our position in fileIndices/outputFiles
             Map<Integer, Integer> indexToPos = new HashMap<Integer, Integer>();
             for (int i = 0; i < fileIndices.size(); i++) {
                 indexToPos.put(fileIndices.get(i), i);
             }
 
+            // Bulk extraction state
             final boolean encryptedFinal = encrypted;
             final String effectivePassword = password == null ? "" : password;
             final File[] currentOutput = new File[1];
@@ -669,7 +674,7 @@ public final class JBindExtractorMain {
         if (entry.length() == 0) {
             return fallback;
         }
-
+        // Sanitize Windows special characters from each path segment
         String[] segments = entry.split("/", -1);
         StringBuilder sanitized = new StringBuilder();
         for (int i = 0; i < segments.length; i++) {
@@ -703,7 +708,7 @@ public final class JBindExtractorMain {
         if (Files.isSymbolicLink(file.toPath())) {
             throw new IOException("Zieldatei ist ein Symlink, Schreiben verweigert: " + file.getAbsolutePath());
         }
-
+        // Also check parent directories for symlinks
         File parent = file.getParentFile();
         while (parent != null) {
             if (Files.isSymbolicLink(parent.toPath())) {
@@ -874,6 +879,12 @@ public final class JBindExtractorMain {
         private final List<String> passwords = new ArrayList<String>();
     }
 
+    /**
+     * Bulk extraction callback that implements both IArchiveExtractCallback and
+     * ICryptoGetTextPassword. Using the bulk IInArchive.extract() API instead of
+     * per-item extractSlow() is critical for performance — solid RAR archives
+     * otherwise re-decode from the beginning for every single item.
+     */
     private static final class BulkExtractCallback implements IArchiveExtractCallback, ICryptoGetTextPassword {
         private final IInArchive archive;
         private final Map<Integer, Integer> indexToPos;
@@ -919,12 +930,12 @@ public final class JBindExtractorMain {
 
         @Override
         public void setTotal(long total) {
-
+            // 7z reports total compressed bytes; we track uncompressed via ProgressTracker
         }
 
         @Override
         public void setCompleted(long complete) {
-
+            // Not used — we track per-write progress
         }
 
         @Override
@@ -979,7 +990,7 @@ public final class JBindExtractorMain {
 
         @Override
         public void prepareOperation(ExtractAskMode extractAskMode) {
-
+            // no-op
         }
 
         @Override
@@ -1000,7 +1011,7 @@ public final class JBindExtractorMain {
                             currentOutput[0].setLastModified(modified.getTime());
                         }
                     } catch (Throwable ignored) {
-
+                        // best effort
                     }
                 }
             } else {
@@ -1168,12 +1179,12 @@ public final class JBindExtractorMain {
 
         @Override
         public void setTotal(Long files, Long bytes) {
-
+            // no-op
         }
 
         @Override
         public void setCompleted(Long files, Long bytes) {
-
+            // no-op
         }
 
         @Override
@@ -1185,7 +1196,8 @@ public final class JBindExtractorMain {
             if (filename == null || filename.trim().length() == 0) {
                 return null;
             }
-
+            // Always resolve relative to the archive's parent directory.
+            // Never accept absolute paths to prevent path traversal.
             String baseName = new File(filename).getName();
             if (archiveDir != null) {
                 File relative = new File(archiveDir, baseName);

scripts/provider_smoke_check.mjs

@@ -66,6 +66,8 @@ async function callRealDebrid(link) {
   };
 }
 
+// megaCookie is intentionally cached at module scope so that multiple
+// callMegaDebrid() invocations reuse the same session cookie.
 async function callMegaDebrid(link) {
   if (!megaCookie) {
     const loginRes = await fetch("https://www.mega-debrid.eu/index.php?form=login", {

scripts/release_gitea.mjs

@@ -116,6 +116,7 @@ function getGiteaRepo() {
       }
       return { remote, ...parsed, baseUrl: `${preferredProtocol}//${parsed.host}` };
     } catch {
+      // try next remote
     }
   }
 
@@ -255,13 +256,15 @@ async function createOrGetRelease(baseApi, tag, authHeader, notes) {
     target_commitish: "main",
     name: tag,
     body: notes || `Release ${tag}`,
-    draft: true,
+    draft: false,
     prerelease: false
   };
   const created = await apiRequest("POST", `${baseApi}/releases`, authHeader, JSON.stringify(payload));
   if (created.ok) {
     return created.body;
   }
+  // Gitea can return 409/422/500 UNIQUE when the release was already partially created.
+  // Retry the GET — it may now exist.
   if (created.status === 409 || created.status === 422 || created.status === 500) {
     const retry = await apiRequest("GET", `${baseApi}/releases/tags/${encodeURIComponent(tag)}`, authHeader);
     if (retry.ok) {
@@ -273,17 +276,14 @@ async function createOrGetRelease(baseApi, tag, authHeader, notes) {
 }
 
 async function uploadReleaseAssets(baseApi, releaseId, authHeader, releaseDir, files) {
-  const MAX_ATTEMPTS = 3;
   for (const fileName of files) {
     const filePath = path.join(releaseDir, fileName);
     const fileSize = fs.statSync(filePath).size;
     const uploadUrl = `${baseApi}/releases/${releaseId}/assets?name=${encodeURIComponent(fileName)}`;
 
-    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    // Stream large files instead of loading them entirely into memory
     const fileStream = fs.createReadStream(filePath);
-      let response;
+    const response = await fetch(uploadUrl, {
-      try {
-        response = await fetch(uploadUrl, {
       method: "POST",
       headers: {
         Accept: "application/json",
@@ -294,15 +294,6 @@ async function uploadReleaseAssets(baseApi, releaseId, authHeader, releaseDir, f
       body: fileStream,
       duplex: "half"
     });
-      } catch (error) {
-        fileStream.destroy();
-        if (attempt < MAX_ATTEMPTS) {
-          process.stdout.write(`Upload ${fileName} abgebrochen (Netzwerk, Versuch ${attempt}/${MAX_ATTEMPTS}), neuer Versuch...\n`);
-          await new Promise((resolve) => setTimeout(resolve, 3000 * attempt));
-          continue;
-        }
-        throw new Error(`Asset upload failed for ${fileName} after ${MAX_ATTEMPTS} attempts: ${String(error?.message || error)}`);
-      }
 
     const text = await response.text();
     let parsed;
@@ -314,21 +305,15 @@ async function uploadReleaseAssets(baseApi, releaseId, authHeader, releaseDir, f
 
     if (response.ok) {
       process.stdout.write(`Uploaded: ${fileName}\n`);
-        break;
+      continue;
     }
     if (response.status === 409 || response.status === 422) {
       process.stdout.write(`Skipped existing asset: ${fileName}\n`);
-        break;
-      }
-      if (response.status >= 500 && attempt < MAX_ATTEMPTS) {
-        process.stdout.write(`Upload ${fileName} fehlgeschlagen (${response.status}, Versuch ${attempt}/${MAX_ATTEMPTS}), neuer Versuch...\n`);
-        await new Promise((resolve) => setTimeout(resolve, 3000 * attempt));
       continue;
     }
     throw new Error(`Asset upload failed for ${fileName} (${response.status}): ${JSON.stringify(parsed)}`);
   }
 }
-}
 
 async function main() {
   const rootDir = process.cwd();
@@ -378,11 +363,6 @@ async function main() {
   const release = await createOrGetRelease(baseApi, tag, authHeader, releaseNotes);
   await uploadReleaseAssets(baseApi, release.id, authHeader, assets.releaseDir, assets.files);
 
-  const published = await apiRequest("PATCH", `${baseApi}/releases/${release.id}`, authHeader, JSON.stringify({ draft: false }));
-  if (!published.ok) {
-    throw new Error(`Failed to publish release (${published.status}): ${JSON.stringify(published.body)}`);
-  }
-
   process.stdout.write(`Release published: ${release.html_url || `${repo.baseUrl}/${repo.owner}/${repo.repo}/releases/tag/${tag}`}\n`);
 }
 

src/main/account-check.ts

@@ -1,197 +0,0 @@
-import type { AppSettings, DebridAccountStatus } from "../shared/types";
-import { parseMegaDebridAccounts, type MegaDebridAccountEntry } from "../shared/mega-debrid-accounts";
-import { parseDebridLinkApiKeys, type DebridLinkApiKeyEntry } from "../shared/debrid-link-keys";
-import { logger } from "./logger";
-import { compactErrorText } from "./utils";
-
-const MEGA_DEBRID_API = "https://www.mega-debrid.eu/api.php";
-const DEBRID_LINK_API = "https://debrid-link.com/api/v2";
-const CHECK_USER_AGENT =
-  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
-const CHECK_TIMEOUT_MS = 20000;
-
-function timeoutSignal(signal: AbortSignal | undefined, ms: number): AbortSignal {
-  const timeout = AbortSignal.timeout(ms);
-  return signal ? AbortSignal.any([signal, timeout]) : timeout;
-}
-
-function parseJsonSafe(text: string): Record<string, unknown> | null {
-  try {
-    const parsed = JSON.parse(text) as unknown;
-    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : null;
-  } catch {
-    return null;
-  }
-}
-
-function formatRemaining(premiumUntilMs: number | null, now: number): string {
-  if (premiumUntilMs == null) {
-    return "Premium-Status unbekannt";
-  }
-  if (premiumUntilMs <= 0) {
-    return "Kein Premium";
-  }
-  const remainingMs = premiumUntilMs - now;
-  if (remainingMs <= 0) {
-    return "Premium abgelaufen";
-  }
-  const days = Math.floor(remainingMs / (24 * 60 * 60 * 1000));
-  if (days >= 1) {
-    return `Premium noch ${days} Tag${days === 1 ? "" : "e"}`;
-  }
-  const hours = Math.max(1, Math.floor(remainingMs / (60 * 60 * 1000)));
-  return `Premium noch ${hours} Std`;
-}
-
-export async function checkMegaDebridAccount(
-  account: MegaDebridAccountEntry,
-  signal?: AbortSignal,
-  now = Date.now()
-): Promise<DebridAccountStatus> {
-  const base: DebridAccountStatus = {
-    accountId: account.id,
-    provider: "megadebrid",
-    label: account.label,
-    maskedLogin: account.maskedLogin,
-    valid: false,
-    isPremium: false,
-    premiumUntilMs: null,
-    message: "",
-    checkedAt: now
-  };
-  try {
-    const url = `${MEGA_DEBRID_API}?action=connectUser&login=${encodeURIComponent(account.login)}&password=${encodeURIComponent(account.password)}`;
-    const response = await fetch(url, {
-      headers: { "User-Agent": CHECK_USER_AGENT },
-      signal: timeoutSignal(signal, CHECK_TIMEOUT_MS)
-    });
-    const text = await response.text();
-    const payload = parseJsonSafe(text);
-    if (!response.ok || !payload) {
-      return { ...base, message: `Login fehlgeschlagen (HTTP ${response.status})` };
-    }
-    if (payload.response_code !== "ok") {
-      const reason = String(payload.response_text || payload.response_code || "Login abgelehnt");
-      return { ...base, message: `Ungueltiger Login: ${reason}` };
-    }
-    const vipEndRaw = Number(payload.vip_end || 0);
-    const premiumUntilMs = Number.isFinite(vipEndRaw) && vipEndRaw > 0 ? vipEndRaw * 1000 : 0;
-    const isPremium = premiumUntilMs > now;
-    const email = String(payload.email || "").trim() || undefined;
-    return {
-      ...base,
-      valid: true,
-      isPremium,
-      premiumUntilMs,
-      email,
-      message: formatRemaining(premiumUntilMs, now)
-    };
-  } catch (error) {
-    const errText = compactErrorText(error);
-    const aborted = signal?.aborted || /aborted/i.test(errText);
-    return {
-      ...base,
-      message: aborted ? "Pruefung abgebrochen" : `Pruefung fehlgeschlagen: ${errText}`
-    };
-  }
-}
-
-export async function checkDebridLinkKey(
-  key: DebridLinkApiKeyEntry,
-  signal?: AbortSignal,
-  now = Date.now()
-): Promise<DebridAccountStatus> {
-  const base: DebridAccountStatus = {
-    accountId: key.id,
-    provider: "debridlink",
-    label: key.label,
-    maskedLogin: key.masked,
-    valid: false,
-    isPremium: false,
-    premiumUntilMs: null,
-    message: "",
-    checkedAt: now
-  };
-  try {
-    const response = await fetch(`${DEBRID_LINK_API}/account/infos`, {
-      headers: {
-        Authorization: `Bearer ${key.token}`,
-        "User-Agent": CHECK_USER_AGENT
-      },
-      signal: timeoutSignal(signal, CHECK_TIMEOUT_MS)
-    });
-    const text = await response.text();
-    const payload = parseJsonSafe(text);
-    if (!response.ok || !payload) {
-      if (response.status === 401 || response.status === 403) {
-        return { ...base, message: "Ungueltiger API-Key (nicht autorisiert)" };
-      }
-      return { ...base, message: `Pruefung fehlgeschlagen (HTTP ${response.status})` };
-    }
-    if (payload.success === false) {
-      const reason = String(payload.error || "Key abgelehnt");
-      return { ...base, message: `Ungueltiger API-Key: ${reason}` };
-    }
-    const value = (payload.value && typeof payload.value === "object" ? payload.value : payload) as Record<string, unknown>;
-    const premiumLeftSec = Number(value.premiumLeft || 0);
-    const accountType = Number(value.accountType || 0);
-    const premiumUntilMs = Number.isFinite(premiumLeftSec) && premiumLeftSec > 0 ? now + premiumLeftSec * 1000 : 0;
-    const isPremium = premiumUntilMs > now || accountType > 0;
-    const username = String(value.username || "").trim() || undefined;
-    return {
-      ...base,
-      valid: true,
-      isPremium,
-      premiumUntilMs: premiumUntilMs > 0 ? premiumUntilMs : (accountType > 0 ? null : 0),
-      email: username,
-      message: premiumUntilMs > 0
-        ? formatRemaining(premiumUntilMs, now)
-        : (accountType > 0 ? "Premium aktiv" : "Kein Premium (Free)")
-    };
-  } catch (error) {
-    const errText = compactErrorText(error);
-    const aborted = signal?.aborted || /aborted/i.test(errText);
-    return {
-      ...base,
-      message: aborted ? "Pruefung abgebrochen" : `Pruefung fehlgeschlagen: ${errText}`
-    };
-  }
-}
-
-export async function checkAllDebridAccounts(
-  settings: AppSettings,
-  signal?: AbortSignal
-): Promise<DebridAccountStatus[]> {
-  const now = Date.now();
-  const megaAccounts = parseMegaDebridAccounts(settings.megaCredentials || "", settings.megaPassword || "");
-  const debridLinkKeys = parseDebridLinkApiKeys(settings.debridLinkApiKeys || "");
-
-  const taskFns: Array<() => Promise<DebridAccountStatus>> = [
-    ...megaAccounts.map((account) => () => checkMegaDebridAccount(account, signal, now)),
-    ...debridLinkKeys.map((key) => () => checkDebridLinkKey(key, signal, now))
-  ];
-
-  const results = await runWithConcurrency(taskFns, CHECK_CONCURRENCY);
-  logger.info(
-    `Account-Check abgeschlossen: ${results.length} Accounts geprueft ` +
-    `(${results.filter((r) => r.valid).length} gueltig, ${results.filter((r) => r.isPremium).length} premium)`
-  );
-  return results;
-}
-
-const CHECK_CONCURRENCY = 4;
-
-async function runWithConcurrency<T>(taskFns: Array<() => Promise<T>>, limit: number): Promise<T[]> {
-  const results: T[] = new Array(taskFns.length);
-  let nextIndex = 0;
-  const worker = async (): Promise<void> => {
-    while (nextIndex < taskFns.length) {
-      const current = nextIndex;
-      nextIndex += 1;
-      results[current] = await taskFns[current]();
-    }
-  };
-  const workers = Array.from({ length: Math.min(limit, taskFns.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
-}

src/main/account-rotation-log.ts

@@ -1,204 +0,0 @@
-import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
-import path from "node:path";
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { RotationEvent } from "../shared/types";
-
-export type RotationItemSink = (event: RotationEvent) => void;
-const rotationItemContext = new AsyncLocalStorage<RotationItemSink>();
-
-export function runWithRotationItemSink<T>(sink: RotationItemSink, fn: () => Promise<T>): Promise<T> {
-  return rotationItemContext.run(sink, fn);
-}
-
-type RotationLevel = "INFO" | "WARN" | "ERROR";
-
-const ROTATION_EVENT_RING_MAX = 60;
-const rotationEventRing: RotationEvent[] = [];
-let rotationEventSeq = 0;
-let rotationEventListener: ((event: RotationEvent) => void) | null = null;
-
-export function setRotationEventListener(listener: ((event: RotationEvent) => void) | null): void {
-  rotationEventListener = listener;
-}
-
-export function getRecentRotationEvents(limit = ROTATION_EVENT_RING_MAX): RotationEvent[] {
-  const slice = rotationEventRing.slice(-limit);
-  slice.reverse();
-  return slice;
-}
-
-function isUiRelevantRotationEvent(event: string): boolean {
-  return event !== "TEST";
-}
-
-function pushRotationEvent(
-  level: RotationLevel,
-  provider: string,
-  accountLabel: string,
-  event: string,
-  fields?: Record<string, unknown>,
-  at = Date.now()
-): void {
-  rotationEventSeq += 1;
-  const entry: RotationEvent = {
-    id: `rot_${at}_${rotationEventSeq}`,
-    at,
-    level,
-    provider,
-    accountLabel,
-    event,
-    reason: fields && fields.reason != null ? String(fields.reason) : undefined,
-    category: fields && fields.category != null ? String(fields.category) : undefined,
-    cooldownSec: fields && fields.cooldownSec != null ? Number(fields.cooldownSec) || 0 : undefined,
-    next: fields && fields.next != null ? String(fields.next) : undefined
-  };
-
-  const itemSink = rotationItemContext.getStore();
-  if (itemSink) {
-    try {
-      itemSink(entry);
-    } catch {
-    }
-  }
-
-  if (!isUiRelevantRotationEvent(event)) {
-    return;
-  }
-  rotationEventRing.push(entry);
-  if (rotationEventRing.length > ROTATION_EVENT_RING_MAX) {
-    rotationEventRing.splice(0, rotationEventRing.length - ROTATION_EVENT_RING_MAX);
-  }
-  if (rotationEventListener) {
-    try {
-      rotationEventListener(entry);
-    } catch {
-    }
-  }
-}
-
-const ROTATION_LOG_MAX_FILE_BYTES = Number(process.env.RD_ACCOUNT_ROTATION_LOG_MAX_BYTES || 5 * 1024 * 1024);
-const ROTATION_LOG_RETENTION_DAYS = Number(process.env.RD_ACCOUNT_ROTATION_LOG_RETENTION_DAYS || 14);
-
-let rotationLogPath: string | null = null;
-
-function sanitizeFieldValue(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value.replace(/\r?\n/g, "\\n");
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value).replace(/\r?\n/g, "\\n");
-  } catch {
-    return String(value);
-  }
-}
-
-function formatFields(fields?: Record<string, unknown>): string {
-  if (!fields) {
-    return "";
-  }
-  const parts = Object.entries(fields)
-    .filter(([, value]) => value !== undefined && value !== null && sanitizeFieldValue(value) !== "")
-    .map(([key, value]) => `${key}=${sanitizeFieldValue(value)}`);
-  return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
-}
-
-function rotateIfNeeded(filePath: string): void {
-  try {
-    const stat = fs.statSync(filePath);
-    if (stat.size < ROTATION_LOG_MAX_FILE_BYTES) {
-      return;
-    }
-    const backup = `${filePath}.old`;
-    try {
-      fs.rmSync(backup, { force: true });
-    } catch {
-    }
-    fs.renameSync(filePath, backup);
-  } catch {
-  }
-}
-
-function cleanupOldBackup(filePath: string): void {
-  const backup = `${filePath}.old`;
-  try {
-    const stat = fs.statSync(backup);
-    const cutoff = Date.now() - ROTATION_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    if (stat.mtimeMs < cutoff) {
-      fs.rmSync(backup, { force: true });
-    }
-  } catch {
-  }
-}
-
-export function initAccountRotationLog(baseDir: string): void {
-  rotationLogPath = path.join(baseDir, "account-rotation.log");
-  try {
-    fs.mkdirSync(path.dirname(rotationLogPath), { recursive: true });
-    cleanupOldBackup(rotationLogPath);
-    if (!fs.existsSync(rotationLogPath)) {
-      fs.writeFileSync(rotationLogPath, "", "utf8");
-    }
-    rotateIfNeeded(rotationLogPath);
-    if (!fs.existsSync(rotationLogPath)) {
-      fs.writeFileSync(rotationLogPath, "", "utf8");
-    }
-    fs.appendFileSync(
-      rotationLogPath,
-      `=== Account-Rotation Log Start: ${logTimestamp()} ===\n`,
-      "utf8"
-    );
-  } catch {
-    rotationLogPath = null;
-  }
-}
-
-export function logAccountRotation(
-  level: RotationLevel,
-  provider: string,
-  accountLabel: string,
-  event: string,
-  fields?: Record<string, unknown>
-): void {
-  pushRotationEvent(level, provider, accountLabel, event, fields);
-  if (!rotationLogPath) {
-    return;
-  }
-  try {
-    rotateIfNeeded(rotationLogPath);
-    if (!fs.existsSync(rotationLogPath)) {
-      fs.writeFileSync(rotationLogPath, "", "utf8");
-    }
-    const head = `${logTimestamp()} [${level}] ${provider} | ${accountLabel} | ${event}`;
-    fs.appendFileSync(rotationLogPath, `${head}${formatFields(fields)}\n`, "utf8");
-  } catch {
-  }
-}
-
-export function getAccountRotationLogPath(): string | null {
-  if (!rotationLogPath) {
-    return null;
-  }
-  return fs.existsSync(rotationLogPath) ? rotationLogPath : null;
-}
-
-export function shutdownAccountRotationLog(): void {
-  if (!rotationLogPath) {
-    return;
-  }
-  try {
-    fs.appendFileSync(
-      rotationLogPath,
-      `=== Account-Rotation Log Ende: ${logTimestamp()} ===\n`,
-      "utf8"
-    );
-  } catch {
-  }
-  rotationLogPath = null;
-}

src/main/all-debrid-web.ts

@@ -243,10 +243,12 @@ export class AllDebridWebFallback {
           storages: ["cookies", "indexdb", "localstorage", "serviceworkers", "cachestorage"]
         });
       } catch {
+        // ignore
       }
       try {
         await currentSession.clearCache();
       } catch {
+        // ignore
       }
     }
   }

src/main/app-controller.ts

@@ -1,12 +1,10 @@
 import path from "node:path";
-import v8 from "node:v8";
 import { app } from "electron";
 import { getDebridLinkApiKeyIds } from "../shared/debrid-link-keys";
 import {
   AddLinksPayload,
   AllDebridHostInfo,
   AppSettings,
-  DebridAccountStatus,
   DebridProvider,
   DuplicatePolicy,
   HistoryEntry,
@@ -25,33 +23,18 @@ import { importDlcContainers } from "./container";
 import { APP_VERSION } from "./constants";
 import { DownloadManager } from "./download-manager";
 import { fetchAllDebridHostInfo, fetchDebridLinkHostLimits } from "./debrid";
-import { checkAllDebridAccounts, checkMegaDebridAccount } from "./account-check";
-import { parseMegaDebridAccounts } from "../shared/mega-debrid-accounts";
 import { parseCollectorInput } from "./link-parser";
 import { configureLogger, getLogFilePath, logger } from "./logger";
 import { AllDebridWebFallback } from "./all-debrid-web";
 import { BestDebridWebFallback } from "./bestdebrid-web";
 import { RealDebridWebFallback } from "./realdebrid-web";
-import { getItemLogPath, initItemLogs, shutdownItemLogs } from "./item-log";
 import { getPackageLogPath, initPackageLogs, shutdownPackageLogs } from "./package-log";
 import { initSessionLog, getSessionLogPath, shutdownSessionLog } from "./session-log";
 import { MegaWebFallback } from "./mega-web-fallback";
-import { addHistoryEntry, addHistoryEntryForRetention, cancelPendingAsyncSaves, clearHistory, createStoragePaths, loadHistoryForRetention, loadSession, loadSettings, normalizeHistoryEntry, normalizeLoadedSession, normalizeLoadedSessionTransientFields, normalizeSettings, removeHistoryEntry, resetHistoryForRetention, saveHistory, saveSession, saveSettings } from "./storage";
+import { addHistoryEntry, cancelPendingAsyncSaves, clearHistory, createStoragePaths, loadHistory, loadSession, loadSettings, normalizeHistoryEntry, normalizeLoadedSession, normalizeLoadedSessionTransientFields, normalizeSettings, removeHistoryEntry, saveHistory, saveSession, saveSettings } from "./storage";
 import { abortActiveUpdateDownload, checkGitHubUpdate, installLatestUpdate } from "./update";
-import { rotateDebugToken, startDebugServer, stopDebugServer } from "./debug-server";
+import { startDebugServer, stopDebugServer } from "./debug-server";
 import { encryptBackup, decryptBackup } from "./backup-crypto";
-import { buildBackupPayload, planBackupImport } from "./backup-payload";
-import { getAuditLogPath, initAuditLog, logAuditEvent, shutdownAuditLog } from "./audit-log";
-import { initAccountRotationLog, shutdownAccountRotationLog } from "./account-rotation-log";
-import { runStartupHealthCheck } from "./startup-health-check";
-import { getDebugSetupCheck } from "./debug-setup";
-import { buildLinkExportSelection, serializeLinkExportText } from "./link-export";
-import { getRenameLogPath, initRenameLog, shutdownRenameLog } from "./rename-log";
-import { getDesktopRenameLogPath, initDesktopRenameLog, shutdownDesktopRenameLog } from "./desktop-rename-log";
-import { buildAccountSummary, diffAccountSummary } from "./support-data";
-import { buildSupportBundle, getSupportBundleDefaultFileName } from "./support-bundle";
-import { getTraceConfig, getTraceLogPath, initTraceLog, logTraceEvent, setTraceEnabled, shutdownTraceLog } from "./trace-log";
-import type { DebugSetupCheckResult, SupportTraceConfig } from "../shared/types";
 
 function sanitizeSettingsPatch(partial: Partial<AppSettings>): Partial<AppSettings> {
   const entries = Object.entries(partial || {}).filter(([, value]) => value !== undefined);
@@ -84,27 +67,12 @@ export class AppController {
   private onStateHandler: ((snapshot: UiSnapshot) => void) | null = null;
 
   private autoResumePending = false;
-  private runtimeStatsTimer: NodeJS.Timeout | null = null;
-  private lastMemoryWarnAt = 0;
 
   public constructor() {
     configureLogger(this.storagePaths.baseDir);
     initSessionLog(this.storagePaths.baseDir);
     initPackageLogs(this.storagePaths.baseDir);
-    initItemLogs(this.storagePaths.baseDir);
-    initAuditLog(this.storagePaths.baseDir);
-    initAccountRotationLog(this.storagePaths.baseDir);
-    initRenameLog(this.storagePaths.baseDir);
-    let desktopDir: string | null = null;
-    try {
-      desktopDir = app.getPath("desktop");
-    } catch {
-      desktopDir = null;
-    }
-    initDesktopRenameLog(desktopDir);
-    initTraceLog(this.storagePaths.baseDir);
     this.settings = loadSettings(this.storagePaths);
-    resetHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode);
     const session = loadSession(this.storagePaths);
     this.megaWebFallback = new MegaWebFallback(() => ({
       login: this.settings.megaLogin,
@@ -114,13 +82,13 @@ export class AppController {
     this.allDebridWebFallback = new AllDebridWebFallback(() => this.settings.rememberToken);
     this.bestDebridWebFallback = new BestDebridWebFallback(() => this.settings.rememberToken);
     this.manager = new DownloadManager(this.settings, session, this.storagePaths, {
-      megaWebUnrestrict: (link: string, signal?: AbortSignal, account?: { login: string; password: string }) => this.megaWebFallback.unrestrict(link, signal, account),
+      megaWebUnrestrict: (link: string, signal?: AbortSignal) => this.megaWebFallback.unrestrict(link, signal),
       allDebridWebUnrestrict: (link: string, signal?: AbortSignal) => this.allDebridWebFallback.unrestrict(link, signal),
       realDebridWebUnrestrict: (link: string, signal?: AbortSignal) => this.realDebridWebFallback.unrestrict(link, signal),
       bestDebridWebUnrestrict: (link: string, signal?: AbortSignal) => this.bestDebridWebFallback.unrestrict(link, signal),
       invalidateMegaSession: () => this.megaWebFallback.invalidateSession(),
       onHistoryEntry: (entry: HistoryEntry) => {
-        addHistoryEntryForRetention(this.storagePaths, this.settings.historyRetentionMode, entry);
+        addHistoryEntry(this.storagePaths, entry);
       }
     });
     this.manager.on("state", (snapshot: UiSnapshot) => {
@@ -128,45 +96,7 @@ export class AppController {
     });
     logger.info(`App gestartet v${APP_VERSION}`);
     logger.info(`Log-Datei: ${getLogFilePath()}`);
-    logAuditEvent("INFO", "App gestartet", {
-      appVersion: APP_VERSION,
-      runtimeDir: this.storagePaths.baseDir
-    });
-    try {
-      const report = runStartupHealthCheck(this.settings, this.storagePaths);
-      if (report.errorCount > 0 || report.warnCount > 0) {
-        logger.warn(`Health-Check: ${report.errorCount} Fehler, ${report.warnCount} Warnungen, ${report.infoCount} Info`);
-      } else {
-        logger.info(`Health-Check: alles OK (${report.infoCount} Info)`);
-      }
-      for (const finding of report.findings) {
-        const line = finding.hint
-          ? `Health-Check [${finding.code}]: ${finding.message} — ${finding.hint}`
-          : `Health-Check [${finding.code}]: ${finding.message}`;
-        if (finding.severity === "ERROR") {
-          logger.error(line);
-        } else if (finding.severity === "WARN") {
-          logger.warn(line);
-        } else {
-          logger.info(line);
-        }
-        if (finding.severity !== "INFO") {
-          logAuditEvent(finding.severity, `Health-Check: ${finding.code}`, {
-            message: finding.message,
-            hint: finding.hint || ""
-          });
-        }
-      }
-    } catch (err) {
-      logger.warn(`Health-Check uebersprungen (Fehler): ${String((err as Error).message || err)}`);
-    }
     startDebugServer(this.manager, this.storagePaths.baseDir);
-    this.runtimeStatsTimer = setInterval(() => {
-      this.manager.persistRuntimeStats();
-      this.settings = this.manager.getSettings();
-      this.checkMemoryPressure();
-    }, 60_000);
-    this.runtimeStatsTimer.unref?.();
 
     if (this.settings.autoResumeOnStart) {
       const snapshot = this.manager.getSnapshot();
@@ -175,6 +105,8 @@ export class AppController {
         void this.manager.getStartConflicts().then((conflicts) => {
           const hasConflicts = conflicts.length > 0;
           if (this.hasAnyProviderToken(this.settings) && !hasConflicts) {
+            // If the onState handler is already set (renderer connected), start immediately.
+            // Otherwise mark as pending so the onState setter triggers the start.
             if (this.onStateHandler) {
               logger.info("Auto-Resume beim Start aktiviert (nach Konflikt-Check)");
               void this.manager.start().catch((err) => logger.warn(`Auto-Resume Start Fehler: ${String(err)}`));
@@ -190,34 +122,6 @@ export class AppController {
     }
   }
 
-  // Early-warning for OOM on a long-running process. Measured against the V8
-  // heap_size_limit (the real ceiling at which the process is killed), NOT against
-  // heapTotal: V8 routinely runs near-full of its current heapTotal just before it
-  // grows it, so a heapUsed/heapTotal ratio would cry wolf and — since every WARN
-  // now feeds the error ring — crowd real failures out. Throttled to 1 warning per
-  // 5 min so a genuine sustained-pressure run does not spam the log/ring.
-  private checkMemoryPressure(): void {
-    try {
-      const mem = process.memoryUsage();
-      const heapLimit = v8.getHeapStatistics().heap_size_limit;
-      const ratio = heapLimit > 0 ? mem.heapUsed / heapLimit : 0;
-      if (ratio < 0.9) {
-        return;
-      }
-      const now = Date.now();
-      if (now - this.lastMemoryWarnAt < 5 * 60_000) {
-        return;
-      }
-      this.lastMemoryWarnAt = now;
-      const mb = (bytes: number): number => Math.round(bytes / 1048576);
-      logger.warn(
-        `Speicherdruck: heapUsed=${mb(mem.heapUsed)}MB von Limit ${mb(heapLimit)}MB ` +
-        `(${Math.round(ratio * 100)}%), heapTotal=${mb(mem.heapTotal)}MB, rss=${mb(mem.rss)}MB, external=${mb(mem.external)}MB`
-      );
-    } catch {
-    }
-  }
-
   private hasAnyProviderToken(settings: AppSettings): boolean {
     return Boolean(
       settings.token.trim()
@@ -245,6 +149,7 @@ export class AppController {
         void this.manager.start().catch((err) => logger.warn(`Auto-Resume Start Fehler: ${String(err)}`));
         logger.info("Auto-Resume beim Start aktiviert");
       } else {
+        // Trigger pending extractions without starting the session
         this.manager.triggerIdleExtractions();
       }
     }
@@ -262,68 +167,6 @@ export class AppController {
     return this.settings;
   }
 
-  public getAuditLogPath(): string | null {
-    return getAuditLogPath();
-  }
-
-  public getRenameLogPath(): string | null {
-    return getRenameLogPath();
-  }
-
-  public getDesktopRenameLogPath(): string | null {
-    return getDesktopRenameLogPath();
-  }
-
-  public getTraceLogPath(): string | null {
-    return getTraceLogPath();
-  }
-
-  public getTraceConfig(): SupportTraceConfig {
-    return getTraceConfig();
-  }
-
-  public rotateDebugToken(): { path: string; token: string } {
-    const rotated = rotateDebugToken(this.storagePaths.baseDir);
-    this.audit("WARN", "Debug-Token rotiert", { path: rotated.path });
-    return rotated;
-  }
-
-  public getDebugSetupCheck(): DebugSetupCheckResult {
-    return getDebugSetupCheck(this.storagePaths.baseDir);
-  }
-
-  private audit(level: "INFO" | "WARN" | "ERROR", message: string, fields?: Record<string, unknown>): void {
-    logAuditEvent(level, message, fields);
-    logTraceEvent(level, "audit", message, fields);
-  }
-
-  public setTraceEnabled(enabled: boolean, note = "", durationMs?: number): SupportTraceConfig {
-    const next = setTraceEnabled(enabled, note, durationMs);
-    this.audit("INFO", enabled ? "Support-Trace aktiviert" : "Support-Trace deaktiviert", { note });
-    return next;
-  }
-
-  // Carry the live, runtime-maintained usage/status counters onto a settings
-  // object about to be applied, so they are never rolled back to a stale snapshot.
-  // All-time totals take the max; daily/total usage and account statuses are taken
-  // live; per-key Debrid-Link usage is filtered to keys that still exist.
-  private overlayLiveUsageCounters(target: AppSettings): void {
-    const liveSettings = this.manager.getSettings();
-    target.totalDownloadedAllTime = Math.max(target.totalDownloadedAllTime || 0, liveSettings.totalDownloadedAllTime || 0);
-    target.totalCompletedFilesAllTime = Math.max(target.totalCompletedFilesAllTime || 0, liveSettings.totalCompletedFilesAllTime || 0);
-    target.totalRuntimeAllTimeMs = Math.max(target.totalRuntimeAllTimeMs || 0, this.manager.getLiveTotalRuntimeMs());
-    target.providerDailyUsageDay = liveSettings.providerDailyUsageDay;
-    target.providerDailyUsageBytes = { ...(liveSettings.providerDailyUsageBytes || {}) };
-    target.providerTotalUsageBytes = { ...(liveSettings.providerTotalUsageBytes || {}) };
-    target.debridLinkApiKeyDailyUsageBytes = Object.fromEntries(
-      Object.entries(liveSettings.debridLinkApiKeyDailyUsageBytes || {}).filter(([keyId]) => getDebridLinkApiKeyIds(target.debridLinkApiKeys).includes(keyId))
-    );
-    target.debridLinkApiKeyTotalUsageBytes = Object.fromEntries(
-      Object.entries(liveSettings.debridLinkApiKeyTotalUsageBytes || {}).filter(([keyId]) => getDebridLinkApiKeyIds(target.debridLinkApiKeys).includes(keyId))
-    );
-    target.debridAccountStatuses = { ...(liveSettings.debridAccountStatuses || {}) };
-  }
-
   public updateSettings(partial: Partial<AppSettings>): AppSettings {
     const sanitizedPatch = sanitizeSettingsPatch(partial);
     const previousSettings = this.settings;
@@ -336,18 +179,22 @@ export class AppController {
       return previousSettings;
     }
 
-    this.overlayLiveUsageCounters(nextSettings);
+    // Preserve the live all-time counters from the download manager
-    const retentionChanged = previousSettings.historyRetentionMode !== nextSettings.historyRetentionMode;
+    const liveSettings = this.manager.getSettings();
+    nextSettings.totalDownloadedAllTime = Math.max(nextSettings.totalDownloadedAllTime || 0, liveSettings.totalDownloadedAllTime || 0);
+    nextSettings.totalCompletedFilesAllTime = Math.max(nextSettings.totalCompletedFilesAllTime || 0, liveSettings.totalCompletedFilesAllTime || 0);
+    nextSettings.providerDailyUsageDay = liveSettings.providerDailyUsageDay;
+    nextSettings.providerDailyUsageBytes = { ...(liveSettings.providerDailyUsageBytes || {}) };
+    nextSettings.providerTotalUsageBytes = { ...(liveSettings.providerTotalUsageBytes || {}) };
+    nextSettings.debridLinkApiKeyDailyUsageBytes = Object.fromEntries(
+      Object.entries(liveSettings.debridLinkApiKeyDailyUsageBytes || {}).filter(([keyId]) => getDebridLinkApiKeyIds(nextSettings.debridLinkApiKeys).includes(keyId))
+    );
+    nextSettings.debridLinkApiKeyTotalUsageBytes = Object.fromEntries(
+      Object.entries(liveSettings.debridLinkApiKeyTotalUsageBytes || {}).filter(([keyId]) => getDebridLinkApiKeyIds(nextSettings.debridLinkApiKeys).includes(keyId))
+    );
     this.settings = nextSettings;
-    if (retentionChanged) {
-      resetHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode);
-    }
     saveSettings(this.storagePaths, this.settings);
     this.manager.setSettings(this.settings);
-    this.audit("INFO", "Einstellungen aktualisiert", {
-      changedKeys: Object.keys(sanitizedPatch),
-      accountChanges: diffAccountSummary(previousSettings, this.settings)
-    });
     if (previousSettings.rememberToken && !this.settings.rememberToken) {
       void this.realDebridWebFallback.clearSessions().catch((error) => {
         logger.warn(`Real-Debrid Web-Session konnte nicht gelöscht werden: ${String(error)}`);
@@ -371,7 +218,6 @@ export class AppController {
     this.settings = nextSettings;
     saveSettings(this.storagePaths, this.settings);
     this.manager.setSettings(this.settings);
-    this.audit("INFO", "Provider-Tagesnutzung zurückgesetzt", { provider });
     return this.settings;
   }
 
@@ -384,27 +230,19 @@ export class AppController {
     this.settings = nextSettings;
     saveSettings(this.storagePaths, this.settings);
     this.manager.setSettings(this.settings);
-    this.audit("INFO", "Debrid-Link-Key-Tagesnutzung zurückgesetzt", { keyId });
     return this.settings;
   }
 
   public async openRealDebridLoginWindow(): Promise<void> {
-    this.audit("INFO", "Real-Debrid Login-Fenster geöffnet");
     await this.realDebridWebFallback.openLoginWindow();
   }
 
   public async openAllDebridLoginWindow(): Promise<void> {
-    this.audit("INFO", "AllDebrid Login-Fenster geöffnet");
     await this.allDebridWebFallback.openLoginWindow();
   }
 
   public async importBestDebridCookies(filePath: string): Promise<number> {
-    const imported = await this.bestDebridWebFallback.importCookiesFromFile(filePath);
+    return this.bestDebridWebFallback.importCookiesFromFile(filePath);
-    this.audit("INFO", "BestDebrid Cookies importiert", {
-      filePath,
-      imported
-    });
-    return imported;
   }
 
   public async getAllDebridHostInfo(host = "rapidgator"): Promise<AllDebridHostInfo> {
@@ -422,27 +260,6 @@ export class AppController {
     return fetchDebridLinkHostLimits(this.settings.debridLinkApiKeys, host);
   }
 
-public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
-    const statuses = await checkAllDebridAccounts(this.settings);
-    this.manager.applyDebridAccountStatuses(statuses);
-    this.audit("INFO", "Debrid-Accounts geprueft", {
-      total: statuses.length,
-      valid: statuses.filter((s) => s.valid).length,
-      premium: statuses.filter((s) => s.isPremium).length
-    });
-    return statuses;
-  }
-
-  public async checkSingleMegaDebridAccount(login: string, password: string): Promise<DebridAccountStatus | null> {
-    const entry = parseMegaDebridAccounts(`${login.trim()}:${password.trim()}`)[0];
-    if (!entry) {
-      return null;
-    }
-    const status = await checkMegaDebridAccount(entry);
-    this.manager.applyDebridAccountStatuses([status]);
-    this.audit("INFO", "Mega-Debrid-Account einzeln geprueft", { valid: status.valid, premium: status.isPremium });
-    return status;
-  }
   public async checkUpdates(): Promise<UpdateCheckResult> {
     const result = await checkGitHubUpdate(this.settings.updateRepo);
     if (!result.error) {
@@ -453,10 +270,11 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
   }
 
   public async installUpdate(onProgress?: (progress: UpdateInstallProgress) => void): Promise<UpdateInstallResult> {
+    // Stop active downloads before installing. Extractions may continue briefly
+    // until prepareForShutdown() is called during app quit.
     if (this.manager.isSessionRunning()) {
-      this.manager.stop({ parkForRestart: true });
+      this.manager.stop();
     }
-    this.manager.persistNowSync();
 
     const cacheAgeMs = Date.now() - this.lastUpdateCheckAt;
     const cached = this.lastUpdateCheck && !this.lastUpdateCheck.error && cacheAgeMs <= 10 * 60 * 1000
@@ -473,17 +291,9 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
   public addLinks(payload: AddLinksPayload): { addedPackages: number; addedLinks: number; invalidCount: number } {
     const parsed = parseCollectorInput(payload.rawText, payload.packageName || this.settings.packageName);
     if (parsed.length === 0) {
-      this.audit("WARN", "Links hinzufügen ohne gültigen Inhalt", {
-        hasPackageName: Boolean(payload.packageName)
-      });
       return { addedPackages: 0, addedLinks: 0, invalidCount: 1 };
     }
     const result = this.manager.addPackages(parsed);
-    this.audit("INFO", "Links hinzugefügt", {
-      addedPackages: result.addedPackages,
-      addedLinks: result.addedLinks,
-      requestedPackages: parsed.length
-    });
     return { ...result, invalidCount: 0 };
   }
 
@@ -495,11 +305,6 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
       ...(pkg.fileNames ? { fileNames: pkg.fileNames } : {})
     }));
     const result = this.manager.addPackages(merged);
-    this.audit("INFO", "Container importiert", {
-      files: filePaths.length,
-      addedPackages: result.addedPackages,
-      addedLinks: result.addedLinks
-    });
     return result;
   }
 
@@ -512,114 +317,67 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
   }
 
   public clearAll(): void {
-    this.audit("WARN", "Queue komplett geleert");
     this.manager.clearAll();
   }
 
   public async start(): Promise<void> {
-    this.audit("INFO", "Session-Start ausgelöst");
     await this.manager.start();
   }
 
   public async startPackages(packageIds: string[]): Promise<void> {
-    this.audit("INFO", "Paket-Start ausgelöst", { packageIds });
     await this.manager.startPackages(packageIds);
   }
 
   public async startItems(itemIds: string[]): Promise<void> {
-    this.audit("INFO", "Item-Start ausgelöst", { itemIds });
     await this.manager.startItems(itemIds);
   }
 
   public stop(): void {
-    this.audit("INFO", "Session-Stopp ausgelöst");
     this.manager.stop();
   }
 
   public togglePause(): boolean {
-    const paused = this.manager.togglePause();
+    return this.manager.togglePause();
-    this.audit("INFO", "Pause umgeschaltet", { paused });
-    return paused;
   }
 
   public retryExtraction(packageId: string): void {
-    this.audit("INFO", "Extraktion manuell wiederholt", { packageId });
     this.manager.retryExtraction(packageId);
   }
 
   public extractNow(packageId: string): void {
-    this.audit("INFO", "Jetzt entpacken ausgelöst", { packageId });
     this.manager.extractNow(packageId);
   }
 
   public resetPackage(packageId: string): void {
-    this.audit("INFO", "Paket zurückgesetzt", { packageId });
     this.manager.resetPackage(packageId);
   }
 
   public cancelPackage(packageId: string): void {
-    this.audit("WARN", "Paket abgebrochen", { packageId });
     this.manager.cancelPackage(packageId);
   }
 
   public renamePackage(packageId: string, newName: string): void {
-    this.audit("INFO", "Paket umbenannt", { packageId, newName });
     this.manager.renamePackage(packageId, newName);
   }
 
   public reorderPackages(packageIds: string[]): void {
-    this.audit("INFO", "Paketreihenfolge geändert", { packageIds });
     this.manager.reorderPackages(packageIds);
   }
 
   public removeItem(itemId: string): void {
-    this.audit("WARN", "Item entfernt", { itemId });
     this.manager.removeItem(itemId);
   }
 
   public togglePackage(packageId: string): void {
-    this.audit("INFO", "Paket aktiviert/deaktiviert", { packageId });
     this.manager.togglePackage(packageId);
   }
 
-  public exportPackageSelection(packageIds: string[]): { text: string; defaultFileName: string; packageCount: number; linkCount: number } {
-    const selection = buildLinkExportSelection(this.manager.getSnapshot(), packageIds, []);
-    this.audit("INFO", "Paket-Auswahl exportiert", {
-      packageCount: selection.packageCount,
-      linkCount: selection.linkCount,
-      packageIds
-    });
-    return {
-      text: serializeLinkExportText(selection.packages),
-      defaultFileName: selection.defaultFileName,
-      packageCount: selection.packageCount,
-      linkCount: selection.linkCount
-    };
-  }
-
-  public exportItemSelection(itemIds: string[]): { text: string; defaultFileName: string; packageCount: number; linkCount: number } {
-    const selection = buildLinkExportSelection(this.manager.getSnapshot(), [], itemIds);
-    this.audit("INFO", "Item-Auswahl exportiert", {
-      packageCount: selection.packageCount,
-      linkCount: selection.linkCount,
-      itemIds
-    });
-    return {
-      text: serializeLinkExportText(selection.packages),
-      defaultFileName: selection.defaultFileName,
-      packageCount: selection.packageCount,
-      linkCount: selection.linkCount
-    };
-  }
-
   public exportQueue(): string {
     return this.manager.exportQueue();
   }
 
   public importQueue(json: string): { addedPackages: number; addedLinks: number } {
-    const result = this.manager.importQueue(json);
+    return this.manager.importQueue(json);
-    this.audit("INFO", "Import-Datei verarbeitet", result);
-    return result;
   }
 
   public getSessionStats(): SessionStats {
@@ -627,120 +385,80 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
   }
 
   public resetSessionStats(): void {
-    this.audit("INFO", "Session-Statistik zurückgesetzt");
     this.manager.resetSessionStats();
   }
 
   public resetDownloadStats(): void {
     this.manager.resetDownloadStats();
     this.settings = this.manager.getSettings();
-    this.audit("INFO", "Download-Statistik zurückgesetzt");
   }
 
   public exportBackup(): Buffer {
-    const includeDownloads = Boolean(this.settings.backupIncludeDownloads);
+    const settings = { ...this.settings };
-    const payloadObj = buildBackupPayload({
+    const session = this.manager.getSession();
-      settings: { ...this.settings },
+    const history = loadHistory(this.storagePaths);
+    const payload = JSON.stringify({
+      version: 2,
       appVersion: APP_VERSION,
       exportedAt: new Date().toISOString(),
-      session: this.manager.getSession(),
+      settings,
-      history: loadHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode)
+      session,
+      history
     });
-    this.audit("INFO", "Backup exportiert", {
+    return encryptBackup(payload);
-      kind: payloadObj.kind,
-      historyEntries: payloadObj.history ? payloadObj.history.length : 0,
-      sessionItems: payloadObj.session ? Object.keys(payloadObj.session.items).length : 0,
-      sessionPackages: payloadObj.session ? Object.keys(payloadObj.session.packages).length : 0
-    });
-    return encryptBackup(JSON.stringify(payloadObj));
   }
 
-  public exportSupportBundle(): { buffer: Buffer; defaultFileName: string } {
+  public importBackup(data: Buffer): { restored: boolean; message: string } {
-    this.audit("INFO", "Support-Bundle exportiert");
-    logTraceEvent("INFO", "support", "Support-Bundle erstellt", {
-      packageCount: Object.keys(this.manager.getSnapshot().session.packages).length,
-      itemCount: Object.keys(this.manager.getSnapshot().session.items).length
-    });
-    return {
-      buffer: buildSupportBundle(this.manager, this.storagePaths.baseDir, { hostDiagnosticsMode: "cached" }),
-      defaultFileName: getSupportBundleDefaultFileName()
-    };
-  }
-
-  public getSupportBundleDefaultFileName(): string {
-    return getSupportBundleDefaultFileName();
-  }
-
-  public importBackup(data: Buffer): { restored: boolean; relaunch: boolean; message: string } {
     let parsed: Record<string, unknown>;
     try {
+      // Try encrypted MDD format first
       const json = decryptBackup(data);
       parsed = JSON.parse(json) as Record<string, unknown>;
     } catch {
+      // Fallback: try legacy plaintext JSON (old backups)
       try {
         const json = data.toString("utf8");
         parsed = JSON.parse(json) as Record<string, unknown>;
       } catch {
-        return { restored: false, relaunch: false, message: "Backup-Datei konnte nicht entschlüsselt werden" };
+        return { restored: false, message: "Backup-Datei konnte nicht entschlüsselt werden" };
       }
     }
-    const plan = planBackupImport(parsed);
+    if (!parsed || typeof parsed !== "object" || !parsed.settings || !parsed.session) {
-    if (!plan.valid) {
+      return { restored: false, message: "Kein gültiges Backup (settings/session fehlen)" };
-      return { restored: false, relaunch: false, message: plan.message };
     }
-    const hasSession = plan.restoreDownloads;
 
+    // Restore settings — ALL credentials are included (no more masking)
     const importedSettings = parsed.settings as AppSettings;
-    const importedSettingsRecord = importedSettings as unknown as Record<string, unknown>;
+    // Legacy backup compatibility: if credentials were masked with ***, keep current values
-    const currentSettingsRecord = this.settings as unknown as Record<string, unknown>;
     const SENSITIVE_KEYS: (keyof AppSettings)[] = [
       "token", "megaLogin", "megaPassword", "bestToken", "allDebridToken",
       "ddownloadLogin", "ddownloadPassword", "oneFichierApiKey",
       "debridLinkApiKeys", "linkSnappyLogin", "linkSnappyPassword"
     ];
     for (const key of SENSITIVE_KEYS) {
-      const val = importedSettingsRecord[key];
+      const val = (importedSettings as Record<string, unknown>)[key];
       if (typeof val === "string" && val.startsWith("***")) {
-        importedSettingsRecord[key] = currentSettingsRecord[key];
+        (importedSettings as Record<string, unknown>)[key] = (this.settings as Record<string, unknown>)[key];
       }
     }
     const restoredSettings = normalizeSettings(importedSettings);
-
-    // Settings-only backup: keep the running queue AND the live counters untouched.
-    // Overlay the live usage/status counters so they don't roll back to the backup's
-    // (older) snapshot (BUG I), and suppress the retroactive cleanup sweep so the
-    // backup's cleanup policy can't purge the live completed queue here (BUG B) — the
-    // policy still governs FUTURE completions through the normal path. Do NOT stop the
-    // manager, wipe the session, block persistence or relaunch.
-    if (!hasSession) {
-      this.overlayLiveUsageCounters(restoredSettings);
-      this.settings = restoredSettings;
-      saveSettings(this.storagePaths, this.settings);
-      this.manager.setSettings(this.settings, { suppressRetroactiveCleanup: true });
-      this.audit("INFO", "Backup importiert (nur Einstellungen)", {
-        accountSummary: buildAccountSummary(this.settings)
-      });
-      return {
-        restored: true,
-        relaunch: false,
-        message: "Einstellungen wiederhergestellt"
-      };
-    }
-
     this.settings = restoredSettings;
     saveSettings(this.storagePaths, this.settings);
     this.manager.setSettings(this.settings);
 
+    // Full stop including extraction abort
     this.manager.stop();
     this.manager.abortAllPostProcessing();
     this.manager.clearPersistTimer();
     cancelPendingAsyncSaves();
 
+    // Restore session
     const restoredSession = normalizeLoadedSessionTransientFields(
       normalizeLoadedSession(parsed.session)
     );
     saveSession(this.storagePaths, restoredSession);
 
+    // Restore history (if present in backup)
     if (Array.isArray(parsed.history) && parsed.history.length > 0) {
       const normalizedHistory = (parsed.history as unknown[])
         .map((raw, idx) => normalizeHistoryEntry(raw, idx))
@@ -751,16 +469,11 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
       }
     }
 
-    resetHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode);
+    // Prevent prepareForShutdown from overwriting the restored data
-
     this.manager.skipShutdownPersist = true;
     this.manager.blockAllPersistence = true;
-    logger.info("Backup wiederhergestellt — App startet automatisch neu");
+    logger.info("Backup wiederhergestellt (verschlüsseltes Format)");
-    this.audit("WARN", "Backup importiert", {
+    return { restored: true, message: "Backup wiederhergestellt. Bitte App neustarten." };
-      historyEntries: Array.isArray(parsed.history) ? parsed.history.length : 0,
-      accountSummary: buildAccountSummary(this.settings)
-    });
-    return { restored: true, relaunch: true, message: "Backup wiederhergestellt – App startet automatisch neu…" };
   }
 
   public getSessionLogPath(): string | null {
@@ -771,15 +484,7 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
     return this.manager.getPackageLogPath(packageId) || getPackageLogPath(packageId);
   }
 
-  public getItemLogPath(itemId: string): string | null {
-    return this.manager.getItemLogPath(itemId) || getItemLogPath(itemId);
-  }
-
   public shutdown(): void {
-    if (this.runtimeStatsTimer) {
-      clearInterval(this.runtimeStatsTimer);
-      this.runtimeStatsTimer = null;
-    }
     stopDebugServer();
     abortActiveUpdateDownload();
     this.manager.prepareForShutdown();
@@ -789,56 +494,34 @@ public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
     this.bestDebridWebFallback.dispose();
     shutdownSessionLog();
     shutdownPackageLogs();
-    shutdownItemLogs();
-    shutdownRenameLog();
-    shutdownDesktopRenameLog();
-    this.audit("INFO", "App beendet");
-    shutdownTraceLog();
-    shutdownAccountRotationLog();
-    shutdownAuditLog();
-    if (this.settings.historyRetentionMode === "session") {
-      clearHistory(this.storagePaths);
-    }
     logger.info("App beendet");
   }
 
   public getHistory(): HistoryEntry[] {
-    return loadHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode);
+    return loadHistory(this.storagePaths);
   }
 
   public clearHistory(): void {
-    this.audit("WARN", "Verlauf geleert");
     clearHistory(this.storagePaths);
   }
 
   public setPackagePriority(packageId: string, priority: PackagePriority): void {
-    this.audit("INFO", "Paket-Priorität geändert", { packageId, priority });
     this.manager.setPackagePriority(packageId, priority);
   }
 
   public skipItems(itemIds: string[]): void {
-    this.audit("INFO", "Items übersprungen", { itemIds });
     this.manager.skipItems(itemIds);
   }
 
   public resetItems(itemIds: string[]): void {
-    this.audit("INFO", "Items zurückgesetzt", { itemIds });
     this.manager.resetItems(itemIds);
   }
 
   public removeHistoryEntry(entryId: string): void {
-    this.audit("INFO", "Verlaufseintrag entfernt", { entryId });
     removeHistoryEntry(this.storagePaths, entryId);
   }
 
   public addToHistory(entry: HistoryEntry): void {
-    this.audit("INFO", "Verlaufseintrag hinzugefügt", {
-      id: entry.id,
-      name: entry.name,
-      status: entry.status,
-      provider: entry.provider,
-      fileCount: entry.fileCount
-    });
     addHistoryEntry(this.storagePaths, entry);
   }
 }

src/main/audit-log.ts

@@ -1,119 +0,0 @@
-import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
-import path from "node:path";
-
-type AuditLevel = "INFO" | "WARN" | "ERROR";
-
-const AUDIT_LOG_MAX_FILE_BYTES = Number(process.env.RD_AUDIT_LOG_MAX_BYTES || 10 * 1024 * 1024);
-const AUDIT_LOG_RETENTION_DAYS = Number(process.env.RD_AUDIT_LOG_RETENTION_DAYS || 30);
-
-let auditLogPath: string | null = null;
-
-function sanitizeFieldValue(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value.replace(/\r?\n/g, "\\n");
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value).replace(/\r?\n/g, "\\n");
-  } catch {
-    return String(value);
-  }
-}
-
-function formatFields(fields?: Record<string, unknown>): string {
-  if (!fields) {
-    return "";
-  }
-  const parts = Object.entries(fields)
-    .filter(([, value]) => value !== undefined && value !== null && sanitizeFieldValue(value) !== "")
-    .map(([key, value]) => `${key}=${sanitizeFieldValue(value)}`);
-  return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
-}
-
-function rotateIfNeeded(filePath: string): void {
-  try {
-    const stat = fs.statSync(filePath);
-    if (stat.size < AUDIT_LOG_MAX_FILE_BYTES) {
-      return;
-    }
-    const backup = `${filePath}.old`;
-    try {
-      fs.rmSync(backup, { force: true });
-    } catch {
-    }
-    fs.renameSync(filePath, backup);
-  } catch {
-  }
-}
-
-function cleanupOldBackup(filePath: string): void {
-  const backup = `${filePath}.old`;
-  try {
-    const stat = fs.statSync(backup);
-    const cutoff = Date.now() - AUDIT_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    if (stat.mtimeMs < cutoff) {
-      fs.rmSync(backup, { force: true });
-    }
-  } catch {
-  }
-}
-
-export function initAuditLog(baseDir: string): void {
-  auditLogPath = path.join(baseDir, "audit.log");
-  try {
-    fs.mkdirSync(path.dirname(auditLogPath), { recursive: true });
-    cleanupOldBackup(auditLogPath);
-    if (!fs.existsSync(auditLogPath)) {
-      fs.writeFileSync(auditLogPath, "", "utf8");
-    }
-    rotateIfNeeded(auditLogPath);
-    if (!fs.existsSync(auditLogPath)) {
-      fs.writeFileSync(auditLogPath, "", "utf8");
-    }
-    fs.appendFileSync(auditLogPath, `=== Audit-Log Start: ${logTimestamp()} ===\n`, "utf8");
-  } catch {
-    auditLogPath = null;
-  }
-}
-
-export function logAuditEvent(level: AuditLevel, message: string, fields?: Record<string, unknown>): void {
-  if (!auditLogPath) {
-    return;
-  }
-  try {
-    rotateIfNeeded(auditLogPath);
-    if (!fs.existsSync(auditLogPath)) {
-      fs.writeFileSync(auditLogPath, "", "utf8");
-    }
-    fs.appendFileSync(
-      auditLogPath,
-      `${logTimestamp()} [${level}] ${message}${formatFields(fields)}\n`,
-      "utf8"
-    );
-  } catch {
-  }
-}
-
-export function getAuditLogPath(): string | null {
-  if (!auditLogPath) {
-    return null;
-  }
-  return fs.existsSync(auditLogPath) ? auditLogPath : null;
-}
-
-export function shutdownAuditLog(): void {
-  if (!auditLogPath) {
-    return;
-  }
-  try {
-    fs.appendFileSync(auditLogPath, `=== Audit-Log Ende: ${logTimestamp()} ===\n`, "utf8");
-  } catch {
-  }
-  auditLogPath = null;
-}

src/main/backup-crypto.ts

@@ -1,15 +1,22 @@
 import crypto from "node:crypto";
 
+// Fixed app key — like JDownloader 2: deterministic, works on any machine.
+// Not meant to protect against reverse-engineering, just prevents casual
+// plaintext snooping when someone opens the backup file.
 const APP_KEY_MATERIAL = "MDD-v2-backup-aes256gcm-2026";
 const ALGORITHM = "aes-256-gcm";
-const IV_LENGTH = 12;
+const IV_LENGTH = 12; // 96-bit IV for GCM
 const AUTH_TAG_LENGTH = 16;
-const MAGIC = Buffer.from("MDD1");
+const MAGIC = Buffer.from("MDD1"); // file signature
 
 function deriveKey(): Buffer {
   return crypto.createHash("sha256").update(APP_KEY_MATERIAL).digest();
 }
 
+/**
+ * Encrypt a UTF-8 string into an MDD backup buffer.
+ * Format: MAGIC(4) | IV(12) | AUTH_TAG(16) | CIPHERTEXT(…)
+ */
 export function encryptBackup(plaintext: string): Buffer {
   const key = deriveKey();
   const iv = crypto.randomBytes(IV_LENGTH);
@@ -19,6 +26,10 @@ export function encryptBackup(plaintext: string): Buffer {
   return Buffer.concat([MAGIC, iv, authTag, encrypted]);
 }
 
+/**
+ * Decrypt an MDD backup buffer back to a UTF-8 string.
+ * Throws on invalid/corrupted data.
+ */
 export function decryptBackup(data: Buffer): string {
   if (data.length < MAGIC.length + IV_LENGTH + AUTH_TAG_LENGTH) {
     throw new Error("Backup-Datei zu kurz oder ungültig");

src/main/backup-payload.ts

@@ -1,77 +0,0 @@
-import type { AppSettings, SessionState, HistoryEntry } from "../shared/types";
-
-export type BackupKind = "full" | "settings-only";
-
-export interface BackupPayload {
-  version: 2;
-  kind: BackupKind;
-  appVersion: string;
-  exportedAt: string;
-  settings: AppSettings;
-  session?: SessionState;
-  history?: HistoryEntry[];
-}
-
-export interface BuildBackupInput {
-  settings: AppSettings;
-  appVersion: string;
-  exportedAt: string;
-  /** Only bundled when includeDownloads is true. */
-  session: SessionState;
-  history: HistoryEntry[];
-}
-
-/**
- * Build the backup payload. By default ("Download-Liste mitsichern" off) the
- * payload contains ONLY settings — no session, no history. The download list is
- * bundled solely when settings.backupIncludeDownloads is true. An explicit kind
- * marker makes the import side unambiguous and survives hand-edited files.
- */
-export function buildBackupPayload(input: BuildBackupInput): BackupPayload {
-  const includeDownloads = Boolean(input.settings.backupIncludeDownloads);
-  const base: BackupPayload = {
-    version: 2,
-    kind: includeDownloads ? "full" : "settings-only",
-    appVersion: input.appVersion,
-    exportedAt: input.exportedAt,
-    settings: input.settings
-  };
-  if (includeDownloads) {
-    base.session = input.session;
-    base.history = input.history;
-  }
-  return base;
-}
-
-export interface ImportPlan {
-  valid: boolean;
-  /** Restore the download list (session + history) and relaunch. */
-  restoreDownloads: boolean;
-  message: string;
-}
-
-/**
- * Decide how to apply an imported backup based on what the FILE physically
- * contains — NOT the local toggle. A backup without a session restores settings
- * only (no queue wipe, no relaunch); a full backup (with session) restores the
- * queue too. This way an old full backup still restores fully even if the local
- * toggle is currently off, and a settings-only backup never disturbs a running
- * queue.
- */
-export function planBackupImport(parsed: unknown): ImportPlan {
-  if (!parsed || typeof parsed !== "object") {
-    return { valid: false, restoreDownloads: false, message: "Kein gültiges Backup (settings fehlen)" };
-  }
-  const record = parsed as Record<string, unknown>;
-  if (!record.settings || typeof record.settings !== "object") {
-    return { valid: false, restoreDownloads: false, message: "Kein gültiges Backup (settings fehlen)" };
-  }
-  const hasSession = Boolean(record.session) && typeof record.session === "object";
-  return {
-    valid: true,
-    restoreDownloads: hasSession,
-    message: hasSession
-      ? "Backup wiederhergestellt – App startet automatisch neu…"
-      : "Einstellungen wiederhergestellt"
-  };
-}

src/main/bestdebrid-web.ts

@@ -212,15 +212,18 @@ export class BestDebridWebFallback {
           storages: ["cookies", "indexdb", "localstorage", "serviceworkers", "cachestorage"]
         });
       } catch {
+        // ignore
       }
       try {
         await currentSession.clearCache();
       } catch {
+        // ignore
       }
     }
   }
 
   public dispose(): void {
+    // nothing to clean up
   }
 
   private getPartition(): string {
@@ -341,6 +344,7 @@ export class BestDebridWebFallback {
     try {
       await currentSession.clearCache();
     } catch {
+      // ignore cache clear failures
     }
   }
 }

src/main/cleanup.ts

@@ -39,6 +39,7 @@ export function cleanupCancelledPackageArtifacts(packageDir: string): number {
           fs.rmSync(full, { force: true });
           removed += 1;
         } catch {
+          // ignore
         }
       }
     }
@@ -46,10 +47,7 @@ export function cleanupCancelledPackageArtifacts(packageDir: string): number {
   return removed;
 }
 
-export async function cleanupCancelledPackageArtifactsAsync(
+export async function cleanupCancelledPackageArtifactsAsync(packageDir: string): Promise<number> {
-  packageDir: string,
-  options: { shouldAbort?: () => boolean } = {}
-): Promise<number> {
   try {
     await fs.promises.access(packageDir, fs.constants.F_OK);
   } catch {
@@ -60,9 +58,6 @@ export async function cleanupCancelledPackageArtifactsAsync(
   let touched = 0;
   const stack = [packageDir];
   while (stack.length > 0) {
-    if (options.shouldAbort?.()) {
-      return removed;
-    }
     const current = stack.pop() as string;
     let entries: fs.Dirent[] = [];
     try {
@@ -72,9 +67,6 @@ export async function cleanupCancelledPackageArtifactsAsync(
     }
 
     for (const entry of entries) {
-      if (options.shouldAbort?.()) {
-        return removed;
-      }
       const full = path.join(current, entry.name);
       if (entry.isDirectory() && !entry.isSymbolicLink()) {
         stack.push(full);
@@ -83,6 +75,7 @@ export async function cleanupCancelledPackageArtifactsAsync(
           await fs.promises.rm(full, { force: true });
           removed += 1;
         } catch {
+          // ignore
         }
       }
 
@@ -95,10 +88,7 @@ export async function cleanupCancelledPackageArtifactsAsync(
   return removed;
 }
 
-export async function removeDownloadLinkArtifacts(
+export async function removeDownloadLinkArtifacts(extractDir: string): Promise<number> {
-  extractDir: string,
-  options: { shouldAbort?: () => boolean } = {}
-): Promise<number> {
   try {
     await fs.promises.access(extractDir);
   } catch {
@@ -107,16 +97,10 @@ export async function removeDownloadLinkArtifacts(
   let removed = 0;
   const stack = [extractDir];
   while (stack.length > 0) {
-    if (options.shouldAbort?.()) {
-      return removed;
-    }
     const current = stack.pop() as string;
     let entries: fs.Dirent[] = [];
     try { entries = await fs.promises.readdir(current, { withFileTypes: true }); } catch { continue; }
     for (const entry of entries) {
-      if (options.shouldAbort?.()) {
-        return removed;
-      }
       const full = path.join(current, entry.name);
       if (entry.isDirectory() && !entry.isSymbolicLink()) {
         stack.push(full);
@@ -148,6 +132,7 @@ export async function removeDownloadLinkArtifacts(
           await fs.promises.rm(full, { force: true });
           removed += 1;
         } catch {
+          // ignore
         }
       }
     }
@@ -155,10 +140,7 @@ export async function removeDownloadLinkArtifacts(
   return removed;
 }
 
-export async function removeSampleArtifacts(
+export async function removeSampleArtifacts(extractDir: string): Promise<{ files: number; dirs: number }> {
-  extractDir: string,
-  options: { shouldAbort?: () => boolean } = {}
-): Promise<{ files: number; dirs: number }> {
   try {
     await fs.promises.access(extractDir);
   } catch {
@@ -202,16 +184,10 @@ export async function removeSampleArtifacts(
   };
 
   while (stack.length > 0) {
-    if (options.shouldAbort?.()) {
-      return { files: removedFiles, dirs: removedDirs };
-    }
     const current = stack.pop() as string;
     let entries: fs.Dirent[] = [];
     try { entries = await fs.promises.readdir(current, { withFileTypes: true }); } catch { continue; }
     for (const entry of entries) {
-      if (options.shouldAbort?.()) {
-        return { files: removedFiles, dirs: removedDirs };
-      }
       const full = path.join(current, entry.name);
       if (entry.isDirectory() || entry.isSymbolicLink()) {
         const base = entry.name.toLowerCase();
@@ -237,6 +213,7 @@ export async function removeSampleArtifacts(
           await fs.promises.rm(full, { force: true });
           removedFiles += 1;
         } catch {
+          // ignore
         }
       }
     }
@@ -244,9 +221,6 @@ export async function removeSampleArtifacts(
 
   sampleDirs.sort((a, b) => b.length - a.length);
   for (const dir of sampleDirs) {
-    if (options.shouldAbort?.()) {
-      return { files: removedFiles, dirs: removedDirs };
-    }
     try {
       const stat = await fs.promises.lstat(dir);
       if (stat.isSymbolicLink()) {
@@ -259,6 +233,7 @@ export async function removeSampleArtifacts(
       removedFiles += filesInDir;
       removedDirs += 1;
     } catch {
+      // ignore
     }
   }
 

src/main/constants.ts

@@ -17,12 +17,12 @@ export const DLC_AES_IV = Buffer.from("9bc24cb995cb8db3", "utf8");
 export const REQUEST_RETRIES = 3;
 export const CHUNK_SIZE = 512 * 1024;
 
-export const WRITE_BUFFER_SIZE = 512 * 1024;
+export const WRITE_BUFFER_SIZE = 512 * 1024;       // 512 KB write buffer (JDownloader: 500 KB)
-export const WRITE_FLUSH_TIMEOUT_MS = 2000;
+export const WRITE_FLUSH_TIMEOUT_MS = 2000;         // 2s flush timeout
-export const ALLOCATION_UNIT_SIZE = 4096;
+export const ALLOCATION_UNIT_SIZE = 4096;           // 4 KB NTFS alignment
-export const STREAM_HIGH_WATER_MARK = 512 * 1024;
+export const STREAM_HIGH_WATER_MARK = 512 * 1024;       // 512 KB stream buffer — lower than before (2 MB) so backpressure triggers sooner when disk is slow
-export const DISK_BUSY_THRESHOLD_MS = 300;
+export const DISK_BUSY_THRESHOLD_MS = 300;               // Internal detection threshold for disk backpressure
-export const DISK_BUSY_STATUS_THRESHOLD_MS = 500;
+export const DISK_BUSY_STATUS_THRESHOLD_MS = 500;        // Delay UI/log display for brief disk-write spikes
 
 export const SAMPLE_DIR_NAMES = new Set(["sample", "samples"]);
 export const SAMPLE_VIDEO_EXTENSIONS = new Set([".mkv", ".mp4", ".avi", ".mov", ".wmv", ".m4v", ".ts", ".m2ts", ".webm"]);
@@ -46,7 +46,6 @@ export function defaultSettings(): AppSettings {
     realDebridUseWebLogin: false,
     megaLogin: "",
     megaPassword: "",
-    megaCredentials: "",
     megaDebridApiEnabled: false,
     megaDebridWebEnabled: false,
     megaDebridPreferApi: true,
@@ -72,8 +71,6 @@ export function defaultSettings(): AppSettings {
     packageName: "",
     autoExtract: true,
     autoRename4sf4sj: false,
-    keepGermanAudioOnly: false,
-    germanAudioMode: "tag",
     extractDir: path.join(baseDir, "_entpackt"),
     collectMkvToLibrary: false,
     mkvLibraryDir: path.join(baseDir, "_mkv"),
@@ -100,16 +97,13 @@ export function defaultSettings(): AppSettings {
     minimizeToTray: false,
     theme: "dark" as const,
     collapseNewPackages: true,
-    historyRetentionMode: "permanent",
     accountListShowDetailedDebridLinkKeys: false,
     autoSortPackagesByProgress: true,
     autoSkipExtracted: false,
     hideExtractedItems: true,
     confirmDeleteSelection: true,
-    backupIncludeDownloads: false,
     totalDownloadedAllTime: 0,
     totalCompletedFilesAllTime: 0,
-    totalRuntimeAllTimeMs: 0,
     bandwidthSchedules: [],
     columnOrder: ["name", "size", "progress", "hoster", "account", "prio", "status", "speed"],
     extractCpuPriority: "high",
@@ -122,11 +116,6 @@ export function defaultSettings(): AppSettings {
     debridLinkApiKeyDailyLimitBytes: {},
     debridLinkApiKeyDailyUsageBytes: {},
     debridLinkApiKeyTotalUsageBytes: {},
-    megaDebridDisabledAccountIds: [],
-    megaDebridAccountDailyLimitBytes: {},
-    megaDebridAccountDailyUsageBytes: {},
-    megaDebridAccountTotalUsageBytes: {},
-    debridAccountStatuses: {},
     providerDailyUsageDay: getProviderUsageDayKey(),
     scheduledStartEpochMs: 0
   };

src/main/container.ts

@@ -113,11 +113,13 @@ function parsePackagesFromDlcXml(xml: string): ParsedPackageInput[] {
           try {
             fileName = Buffer.from(fnMatch[1].trim(), "base64").toString("utf8").trim();
           } catch {
+            // ignore
           }
         }
         links.push(url);
         fileNames.push(sanitizeFilename(fileName));
       } catch {
+        // skip broken entries
       }
     }
 
@@ -130,6 +132,7 @@ function parsePackagesFromDlcXml(xml: string): ParsedPackageInput[] {
             links.push(url);
           }
         } catch {
+          // skip broken entries
         }
       }
     }

src/main/debug-server.ts

@@ -1,105 +1,15 @@
 import http from "node:http";
 import fs from "node:fs";
 import path from "node:path";
-import crypto from "node:crypto";
-import { APP_VERSION } from "./constants";
-import { getAuditLogPath } from "./audit-log";
-import { getDebugSetupCheck } from "./debug-setup";
 import { logger, getLogFilePath } from "./logger";
-import { getRecentErrors } from "./error-ring";
-import { getItemLogPath as getPersistedItemLogPath } from "./item-log";
-import { getSessionLogPath } from "./session-log";
-import { getPackageLogPath as getPersistedPackageLogPath } from "./package-log";
-import { getRenameLogPath } from "./rename-log";
-import { createStoragePaths, loadHistory, loadSettings } from "./storage";
-import { buildAccountSummary, buildRedactedSettingsPayload, buildStatsPayload, summarizeHistoryEntry } from "./support-data";
-import { buildSupportBundle, getSupportBundleDefaultFileName } from "./support-bundle";
-import { getTraceConfig, getTraceConfigPath, getTraceLogPath, logTraceEvent, setTraceEnabled, updateTraceConfig } from "./trace-log";
-import { getWindowsHostDiagnostics } from "./windows-host-diagnostics";
 import type { DownloadManager } from "./download-manager";
-import type { DownloadItem, PackageEntry, UiSnapshot } from "../shared/types";
 
 const DEFAULT_PORT = 9868;
-const DEFAULT_HOST = "127.0.0.1";
 const MAX_LOG_LINES = 10000;
-const AI_MANIFEST_FILE = "debug_ai_manifest.json";
-
-type DebugEndpointDescriptor = {
-  method: "GET";
-  path: string;
-  queryExample?: string;
-  description: string;
-};
-
-const DEBUG_ENDPOINTS: DebugEndpointDescriptor[] = [
-  { method: "GET", path: "/health", description: "Basic health, uptime, and memory information." },
-  { method: "GET", path: "/meta", description: "Lists runtime metadata and all available endpoints." },
-  { method: "GET", path: "/debug/setup", description: "Checks whether the local debug setup is configured for support." },
-  { method: "GET", path: "/self-check", description: "Extended support self-check with disk space, log sizes, and support bundle estimate." },
-  { method: "GET", path: "/host/diagnostics", description: "Returns Windows host crash and dump diagnostics." },
-  { method: "GET", path: "/log", queryExample: "lines=100&grep=keyword", description: "Legacy alias for the main application log tail." },
-  { method: "GET", path: "/logs/main", queryExample: "lines=100&grep=keyword", description: "Reads the main application log tail." },
-  { method: "GET", path: "/logs/audit", queryExample: "lines=100&grep=keyword", description: "Reads the audit log for support-relevant UI and admin actions." },
-  { method: "GET", path: "/logs/rename", queryExample: "lines=100&grep=keyword", description: "Reads the dedicated rename and MKV move log." },
-  { method: "GET", path: "/logs/trace", queryExample: "lines=100&grep=keyword", description: "Reads the optional support trace log." },
-  { method: "GET", path: "/logs/session", queryExample: "lines=100&grep=keyword", description: "Reads the session log tail." },
-  { method: "GET", path: "/logs/package", queryExample: "package=Release&lines=100&grep=keyword", description: "Reads the package log for a specific package name or id." },
-  { method: "GET", path: "/logs/item", queryExample: "item=episode.part2.rar&lines=100&grep=keyword", description: "Reads the item log for a specific file name or item id." },
-  { method: "GET", path: "/errors", queryExample: "level=ERROR&limit=100", description: "Returns the in-memory ring of the most recent WARN/ERROR log lines." },
-  { method: "GET", path: "/trace/config", queryExample: "enable=1&note=support&durationMinutes=120", description: "Reads or updates the support trace configuration." },
-  { method: "GET", path: "/settings", description: "Returns a redacted settings snapshot without raw secrets." },
-  { method: "GET", path: "/accounts", description: "Returns a redacted account/provider configuration summary." },
-  { method: "GET", path: "/stats", description: "Returns live session stats plus persisted all-time totals." },
-  { method: "GET", path: "/history", queryExample: "limit=50&status=completed", description: "Returns history entries with optional filters." },
-  { method: "GET", path: "/status", description: "Returns a live high-level status overview." },
-  { method: "GET", path: "/packages", queryExample: "package=Release&includeItems=1", description: "Lists packages and optional per-item detail." },
-  { method: "GET", path: "/items", queryExample: "status=downloading&package=Release", description: "Lists items and supports status/package filters." },
-  { method: "GET", path: "/session", queryExample: "package=Release", description: "Returns session-wide or package-scoped item state." },
-  { method: "GET", path: "/support/bundle", description: "Downloads a ZIP support bundle with logs, diagnostics, and redacted state." },
-  { method: "GET", path: "/diagnostics", queryExample: "package=Release&lines=150", description: "Returns a combined support snapshot with logs, status, settings, accounts, stats, history, and host diagnostics." }
-];
 
 let server: http.Server | null = null;
 let manager: DownloadManager | null = null;
 let authToken = "";
-let bindHost = DEFAULT_HOST;
-let bindPort = DEFAULT_PORT;
-let runtimeBaseDir = "";
-
-function getStoragePaths() {
-  return createStoragePaths(runtimeBaseDir);
-}
-
-function readSupportSettings() {
-  return loadSettings(getStoragePaths());
-}
-
-function readSupportHistory() {
-  return loadHistory(getStoragePaths());
-}
-
-function extractDebugClientIp(req: http.IncomingMessage): string {
-  const forwarded = req.headers["x-forwarded-for"];
-  const forwardedValue = Array.isArray(forwarded) ? forwarded[0] : forwarded;
-  const forwardedIp = String(forwardedValue || "").split(",")[0]?.trim();
-  if (forwardedIp) {
-    return forwardedIp;
-  }
-  const realIp = String(req.headers["x-real-ip"] || "").trim();
-  if (realIp) {
-    return realIp;
-  }
-  const remote = String(req.socket.remoteAddress || req.socket.address()?.address || "").trim();
-  return remote.replace(/^::ffff:/i, "");
-}
-
-function getAiManifestPath(baseDir: string = runtimeBaseDir): string {
-  return path.join(baseDir, AI_MANIFEST_FILE);
-}
-
-function getDebugTokenPath(baseDir: string = runtimeBaseDir): string {
-  return path.join(baseDir, "debug_token.txt");
-}
 
 function loadToken(baseDir: string): string {
   const tokenPath = path.join(baseDir, "debug_token.txt");
@@ -118,28 +28,11 @@ function getPort(baseDir: string): number {
       return n;
     }
   } catch {
+    // ignore
   }
   return DEFAULT_PORT;
 }
 
-function getHost(baseDir: string): string {
-  const hostPath = path.join(baseDir, "debug_host.txt");
-  try {
-    const raw = fs.readFileSync(hostPath, "utf8").trim();
-    if (!raw) {
-      return DEFAULT_HOST;
-    }
-    if (/^(localhost|0\.0\.0\.0|127\.0\.0\.1|::1)$/i.test(raw)) {
-      return raw;
-    }
-    if (/^[a-z0-9.-]+$/i.test(raw)) {
-      return raw;
-    }
-  } catch {
-  }
-  return DEFAULT_HOST;
-}
-
 function checkAuth(req: http.IncomingMessage): boolean {
   if (!authToken) {
     return false;
@@ -162,37 +55,10 @@ function jsonResponse(res: http.ServerResponse, status: number, data: unknown):
   res.end(body);
 }
 
-function binaryResponse(
+function readLogTail(lines: number): string[] {
-  res: http.ServerResponse,
+  const logPath = getLogFilePath();
-  status: number,
-  body: Buffer,
-  contentType: string,
-  fileName?: string
-): void {
-  res.writeHead(status, {
-    "Content-Type": contentType,
-    "Content-Length": String(body.length),
-    "Access-Control-Allow-Origin": "*",
-    "Cache-Control": "no-cache",
-    ...(fileName ? { "Content-Disposition": `attachment; filename="${fileName}"` } : {})
-  });
-  res.end(body);
-}
-
-function normalizeLinesParam(rawValue: string | null, fallback: number): number {
-  const parsed = Number(rawValue || String(fallback));
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return fallback;
-  }
-  return Math.max(1, Math.min(Math.floor(parsed), MAX_LOG_LINES));
-}
-
-function readLogTailFromFile(filePath: string | null, lines: number): string[] {
-  if (!filePath) {
-    return ["(Log-Datei nicht gefunden)"];
-  }
   try {
-    const content = fs.readFileSync(filePath, "utf8");
+    const content = fs.readFileSync(logPath, "utf8");
     const allLines = content.split("\n").filter((l) => l.trim().length > 0);
     return allLines.slice(-Math.min(lines, MAX_LOG_LINES));
   } catch {
@@ -200,543 +66,42 @@ function readLogTailFromFile(filePath: string | null, lines: number): string[] {
   }
 }
 
-function filterLines(lines: string[], grep: string): string[] {
-  const pattern = String(grep || "").trim().toLowerCase();
-  if (!pattern) {
-    return lines;
-  }
-  return lines.filter((line) => line.toLowerCase().includes(pattern));
-}
-
-function toBooleanQuery(value: string | null): boolean | null {
-  if (value === null) {
-    return null;
-  }
-  if (/^(1|true|yes|on)$/i.test(value)) {
-    return true;
-  }
-  if (/^(0|false|no|off)$/i.test(value)) {
-    return false;
-  }
-  return null;
-}
-
-function sanitizeRequestUrlForTrace(rawUrl: string): string {
-  try {
-    const url = new URL(rawUrl || "/", "http://localhost");
-    if (url.searchParams.has("token")) {
-      url.searchParams.set("token", "***");
-    }
-    return `${url.pathname}${url.search}`;
-  } catch {
-    return String(rawUrl || "/");
-  }
-}
-
-function formatEndpointSummary(endpoint: DebugEndpointDescriptor): string {
-  return `${endpoint.method} ${endpoint.path}${endpoint.queryExample ? `?${endpoint.queryExample}` : ""}`;
-}
-
-function getEndpointSummaries(): string[] {
-  return DEBUG_ENDPOINTS.map((endpoint) => formatEndpointSummary(endpoint));
-}
-
-function buildAiManifest(baseDir: string): Record<string, unknown> {
-  const remoteHostHint = bindHost === "0.0.0.0"
-    ? "Use the server IP or DNS name for remote access. Ask the user only for that host value if it is unknown."
-    : "If remote access is required and the bind host is local-only, switch debug_host.txt to 0.0.0.0 and reopen the firewall.";
-
-  return {
-    schemaVersion: 1,
-    generatedAt: new Date().toISOString(),
-    appVersion: APP_VERSION,
-    runtimeBaseDir: baseDir,
-    purpose: "Machine-readable support manifest for AI tools and remote troubleshooting.",
-    quickstart: [
-      "Read debug_token.txt and debug_port.txt from this runtime folder.",
-      "If remote access is needed, ask the user only for the server IP or DNS name.",
-      "Call /meta first to confirm the server is reachable and to re-read the endpoint list.",
-      "Use /self-check or /debug/setup to quickly verify whether token, host, manifest, trace, disk space, and log sizes are in a good support state.",
-      "Use /diagnostics for an overview, then drill into /logs/item, /logs/package, /logs/rename, /status, /packages, /items, /settings, /accounts, /stats, /history, or /logs/trace.",
-      "If a full handoff is needed, download /support/bundle as a ZIP."
-    ],
-    auth: {
-      required: true,
-      methods: [
-        "Authorization: Bearer <token>",
-        "?token=<token>"
-      ],
-      tokenFile: path.join(baseDir, "debug_token.txt")
-    },
-    runtimeFiles: {
-      hostFile: path.join(baseDir, "debug_host.txt"),
-      portFile: path.join(baseDir, "debug_port.txt"),
-      tokenFile: path.join(baseDir, "debug_token.txt"),
-      mainLogFile: getLogFilePath(),
-      auditLogFile: getAuditLogPath(),
-      renameLogFile: getRenameLogPath(),
-      traceLogFile: getTraceLogPath(),
-      traceConfigFile: getTraceConfigPath(),
-      sessionLogFile: getSessionLogPath(),
-      packageLogDir: path.join(baseDir, "package-logs"),
-      itemLogDir: path.join(baseDir, "item-logs"),
-      settingsFile: path.join(baseDir, "rd_downloader_config.json"),
-      sessionFile: path.join(baseDir, "rd_session_state.json"),
-      historyFile: path.join(baseDir, "rd_history.json")
-    },
-    debugServer: {
-      enabled: Boolean(authToken),
-      host: bindHost,
-      port: bindPort,
-      localBaseUrl: `http://127.0.0.1:${bindPort}`,
-      remoteBaseUrlTemplate: `http://<SERVER_IP_OR_DNS>:${bindPort}`,
-      remoteHostHint
-    },
-    setupCheckEndpoint: "/debug/setup",
-    selfCheckEndpoint: "/self-check",
-    askUserFor: [
-      "Server IP or DNS name, if remote access is required and not already known."
-    ],
-    endpoints: DEBUG_ENDPOINTS.map((endpoint) => ({
-      ...endpoint,
-      summary: formatEndpointSummary(endpoint)
-    }))
-  };
-}
-
-function writeAiManifest(baseDir: string): void {
-  try {
-    fs.writeFileSync(getAiManifestPath(baseDir), JSON.stringify(buildAiManifest(baseDir), null, 2), "utf8");
-  } catch (error) {
-    logger.warn(`Debug-Server: KI-Support-Datei konnte nicht geschrieben werden: ${String(error)}`);
-  }
-}
-
-export function rotateDebugToken(baseDir: string = runtimeBaseDir): { path: string; token: string } {
-  const token = crypto.randomBytes(24).toString("hex");
-  const tokenPath = getDebugTokenPath(baseDir);
-  fs.writeFileSync(tokenPath, `${token}\n`, "utf8");
-  if (baseDir === runtimeBaseDir) {
-    authToken = token;
-    writeAiManifest(baseDir);
-  }
-  logger.info(`Debug-Server Token rotiert: ${tokenPath}`);
-  logTraceEvent("INFO", "support", "Debug-Token rotiert", { tokenPath });
-  return { path: tokenPath, token };
-}
-
-function summarizeItem(item: DownloadItem): Record<string, unknown> {
-  return {
-    id: item.id,
-    packageId: item.packageId,
-    fileName: item.fileName,
-    status: item.status,
-    fullStatus: item.fullStatus,
-    provider: item.provider,
-    providerLabel: item.providerLabel || "",
-    progress: item.progressPercent,
-    speedMBs: +(item.speedBps / 1024 / 1024).toFixed(2),
-    downloadedMB: +(item.downloadedBytes / 1024 / 1024).toFixed(1),
-    totalMB: item.totalBytes ? +(item.totalBytes / 1024 / 1024).toFixed(1) : null,
-    retries: item.retries,
-    lastError: item.lastError,
-    targetPath: item.targetPath,
-    updatedAt: item.updatedAt
-  };
-}
-
-function summarizePackage(snapshot: UiSnapshot, pkg: PackageEntry, includeItems: boolean): Record<string, unknown> {
-  const ids = new Set(pkg.itemIds);
-  const packageItems = Object.values(snapshot.session.items).filter((item) => ids.has(item.id));
-  const byStatus: Record<string, number> = {};
-  for (const item of packageItems) {
-    byStatus[item.status] = (byStatus[item.status] || 0) + 1;
-  }
-  return {
-    id: pkg.id,
-    name: pkg.name,
-    status: pkg.status,
-    enabled: pkg.enabled,
-    cancelled: pkg.cancelled,
-    outputDir: pkg.outputDir,
-    extractDir: pkg.extractDir,
-    postProcessLabel: pkg.postProcessLabel || "",
-    itemCount: pkg.itemIds.length,
-    itemCounts: byStatus,
-    updatedAt: pkg.updatedAt,
-    items: includeItems ? packageItems.map((item) => summarizeItem(item)) : undefined
-  };
-}
-
-function findPackage(snapshot: UiSnapshot, query: string): PackageEntry | null {
-  const needle = String(query || "").trim().toLowerCase();
-  if (!needle) {
-    return null;
-  }
-  return Object.values(snapshot.session.packages).find((pkg) =>
-    pkg.id.toLowerCase() === needle || pkg.name.toLowerCase().includes(needle)
-  ) || null;
-}
-
-function findItem(snapshot: UiSnapshot, query: string): DownloadItem | null {
-  const needle = String(query || "").trim().toLowerCase();
-  if (!needle) {
-    return null;
-  }
-  return Object.values(snapshot.session.items).find((item) =>
-    item.id.toLowerCase() === needle || item.fileName.toLowerCase().includes(needle)
-  ) || null;
-}
-
-function getPackageLogPathForQuery(snapshot: UiSnapshot, query: string): { pkg: PackageEntry | null; logPath: string | null } {
-  const pkg = findPackage(snapshot, query);
-  if (pkg) {
-    const livePath = manager?.getPackageLogPath(pkg.id) || null;
-    return { pkg, logPath: livePath || getPersistedPackageLogPath(pkg.id) };
-  }
-  const directPath = getPersistedPackageLogPath(String(query || "").trim());
-  return { pkg: null, logPath: directPath };
-}
-
-function getItemLogPathForQuery(snapshot: UiSnapshot, query: string): { item: DownloadItem | null; logPath: string | null } {
-  const item = findItem(snapshot, query);
-  if (item) {
-    const livePath = manager?.getItemLogPath(item.id) || null;
-    return { item, logPath: livePath || getPersistedItemLogPath(item.id) };
-  }
-  const directPath = getPersistedItemLogPath(String(query || "").trim());
-  return { item: null, logPath: directPath };
-}
-
-function buildStatusPayload(snapshot: UiSnapshot): Record<string, unknown> {
-  const items = Object.values(snapshot.session.items);
-  const packages = Object.values(snapshot.session.packages);
-
-  const byStatus: Record<string, number> = {};
-  for (const item of items) {
-    byStatus[item.status] = (byStatus[item.status] || 0) + 1;
-  }
-
-  const activeItems = items
-    .filter((item) => item.status === "downloading" || item.status === "validating")
-    .map((item) => summarizeItem(item));
-
-  const failedItems = items
-    .filter((item) => item.status === "failed")
-    .map((item) => summarizeItem(item));
-
-  return {
-    running: snapshot.session.running,
-    paused: snapshot.session.paused,
-    speed: snapshot.speedText,
-    eta: snapshot.etaText,
-    itemCounts: byStatus,
-    totalItems: items.length,
-    totalPackages: packages.length,
-    packages: packages.map((pkg) => summarizePackage(snapshot, pkg, false)),
-    activeItems,
-    failedItems: failedItems.length > 0 ? failedItems : undefined
-  };
-}
-
 function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
-  const url = new URL(req.url || "/", "http://localhost");
-  const pathname = url.pathname;
-  const traceConfig = getTraceConfig();
-  if (traceConfig.enabled && traceConfig.logDebugRequests) {
-    logTraceEvent("INFO", "debug-http", "Request", {
-      method: req.method || "GET",
-      url: sanitizeRequestUrlForTrace(req.url || "/"),
-      clientIp: extractDebugClientIp(req)
-    });
-  }
-
   if (req.method === "OPTIONS") {
     res.writeHead(204, {
       "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Headers": "Authorization",
+      "Access-Control-Allow-Headers": "Authorization"
-      "Access-Control-Allow-Methods": "GET,OPTIONS"
     });
     res.end();
     return;
   }
 
   if (!checkAuth(req)) {
-    if (traceConfig.enabled && traceConfig.logDebugRequests) {
-      logTraceEvent("WARN", "debug-http", "Unauthorized request", {
-        method: req.method || "GET",
-        url: sanitizeRequestUrlForTrace(req.url || "/"),
-        clientIp: extractDebugClientIp(req)
-      });
-    }
     jsonResponse(res, 401, { error: "Unauthorized" });
     return;
   }
 
+  const url = new URL(req.url || "/", "http://localhost");
+  const pathname = url.pathname;
+
   if (pathname === "/health") {
     jsonResponse(res, 200, {
       status: "ok",
-      appVersion: APP_VERSION,
       uptime: Math.floor(process.uptime()),
       memoryMB: Math.round(process.memoryUsage().rss / 1024 / 1024)
     });
     return;
   }
 
-  if (pathname === "/meta") {
+  if (pathname === "/log") {
-    jsonResponse(res, 200, {
+    const count = Math.min(Number(url.searchParams.get("lines") || "100"), MAX_LOG_LINES);
-      appVersion: APP_VERSION,
-      runtimeBaseDir,
-      debugServer: {
-        host: bindHost,
-        port: bindPort
-      },
-      supportFiles: {
-        aiManifest: getAiManifestPath(),
-        traceConfig: getTraceConfigPath(),
-        traceLog: getTraceLogPath()
-      },
-      supportChecks: {
-        setup: "/debug/setup",
-        selfCheck: "/self-check"
-      },
-      logPaths: {
-        main: getLogFilePath(),
-        audit: getAuditLogPath(),
-        rename: getRenameLogPath(),
-        session: getSessionLogPath(),
-        trace: getTraceLogPath()
-      },
-      endpoints: getEndpointSummaries()
-    });
-    return;
-  }
-
-  if (pathname === "/debug/setup" || pathname === "/self-check") {
-    jsonResponse(res, 200, getDebugSetupCheck(runtimeBaseDir));
-    return;
-  }
-
-  if (pathname === "/host/diagnostics") {
-    jsonResponse(res, 200, getWindowsHostDiagnostics());
-    return;
-  }
-
-  if (pathname === "/log" || pathname === "/logs/main") {
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
     const grep = url.searchParams.get("grep") || "";
-    const lines = filterLines(readLogTailFromFile(getLogFilePath(), count), grep);
+    let lines = readLogTail(count);
-    jsonResponse(res, 200, { lines, count: lines.length });
-    return;
-  }
-
-  if (pathname === "/errors") {
-    const levelFilter = (url.searchParams.get("level") || "").toUpperCase();
-    const limit = normalizeLinesParam(url.searchParams.get("limit"), 100);
-    let entries = getRecentErrors();
-    if (levelFilter === "ERROR" || levelFilter === "WARN") {
-      entries = entries.filter((entry) => entry.level === levelFilter);
-    }
-    const limited = entries.slice(-limit);
-    jsonResponse(res, 200, { count: limited.length, total: entries.length, entries: limited });
-    return;
-  }
-
-  if (pathname === "/logs/audit") {
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
-    const grep = url.searchParams.get("grep") || "";
-    const logPath = getAuditLogPath();
-    const lines = filterLines(readLogTailFromFile(logPath, count), grep);
-    jsonResponse(res, 200, {
-      path: logPath,
-      lines,
-      count: lines.length
-    });
-    return;
-  }
-
-  if (pathname === "/logs/rename") {
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
-    const grep = url.searchParams.get("grep") || "";
-    const logPath = getRenameLogPath();
-    const lines = filterLines(readLogTailFromFile(logPath, count), grep);
-    jsonResponse(res, 200, {
-      path: logPath,
-      lines,
-      count: lines.length
-    });
-    return;
-  }
-
-  if (pathname === "/logs/trace") {
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
-    const grep = url.searchParams.get("grep") || "";
-    const logPath = getTraceLogPath();
-    const lines = filterLines(readLogTailFromFile(logPath, count), grep);
-    jsonResponse(res, 200, {
-      path: logPath,
-      configPath: getTraceConfigPath(),
-      config: getTraceConfig(),
-      lines,
-      count: lines.length
-    });
-    return;
-  }
-
-  if (pathname === "/logs/session") {
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
-    const grep = url.searchParams.get("grep") || "";
-    const logPath = getSessionLogPath();
-    const lines = filterLines(readLogTailFromFile(logPath, count), grep);
-    jsonResponse(res, 200, {
-      path: logPath,
-      lines,
-      count: lines.length
-    });
-    return;
-  }
-
-  if (pathname === "/trace/config") {
-    const patch: Record<string, unknown> = {};
-    const enabled = toBooleanQuery(url.searchParams.get("enable"));
-    const includeMainLog = toBooleanQuery(url.searchParams.get("includeMainLog"));
-    const includeAudit = toBooleanQuery(url.searchParams.get("includeAudit"));
-    const logDebugRequests = toBooleanQuery(url.searchParams.get("logDebugRequests"));
-    if (enabled !== null) {
-      patch.enabled = enabled;
-    }
-    if (includeMainLog !== null) {
-      patch.includeMainLog = includeMainLog;
-    }
-    if (includeAudit !== null) {
-      patch.includeAudit = includeAudit;
-    }
-    if (logDebugRequests !== null) {
-      patch.logDebugRequests = logDebugRequests;
-    }
-    const note = String(url.searchParams.get("note") || "").trim();
-    const durationMinutesRaw = Number(url.searchParams.get("durationMinutes") || "120");
-    const durationMinutes = Number.isFinite(durationMinutesRaw) && durationMinutesRaw > 0
-      ? Math.min(Math.floor(durationMinutesRaw), 24 * 60)
-      : 120;
-    let config = getTraceConfig();
-    if (enabled !== null) {
-      config = setTraceEnabled(enabled, note, durationMinutes * 60 * 1000);
-    }
-    const configPatch = { ...patch };
-    delete configPatch.enabled;
-    if (Object.keys(configPatch).length > 0) {
-      config = updateTraceConfig(configPatch);
-    }
-    if (Object.keys(patch).length > 0) {
-      logTraceEvent("INFO", "support", "Trace-Konfiguration über Debug-Server geändert", { ...patch, note, durationMinutes });
-    }
-    jsonResponse(res, 200, {
-      path: getTraceConfigPath(),
-      logPath: getTraceLogPath(),
-      config
-    });
-    return;
-  }
-
-  if (pathname === "/logs/package") {
-    if (!manager) {
-      jsonResponse(res, 503, { error: "Manager not initialized" });
-      return;
-    }
-    const snapshot = manager.getSnapshot();
-    const packageQuery = url.searchParams.get("package") || url.searchParams.get("packageId") || "";
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
-    const grep = url.searchParams.get("grep") || "";
-    const resolved = getPackageLogPathForQuery(snapshot, packageQuery);
-    if (!resolved.logPath) {
-      jsonResponse(res, 404, { error: "Package log not found", package: packageQuery });
-      return;
-    }
-    const lines = filterLines(readLogTailFromFile(resolved.logPath, count), grep);
-    jsonResponse(res, 200, {
-      package: resolved.pkg ? summarizePackage(snapshot, resolved.pkg, false) : undefined,
-      path: resolved.logPath,
-      lines,
-      count: lines.length
-    });
-    return;
-  }
-
-  if (pathname === "/logs/item") {
-    if (!manager) {
-      jsonResponse(res, 503, { error: "Manager not initialized" });
-      return;
-    }
-    const snapshot = manager.getSnapshot();
-    const itemQuery = url.searchParams.get("item") || url.searchParams.get("itemId") || "";
-    const count = normalizeLinesParam(url.searchParams.get("lines"), 100);
-    const grep = url.searchParams.get("grep") || "";
-    const resolved = getItemLogPathForQuery(snapshot, itemQuery);
-    if (!resolved.logPath) {
-      jsonResponse(res, 404, { error: "Item log not found", item: itemQuery });
-      return;
-    }
-    const lines = filterLines(readLogTailFromFile(resolved.logPath, count), grep);
-    jsonResponse(res, 200, {
-      item: resolved.item ? summarizeItem(resolved.item) : undefined,
-      path: resolved.logPath,
-      lines,
-      count: lines.length
-    });
-    return;
-  }
-
-  if (pathname === "/settings") {
-    const settings = readSupportSettings();
-    jsonResponse(res, 200, buildRedactedSettingsPayload(settings));
-    return;
-  }
-
-  if (pathname === "/accounts") {
-    const settings = readSupportSettings();
-    jsonResponse(res, 200, buildAccountSummary(settings));
-    return;
-  }
-
-  if (pathname === "/stats") {
-    if (!manager) {
-      jsonResponse(res, 503, { error: "Manager not initialized" });
-      return;
-    }
-    const snapshot = manager.getSnapshot();
-    const settings = readSupportSettings();
-    jsonResponse(res, 200, {
-      ...buildStatsPayload(snapshot),
-      allTime: {
-        totalDownloadedAllTime: settings.totalDownloadedAllTime,
-        totalCompletedFilesAllTime: settings.totalCompletedFilesAllTime,
-        totalRuntimeAllTimeMs: settings.totalRuntimeAllTimeMs
-      }
-    });
-    return;
-  }
-
-  if (pathname === "/history") {
-    const entries = readSupportHistory();
-    const limit = normalizeLinesParam(url.searchParams.get("limit"), 50);
-    const statusFilter = String(url.searchParams.get("status") || "").trim().toLowerCase();
-    const grep = String(url.searchParams.get("grep") || "").trim().toLowerCase();
-    let filtered = entries;
-    if (statusFilter) {
-      filtered = filtered.filter((entry) => String(entry.status || "").toLowerCase() === statusFilter);
-    }
     if (grep) {
-      filtered = filtered.filter((entry) => JSON.stringify(summarizeHistoryEntry(entry)).toLowerCase().includes(grep));
+      const pattern = grep.toLowerCase();
+      lines = lines.filter((l) => l.toLowerCase().includes(pattern));
     }
-    const sliced = filtered
+    jsonResponse(res, 200, { lines, count: lines.length });
-      .sort((a, b) => Number(b.completedAt || 0) - Number(a.completedAt || 0))
-      .slice(0, limit);
-    jsonResponse(res, 200, {
-      count: sliced.length,
-      total: filtered.length,
-      entries: sliced.map((entry) => summarizeHistoryEntry(entry))
-    });
     return;
   }
 
@@ -746,26 +111,53 @@ function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): voi
       return;
     }
     const snapshot = manager.getSnapshot();
-    jsonResponse(res, 200, buildStatusPayload(snapshot));
+    const items = Object.values(snapshot.session.items);
-    return;
+    const packages = Object.values(snapshot.session.packages);
+
+    const byStatus: Record<string, number> = {};
+    for (const item of items) {
+      byStatus[item.status] = (byStatus[item.status] || 0) + 1;
     }
 
-  if (pathname === "/packages") {
+    const activeItems = items
-    if (!manager) {
+      .filter((i) => i.status === "downloading" || i.status === "validating")
-      jsonResponse(res, 503, { error: "Manager not initialized" });
+      .map((i) => ({
-      return;
+        id: i.id,
-    }
+        fileName: i.fileName,
-    const snapshot = manager.getSnapshot();
+        status: i.status,
-    const packageQuery = url.searchParams.get("package") || "";
+        fullStatus: i.fullStatus,
-    const includeItems = /^(1|true|yes)$/i.test(String(url.searchParams.get("includeItems") || ""));
+        provider: i.provider,
-    let packages = Object.values(snapshot.session.packages);
+        progress: i.progressPercent,
-    if (packageQuery) {
+        speedMBs: +(i.speedBps / 1024 / 1024).toFixed(2),
-      const needle = packageQuery.toLowerCase();
+        downloadedMB: +(i.downloadedBytes / 1024 / 1024).toFixed(1),
-      packages = packages.filter((pkg) => pkg.id.toLowerCase() === needle || pkg.name.toLowerCase().includes(needle));
+        totalMB: i.totalBytes ? +(i.totalBytes / 1024 / 1024).toFixed(1) : null,
-    }
+        retries: i.retries,
+        lastError: i.lastError
+      }));
+
+    const failedItems = items
+      .filter((i) => i.status === "failed")
+      .map((i) => ({
+        fileName: i.fileName,
+        lastError: i.lastError,
+        retries: i.retries,
+        provider: i.provider
+      }));
+
     jsonResponse(res, 200, {
-      count: packages.length,
+      running: snapshot.session.running,
-      packages: packages.map((pkg) => summarizePackage(snapshot, pkg, includeItems))
+      paused: snapshot.session.paused,
+      speed: snapshot.speedText,
+      eta: snapshot.etaText,
+      itemCounts: byStatus,
+      totalItems: items.length,
+      packages: packages.map((p) => ({
+        name: p.name,
+        status: p.status,
+        items: p.itemIds.length
+      })),
+      activeItems,
+      failedItems: failedItems.length > 0 ? failedItems : undefined
     });
     return;
   }
@@ -783,7 +175,9 @@ function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): voi
       items = items.filter((i) => i.status === filter);
     }
     if (pkg) {
-      const matchedPkg = findPackage(snapshot, pkg);
+      const pkgLower = pkg.toLowerCase();
+      const matchedPkg = Object.values(snapshot.session.packages)
+        .find((p) => p.name.toLowerCase().includes(pkgLower));
       if (matchedPkg) {
         const ids = new Set(matchedPkg.itemIds);
         items = items.filter((i) => ids.has(i.id));
@@ -791,7 +185,18 @@ function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): voi
     }
     jsonResponse(res, 200, {
       count: items.length,
-      items: items.map((i) => summarizeItem(i))
+      items: items.map((i) => ({
+        fileName: i.fileName,
+        status: i.status,
+        fullStatus: i.fullStatus,
+        provider: i.provider,
+        progress: i.progressPercent,
+        speedMBs: +(i.speedBps / 1024 / 1024).toFixed(2),
+        downloadedMB: +(i.downloadedBytes / 1024 / 1024).toFixed(1),
+        totalMB: i.totalBytes ? +(i.totalBytes / 1024 / 1024).toFixed(1) : null,
+        retries: i.retries,
+        lastError: i.lastError
+      }))
     });
     return;
   }
@@ -804,14 +209,16 @@ function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): voi
     const snapshot = manager.getSnapshot();
     const pkg = url.searchParams.get("package");
     if (pkg) {
-      const matchedPkg = findPackage(snapshot, pkg);
+      const pkgLower = pkg.toLowerCase();
+      const matchedPkg = Object.values(snapshot.session.packages)
+        .find((p) => p.name.toLowerCase().includes(pkgLower));
       if (matchedPkg) {
         const ids = new Set(matchedPkg.itemIds);
         const pkgItems = Object.values(snapshot.session.items)
           .filter((i) => ids.has(i.id));
         jsonResponse(res, 200, {
-          package: summarizePackage(snapshot, matchedPkg, false),
+          package: matchedPkg,
-          items: pkgItems.map((item) => summarizeItem(item))
+          items: pkgItems
         });
         return;
       }
@@ -831,113 +238,31 @@ function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): voi
     return;
   }
 
-  if (pathname === "/support/bundle") {
-    if (!manager) {
-      jsonResponse(res, 503, { error: "Manager not initialized" });
-      return;
-    }
-    const fileName = getSupportBundleDefaultFileName();
-    const body = buildSupportBundle(manager, runtimeBaseDir);
-    logTraceEvent("INFO", "support", "Support-Bundle über Debug-Server heruntergeladen", {
-      fileName,
-      sizeBytes: body.length
-    });
-    binaryResponse(res, 200, body, "application/zip", fileName);
-    return;
-  }
-
-  if (pathname === "/diagnostics") {
-    if (!manager) {
-      jsonResponse(res, 503, { error: "Manager not initialized" });
-      return;
-    }
-    const snapshot = manager.getSnapshot();
-    const lineCount = normalizeLinesParam(url.searchParams.get("lines"), 150);
-    const grep = url.searchParams.get("grep") || "";
-    const packageQuery = url.searchParams.get("package") || "";
-    const mainLogPath = getLogFilePath();
-    const sessionLogPath = getSessionLogPath();
-    const selectedPackage = packageQuery ? findPackage(snapshot, packageQuery) : null;
-    const packageLogPath = selectedPackage
-      ? manager.getPackageLogPath(selectedPackage.id) || getPersistedPackageLogPath(selectedPackage.id)
-      : null;
-    jsonResponse(res, 200, {
-      meta: {
-        appVersion: APP_VERSION,
-        serverTime: new Date().toISOString(),
-        runtimeBaseDir,
-        debugServer: {
-          host: bindHost,
-          port: bindPort
-        },
-        setup: getDebugSetupCheck(runtimeBaseDir)
-      },
-      status: buildStatusPayload(snapshot),
-      settings: buildRedactedSettingsPayload(readSupportSettings()),
-      stats: buildStatsPayload(snapshot),
-      accounts: buildAccountSummary(readSupportSettings()),
-      history: {
-        total: readSupportHistory().length,
-        recent: readSupportHistory()
-          .sort((a, b) => Number(b.completedAt || 0) - Number(a.completedAt || 0))
-          .slice(0, 10)
-          .map((entry) => summarizeHistoryEntry(entry))
-      },
-      host: getWindowsHostDiagnostics(),
-      selectedPackage: selectedPackage ? summarizePackage(snapshot, selectedPackage, true) : undefined,
-      logs: {
-        main: {
-          path: mainLogPath,
-          lines: filterLines(readLogTailFromFile(mainLogPath, lineCount), grep)
-        },
-        audit: {
-          path: getAuditLogPath(),
-          lines: filterLines(readLogTailFromFile(getAuditLogPath(), lineCount), grep)
-        },
-        rename: {
-          path: getRenameLogPath(),
-          lines: filterLines(readLogTailFromFile(getRenameLogPath(), lineCount), grep)
-        },
-        trace: {
-          path: getTraceLogPath(),
-          config: getTraceConfig(),
-          lines: filterLines(readLogTailFromFile(getTraceLogPath(), lineCount), grep)
-        },
-        session: {
-          path: sessionLogPath,
-          lines: filterLines(readLogTailFromFile(sessionLogPath, lineCount), grep)
-        },
-        package: selectedPackage ? {
-          path: packageLogPath,
-          lines: filterLines(readLogTailFromFile(packageLogPath, lineCount), grep)
-        } : undefined
-      }
-    });
-    return;
-  }
-
   jsonResponse(res, 404, {
     error: "Not found",
-    endpoints: getEndpointSummaries()
+    endpoints: [
+      "GET /health",
+      "GET /log?lines=100&grep=keyword",
+      "GET /status",
+      "GET /items?status=downloading&package=Bloodline",
+      "GET /session?package=Criminal"
+    ]
   });
 }
 
 export function startDebugServer(mgr: DownloadManager, baseDir: string): void {
-  runtimeBaseDir = baseDir;
   authToken = loadToken(baseDir);
-  bindPort = getPort(baseDir);
-  bindHost = getHost(baseDir);
-  writeAiManifest(baseDir);
   if (!authToken) {
     logger.info("Debug-Server: Kein Token in debug_token.txt, Server wird nicht gestartet");
     return;
   }
 
   manager = mgr;
+  const port = getPort(baseDir);
 
   server = http.createServer(handleRequest);
-  server.listen(bindPort, bindHost, () => {
+  server.listen(port, "127.0.0.1", () => {
-    logger.info(`Debug-Server gestartet auf ${bindHost}:${bindPort}`);
+    logger.info(`Debug-Server gestartet auf Port ${port}`);
   });
   server.on("error", (err) => {
     logger.warn(`Debug-Server Fehler: ${String(err)}`);

src/main/debug-setup.ts

@@ -1,435 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { execFileSync } from "node:child_process";
-import { getSessionLogPath } from "./session-log";
-import { createStoragePaths, loadSettings } from "./storage";
-import type {
-  DebugSetupCheckResult,
-  SupportBundleEstimate,
-  SupportDirectorySizeInfo,
-  SupportDiskSpaceInfo,
-  SupportFileSizeInfo,
-  SupportTraceConfig
-} from "../shared/types";
-
-const DEFAULT_PORT = 9868;
-const DEFAULT_HOST = "127.0.0.1";
-const AI_MANIFEST_FILE = "debug_ai_manifest.json";
-const LOW_FREE_BYTES_THRESHOLD = Number(process.env.RD_SELF_CHECK_LOW_FREE_BYTES || 20 * 1024 * 1024 * 1024);
-const LOW_FREE_PERCENT_THRESHOLD = Number(process.env.RD_SELF_CHECK_LOW_FREE_PERCENT || 5);
-const LOW_FREE_PERCENT_BYTES_GUARD = Number(process.env.RD_SELF_CHECK_LOW_FREE_PERCENT_BYTES_GUARD || 50 * 1024 * 1024 * 1024);
-const LARGE_LOG_BYTES_THRESHOLD = Number(process.env.RD_SELF_CHECK_LARGE_LOG_BYTES || 250 * 1024 * 1024);
-const LARGE_BUNDLE_BYTES_THRESHOLD = Number(process.env.RD_SELF_CHECK_LARGE_BUNDLE_BYTES || 150 * 1024 * 1024);
-const BUNDLE_OVERVIEW_SLACK_BYTES = 256 * 1024;
-
-function formatByteCount(bytes: number): string {
-  if (!Number.isFinite(bytes) || bytes < 0) {
-    return "0 B";
-  }
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  }
-  if (bytes < 1024 * 1024 * 1024) {
-    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-  }
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-
-function readToken(baseDir: string): string {
-  try {
-    return fs.readFileSync(path.join(baseDir, "debug_token.txt"), "utf8").trim();
-  } catch {
-    return "";
-  }
-}
-
-function readPort(baseDir: string): number {
-  try {
-    const raw = Number(fs.readFileSync(path.join(baseDir, "debug_port.txt"), "utf8").trim());
-    if (Number.isFinite(raw) && raw >= 1024 && raw <= 65535) {
-      return raw;
-    }
-  } catch {
-  }
-  return DEFAULT_PORT;
-}
-
-function readHost(baseDir: string): string {
-  try {
-    const raw = fs.readFileSync(path.join(baseDir, "debug_host.txt"), "utf8").trim();
-    if (!raw) {
-      return DEFAULT_HOST;
-    }
-    if (/^(localhost|0\.0\.0\.0|127\.0\.0\.1|::1)$/i.test(raw)) {
-      return raw;
-    }
-    if (/^[a-z0-9.-]+$/i.test(raw)) {
-      return raw;
-    }
-  } catch {
-  }
-  return DEFAULT_HOST;
-}
-
-function readTraceConfig(baseDir: string): SupportTraceConfig {
-  const fallback: SupportTraceConfig = {
-    enabled: false,
-    includeMainLog: true,
-    includeAudit: true,
-    logDebugRequests: true,
-    autoDisableAt: null,
-    updatedAt: new Date(0).toISOString()
-  };
-  try {
-    const filePath = path.join(baseDir, "trace_config.json");
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8")) as Partial<SupportTraceConfig>;
-    return {
-      enabled: Boolean(parsed.enabled),
-      includeMainLog: parsed.includeMainLog === undefined ? true : Boolean(parsed.includeMainLog),
-      includeAudit: parsed.includeAudit === undefined ? true : Boolean(parsed.includeAudit),
-      logDebugRequests: parsed.logDebugRequests === undefined ? true : Boolean(parsed.logDebugRequests),
-      autoDisableAt: typeof parsed.autoDisableAt === "string" && parsed.autoDisableAt.trim() ? parsed.autoDisableAt : null,
-      updatedAt: typeof parsed.updatedAt === "string" && parsed.updatedAt.trim() ? parsed.updatedAt : fallback.updatedAt
-    };
-  } catch {
-    return fallback;
-  }
-}
-
-function getFileSizeInfo(filePath: string | null): SupportFileSizeInfo {
-  if (!filePath) {
-    return { path: null, exists: false, bytes: 0 };
-  }
-  try {
-    const stat = fs.statSync(filePath);
-    return {
-      path: filePath,
-      exists: true,
-      bytes: stat.size
-    };
-  } catch {
-    return {
-      path: filePath,
-      exists: false,
-      bytes: 0
-    };
-  }
-}
-
-function getDirectorySizeInfo(dirPath: string, skipPath?: string | null): SupportDirectorySizeInfo {
-  if (!fs.existsSync(dirPath)) {
-    return {
-      path: dirPath,
-      exists: false,
-      fileCount: 0,
-      bytes: 0
-    };
-  }
-
-  let bytes = 0;
-  let fileCount = 0;
-  const queue = [dirPath];
-  while (queue.length > 0) {
-    const current = queue.pop();
-    if (!current) {
-      continue;
-    }
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-        continue;
-      }
-      if (skipPath && path.resolve(fullPath) === path.resolve(skipPath)) {
-        continue;
-      }
-      try {
-        bytes += fs.statSync(fullPath).size;
-        fileCount += 1;
-      } catch {
-      }
-    }
-  }
-
-  return {
-    path: dirPath,
-    exists: true,
-    fileCount,
-    bytes
-  };
-}
-
-function resolveExistingPath(targetPath: string): string {
-  let current = path.resolve(targetPath);
-  while (!fs.existsSync(current)) {
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return current;
-}
-
-function getWindowsDiskSpaceInfo(existingPath: string): SupportDiskSpaceInfo | null {
-  if (process.platform !== "win32") {
-    return null;
-  }
-  const root = path.parse(existingPath).root.replace(/[\\/]+$/g, "");
-  const driveName = root.replace(":", "");
-  if (!/^[A-Za-z]$/.test(driveName)) {
-    return null;
-  }
-  try {
-    const raw = execFileSync(
-      "powershell",
-      [
-        "-NoProfile",
-        "-Command",
-        `$drive = Get-PSDrive -Name '${driveName}'; if ($drive) { [pscustomobject]@{ FreeSpace = [int64]$drive.Free; Size = [int64]($drive.Used + $drive.Free) } | ConvertTo-Json -Compress }`
-      ],
-      {
-        encoding: "utf8",
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: 3000
-      }
-    ).trim();
-    if (!raw) {
-      return null;
-    }
-    const parsed = JSON.parse(raw) as { FreeSpace?: number | string; Size?: number | string };
-    const totalBytes = Number(parsed.Size);
-    const freeBytes = Number(parsed.FreeSpace);
-    const freePercent = Number.isFinite(totalBytes) && totalBytes > 0
-      ? Math.round((freeBytes / totalBytes) * 1000) / 10
-      : null;
-    return {
-      path: existingPath,
-      totalBytes: Number.isFinite(totalBytes) ? totalBytes : null,
-      freeBytes: Number.isFinite(freeBytes) ? freeBytes : null,
-      freePercent
-    };
-  } catch {
-    return null;
-  }
-}
-
-function getDiskSpaceInfo(targetPath: string): SupportDiskSpaceInfo {
-  const existingPath = resolveExistingPath(targetPath);
-  try {
-    const stat = fs.statfsSync(existingPath);
-    const totalBytes = Number(stat.blocks) * Number(stat.bsize);
-    const freeBytes = Number(stat.bavail) * Number(stat.bsize);
-    const freePercent = totalBytes > 0
-      ? Math.round((freeBytes / totalBytes) * 1000) / 10
-      : null;
-    return {
-      path: existingPath,
-      totalBytes,
-      freeBytes,
-      freePercent
-    };
-  } catch {
-    const windowsFallback = getWindowsDiskSpaceInfo(existingPath);
-    if (windowsFallback) {
-      return windowsFallback;
-    }
-    return {
-      path: existingPath,
-      totalBytes: null,
-      freeBytes: null,
-      freePercent: null
-    };
-  }
-}
-
-function getSupportBundleEstimate(
-  baseDir: string,
-  logSummary: DebugSetupCheckResult["logSummary"]
-): SupportBundleEstimate {
-  const storagePaths = createStoragePaths(baseDir);
-  const staticFiles = [
-    path.join(baseDir, AI_MANIFEST_FILE),
-    path.join(baseDir, "debug_host.txt"),
-    path.join(baseDir, "debug_port.txt"),
-    storagePaths.configFile,
-    storagePaths.sessionFile,
-    storagePaths.historyFile,
-    path.join(baseDir, "trace_config.json")
-  ].map((filePath) => getFileSizeInfo(filePath));
-
-  const staticBytes = staticFiles.reduce((sum, entry) => sum + entry.bytes, 0);
-  const duplicatedLiveLogBytes = logSummary.session.bytes + logSummary.packageLogs.bytes + logSummary.itemLogs.bytes;
-  const estimatedEntries = 10
-    + staticFiles.filter((entry) => entry.exists).length
-    + Number(logSummary.main.exists)
-    + Number(logSummary.mainBackup.exists)
-    + Number(logSummary.audit.exists)
-    + Number(logSummary.auditBackup.exists)
-    + Number(logSummary.rename.exists)
-    + Number(logSummary.renameBackup.exists)
-    + Number(logSummary.session.exists)
-    + Number(logSummary.trace.exists)
-    + Number(logSummary.traceBackup.exists)
-    + logSummary.sessionLogs.fileCount
-    + logSummary.packageLogs.fileCount
-    + logSummary.itemLogs.fileCount
-    + logSummary.packageLogs.fileCount
-    + logSummary.itemLogs.fileCount;
-
-  return {
-    estimatedBytes: staticBytes + logSummary.totalBytes + duplicatedLiveLogBytes + BUNDLE_OVERVIEW_SLACK_BYTES,
-    estimatedEntries,
-    duplicatedLiveLogBytes,
-    note: "Schätzwert vor ZIP-Komprimierung; aktueller Session-Log sowie Live-Paket-/Item-Logs werden im Bundle zusätzlich gespiegelt."
-  };
-}
-
-export function getDebugSetupCheck(baseDir: string): DebugSetupCheckResult {
-  const host = readHost(baseDir);
-  const port = readPort(baseDir);
-  const token = readToken(baseDir);
-  const storagePaths = createStoragePaths(baseDir);
-  const settings = loadSettings(storagePaths);
-  const tokenPath = path.join(baseDir, "debug_token.txt");
-  const aiManifestPath = path.join(baseDir, AI_MANIFEST_FILE);
-  const traceConfigPath = path.join(baseDir, "trace_config.json");
-  const traceLogPath = path.join(baseDir, "trace.log");
-  const traceConfig = readTraceConfig(baseDir);
-  const sessionLogPath = getSessionLogPath();
-  const localOnly = /^(127\.0\.0\.1|localhost|::1)$/i.test(host);
-  const warnings: string[] = [];
-  const notes: string[] = [];
-
-  const logSummary: DebugSetupCheckResult["logSummary"] = {
-    main: getFileSizeInfo(path.join(baseDir, "rd_downloader.log")),
-    mainBackup: getFileSizeInfo(path.join(baseDir, "rd_downloader.log.old")),
-    audit: getFileSizeInfo(path.join(baseDir, "audit.log")),
-    auditBackup: getFileSizeInfo(path.join(baseDir, "audit.log.old")),
-    rename: getFileSizeInfo(path.join(baseDir, "rename.log")),
-    renameBackup: getFileSizeInfo(path.join(baseDir, "rename.log.old")),
-    session: getFileSizeInfo(sessionLogPath),
-    trace: getFileSizeInfo(traceLogPath),
-    traceBackup: getFileSizeInfo(path.join(baseDir, "trace.log.old")),
-    sessionLogs: getDirectorySizeInfo(path.join(baseDir, "session-logs"), sessionLogPath),
-    packageLogs: getDirectorySizeInfo(path.join(baseDir, "package-logs")),
-    itemLogs: getDirectorySizeInfo(path.join(baseDir, "item-logs")),
-    totalBytes: 0
-  };
-  logSummary.totalBytes = [
-    logSummary.main.bytes,
-    logSummary.mainBackup.bytes,
-    logSummary.audit.bytes,
-    logSummary.auditBackup.bytes,
-    logSummary.rename.bytes,
-    logSummary.renameBackup.bytes,
-    logSummary.session.bytes,
-    logSummary.trace.bytes,
-    logSummary.traceBackup.bytes,
-    logSummary.sessionLogs.bytes,
-    logSummary.packageLogs.bytes,
-    logSummary.itemLogs.bytes
-  ].reduce((sum, value) => sum + value, 0);
-
-  const diskSpace: DebugSetupCheckResult["diskSpace"] = {
-    runtime: getDiskSpaceInfo(baseDir),
-    output: getDiskSpaceInfo(settings.outputDir),
-    extract: getDiskSpaceInfo(settings.extractDir)
-  };
-  const supportBundle = getSupportBundleEstimate(baseDir, logSummary);
-
-  if (!token) {
-    warnings.push("debug_token.txt fehlt oder ist leer. Der Debug-Server startet dann nicht.");
-  }
-  if (localOnly) {
-    warnings.push("Der Debug-Server ist aktuell nur lokal erreichbar. Für Remote-Support debug_host.txt auf 0.0.0.0 setzen.");
-  } else {
-    notes.push("Der Debug-Server ist für Remote-Zugriff konfiguriert. Firewall oder Provider-Regeln müssen separat offen sein.");
-  }
-  if (!fs.existsSync(aiManifestPath)) {
-    warnings.push("debug_ai_manifest.json fehlt. App einmal neu starten, damit die KI-Support-Datei neu geschrieben wird.");
-  }
-  if (!fs.existsSync(traceConfigPath)) {
-    warnings.push("trace_config.json fehlt. Trace-Funktionen sind lokal noch nicht initialisiert.");
-  }
-  if (traceConfig.enabled && !traceConfig.autoDisableAt) {
-    warnings.push("Support-Trace ist aktiv ohne automatische Abschaltzeit. Einmal neu aktivieren, damit die 2-Stunden-Begrenzung gesetzt wird.");
-  }
-  if (traceConfig.enabled && traceConfig.autoDisableAt) {
-    notes.push(`Support-Trace aktiv bis ${traceConfig.autoDisableAt}.`);
-  }
-
-  for (const entry of [
-    { label: "Runtime", info: diskSpace.runtime },
-    { label: "Download-Ziel", info: diskSpace.output },
-    { label: "Entpack-Ziel", info: diskSpace.extract }
-  ]) {
-    if (entry.info.freeBytes === null || entry.info.totalBytes === null) {
-      warnings.push(`${entry.label}: Freier Speicherplatz konnte nicht gelesen werden (${entry.info.path}).`);
-      continue;
-    }
-    const lowByAbsolute = entry.info.freeBytes < LOW_FREE_BYTES_THRESHOLD;
-    const lowByPercent = entry.info.freePercent !== null
-      && entry.info.freePercent < LOW_FREE_PERCENT_THRESHOLD
-      && entry.info.freeBytes < LOW_FREE_PERCENT_BYTES_GUARD;
-    if (lowByAbsolute || lowByPercent) {
-      warnings.push(`${entry.label}: wenig freier Speicherplatz (${formatByteCount(entry.info.freeBytes)} frei auf ${entry.info.path}).`);
-    }
-  }
-
-  if (logSummary.totalBytes >= LARGE_LOG_BYTES_THRESHOLD) {
-    warnings.push(`Support-Logs sind bereits recht groß (${formatByteCount(logSummary.totalBytes)}). Rotation greift, aber ein Bundle wird entsprechend umfangreicher.`);
-  } else {
-    notes.push(`Aktuelle Support-Logmenge: ${formatByteCount(logSummary.totalBytes)}.`);
-  }
-
-  if (supportBundle.estimatedBytes >= LARGE_BUNDLE_BYTES_THRESHOLD) {
-    warnings.push(`Support-Bundle wird voraussichtlich groß (${formatByteCount(supportBundle.estimatedBytes)} vor ZIP-Komprimierung).`);
-  } else {
-    notes.push(`Support-Bundle-Schätzung: etwa ${formatByteCount(supportBundle.estimatedBytes)}.`);
-  }
-
-  notes.push("Die App kann Netzwerk-Firewalls oder Provider-Sicherheitsgruppen nicht direkt prüfen.");
-
-  return {
-    status: warnings.length > 0 ? "warn" : "ok",
-    enabled: Boolean(token),
-    runtimeBaseDir: baseDir,
-    host,
-    port,
-    localOnly,
-    tokenConfigured: Boolean(token),
-    tokenPath,
-    aiManifestPath,
-    aiManifestPresent: fs.existsSync(aiManifestPath),
-    traceConfigPath: fs.existsSync(traceConfigPath) ? traceConfigPath : null,
-    traceLogPath: fs.existsSync(traceLogPath) ? traceLogPath : null,
-    traceEnabled: traceConfig.enabled,
-    traceAutoDisableAt: traceConfig.autoDisableAt,
-    diskSpace,
-    logSummary,
-    supportBundle,
-    warnings,
-    notes,
-    localUrls: {
-      health: `http://127.0.0.1:${port}/health?token=${token || "<TOKEN>"}`,
-      meta: `http://127.0.0.1:${port}/meta?token=${token || "<TOKEN>"}`,
-      diagnostics: `http://127.0.0.1:${port}/diagnostics?token=${token || "<TOKEN>"}`
-    },
-    remoteUrlTemplates: {
-      health: `http://<SERVER_IP_OR_DNS>:${port}/health?token=${token || "<TOKEN>"}`,
-      meta: `http://<SERVER_IP_OR_DNS>:${port}/meta?token=${token || "<TOKEN>"}`,
-      diagnostics: `http://<SERVER_IP_OR_DNS>:${port}/diagnostics?token=${token || "<TOKEN>"}`
-    }
-  };
-}

src/main/desktop-rename-log.ts

@@ -1,252 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { logTimestamp } from "./log-timestamp";
-
-type DesktopRenameLevel = "INFO" | "WARN" | "ERROR";
-
-const FOLDER_NAME = "Downloader-Log";
-
-let logDir: string | null = null;
-let logFilePath: string | null = null;
-let sessionHeader = "";
-
-function fileTimestamp(date: Date = new Date()): string {
-  const pad = (value: number): string => String(value).padStart(2, "0");
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}_`
-    + `${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
-}
-
-function sanitizeFieldValue(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value.replace(/\r?\n/g, "\\n");
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value).replace(/\r?\n/g, "\\n");
-  } catch {
-    return String(value);
-  }
-}
-
-function formatFields(fields?: Record<string, unknown>): string {
-  if (!fields) {
-    return "";
-  }
-  const parts = Object.entries(fields)
-    .filter(([, value]) => value !== undefined && value !== null && sanitizeFieldValue(value) !== "")
-    .map(([key, value]) => `${key}=${sanitizeFieldValue(value)}`);
-  return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
-}
-
-function ensureWritable(): boolean {
-  if (!logDir || !logFilePath) {
-    return false;
-  }
-  try {
-    fs.mkdirSync(logDir, { recursive: true });
-    if (!fs.existsSync(logFilePath)) {
-      fs.writeFileSync(logFilePath, sessionHeader, "utf8");
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function initDesktopRenameLog(desktopDir: string | null | undefined): void {
-  try {
-    const base = String(desktopDir || "").trim();
-    if (!base) {
-      logDir = null;
-      logFilePath = null;
-      return;
-    }
-    logDir = path.join(base, FOLDER_NAME);
-    logFilePath = path.join(logDir, `rename-session_${fileTimestamp()}.txt`);
-    sessionHeader = `=== Rename-Session gestartet: ${logTimestamp()} ===\n`
-      + "Diese Datei protokolliert JEDEN Umbenenn-/Verschiebevorgang dieser Programm-Sitzung\n"
-      + "und verifiziert nach jedem Vorgang, ob die Datei wirklich unter dem Zielnamen auf der\n"
-      + "Platte liegt (und die Quelle verschwunden ist). [INFO]=ok, [ERROR]=Verifikation gescheitert.\n\n";
-    fs.mkdirSync(logDir, { recursive: true });
-    fs.writeFileSync(logFilePath, sessionHeader, "utf8");
-  } catch {
-    logDir = null;
-    logFilePath = null;
-  }
-}
-
-export function logDesktopRename(level: DesktopRenameLevel, message: string, fields?: Record<string, unknown>): void {
-  if (!ensureWritable() || !logFilePath) {
-    return;
-  }
-  try {
-    fs.appendFileSync(logFilePath, `${logTimestamp()} [${level}] ${message}${formatFields(fields)}\n`, "utf8");
-  } catch {
-  }
-}
-
-export function getDesktopRenameLogPath(): string | null {
-  if (!logFilePath) {
-    return null;
-  }
-  try {
-    return fs.existsSync(logFilePath) ? logFilePath : null;
-  } catch {
-    return null;
-  }
-}
-
-export function shutdownDesktopRenameLog(): void {
-  if (ensureWritable() && logFilePath) {
-    try {
-      fs.appendFileSync(logFilePath, `=== Rename-Session beendet: ${logTimestamp()} ===\n`, "utf8");
-    } catch {
-    }
-  }
-  logDir = null;
-  logFilePath = null;
-}
-
-export interface RenameVerification {
-  ok: boolean;
-  level: "INFO" | "WARN" | "ERROR";
-  targetExists: boolean;
-  onDiskName: string | null;
-  nameMatches: boolean;
-  sourceGone: boolean;
-  targetSize: number | null;
-  reason: string;
-}
-
-function toLongPath(filePath: string): string {
-  const absolute = path.resolve(String(filePath || ""));
-  if (process.platform !== "win32") {
-    return absolute;
-  }
-  if (!absolute || absolute.startsWith("\\\\?\\")) {
-    return absolute;
-  }
-  if (absolute.length < 248) {
-    return absolute;
-  }
-  if (absolute.startsWith("\\\\")) {
-    return `\\\\?\\UNC\\${absolute.slice(2)}`;
-  }
-  return `\\\\?\\${absolute}`;
-}
-
-function resolveOnDiskName(requested: string, entries: string[] | null): string | null {
-  if (entries === null) {
-    return null;
-  }
-  const requestedLower = requested.toLowerCase();
-  return entries.find((entry) => entry === requested)
-    || entries.find((entry) => entry.toLowerCase() === requestedLower)
-    || requested;
-}
-
-function buildVerification(
-  sourcePath: string,
-  targetPath: string,
-  facts: { targetExists: boolean; targetSize: number | null; dirEntries: string[] | null; sourceExists: boolean }
-): RenameVerification {
-  const requested = path.basename(targetPath);
-  const dirReadFailed = facts.targetExists && facts.dirEntries === null;
-  const onDiskName = facts.targetExists ? resolveOnDiskName(requested, facts.dirEntries) : null;
-
-  const samePath = path.resolve(sourcePath).toLowerCase() === path.resolve(targetPath).toLowerCase();
-  const sourceGone = samePath ? true : !facts.sourceExists;
-  const nameMatches = facts.targetExists && !dirReadFailed && onDiskName === requested;
-
-  const problems: string[] = [];
-  let level: "INFO" | "WARN" | "ERROR" = "INFO";
-  if (!facts.targetExists) {
-    problems.push("Zieldatei nach Rename NICHT gefunden");
-    level = "ERROR";
-  } else if (!dirReadFailed && !nameMatches) {
-    problems.push(`On-Disk-Name weicht ab (ist "${onDiskName}", erwartet "${requested}")`);
-    level = "ERROR";
-  }
-  if (!samePath && facts.targetExists && !sourceGone) {
-    problems.push("Quelldatei existiert noch (moeglicher halb-fertiger Verschiebevorgang)");
-    level = "ERROR";
-  }
-  if (level === "INFO" && dirReadFailed) {
-    problems.push("Zielverzeichnis nicht lesbar — Schreibweise nicht verifiziert");
-    level = "WARN";
-  }
-
-  return {
-    ok: level === "INFO",
-    level,
-    targetExists: facts.targetExists,
-    onDiskName,
-    nameMatches,
-    sourceGone,
-    targetSize: facts.targetSize,
-    reason: problems.join("; ")
-  };
-}
-
-export function verifyRename(sourcePath: string, targetPath: string): RenameVerification {
-  const longTarget = toLongPath(targetPath);
-  let targetExists = false;
-  let targetSize: number | null = null;
-  try {
-    const stat = fs.statSync(longTarget);
-    targetExists = true;
-    targetSize = stat.size;
-  } catch {
-    targetExists = false;
-  }
-  let dirEntries: string[] | null = null;
-  if (targetExists) {
-    try {
-      dirEntries = fs.readdirSync(path.dirname(longTarget));
-    } catch {
-      dirEntries = null;
-    }
-  }
-  let sourceExists = false;
-  try {
-    fs.statSync(toLongPath(sourcePath));
-    sourceExists = true;
-  } catch {
-    sourceExists = false;
-  }
-  return buildVerification(sourcePath, targetPath, { targetExists, targetSize, dirEntries, sourceExists });
-}
-
-export async function verifyRenameAsync(sourcePath: string, targetPath: string): Promise<RenameVerification> {
-  const longTarget = toLongPath(targetPath);
-  let targetExists = false;
-  let targetSize: number | null = null;
-  try {
-    const stat = await fs.promises.stat(longTarget);
-    targetExists = true;
-    targetSize = stat.size;
-  } catch {
-    targetExists = false;
-  }
-  let dirEntries: string[] | null = null;
-  if (targetExists) {
-    try {
-      dirEntries = await fs.promises.readdir(path.dirname(longTarget));
-    } catch {
-      dirEntries = null;
-    }
-  }
-  let sourceExists = false;
-  try {
-    await fs.promises.stat(toLongPath(sourcePath));
-    sourceExists = true;
-  } catch {
-    sourceExists = false;
-  }
-  return buildVerification(sourcePath, targetPath, { targetExists, targetSize, dirEntries, sourceExists });
-}

src/main/download-completion.ts

@@ -1,150 +0,0 @@
-import { ALLOCATION_UNIT_SIZE } from "./constants";
-
-export type DownloadCompletionSource =
-  | "content-range"
-  | "content-length"
-  | "provider-metadata"
-  | "stream-end";
-
-export type DownloadCompletionPlan = {
-  expectedTotal: number | null;
-  source: DownloadCompletionSource;
-  canFinishEarly: boolean;
-};
-
-export function planDownloadCompletion(args: {
-  existingBytes: number;
-  responseStatus: number;
-  contentLength: number;
-  totalFromRange: number | null;
-  knownTotal: number | null;
-  correctedTotal: number | null;
-}): DownloadCompletionPlan {
-  const existingBytes = Math.max(0, Math.floor(Number(args.existingBytes) || 0));
-  const responseStatus = Math.floor(Number(args.responseStatus) || 0);
-  const contentLength = Math.max(0, Math.floor(Number(args.contentLength) || 0));
-  const totalFromRange = Number.isFinite(args.totalFromRange || NaN)
-    ? Math.max(0, Math.floor(args.totalFromRange || 0))
-    : 0;
-  const correctedTotal = Number.isFinite(args.correctedTotal || NaN)
-    ? Math.max(0, Math.floor(args.correctedTotal || 0))
-    : 0;
-  const knownTotal = Number.isFinite(args.knownTotal || NaN)
-    ? Math.max(0, Math.floor(args.knownTotal || 0))
-    : 0;
-
-  if (correctedTotal > 0) {
-    return {
-      expectedTotal: correctedTotal,
-      source: totalFromRange > 0 ? "content-range" : "content-length",
-      canFinishEarly: true
-    };
-  }
-
-  if (totalFromRange > 0) {
-    return {
-      expectedTotal: totalFromRange,
-      source: "content-range",
-      canFinishEarly: true
-    };
-  }
-
-  if (contentLength > 0) {
-    return {
-      expectedTotal: responseStatus === 206 ? existingBytes + contentLength : contentLength,
-      source: "content-length",
-      canFinishEarly: true
-    };
-  }
-
-  if (knownTotal > 0) {
-    return {
-      expectedTotal: knownTotal,
-      source: "provider-metadata",
-      canFinishEarly: false
-    };
-  }
-
-  return {
-    expectedTotal: null,
-    source: "stream-end",
-    canFinishEarly: false
-  };
-}
-
-export function validateDownloadedFileCompletion(args: {
-  actualBytes: number;
-  plan: DownloadCompletionPlan;
-  toleranceBytes?: number;
-}): {
-  ok: boolean;
-  totalBytes: number;
-  acceptedMetadataMismatch: boolean;
-  error?: string;
-} {
-  const actualBytes = Math.max(0, Math.floor(Number(args.actualBytes) || 0));
-  const expectedTotal = Number.isFinite(args.plan.expectedTotal || NaN)
-    ? Math.max(0, Math.floor(args.plan.expectedTotal || 0))
-    : 0;
-  const toleranceBytes = Math.max(0, Math.floor(Number(args.toleranceBytes ?? ALLOCATION_UNIT_SIZE) || 0));
-
-  if (
-    expectedTotal > 0 &&
-    (args.plan.source === "content-range" || args.plan.source === "content-length") &&
-    actualBytes + toleranceBytes < expectedTotal
-  ) {
-    return {
-      ok: false,
-      totalBytes: expectedTotal,
-      acceptedMetadataMismatch: false,
-      error: `download_underflow:${actualBytes}/${expectedTotal}`
-    };
-  }
-
-  if (actualBytes <= 0 && expectedTotal > 0) {
-    return {
-      ok: false,
-      totalBytes: expectedTotal,
-      acceptedMetadataMismatch: false,
-      error: `download_underflow:${actualBytes}/${expectedTotal}`
-    };
-  }
-
-  if (args.plan.source === "provider-metadata") {
-    if (expectedTotal > 0 && actualBytes + toleranceBytes < expectedTotal) {
-      return {
-        ok: false,
-        totalBytes: expectedTotal,
-        acceptedMetadataMismatch: false,
-        error: `download_underflow:${actualBytes}/${expectedTotal}`
-      };
-    }
-    return {
-      ok: true,
-      totalBytes: actualBytes,
-      acceptedMetadataMismatch: expectedTotal > 0 && Math.abs(actualBytes - expectedTotal) > toleranceBytes
-    };
-  }
-
-  if (args.plan.source === "stream-end") {
-    if (actualBytes <= 0) {
-      return {
-        ok: false,
-        totalBytes: 0,
-        acceptedMetadataMismatch: false,
-        error: "download_underflow:0/0"
-      };
-    }
-    return {
-      ok: true,
-      totalBytes: actualBytes,
-      acceptedMetadataMismatch: false
-    };
-  }
-
-  return {
-    ok: true,
-    totalBytes: Math.max(actualBytes, expectedTotal),
-    acceptedMetadataMismatch: false
-  };
-}

src/main/error-ring.ts

@@ -1,45 +0,0 @@
-export interface ErrorRingEntry {
-  ts: string;
-  level: string;
-  message: string;
-}
-
-export interface ErrorRing {
-  push: (entry: ErrorRingEntry) => void;
-  snapshot: () => ErrorRingEntry[];
-  clear: () => void;
-  size: () => number;
-}
-
-export function createErrorRing(capacity: number): ErrorRing {
-  const limit = Math.max(1, Math.floor(capacity));
-  const buffer: ErrorRingEntry[] = [];
-  return {
-    push(entry: ErrorRingEntry): void {
-      buffer.push(entry);
-      while (buffer.length > limit) {
-        buffer.shift();
-      }
-    },
-    snapshot(): ErrorRingEntry[] {
-      return buffer.slice();
-    },
-    clear(): void {
-      buffer.length = 0;
-    },
-    size(): number {
-      return buffer.length;
-    }
-  };
-}
-
-const RECENT_ERROR_CAPACITY = 200;
-const recentErrors = createErrorRing(RECENT_ERROR_CAPACITY);
-
-export function recordRecentError(level: string, message: string, ts: string): void {
-  recentErrors.push({ level, message, ts });
-}
-
-export function getRecentErrors(): ErrorRingEntry[] {
-  return recentErrors.snapshot();
-}

src/main/fs-error.ts

@@ -1,56 +0,0 @@
-// Maps low-level filesystem/OS error codes to a human-readable cause so that a
-// generic "write failed" or "timeout" can be reported as the specific root cause
-// (disk full, permission denied, ...). Pure + side-effect-free for testing.
-
-const DISK_ERROR_REASONS: Record<string, string> = {
-  ENOSPC: "Festplatte voll (ENOSPC)",
-  EDQUOT: "Speicher-Kontingent erschöpft (EDQUOT)",
-  EROFS: "Laufwerk schreibgeschützt (EROFS)",
-  EACCES: "Zugriff verweigert (EACCES)",
-  EPERM: "Operation nicht erlaubt (EPERM)",
-  EMFILE: "Zu viele offene Dateien (EMFILE)",
-  ENFILE: "System-Limit offener Dateien erreicht (ENFILE)",
-  EBUSY: "Datei/Laufwerk belegt (EBUSY)",
-  ENODEV: "Gerät nicht vorhanden (ENODEV)",
-  ENXIO: "Gerät getrennt (ENXIO)",
-  EIO: "Ein-/Ausgabefehler des Datenträgers (EIO)"
-};
-
-export function classifyDiskError(err: unknown): string | null {
-  const code = extractErrorCode(err);
-  if (code && DISK_ERROR_REASONS[code]) {
-    return DISK_ERROR_REASONS[code];
-  }
-  // Some errors arrive as plain strings/messages without a `.code`; fall back to
-  // scanning the text for a known code token.
-  const text = errorText(err);
-  for (const knownCode of Object.keys(DISK_ERROR_REASONS)) {
-    if (text.includes(knownCode)) {
-      return DISK_ERROR_REASONS[knownCode];
-    }
-  }
-  return null;
-}
-
-function extractErrorCode(err: unknown): string {
-  if (err && typeof err === "object") {
-    const code = (err as { code?: unknown }).code;
-    if (typeof code === "string") {
-      return code.toUpperCase();
-    }
-  }
-  return "";
-}
-
-function errorText(err: unknown): string {
-  if (typeof err === "string") {
-    return err;
-  }
-  if (err && typeof err === "object") {
-    const message = (err as { message?: unknown }).message;
-    if (typeof message === "string") {
-      return message;
-    }
-  }
-  return String(err ?? "");
-}

src/main/item-log.ts

@@ -1,232 +0,0 @@
-import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
-import path from "node:path";
-import crypto from "node:crypto";
-
-const ITEM_LOG_FLUSH_INTERVAL_MS = 200;
-const ITEM_LOG_RETENTION_DAYS = 30;
-
-type ItemLogLevel = "INFO" | "WARN" | "ERROR";
-
-export interface ItemLogMeta {
-  itemId: string;
-  packageId: string;
-  packageName: string;
-  fileName: string;
-  targetPath: string;
-}
-
-let itemLogsDir: string | null = null;
-const knownLogPaths = new Map<string, string>();
-const pendingLinesByItem = new Map<string, string[]>();
-const initializedThisProcess = new Set<string>();
-let flushTimer: NodeJS.Timeout | null = null;
-
-function normalizeItemId(itemId: string): string {
-  const trimmed = String(itemId || "").trim();
-  if (!trimmed) {
-    return "";
-  }
-  const safePrefix = trimmed
-    .replace(/[^a-zA-Z0-9._-]/g, "_")
-    .replace(/_+/g, "_")
-    .slice(0, 64)
-    .replace(/^_+|_+$/g, "");
-  const hash = crypto.createHash("sha1").update(trimmed).digest("hex").slice(0, 12);
-  return `${safePrefix || "item"}_${hash}`;
-}
-
-function sanitizeFieldValue(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value.replace(/\r?\n/g, "\\n");
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value).replace(/\r?\n/g, "\\n");
-  } catch {
-    return String(value);
-  }
-}
-
-function formatFields(fields?: Record<string, unknown>): string {
-  if (!fields) {
-    return "";
-  }
-  const parts = Object.entries(fields)
-    .filter(([, value]) => value !== undefined && value !== null && sanitizeFieldValue(value) !== "")
-    .map(([key, value]) => `${key}=${sanitizeFieldValue(value)}`);
-  return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
-}
-
-function getItemLogFilePathFromNormalized(normalized: string): string | null {
-  if (!normalized || !itemLogsDir) {
-    return null;
-  }
-  const existing = knownLogPaths.get(normalized);
-  if (existing) {
-    return existing;
-  }
-  const logPath = path.join(itemLogsDir, `item_${normalized}.txt`);
-  knownLogPaths.set(normalized, logPath);
-  return logPath;
-}
-
-function getItemLogFilePath(itemId: string): string | null {
-  return getItemLogFilePathFromNormalized(normalizeItemId(itemId));
-}
-
-function flushPending(): void {
-  for (const [itemId, lines] of pendingLinesByItem.entries()) {
-    if (lines.length === 0) {
-      continue;
-    }
-    const logPath = getItemLogFilePathFromNormalized(itemId);
-    if (!logPath) {
-      continue;
-    }
-    const chunk = lines.join("");
-    pendingLinesByItem.set(itemId, []);
-    try {
-      fs.appendFileSync(logPath, chunk, "utf8");
-    } catch {
-    }
-  }
-}
-
-function scheduleFlush(): void {
-  if (flushTimer) {
-    return;
-  }
-  flushTimer = setTimeout(() => {
-    flushTimer = null;
-    flushPending();
-  }, ITEM_LOG_FLUSH_INTERVAL_MS);
-}
-
-async function cleanupOldItemLogs(dir: string): Promise<void> {
-  try {
-    const files = await fs.promises.readdir(dir);
-    const cutoff = Date.now() - ITEM_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    for (const file of files) {
-      if (!file.startsWith("item_") || !file.endsWith(".txt")) {
-        continue;
-      }
-      const filePath = path.join(dir, file);
-      try {
-        const stat = await fs.promises.stat(filePath);
-        if (stat.mtimeMs < cutoff) {
-          await fs.promises.unlink(filePath);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-
-function appendLine(itemId: string, line: string): void {
-  const normalized = normalizeItemId(itemId);
-  if (!normalized) {
-    return;
-  }
-  const lines = pendingLinesByItem.get(normalized) || [];
-  lines.push(line);
-  pendingLinesByItem.set(normalized, lines);
-  scheduleFlush();
-}
-
-export function initItemLogs(baseDir: string): void {
-  itemLogsDir = path.join(baseDir, "item-logs");
-  try {
-    fs.mkdirSync(itemLogsDir, { recursive: true });
-  } catch {
-    itemLogsDir = null;
-    return;
-  }
-  void cleanupOldItemLogs(itemLogsDir);
-}
-
-export function ensureItemLog(meta: ItemLogMeta): string | null {
-  const normalizedItemId = normalizeItemId(meta.itemId);
-  const logPath = getItemLogFilePath(meta.itemId);
-  if (!logPath) {
-    return null;
-  }
-  try {
-    fs.mkdirSync(path.dirname(logPath), { recursive: true });
-    if (!fs.existsSync(logPath)) {
-      fs.writeFileSync(logPath, "", "utf8");
-    }
-    if (!initializedThisProcess.has(normalizedItemId)) {
-      initializedThisProcess.add(normalizedItemId);
-      const startedAt = logTimestamp();
-      fs.appendFileSync(
-        logPath,
-        `=== Item-Log Start: ${startedAt} | itemId=${sanitizeFieldValue(String(meta.itemId || ""))} | logKey=${normalizedItemId} | fileName=${sanitizeFieldValue(meta.fileName)} ===\n`,
-        "utf8"
-      );
-      fs.appendFileSync(
-        logPath,
-        `${logTimestamp()} [INFO] Item-Kontext initialisiert${formatFields({
-          packageId: meta.packageId,
-          packageName: meta.packageName,
-          fileName: meta.fileName,
-          targetPath: meta.targetPath
-        })}\n`,
-        "utf8"
-      );
-    }
-  } catch {
-    return null;
-  }
-  return logPath;
-}
-
-export function logItemEvent(
-  itemId: string,
-  level: ItemLogLevel,
-  message: string,
-  fields?: Record<string, unknown>
-): void {
-  const logPath = getItemLogFilePath(itemId);
-  if (!logPath) {
-    return;
-  }
-  const line = `${logTimestamp()} [${level}] ${message}${formatFields(fields)}\n`;
-  appendLine(itemId, line);
-}
-
-export function getItemLogPath(itemId: string): string | null {
-  const logPath = getItemLogFilePath(itemId);
-  if (!logPath) {
-    return null;
-  }
-  return fs.existsSync(logPath) ? logPath : null;
-}
-
-export function shutdownItemLogs(): void {
-  if (flushTimer) {
-    clearTimeout(flushTimer);
-    flushTimer = null;
-  }
-  flushPending();
-  for (const itemId of knownLogPaths.keys()) {
-    const logPath = getItemLogFilePathFromNormalized(itemId);
-    if (!logPath) {
-      continue;
-    }
-    try {
-      fs.appendFileSync(logPath, `=== Item-Log Ende: ${logTimestamp()} ===\n`, "utf8");
-    } catch {
-    }
-  }
-  pendingLinesByItem.clear();
-  knownLogPaths.clear();
-  initializedThisProcess.clear();
-  itemLogsDir = null;
-}

src/main/link-export.ts

@@ -1,116 +0,0 @@
-import type { ParsedPackageInput, UiSnapshot } from "../shared/types";
-import { sanitizeFilename } from "./utils";
-
-export type LinkExportSelection = {
-  packages: ParsedPackageInput[];
-  packageCount: number;
-  linkCount: number;
-  defaultFileName: string;
-};
-
-function formatTimestampForFileName(date: Date): string {
-  const y = date.getFullYear();
-  const mo = String(date.getMonth() + 1).padStart(2, "0");
-  const d = String(date.getDate()).padStart(2, "0");
-  const h = String(date.getHours()).padStart(2, "0");
-  const mi = String(date.getMinutes()).padStart(2, "0");
-  const s = String(date.getSeconds()).padStart(2, "0");
-  return `${y}-${mo}-${d}_${h}-${mi}-${s}`;
-}
-
-function buildDefaultFileName(packages: ParsedPackageInput[]): string {
-  if (packages.length === 1) {
-    const only = packages[0];
-    if (only.links.length === 1) {
-      const itemName = sanitizeFilename(only.fileNames?.[0] || only.name || "link-export");
-      return `${itemName}.txt`;
-    }
-    return `${sanitizeFilename(only.name || "paket-export")}.txt`;
-  }
-  return `rd-link-export-${formatTimestampForFileName(new Date())}.txt`;
-}
-
-export function buildLinkExportSelection(snapshot: UiSnapshot, packageIds: string[], itemIds: string[]): LinkExportSelection {
-  const selectedPackageIds = new Set(packageIds);
-  const selectedItemIds = new Set(itemIds);
-  const packages: ParsedPackageInput[] = [];
-
-  for (const packageId of snapshot.session.packageOrder) {
-    const pkg = snapshot.session.packages[packageId];
-    if (!pkg) {
-      continue;
-    }
-
-    const useWholePackage = selectedPackageIds.has(packageId);
-    const relevantItemIds = useWholePackage
-      ? pkg.itemIds
-      : pkg.itemIds.filter((itemId) => selectedItemIds.has(itemId));
-
-    if (relevantItemIds.length === 0) {
-      continue;
-    }
-
-    const links: string[] = [];
-    const fileNames: string[] = [];
-    for (const itemId of relevantItemIds) {
-      const item = snapshot.session.items[itemId];
-      if (!item || !String(item.url || "").trim()) {
-        continue;
-      }
-      links.push(String(item.url).trim());
-      const rawFileName = String(item.fileName || "").trim();
-      fileNames.push(rawFileName ? sanitizeFilename(rawFileName) : "");
-    }
-
-    if (links.length === 0) {
-      continue;
-    }
-
-    const exportEntry: ParsedPackageInput = {
-      name: sanitizeFilename(pkg.name || "Paket"),
-      links
-    };
-    if (fileNames.some((fileName) => fileName.length > 0)) {
-      exportEntry.fileNames = fileNames;
-    }
-    packages.push(exportEntry);
-  }
-
-  const linkCount = packages.reduce((sum, pkg) => sum + pkg.links.length, 0);
-  return {
-    packages,
-    packageCount: packages.length,
-    linkCount,
-    defaultFileName: buildDefaultFileName(packages)
-  };
-}
-
-export function serializeLinkExportText(packages: ParsedPackageInput[]): string {
-  const lines: string[] = [
-    "# rd-link-export: 1",
-    "# Re-import in Real-Debrid-Downloader keeps package names and optional file names.",
-    ""
-  ];
-
-  for (const pkg of packages) {
-    if (!pkg || !pkg.name || !Array.isArray(pkg.links) || pkg.links.length === 0) {
-      continue;
-    }
-    lines.push(`# package: ${sanitizeFilename(pkg.name)}`);
-    for (let index = 0; index < pkg.links.length; index += 1) {
-      const link = String(pkg.links[index] || "").trim();
-      if (!link) {
-        continue;
-      }
-      const rawFileName = String(pkg.fileNames?.[index] || "").trim();
-      const fileName = rawFileName ? sanitizeFilename(rawFileName) : "";
-      if (fileName) {
-        lines.push(`# file: ${fileName}`);
-      }
-      lines.push(link);
-    }
-    lines.push("");
-  }
-
-  return `${lines.join("\n").trim()}\n`;
-}

src/main/link-parser.ts

@@ -2,35 +2,19 @@ import { ParsedPackageInput } from "../shared/types";
 import { inferPackageNameFromLinks, parsePackagesFromLinksText, sanitizeFilename, uniquePreserveOrder } from "./utils";
 
 export function mergePackageInputs(packages: ParsedPackageInput[]): ParsedPackageInput[] {
-  const grouped = new Map<string, { links: string[]; fileNameByLink: Map<string, string> }>();
+  const grouped = new Map<string, string[]>();
   for (const pkg of packages) {
     const name = sanitizeFilename(pkg.name || inferPackageNameFromLinks(pkg.links));
-    const current = grouped.get(name) ?? { links: [], fileNameByLink: new Map<string, string>() };
+    const list = grouped.get(name) ?? [];
-    for (let index = 0; index < pkg.links.length; index += 1) {
+    for (const link of pkg.links) {
-      const link = String(pkg.links[index] || "").trim();
+      list.push(link);
-      if (!link) {
-        continue;
     }
-      if (!current.links.includes(link)) {
+    grouped.set(name, list);
-        current.links.push(link);
   }
-      const rawFileName = String(pkg.fileNames?.[index] || "").trim();
+  return Array.from(grouped.entries()).map(([name, links]) => ({
-      const fileName = rawFileName ? sanitizeFilename(rawFileName) : "";
-      if (fileName && !current.fileNameByLink.has(link)) {
-        current.fileNameByLink.set(link, fileName);
-      }
-    }
-    grouped.set(name, current);
-  }
-  return Array.from(grouped.entries()).map(([name, entry]) => {
-    const links = uniquePreserveOrder(entry.links);
-    const fileNames = links.map((link) => entry.fileNameByLink.get(link) || "");
-    return {
     name,
-      links,
+    links: uniquePreserveOrder(links)
-      ...(fileNames.some((fileName) => fileName.length > 0) ? { fileNames } : {})
+  }));
-    };
-  });
 }
 
 export function parseCollectorInput(rawText: string, packageName = ""): ParsedPackageInput[] {

src/main/log-timestamp.ts

@@ -1,11 +0,0 @@
-export function logTimestamp(date: Date = new Date()): string {
-  const pad = (value: number, length = 2): string => String(value).padStart(length, "0");
-  const offsetMinutes = -date.getTimezoneOffset();
-  const sign = offsetMinutes >= 0 ? "+" : "-";
-  const absOffset = Math.abs(offsetMinutes);
-  const offset = `${sign}${pad(Math.floor(absOffset / 60))}:${pad(absOffset % 60)}`;
-  return (
-    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
-    `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}${offset}`
-  );
-}

src/main/logger.ts

@@ -1,24 +1,6 @@
 import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
-import { recordRecentError } from "./error-ring";
 import path from "node:path";
 
-export function isDebugFlagEnabled(value: string | undefined): boolean {
-  if (!value) {
-    return false;
-  }
-  return /^(1|true|yes|on)$/i.test(value.trim());
-}
-
-// Read once at startup. Enabling verbose DEBUG logging on the (unattended) server
-// is a deliberate support action that requires a restart — the runtime-toggleable
-// channel is the trace log, not this.
-const DEBUG_ENABLED = isDebugFlagEnabled(process.env.RD_DEBUG);
-
-export function isDebugLoggingEnabled(): boolean {
-  return DEBUG_ENABLED;
-}
-
 let logFilePath = path.resolve(process.cwd(), "rd_downloader.log");
 let fallbackLogFilePath: string | null = null;
 const LOG_FLUSH_INTERVAL_MS = 120;
@@ -27,8 +9,7 @@ const LOG_MAX_FILE_BYTES = 10 * 1024 * 1024;
 const rotateCheckAtByFile = new Map<string, number>();
 
 type LogListener = (line: string) => void;
-const logListeners = new Set<LogListener>();
+let logListener: LogListener | null = null;
-let legacyLogListener: LogListener | null = null;
 
 let pendingLines: string[] = [];
 let pendingChars = 0;
@@ -37,24 +18,7 @@ let flushInFlight = false;
 let exitHookAttached = false;
 
 export function setLogListener(listener: LogListener | null): void {
-  if (legacyLogListener) {
+  logListener = listener;
-    logListeners.delete(legacyLogListener);
-  }
-  legacyLogListener = listener;
-  if (listener) {
-    logListeners.add(listener);
-  }
-}
-
-export function addLogListener(listener: LogListener): void {
-  logListeners.add(listener);
-}
-
-export function removeLogListener(listener: LogListener): void {
-  logListeners.delete(listener);
-  if (legacyLogListener === listener) {
-    legacyLogListener = null;
-  }
 }
 
 export function configureLogger(baseDir: string): void {
@@ -87,6 +51,7 @@ function writeStderr(text: string): void {
   try {
     process.stderr.write(text);
   } catch {
+    // ignore stderr failures
   }
 }
 
@@ -152,9 +117,11 @@ function rotateIfNeeded(filePath: string): void {
     try {
       fs.rmSync(backup, { force: true });
     } catch {
+      // ignore
     }
     fs.renameSync(filePath, backup);
   } catch {
+    // ignore - file may not exist yet
   }
 }
 
@@ -174,6 +141,7 @@ async function rotateIfNeededAsync(filePath: string): Promise<void> {
     await fs.promises.rm(backup, { force: true }).catch(() => {});
     await fs.promises.rename(filePath, backup);
   } catch {
+    // ignore - file may not exist yet
   }
 }
 
@@ -183,14 +151,7 @@ async function flushAsync(): Promise<void> {
   }
 
   flushInFlight = true;
-  // Move (not copy) the pending lines out and take ownership. A concurrent write()
+  const linesSnapshot = pendingLines.slice();
-  // during the await below pushes new lines AND can trim the 1MB cap from the FRONT
-  // of pendingLines; the old count-based removal (pendingLines.slice(snapshot.length))
-  // then sliced off the wrong lines and dropped unwritten ones. Resetting the buffer
-  // here means await-time writes queue independently and nothing desyncs.
-  const linesSnapshot = pendingLines;
-  pendingLines = [];
-  pendingChars = 0;
   const chunk = linesSnapshot.join("");
 
   try {
@@ -207,19 +168,9 @@ async function flushAsync(): Promise<void> {
     } else if (!primary.ok) {
       writeStderr(`LOGGER write failed: ${primary.errorText}\n`);
     }
-    if (!wroteAny) {
+    if (wroteAny) {
-      // Write failed: requeue the unwritten lines AHEAD of anything that arrived
+      pendingLines = pendingLines.slice(linesSnapshot.length);
-      // during the await (preserve order), then re-apply the buffer cap so a
+      pendingChars = Math.max(0, pendingChars - chunk.length);
-      // persistent write failure cannot grow the buffer without bound.
-      pendingLines = linesSnapshot.concat(pendingLines);
-      pendingChars += chunk.length;
-      while (pendingChars > LOG_BUFFER_LIMIT_CHARS && pendingLines.length > 1) {
-        const removed = pendingLines.shift();
-        if (!removed) {
-          break;
-        }
-        pendingChars = Math.max(0, pendingChars - removed.length);
-      }
     }
   } finally {
     flushInFlight = false;
@@ -238,21 +189,14 @@ function ensureExitHook(): void {
   process.once("exit", flushSyncPending);
 }
 
-function write(level: "DEBUG" | "INFO" | "WARN" | "ERROR", message: string): void {
+function write(level: "INFO" | "WARN" | "ERROR", message: string): void {
   ensureExitHook();
-  const ts = logTimestamp();
+  const line = `${new Date().toISOString()} [${level}] ${message}\n`;
-  const line = `${ts} [${level}] ${message}\n`;
   pendingLines.push(line);
   pendingChars += line.length;
 
-  // Single chokepoint: every WARN/ERROR also lands in the in-memory ring so
+  if (logListener) {
-  // "what failed recently" is answerable even after the file rotates.
+    try { logListener(line); } catch { /* ignore */ }
-  if (level === "ERROR" || level === "WARN") {
-    recordRecentError(level, message, ts);
-  }
-
-  for (const listener of logListeners) {
-    try { listener(line); } catch {  }
   }
 
   while (pendingChars > LOG_BUFFER_LIMIT_CHARS && pendingLines.length > 1) {
@@ -271,9 +215,6 @@ function write(level: "DEBUG" | "INFO" | "WARN" | "ERROR", message: string): voi
 }
 
 export const logger = {
-  // Gated to a no-op when RD_DEBUG is unset so verbose call sites cost nothing
-  // (no formatting, no allocation) in the normal/production path.
-  debug: DEBUG_ENABLED ? (msg: string): void => write("DEBUG", msg) : (_msg: string): void => {},
   info: (msg: string): void => write("INFO", msg),
   warn: (msg: string): void => write("WARN", msg),
   error: (msg: string): void => write("ERROR", msg)

src/main/main.ts

@@ -9,6 +9,7 @@ import { APP_NAME } from "./constants";
 import { extractHttpLinksFromText } from "./utils";
 import { cleanupStaleSubstDrives, shutdownDaemon } from "./extractor";
 
+/* ── IPC validation helpers ────────────────────────────────────── */
 function validateString(value: unknown, name: string): string {
   if (typeof value !== "string") {
     throw new Error(`${name} muss ein String sein`);
@@ -43,23 +44,19 @@ function validateStringArray(value: unknown, name: string): string[] {
   return value as string[];
 }
 
+/* ── Single Instance Lock ───────────────────────────────────────── */
 const gotLock = app.requestSingleInstanceLock();
 if (!gotLock) {
   app.exit(0);
   process.exit(0);
 }
 
+/* ── Unhandled error protection ─────────────────────────────────── */
 process.on("uncaughtException", (error) => {
   logger.error(`Uncaught Exception: ${String(error?.stack || error)}`);
 });
 process.on("unhandledRejection", (reason) => {
-  const detail = reason instanceof Error ? (reason.stack || reason.message) : String(reason);
+  logger.error(`Unhandled Rejection: ${String(reason)}`);
-  logger.error(`Unhandled Rejection: ${detail}`);
-});
-// Node-Warnungen (z.B. MaxListenersExceeded, DeprecationWarning) sind ein
-// Frühindikator für Leaks/Fehlnutzung in einem langlaufenden Server-Prozess.
-process.on("warning", (warning) => {
-  logger.warn(`Node-Warnung: ${warning.name}: ${warning.message}${warning.stack ? ` | ${warning.stack.replace(/\s*\n\s*/g, " ⏎ ")}` : ""}`);
 });
 
 let mainWindow: BrowserWindow | null = null;
@@ -116,23 +113,6 @@ function createWindow(): BrowserWindow {
   return window;
 }
 
-let rendererReloadTimes: number[] = [];
-const RENDERER_RELOAD_WINDOW_MS = 5 * 60 * 1000;
-const RENDERER_RELOAD_MAX = 3;
-
-// Circuit breaker: recover from a one-off renderer crash by reloading, but stop
-// after a few crashes in a short window so a reproducible crash can't spin into a
-// reload loop that pegs an unattended server.
-function allowRendererReload(): boolean {
-  const now = Date.now();
-  rendererReloadTimes = rendererReloadTimes.filter((t) => now - t < RENDERER_RELOAD_WINDOW_MS);
-  if (rendererReloadTimes.length >= RENDERER_RELOAD_MAX) {
-    return false;
-  }
-  rendererReloadTimes.push(now);
-  return true;
-}
-
 function bindMainWindowLifecycle(window: BrowserWindow): void {
   window.on("close", (event) => {
     const settings = controller.getSettings();
@@ -147,33 +127,6 @@ function bindMainWindowLifecycle(window: BrowserWindow): void {
       mainWindow = null;
     }
   });
-
-  window.webContents.on("render-process-gone", (_event, details) => {
-    logger.error(`Renderer-Prozess beendet: reason=${details.reason} exitCode=${details.exitCode ?? "?"}`);
-    if (details.reason === "clean-exit" || window.isDestroyed()) {
-      return;
-    }
-    if (allowRendererReload()) {
-      logger.warn("Renderer wird automatisch neu geladen (Wiederherstellung nach Absturz)");
-      try {
-        window.webContents.reload();
-      } catch (error) {
-        logger.error(`Renderer-Reload fehlgeschlagen: ${String(error)}`);
-      }
-    } else {
-      logger.error(`Renderer-Absturz: Auto-Reload gestoppt (mehr als ${RENDERER_RELOAD_MAX} Abstürze in ${RENDERER_RELOAD_WINDOW_MS / 60000} Min) - manueller Neustart nötig`);
-    }
-  });
-
-  // Nur protokollieren, niemals killen/neu laden: "unresponsive" feuert auch
-  // während legitimer langer Sync-Arbeit (große JSON-Serialisierung) und erholt
-  // sich meist von selbst. Eingreifen würde einen Schluckauf zum Ausfall machen.
-  window.webContents.on("unresponsive", () => {
-    logger.warn("Renderer reagiert nicht (unresponsive) - evtl. langer Sync-Task, warte auf Erholung");
-  });
-  window.webContents.on("responsive", () => {
-    logger.info("Renderer wieder reaktionsfähig (responsive)");
-  });
 }
 
 function createTray(): void {
@@ -183,8 +136,7 @@ function createTray(): void {
   const iconPath = path.join(app.getAppPath(), "assets", "app_icon.ico");
   try {
     tray = new Tray(iconPath);
-  } catch (error) {
+  } catch {
-    logger.warn(`Tray-Icon konnte nicht erstellt werden (Headless/RDP/Service?): ${String(error)} - Minimize-to-Tray steht nicht zur Verfuegung, Fenster bleibt sichtbar.`);
     return;
   }
   tray.setToolTip(APP_NAME);
@@ -305,7 +257,7 @@ function registerIpcHandlers(): void {
     if (result.started) {
       updateQuitTimer = setTimeout(() => {
         app.quit();
-      }, 5000);
+      }, 900);
     }
     return result;
   });
@@ -326,6 +278,7 @@ function registerIpcHandlers(): void {
     const result = controller.updateSettings(validated as Partial<AppSettings>);
     updateClipboardWatcher();
     updateTray();
+    // Manage scheduled-start timer
     if (scheduledStartTimer !== null) {
       clearTimeout(scheduledStartTimer);
       scheduledStartTimer = null;
@@ -334,6 +287,7 @@ function registerIpcHandlers(): void {
     if (schedMs > 0) {
       const delay = schedMs - Date.now();
       if (delay <= 0) {
+        // Time already passed — start immediately and clear setting
         void controller.start().catch((err) => logger.warn(`Scheduled-Start Fehler: ${String(err)}`));
         controller.updateSettings({ scheduledStartEpochMs: 0 });
       } else {
@@ -387,6 +341,7 @@ function registerIpcHandlers(): void {
   });
   ipcMain.handle(IPC_CHANNELS.CLEAR_ALL, () => controller.clearAll());
   ipcMain.handle(IPC_CHANNELS.START, () => {
+    // Cancel any pending scheduled start when the user starts manually
     if (scheduledStartTimer !== null) {
       clearTimeout(scheduledStartTimer);
       scheduledStartTimer = null;
@@ -428,40 +383,6 @@ function registerIpcHandlers(): void {
     validateString(packageId, "packageId");
     return controller.togglePackage(packageId);
   });
-  ipcMain.handle(IPC_CHANNELS.EXPORT_PACKAGE_SELECTION, async (_event: IpcMainInvokeEvent, packageIds: string[]) => {
-    const validPackageIds = validateStringArray(packageIds ?? [], "packageIds");
-    const exported = controller.exportPackageSelection(validPackageIds);
-    if (exported.packageCount === 0 || exported.linkCount === 0) {
-      return { saved: false, packageCount: 0, linkCount: 0 };
-    }
-    const options = {
-      defaultPath: exported.defaultFileName,
-      filters: [{ name: "Link Export", extensions: ["txt"] }]
-    };
-    const result = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);
-    if (result.canceled || !result.filePath) {
-      return { saved: false, packageCount: exported.packageCount, linkCount: exported.linkCount };
-    }
-    await fs.promises.writeFile(result.filePath, exported.text, "utf8");
-    return { saved: true, packageCount: exported.packageCount, linkCount: exported.linkCount, filePath: result.filePath };
-  });
-  ipcMain.handle(IPC_CHANNELS.EXPORT_ITEM_SELECTION, async (_event: IpcMainInvokeEvent, itemIds: string[]) => {
-    const validItemIds = validateStringArray(itemIds ?? [], "itemIds");
-    const exported = controller.exportItemSelection(validItemIds);
-    if (exported.packageCount === 0 || exported.linkCount === 0) {
-      return { saved: false, packageCount: 0, linkCount: 0 };
-    }
-    const options = {
-      defaultPath: exported.defaultFileName,
-      filters: [{ name: "Link Export", extensions: ["txt"] }]
-    };
-    const result = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);
-    if (result.canceled || !result.filePath) {
-      return { saved: false, packageCount: exported.packageCount, linkCount: exported.linkCount };
-    }
-    await fs.promises.writeFile(result.filePath, exported.text, "utf8");
-    return { saved: true, packageCount: exported.packageCount, linkCount: exported.linkCount, filePath: result.filePath };
-  });
   ipcMain.handle(IPC_CHANNELS.RETRY_EXTRACTION, (_event: IpcMainInvokeEvent, packageId: string) => {
     validateString(packageId, "packageId");
     return controller.retryExtraction(packageId);
@@ -569,39 +490,11 @@ function registerIpcHandlers(): void {
     return { saved: true };
   });
 
-  ipcMain.handle(IPC_CHANNELS.EXPORT_SUPPORT_BUNDLE, async () => {
-    const options = {
-      defaultPath: controller.getSupportBundleDefaultFileName(),
-      filters: [{ name: "Support Bundle", extensions: ["zip"] }]
-    };
-    const result = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);
-    if (result.canceled || !result.filePath) {
-      return { saved: false };
-    }
-    const exported = controller.exportSupportBundle();
-    await fs.promises.writeFile(result.filePath, exported.buffer);
-    return { saved: true, filePath: result.filePath };
-  });
-
   ipcMain.handle(IPC_CHANNELS.OPEN_LOG, async () => {
     const logPath = getLogFilePath();
     await shell.openPath(logPath);
   });
 
-  ipcMain.handle(IPC_CHANNELS.OPEN_AUDIT_LOG, async () => {
-    const logPath = controller.getAuditLogPath();
-    if (logPath) {
-      await shell.openPath(logPath);
-    }
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OPEN_RENAME_LOG, async () => {
-    const logPath = controller.getRenameLogPath();
-    if (logPath) {
-      await shell.openPath(logPath);
-    }
-  });
-
   ipcMain.handle(IPC_CHANNELS.OPEN_SESSION_LOG, async () => {
     const logPath = controller.getSessionLogPath();
     if (logPath) {
@@ -609,13 +502,6 @@ function registerIpcHandlers(): void {
     }
   });
 
-  ipcMain.handle(IPC_CHANNELS.OPEN_TRACE_LOG, async () => {
-    const logPath = controller.getTraceLogPath();
-    if (logPath) {
-      await shell.openPath(logPath);
-    }
-  });
-
   ipcMain.handle(IPC_CHANNELS.OPEN_PACKAGE_LOG, async (_event: IpcMainInvokeEvent, packageId: string) => {
     validateString(packageId, "packageId");
     const logPath = controller.getPackageLogPath(packageId);
@@ -624,36 +510,6 @@ function registerIpcHandlers(): void {
     }
   });
 
-  ipcMain.handle(IPC_CHANNELS.GET_DEBUG_SETUP_CHECK, async () => controller.getDebugSetupCheck());
-
-  ipcMain.handle(IPC_CHANNELS.GET_TRACE_CONFIG, async () => controller.getTraceConfig());
-
-  ipcMain.handle(IPC_CHANNELS.SET_TRACE_ENABLED, async (_event: IpcMainInvokeEvent, enabled: boolean, note?: string, durationMinutes?: number) => {
-    if (typeof enabled !== "boolean") {
-      throw new Error("enabled muss ein Boolean sein");
-    }
-    if (note !== undefined) {
-      validateString(note, "note");
-    }
-    if (durationMinutes !== undefined && (!Number.isFinite(durationMinutes) || durationMinutes <= 0)) {
-      throw new Error("durationMinutes muss eine positive Zahl sein");
-    }
-    return controller.setTraceEnabled(enabled, note, durationMinutes ? durationMinutes * 60 * 1000 : undefined);
-  });
-
-  ipcMain.handle(IPC_CHANNELS.ROTATE_DEBUG_TOKEN, async () => {
-    const rotated = controller.rotateDebugToken();
-    return { path: rotated.path };
-  });
-
-  ipcMain.handle(IPC_CHANNELS.OPEN_ITEM_LOG, async (_event: IpcMainInvokeEvent, itemId: string) => {
-    validateString(itemId, "itemId");
-    const logPath = controller.getItemLogPath(itemId);
-    if (logPath) {
-      await shell.openPath(logPath);
-    }
-  });
-
   ipcMain.handle(IPC_CHANNELS.OPEN_REALDEBRID_LOGIN, async () => {
     await controller.openRealDebridLoginWindow();
   });
@@ -685,14 +541,6 @@ function registerIpcHandlers(): void {
     return controller.getDebridLinkHostLimits();
   });
 
-  ipcMain.handle(IPC_CHANNELS.CHECK_DEBRID_ACCOUNTS, async () => {
-    return controller.checkDebridAccounts();
-  });
-
-  ipcMain.handle(IPC_CHANNELS.CHECK_MEGA_DEBRID_ACCOUNT, async (_event, login: string, password: string) => {
-    return controller.checkSingleMegaDebridAccount(String(login || ""), String(password || ""));
-  });
-
   ipcMain.handle(IPC_CHANNELS.IMPORT_BACKUP, async () => {
     const options = {
       properties: ["openFile"] as Array<"openFile">,
@@ -713,25 +561,7 @@ function registerIpcHandlers(): void {
       return { restored: false, message: `Backup-Datei zu groß (max 50 MB, Datei hat ${(stat.size / 1024 / 1024).toFixed(1)} MB)` };
     }
     const data = await fs.promises.readFile(filePath);
-    const importResult = controller.importBackup(data);
+    return controller.importBackup(data);
-    // Only a full restore (queue swapped) needs the auto-relaunch. A settings-
-    // only import applied live — relaunching would be pointless and would drop
-    // the running queue.
-    if (importResult.restored && importResult.relaunch) {
-      setTimeout(() => {
-        app.relaunch();
-        app.quit();
-      }, 1500);
-    }
-    return importResult;
-  });
-
-  ipcMain.on(IPC_CHANNELS.LOG_RENDERER_ERROR, (_event, rawReport: unknown) => {
-    try {
-      logger.error(formatRendererErrorReport(rawReport));
-    } catch (error) {
-      logger.error(`[Renderer] Fehlerbericht konnte nicht verarbeitet werden: ${String(error)}`);
-    }
   });
 
   controller.onState = (snapshot) => {
@@ -742,41 +572,6 @@ function registerIpcHandlers(): void {
   };
 }
 
-function formatRendererErrorReport(rawReport: unknown): string {
-  const report = (rawReport && typeof rawReport === "object" ? rawReport : {}) as Record<string, unknown>;
-  const str = (value: unknown): string => (typeof value === "string" ? value : "");
-  const num = (value: unknown): string => (typeof value === "number" && Number.isFinite(value) ? String(value) : "");
-  const kind = str(report.kind) || "error";
-  const message = (str(report.message) || "(ohne Nachricht)").slice(0, 2000);
-  const source = str(report.source);
-  const line = num(report.line);
-  const column = num(report.column);
-  const stack = str(report.stack).slice(0, 4000);
-  const componentStack = str(report.componentStack).slice(0, 4000);
-
-  const parts: string[] = [`[Renderer:${kind}] ${message}`];
-  if (source) {
-    parts.push(`@ ${source}${line ? `:${line}${column ? `:${column}` : ""}` : ""}`);
-  }
-  if (stack) {
-    parts.push(`| stack: ${stack.replace(/\s*\n\s*/g, " ⏎ ")}`);
-  }
-  if (componentStack) {
-    parts.push(`| react: ${componentStack.replace(/\s*\n\s*/g, " ⏎ ")}`);
-  }
-  return parts.join(" ");
-}
-
-app.on("child-process-gone", (_event, details) => {
-  const killed = details.reason !== "clean-exit" && details.reason !== "killed";
-  const line = `Subprozess beendet: type=${details.type} reason=${details.reason} exitCode=${details.exitCode ?? "?"}${details.name ? ` name=${details.name}` : ""}${details.serviceName ? ` service=${details.serviceName}` : ""}`;
-  if (killed) {
-    logger.error(line);
-  } else {
-    logger.warn(line);
-  }
-});
-
 app.on("second-instance", () => {
   if (mainWindow) {
     if (mainWindow.isMinimized()) {

src/main/mega-public-api.ts

@@ -1,129 +0,0 @@
-import crypto from "node:crypto";
-
-const MEGA_API_BASE = "https://g.api.mega.co.nz/cs";
-const MEGA_API_TIMEOUT_MS = 12_000;
-
-export interface MegaFileInfo {
-  name: string;
-  size: number;
-}
-
-const NEW_FORMAT_RE = /^https?:\/\/mega\.(?:nz|co\.nz)\/file\/([A-Za-z0-9_-]+)#([A-Za-z0-9_-]+)/i;
-const LEGACY_FORMAT_RE = /^https?:\/\/mega\.(?:nz|co\.nz)\/#!([A-Za-z0-9_-]+)!([A-Za-z0-9_-]+)/i;
-
-export function isMegaFileUrl(url: string): boolean {
-  const s = String(url || "").trim();
-  return NEW_FORMAT_RE.test(s) || LEGACY_FORMAT_RE.test(s);
-}
-
-function base64UrlDecode(s: string): Buffer | null {
-  let b64 = String(s || "").trim().replace(/-/g, "+").replace(/_/g, "/");
-  while (b64.length % 4 !== 0) b64 += "=";
-  try {
-    return Buffer.from(b64, "base64");
-  } catch {
-    return null;
-  }
-}
-
-export interface ParsedMegaLink {
-  id: string;
-  rawKey: Buffer;
-}
-
-export function parseMegaUrl(url: string): ParsedMegaLink | null {
-  const s = String(url || "").trim();
-  const m = NEW_FORMAT_RE.exec(s) || LEGACY_FORMAT_RE.exec(s);
-  if (!m) return null;
-  const id = m[1];
-  const rawKey = base64UrlDecode(m[2]);
-  if (!rawKey || rawKey.length !== 32) return null;
-  return { id, rawKey };
-}
-
-export function decryptMegaAttributes(encrypted: Buffer, aesKey: Buffer): Record<string, unknown> | null {
-  if (!Buffer.isBuffer(encrypted) || encrypted.length === 0 || encrypted.length % 16 !== 0) return null;
-  if (!Buffer.isBuffer(aesKey) || aesKey.length !== 16) return null;
-  let plain: Buffer;
-  try {
-    const decipher = crypto.createDecipheriv("aes-128-cbc", aesKey, Buffer.alloc(16));
-    decipher.setAutoPadding(false);
-    plain = Buffer.concat([decipher.update(encrypted), decipher.final()]);
-  } catch {
-    return null;
-  }
-  const text = plain.toString("utf8").replace(/\0+$/, "").trim();
-  if (!text.startsWith("MEGA{")) return null;
-  try {
-    return JSON.parse(text.slice(4));
-  } catch {
-    return null;
-  }
-}
-
-function withTimeoutSignal(parent: AbortSignal | undefined, timeoutMs: number): AbortSignal {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort("mega-api-timeout"), timeoutMs);
-  if (parent) {
-    if (parent.aborted) {
-      controller.abort(parent.reason);
-    } else {
-      parent.addEventListener("abort", () => controller.abort(parent.reason), { once: true });
-    }
-  }
-  controller.signal.addEventListener("abort", () => clearTimeout(timer), { once: true });
-  return controller.signal;
-}
-
-export async function resolveMegaFilename(
-  url: string,
-  signal?: AbortSignal
-): Promise<MegaFileInfo | null> {
-  const parsed = parseMegaUrl(url);
-  if (!parsed) return null;
-  const aesKey = parsed.rawKey.subarray(0, 16);
-
-  const apiUrl = `${MEGA_API_BASE}?id=${Math.floor(Math.random() * 1e9)}`;
-  const body = JSON.stringify([{ a: "g", g: 1, p: parsed.id }]);
-
-  let response: Response;
-  try {
-    response = await fetch(apiUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body,
-      signal: withTimeoutSignal(signal, MEGA_API_TIMEOUT_MS)
-    });
-  } catch {
-    return null;
-  }
-  if (!response.ok) return null;
-
-  let payload: unknown;
-  try {
-    payload = await response.json();
-  } catch {
-    return null;
-  }
-
-  if (typeof payload === "number") return null;
-  if (!Array.isArray(payload) || payload.length === 0) return null;
-
-  const first = payload[0];
-  if (typeof first === "number") return null;
-  if (!first || typeof first !== "object") return null;
-
-  const info = first as { s?: unknown; at?: unknown; e?: unknown };
-  if (typeof info.e === "number" && info.e !== 0) return null;
-
-  const size = typeof info.s === "number" && info.s > 0 ? info.s : 0;
-  if (typeof info.at !== "string" || !info.at.trim()) return null;
-
-  const encryptedAttrs = base64UrlDecode(info.at);
-  if (!encryptedAttrs) return null;
-
-  const attrs = decryptMegaAttributes(encryptedAttrs, aesKey);
-  if (!attrs || typeof attrs.n !== "string" || !attrs.n.trim()) return null;
-
-  return { name: attrs.n.trim(), size };
-}

src/main/mega-web-fallback.ts

@@ -16,8 +16,6 @@ const DEBRID_URL = "https://www.mega-debrid.eu/index.php?form=debrid";
 const DEBRID_AJAX_URL = "https://www.mega-debrid.eu/index.php?ajax=debrid&json";
 const DEBRID_REFERER = "https://www.mega-debrid.eu/index.php?page=debrideur&lang=de";
 
-export const MEGA_DEBRID_NO_SERVER_RE = /kein server f(?:ü|u)r diesen hoster|no server (?:is )?available for this host|aucun serveur disponible/i;
-
 function normalizeLink(link: string): string {
   return link.trim().toLowerCase();
 }
@@ -221,38 +219,43 @@ export class MegaWebFallback {
 
   private getCredentials: () => MegaCredentials;
 
-  private sessions = new Map<string, { cookie: string; setAt: number }>();
+  private cookie = "";
+
+  private cookieSetAt = 0;
 
   public constructor(getCredentials: () => MegaCredentials) {
     this.getCredentials = getCredentials;
   }
 
-  public async unrestrict(
+  public async unrestrict(link: string, signal?: AbortSignal): Promise<UnrestrictedLink | null> {
-    link: string,
-    signal?: AbortSignal,
-    account?: { login: string; password: string }
-  ): Promise<UnrestrictedLink | null> {
     const overallSignal = withTimeoutSignal(signal, 180000);
     return this.runExclusive(async () => {
       throwIfAborted(overallSignal);
-      const creds = (account && account.login.trim() && account.password.trim())
+      const creds = this.getCredentials();
-        ? account
-        : this.getCredentials();
       if (!creds.login.trim() || !creds.password.trim()) {
         return null;
       }
-      const key = creds.login.trim().toLowerCase();
-      let cookie = await this.ensureSession(key, creds.login, creds.password, overallSignal);
 
-      let generated = await this.generate(link, cookie, overallSignal);
+      if (!this.cookie || Date.now() - this.cookieSetAt > 20 * 60 * 1000) {
-      if (!generated) {
+        await this.login(creds.login, creds.password, overallSignal);
-        this.sessions.delete(key);
+      }
-        cookie = await this.ensureSession(key, creds.login, creds.password, overallSignal);
+
-        generated = await this.generate(link, cookie, overallSignal);
+      const generated = await this.generate(link, overallSignal);
       if (!generated) {
+        this.cookie = "";
+        await this.login(creds.login, creds.password, overallSignal);
+        const retry = await this.generate(link, overallSignal);
+        if (!retry) {
           return null;
         }
+        return {
+          directUrl: retry.directUrl,
+          fileName: retry.fileName || filenameFromUrl(link),
+          fileSize: null,
+          retriesUsed: 0
+        };
       }
+
       return {
         directUrl: generated.directUrl,
         fileName: generated.fileName || filenameFromUrl(link),
@@ -262,18 +265,9 @@ export class MegaWebFallback {
     }, overallSignal);
   }
 
-  private async ensureSession(key: string, login: string, password: string, signal?: AbortSignal): Promise<string> {
-    const existing = this.sessions.get(key);
-    if (existing && existing.cookie && Date.now() - existing.setAt <= 20 * 60 * 1000) {
-      return existing.cookie;
-    }
-    const cookie = await this.login(login, password, signal);
-    this.sessions.set(key, { cookie, setAt: Date.now() });
-    return cookie;
-  }
-
   public invalidateSession(): void {
-    this.sessions.clear();
+    this.cookie = "";
+    this.cookieSetAt = 0;
   }
 
   private async runExclusive<T>(job: () => Promise<T>, signal?: AbortSignal): Promise<T> {
@@ -292,7 +286,7 @@ export class MegaWebFallback {
     return raceWithAbort(run, signal);
   }
 
-  private async login(login: string, password: string, signal?: AbortSignal): Promise<string> {
+  private async login(login: string, password: string, signal?: AbortSignal): Promise<void> {
     throwIfAborted(signal);
     const response = await fetch(LOGIN_URL, {
       method: "POST",
@@ -329,17 +323,18 @@ export class MegaWebFallback {
       throw new Error("Mega-Web Login ungültig oder Session blockiert");
     }
 
-    return cookie;
+    this.cookie = cookie;
+    this.cookieSetAt = Date.now();
   }
 
-  private async generate(link: string, cookie: string, signal?: AbortSignal): Promise<{ directUrl: string; fileName: string } | null> {
+  private async generate(link: string, signal?: AbortSignal): Promise<{ directUrl: string; fileName: string } | null> {
     throwIfAborted(signal);
     const page = await fetch(DEBRID_URL, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",
         "User-Agent": "Mozilla/5.0",
-        Cookie: cookie,
+        Cookie: this.cookie,
         Referer: DEBRID_REFERER
       },
       body: new URLSearchParams({
@@ -352,17 +347,13 @@ export class MegaWebFallback {
 
     const html = await page.text();
 
+    // Check for permanent hoster errors before looking for debrid codes
     const pageErrors = parsePageErrors(html);
     const permanentError = isPermanentHosterError(pageErrors);
     if (permanentError) {
       throw new Error(`Mega-Web: Link permanent ungültig (${permanentError})`);
     }
 
-    const noServerError = pageErrors.find((err) => MEGA_DEBRID_NO_SERVER_RE.test(err));
-    if (noServerError) {
-      throw new Error(`Mega-Web: ${noServerError}`);
-    }
-
     const code = pickCode(parseCodes(html), link);
     if (!code) {
       return null;
@@ -375,7 +366,7 @@ export class MegaWebFallback {
         headers: {
           "Content-Type": "application/x-www-form-urlencoded",
           "User-Agent": "Mozilla/5.0",
-          Cookie: cookie,
+          Cookie: this.cookie,
           Referer: DEBRID_REFERER
         },
         body: new URLSearchParams({
@@ -404,10 +395,6 @@ export class MegaWebFallback {
           await sleepWithSignal(1200, signal);
           continue;
         }
-        const serverMsg = (parsed.text || "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
-        if (serverMsg && MEGA_DEBRID_NO_SERVER_RE.test(serverMsg)) {
-          throw new Error(`Mega-Web: ${serverMsg}`);
-        }
         return null;
       }
 
@@ -428,7 +415,7 @@ export class MegaWebFallback {
   }
 
   public dispose(): void {
-    this.sessions.clear();
+    this.cookie = "";
   }
 }
 

src/main/package-log.ts

@@ -1,7 +1,5 @@
 import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
 import path from "node:path";
-import crypto from "node:crypto";
 
 const PACKAGE_LOG_FLUSH_INTERVAL_MS = 200;
 const PACKAGE_LOG_RETENTION_DAYS = 30;
@@ -22,17 +20,7 @@ const initializedThisProcess = new Set<string>();
 let flushTimer: NodeJS.Timeout | null = null;
 
 function normalizePackageId(packageId: string): string {
-  const trimmed = String(packageId || "").trim();
+  return String(packageId || "").trim();
-  if (!trimmed) {
-    return "";
-  }
-  const safePrefix = trimmed
-    .replace(/[^a-zA-Z0-9._-]/g, "_")
-    .replace(/_+/g, "_")
-    .slice(0, 64)
-    .replace(/^_+|_+$/g, "");
-  const hash = crypto.createHash("sha1").update(trimmed).digest("hex").slice(0, 12);
-  return `${safePrefix || "pkg"}_${hash}`;
 }
 
 function sanitizeFieldValue(value: unknown): string {
@@ -62,7 +50,8 @@ function formatFields(fields?: Record<string, unknown>): string {
   return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
 }
 
-function getPackageLogFilePathFromNormalized(normalized: string): string | null {
+function getPackageLogFilePath(packageId: string): string | null {
+  const normalized = normalizePackageId(packageId);
   if (!normalized || !packageLogsDir) {
     return null;
   }
@@ -75,16 +64,12 @@ function getPackageLogFilePathFromNormalized(normalized: string): string | null
   return logPath;
 }
 
-function getPackageLogFilePath(packageId: string): string | null {
-  return getPackageLogFilePathFromNormalized(normalizePackageId(packageId));
-}
-
 function flushPending(): void {
   for (const [packageId, lines] of pendingLinesByPackage.entries()) {
     if (lines.length === 0) {
       continue;
     }
-    const logPath = getPackageLogFilePathFromNormalized(packageId);
+    const logPath = getPackageLogFilePath(packageId);
     if (!logPath) {
       continue;
     }
@@ -93,6 +78,7 @@ function flushPending(): void {
     try {
       fs.appendFileSync(logPath, chunk, "utf8");
     } catch {
+      // ignore write errors
     }
   }
 }
@@ -122,9 +108,11 @@ async function cleanupOldPackageLogs(dir: string): Promise<void> {
           await fs.promises.unlink(filePath);
         }
       } catch {
+        // ignore locked/missing files
       }
     }
   } catch {
+    // ignore missing dir
   }
 }
 
@@ -151,8 +139,8 @@ export function initPackageLogs(baseDir: string): void {
 }
 
 export function ensurePackageLog(meta: PackageLogMeta): string | null {
-  const normalizedPackageId = normalizePackageId(meta.packageId);
+  const packageId = normalizePackageId(meta.packageId);
-  const logPath = getPackageLogFilePath(meta.packageId);
+  const logPath = getPackageLogFilePath(packageId);
   if (!logPath) {
     return null;
   }
@@ -161,17 +149,17 @@ export function ensurePackageLog(meta: PackageLogMeta): string | null {
     if (!fs.existsSync(logPath)) {
       fs.writeFileSync(logPath, "", "utf8");
     }
-    if (!initializedThisProcess.has(normalizedPackageId)) {
+    if (!initializedThisProcess.has(packageId)) {
-      initializedThisProcess.add(normalizedPackageId);
+      initializedThisProcess.add(packageId);
-      const startedAt = logTimestamp();
+      const startedAt = new Date().toISOString();
       fs.appendFileSync(
         logPath,
-        `=== Paket-Log Start: ${startedAt} | packageId=${sanitizeFieldValue(String(meta.packageId || ""))} | logKey=${normalizedPackageId} | name=${sanitizeFieldValue(meta.name)} ===\n`,
+        `=== Paket-Log Start: ${startedAt} | packageId=${packageId} | name=${sanitizeFieldValue(meta.name)} ===\n`,
         "utf8"
       );
       fs.appendFileSync(
         logPath,
-        `${logTimestamp()} [INFO] Paket-Kontext initialisiert${formatFields({
+        `${new Date().toISOString()} [INFO] Paket-Kontext initialisiert${formatFields({
           name: meta.name,
           outputDir: meta.outputDir,
           extractDir: meta.extractDir
@@ -195,7 +183,7 @@ export function logPackageEvent(
   if (!logPath) {
     return;
   }
-  const line = `${logTimestamp()} [${level}] ${message}${formatFields(fields)}\n`;
+  const line = `${new Date().toISOString()} [${level}] ${message}${formatFields(fields)}\n`;
   appendLine(packageId, line);
 }
 
@@ -214,13 +202,14 @@ export function shutdownPackageLogs(): void {
   }
   flushPending();
   for (const packageId of knownLogPaths.keys()) {
-    const logPath = getPackageLogFilePathFromNormalized(packageId);
+    const logPath = getPackageLogFilePath(packageId);
     if (!logPath) {
       continue;
     }
     try {
-      fs.appendFileSync(logPath, `=== Paket-Log Ende: ${logTimestamp()} ===\n`, "utf8");
+      fs.appendFileSync(logPath, `=== Paket-Log Ende: ${new Date().toISOString()} ===\n`, "utf8");
     } catch {
+      // ignore
     }
   }
   pendingLinesByPackage.clear();

src/main/realdebrid-web.ts

@@ -158,10 +158,12 @@ export class RealDebridWebFallback {
           storages: ["cookies", "indexdb", "localstorage", "serviceworkers", "cachestorage"]
         });
       } catch {
+        // ignore
       }
       try {
         await currentSession.clearCache();
       } catch {
+        // ignore
       }
     }
   }
@@ -318,6 +320,7 @@ export class RealDebridWebFallback {
         return this.rememberToken(token);
       }
     } catch {
+      // ignore window scraping errors and fall back to session fetch
     }
 
     return null;
@@ -327,12 +330,14 @@ export class RealDebridWebFallback {
     try {
       await this.extractApiTokenFromWindow(window);
     } catch {
+      // ignore best-effort token warmup failures
     }
   }
 
   private async extractApiToken(signal?: AbortSignal): Promise<string | null> {
     throwIfAborted(signal);
 
+    // Return cached token if fresh (max 30 min)
     if (this.cachedToken && Date.now() - this.cachedTokenAt < 30 * 60 * 1000) {
       return this.cachedToken;
     }
@@ -394,6 +399,7 @@ export class RealDebridWebFallback {
         const text = await response.text();
 
         if (response.status === 401 || response.status === 403) {
+          // Token expired or revoked — invalidate cache
           this.cachedToken = "";
           this.cachedTokenAt = 0;
           return { kind: "login_required" };

src/main/realdebrid.ts

@@ -82,6 +82,8 @@ async function sleepWithSignal(ms: number, signal?: AbortSignal): Promise<void>
     await sleep(ms);
     return;
   }
+  // Check before entering the Promise constructor to avoid a race where the timer
+  // resolves before the aborted check runs (especially when ms=0).
   if (signal.aborted) {
     throw new Error("aborted");
   }

src/main/rename-log.ts

@@ -1,119 +0,0 @@
-import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
-import path from "node:path";
-
-type RenameLogLevel = "INFO" | "WARN" | "ERROR";
-
-const RENAME_LOG_MAX_FILE_BYTES = Number(process.env.RD_RENAME_LOG_MAX_BYTES || 10 * 1024 * 1024);
-const RENAME_LOG_RETENTION_DAYS = Number(process.env.RD_RENAME_LOG_RETENTION_DAYS || 30);
-
-let renameLogPath: string | null = null;
-
-function sanitizeFieldValue(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value.replace(/\r?\n/g, "\\n");
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value).replace(/\r?\n/g, "\\n");
-  } catch {
-    return String(value);
-  }
-}
-
-function formatFields(fields?: Record<string, unknown>): string {
-  if (!fields) {
-    return "";
-  }
-  const parts = Object.entries(fields)
-    .filter(([, value]) => value !== undefined && value !== null && sanitizeFieldValue(value) !== "")
-    .map(([key, value]) => `${key}=${sanitizeFieldValue(value)}`);
-  return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
-}
-
-function rotateIfNeeded(filePath: string): void {
-  try {
-    const stat = fs.statSync(filePath);
-    if (stat.size < RENAME_LOG_MAX_FILE_BYTES) {
-      return;
-    }
-    const backup = `${filePath}.old`;
-    try {
-      fs.rmSync(backup, { force: true });
-    } catch {
-    }
-    fs.renameSync(filePath, backup);
-  } catch {
-  }
-}
-
-function cleanupOldBackup(filePath: string): void {
-  const backup = `${filePath}.old`;
-  try {
-    const stat = fs.statSync(backup);
-    const cutoff = Date.now() - RENAME_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    if (stat.mtimeMs < cutoff) {
-      fs.rmSync(backup, { force: true });
-    }
-  } catch {
-  }
-}
-
-export function initRenameLog(baseDir: string): void {
-  renameLogPath = path.join(baseDir, "rename.log");
-  try {
-    fs.mkdirSync(path.dirname(renameLogPath), { recursive: true });
-    cleanupOldBackup(renameLogPath);
-    if (!fs.existsSync(renameLogPath)) {
-      fs.writeFileSync(renameLogPath, "", "utf8");
-    }
-    rotateIfNeeded(renameLogPath);
-    if (!fs.existsSync(renameLogPath)) {
-      fs.writeFileSync(renameLogPath, "", "utf8");
-    }
-    fs.appendFileSync(renameLogPath, `=== Rename-Log Start: ${logTimestamp()} ===\n`, "utf8");
-  } catch {
-    renameLogPath = null;
-  }
-}
-
-export function logRenameEvent(level: RenameLogLevel, message: string, fields?: Record<string, unknown>): void {
-  if (!renameLogPath) {
-    return;
-  }
-  try {
-    rotateIfNeeded(renameLogPath);
-    if (!fs.existsSync(renameLogPath)) {
-      fs.writeFileSync(renameLogPath, "", "utf8");
-    }
-    fs.appendFileSync(
-      renameLogPath,
-      `${logTimestamp()} [${level}] ${message}${formatFields(fields)}\n`,
-      "utf8"
-    );
-  } catch {
-  }
-}
-
-export function getRenameLogPath(): string | null {
-  if (!renameLogPath) {
-    return null;
-  }
-  return fs.existsSync(renameLogPath) ? renameLogPath : null;
-}
-
-export function shutdownRenameLog(): void {
-  if (!renameLogPath) {
-    return;
-  }
-  try {
-    fs.appendFileSync(renameLogPath, `=== Rename-Log Ende: ${logTimestamp()} ===\n`, "utf8");
-  } catch {
-  }
-  renameLogPath = null;
-}

src/main/session-log.ts

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
 import path from "node:path";
 import { setLogListener } from "./logger";
 
@@ -30,6 +29,7 @@ function flushPending(): void {
   try {
     fs.appendFileSync(sessionLogPath, chunk, "utf8");
   } catch {
+    // ignore write errors
   }
 }
 
@@ -66,9 +66,11 @@ async function cleanupOldSessionLogs(dir: string, maxAgeDays: number): Promise<v
           await fs.promises.unlink(filePath);
         }
       } catch {
+        // ignore - file may be locked
       }
     }
   } catch {
+    // ignore - dir may not exist
   }
 }
 
@@ -84,7 +86,7 @@ export function initSessionLog(baseDir: string): void {
   const timestamp = formatTimestamp();
   sessionLogPath = path.join(sessionLogsDir, `session_${timestamp}.txt`);
 
-  const isoTimestamp = logTimestamp();
+  const isoTimestamp = new Date().toISOString();
   try {
     fs.writeFileSync(sessionLogPath, `=== Session gestartet: ${isoTimestamp} ===\n`, "utf8");
   } catch {
@@ -106,16 +108,19 @@ export function shutdownSessionLog(): void {
     return;
   }
 
+  // Flush any pending lines
   if (flushTimer) {
     clearTimeout(flushTimer);
     flushTimer = null;
   }
   flushPending();
 
-  const isoTimestamp = logTimestamp();
+  // Write closing line
+  const isoTimestamp = new Date().toISOString();
   try {
     fs.appendFileSync(sessionLogPath, `=== Session beendet: ${isoTimestamp} ===\n`, "utf8");
   } catch {
+    // ignore
   }
 
   setLogListener(null);

src/main/startup-health-check.ts

@@ -1,195 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { AppSettings } from "../shared/types";
-import { parseDebridLinkApiKeys } from "../shared/debrid-link-keys";
-import { parseMegaDebridAccounts } from "../shared/mega-debrid-accounts";
-import { StoragePaths } from "./storage";
-
-export type HealthCheckSeverity = "INFO" | "WARN" | "ERROR";
-
-export interface HealthCheckFinding {
-  severity: HealthCheckSeverity;
-  code: string;
-  message: string;
-  hint?: string;
-}
-
-export interface HealthCheckReport {
-  findings: HealthCheckFinding[];
-  errorCount: number;
-  warnCount: number;
-  infoCount: number;
-}
-
-const LOW_DISK_SPACE_BYTES = 5 * 1024 * 1024 * 1024;
-const LARGE_STATE_FILE_BYTES = 50 * 1024 * 1024;
-
-function safeExists(p: string): boolean {
-  try {
-    return fs.existsSync(p);
-  } catch {
-    return false;
-  }
-}
-
-function getFileSizeBytes(p: string): number {
-  try {
-    const stat = fs.statSync(p);
-    return stat.size;
-  } catch {
-    return 0;
-  }
-}
-
-function isWritable(dir: string): boolean {
-  const probe = path.join(dir, `.rddl-health-probe-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  try {
-    fs.writeFileSync(probe, "x", { encoding: "utf8" });
-    fs.rmSync(probe, { force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function getFreeDiskSpaceBytes(target: string): number | null {
-  try {
-    const statfs = (fs as unknown as { statfsSync?: (p: string) => { bavail: bigint; bsize: bigint } }).statfsSync;
-    if (typeof statfs !== "function") {
-      return null;
-    }
-    const result = statfs(target);
-    const bavail = BigInt(result.bavail);
-    const bsize = BigInt(result.bsize);
-    const free = bavail * bsize;
-    if (free > BigInt(Number.MAX_SAFE_INTEGER)) {
-      return Number.MAX_SAFE_INTEGER;
-    }
-    return Number(free);
-  } catch {
-    return null;
-  }
-}
-
-function countConfiguredProviders(settings: AppSettings): { count: number; providers: string[] } {
-  const providers: string[] = [];
-  if (settings.token?.trim() || settings.realDebridUseWebLogin) {
-    providers.push("Real-Debrid");
-  }
-  if (settings.allDebridToken?.trim() || settings.allDebridUseWebLogin) {
-    providers.push("AllDebrid");
-  }
-  if (settings.bestToken?.trim() || settings.bestDebridUseWebLogin) {
-    providers.push("BestDebrid");
-  }
-  if (settings.oneFichierApiKey?.trim()) {
-    providers.push("1Fichier");
-  }
-  if (settings.ddownloadLogin?.trim() && settings.ddownloadPassword?.trim()) {
-    providers.push("DDownload");
-  }
-  if (settings.linkSnappyLogin?.trim() && settings.linkSnappyPassword?.trim()) {
-    providers.push("LinkSnappy");
-  }
-  const dlKeys = parseDebridLinkApiKeys(settings.debridLinkApiKeys || "");
-  if (dlKeys.length > 0) {
-    providers.push(`Debrid-Link (${dlKeys.length} Key${dlKeys.length === 1 ? "" : "s"})`);
-  }
-  const megaAccounts = parseMegaDebridAccounts(settings.megaCredentials || "");
-  const legacyMegaConfigured = Boolean(settings.megaLogin?.trim() && settings.megaPassword?.trim());
-  if (megaAccounts.length > 0) {
-    providers.push(`Mega-Debrid (${megaAccounts.length} Acc)`);
-  } else if (legacyMegaConfigured) {
-    providers.push("Mega-Debrid");
-  }
-  return { count: providers.length, providers };
-}
-
-export function runStartupHealthCheck(settings: AppSettings, storagePaths: StoragePaths): HealthCheckReport {
-  const findings: HealthCheckFinding[] = [];
-
-  const outputDir = String(settings.outputDir || "").trim();
-  if (!outputDir) {
-    findings.push({
-      severity: "WARN",
-      code: "outputDir_missing",
-      message: "Kein Download-Ziel-Verzeichnis konfiguriert",
-      hint: "In den Einstellungen unter 'Downloads' einen Ziel-Ordner setzen, sonst koennen keine Downloads starten."
-    });
-  } else if (!safeExists(outputDir)) {
-    findings.push({
-      severity: "WARN",
-      code: "outputDir_not_found",
-      message: `Download-Ziel-Ordner existiert nicht: ${outputDir}`,
-      hint: "Der Ordner wird beim ersten Download automatisch erstellt, sofern der Elternordner existiert und beschreibbar ist."
-    });
-  } else if (!isWritable(outputDir)) {
-    findings.push({
-      severity: "ERROR",
-      code: "outputDir_not_writable",
-      message: `Download-Ziel-Ordner ist NICHT beschreibbar: ${outputDir}`,
-      hint: "Rechte pruefen oder anderen Ordner waehlen. Downloads werden sonst direkt scheitern."
-    });
-  } else {
-    const freeBytes = getFreeDiskSpaceBytes(outputDir);
-    if (freeBytes !== null && freeBytes < LOW_DISK_SPACE_BYTES) {
-      const freeMb = Math.round(freeBytes / (1024 * 1024));
-      findings.push({
-        severity: "WARN",
-        code: "low_disk_space",
-        message: `Wenig freier Speicher im Download-Ordner: ~${freeMb} MB verfuegbar (Schwelle ${LOW_DISK_SPACE_BYTES / (1024 * 1024 * 1024)} GB)`,
-        hint: "Groessere Downloads koennen auf halbem Weg fehlschlagen. Vorher Platz schaffen oder anderen Ordner waehlen."
-      });
-    }
-  }
-
-  const { count, providers } = countConfiguredProviders(settings);
-  if (count === 0) {
-    findings.push({
-      severity: "WARN",
-      code: "no_provider_configured",
-      message: "Kein Debrid-Provider konfiguriert — Downloads werden nicht funktionieren",
-      hint: "In den Einstellungen mindestens einen Provider (Real-Debrid, Mega-Debrid, Debrid-Link, ...) einrichten."
-    });
-  } else {
-    findings.push({
-      severity: "INFO",
-      code: "providers_configured",
-      message: `Konfigurierte Provider: ${providers.join(", ")}`
-    });
-  }
-
-  if (safeExists(storagePaths.sessionFile)) {
-    const sizeBytes = getFileSizeBytes(storagePaths.sessionFile);
-    if (sizeBytes > LARGE_STATE_FILE_BYTES) {
-      const sizeMb = Math.round(sizeBytes / (1024 * 1024));
-      findings.push({
-        severity: "WARN",
-        code: "large_state_file",
-        message: `State-Datei ist sehr gross: ${sizeMb} MB (${path.basename(storagePaths.sessionFile)})`,
-        hint: "Alte abgeschlossene Pakete aus der Queue entfernen, damit Startup + Save schneller werden."
-      });
-    }
-  }
-
-  if (!safeExists(storagePaths.baseDir)) {
-    findings.push({
-      severity: "ERROR",
-      code: "baseDir_missing",
-      message: `Runtime-Verzeichnis existiert nicht: ${storagePaths.baseDir}`,
-      hint: "Ohne Runtime-Verzeichnis koennen weder Settings noch Session-State persistiert werden."
-    });
-  } else if (!isWritable(storagePaths.baseDir)) {
-    findings.push({
-      severity: "ERROR",
-      code: "baseDir_not_writable",
-      message: `Runtime-Verzeichnis ist NICHT beschreibbar: ${storagePaths.baseDir}`,
-      hint: "Rechte auf das Runtime-Verzeichnis pruefen (%APPDATA%/Real-Debrid-Downloader/runtime)."
-    });
-  }
-
-  const errorCount = findings.filter((f) => f.severity === "ERROR").length;
-  const warnCount = findings.filter((f) => f.severity === "WARN").length;
-  const infoCount = findings.filter((f) => f.severity === "INFO").length;
-  return { findings, errorCount, warnCount, infoCount };
-}

src/main/storage.ts

@@ -2,8 +2,7 @@ import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { getDebridLinkApiKeyIds } from "../shared/debrid-link-keys";
-import { getMegaDebridAccountIds } from "../shared/mega-debrid-accounts";
+import { AppSettings, BandwidthScheduleEntry, DebridFallbackProvider, DebridProvider, DownloadItem, DownloadStatus, HistoryEntry, PackageEntry, PackagePriority, SessionState } from "../shared/types";
-import { AppSettings, BandwidthScheduleEntry, DebridAccountStatus, DebridFallbackProvider, DebridProvider, DownloadItem, DownloadStatus, HistoryEntry, HistoryRetentionMode, PackageEntry, PackagePriority, SessionState } from "../shared/types";
 import { getProviderUsageDayKey } from "../shared/provider-daily-limits";
 import { defaultSettings } from "./constants";
 import { logger } from "./logger";
@@ -16,50 +15,17 @@ const VALID_FINISHED_POLICIES = new Set(["never", "immediate", "on_start", "pack
 const VALID_SPEED_MODES = new Set(["global", "per_download"]);
 const VALID_THEMES = new Set(["dark", "light"]);
 const VALID_EXTRACT_CPU_PRIORITIES = new Set(["high", "middle", "low"]);
-const VALID_HISTORY_RETENTION_MODES = new Set<HistoryRetentionMode>(["never", "session", "permanent"]);
 const VALID_PACKAGE_PRIORITIES = new Set<string>(["high", "normal", "low"]);
 const VALID_DOWNLOAD_STATUSES = new Set<DownloadStatus>([
   "queued", "validating", "downloading", "paused", "reconnect_wait", "extracting", "integrity_check", "completed", "failed", "cancelled"
 ]);
 const VALID_ITEM_PROVIDERS = new Set<DebridProvider>(["realdebrid", "megadebrid", "megadebrid-api", "megadebrid-web", "bestdebrid", "alldebrid", "ddownload", "onefichier", "debridlink"]);
 const VALID_ONLINE_STATUSES = new Set(["online", "offline", "checking"]);
-const SAFE_SESSION_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
 
 function asText(value: unknown): string {
   return String(value ?? "").trim();
 }
 
-function normalizeSessionId(value: unknown): string {
-  const text = asText(value);
-  if (!text || !SAFE_SESSION_ID_RE.test(text)) {
-    return "";
-  }
-  return text;
-}
-
-function isPathInsideDir(filePath: string, dirPath: string): boolean {
-  try {
-    const resolvedFile = path.resolve(filePath);
-    const resolvedDir = path.resolve(dirPath);
-    const normalizedFile = process.platform === "win32" ? resolvedFile.toLowerCase() : resolvedFile;
-    const normalizedDir = process.platform === "win32" ? resolvedDir.toLowerCase() : resolvedDir;
-    return normalizedFile === normalizedDir || normalizedFile.startsWith(`${normalizedDir}${path.sep}`);
-  } catch {
-    return false;
-  }
-}
-
-function normalizeSessionTargetPath(value: unknown, packageOutputDir: string): string {
-  const targetPath = asText(value);
-  if (!targetPath || !packageOutputDir || !path.isAbsolute(targetPath)) {
-    return "";
-  }
-  if (!isPathInsideDir(targetPath, packageOutputDir)) {
-    return "";
-  }
-  return path.resolve(targetPath);
-}
-
 function clampNumber(value: unknown, fallback: number, min: number, max: number): number {
   const num = Number(value);
   if (!Number.isFinite(num)) {
@@ -120,6 +86,7 @@ function normalizeColumnOrder(raw: unknown): string[] {
       result.push(col);
     }
   }
+  // "name" is mandatory — ensure it's always present
   if (!seen.has("name")) {
     result.unshift("name");
   }
@@ -229,39 +196,6 @@ function normalizeNamedByteMap(raw: unknown, allowedKeys: readonly string[]): Re
   return result;
 }
 
-function normalizeDebridAccountStatuses(
-  value: unknown,
-  megaIds: string[],
-  debridLinkIds: string[]
-): Record<string, DebridAccountStatus> {
-  const allowed = new Set([...megaIds, ...debridLinkIds]);
-  const result: Record<string, DebridAccountStatus> = {};
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
-      if (!allowed.has(key) || !raw || typeof raw !== "object") {
-        continue;
-      }
-      const entry = raw as Partial<DebridAccountStatus>;
-      if (typeof entry.accountId !== "string" || typeof entry.checkedAt !== "number") {
-        continue;
-      }
-      result[key] = {
-        accountId: entry.accountId,
-        provider: entry.provider === "debridlink" ? "debridlink" : "megadebrid",
-        label: String(entry.label || ""),
-        maskedLogin: String(entry.maskedLogin || ""),
-        valid: Boolean(entry.valid),
-        isPremium: Boolean(entry.isPremium),
-        premiumUntilMs: typeof entry.premiumUntilMs === "number" ? entry.premiumUntilMs : null,
-        email: typeof entry.email === "string" ? entry.email : undefined,
-        message: String(entry.message || ""),
-        checkedAt: entry.checkedAt
-      };
-    }
-  }
-  return result;
-}
-
 function normalizeStringList(raw: unknown, allowedKeys: readonly string[]): string[] {
   if (!Array.isArray(raw)) {
     return [];
@@ -308,6 +242,7 @@ function normalizeProviderOrder(
   if (Array.isArray(raw) && raw.length > 0) {
     list = raw;
   } else {
+    // Migrate from old primary/secondary/tertiary
     const candidates = [legacyPrimary, legacySecondary, legacyTertiary].filter(
       (v) => v && String(v).trim() && String(v).trim() !== "none"
     );
@@ -345,11 +280,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
   const currentUsageDay = getProviderUsageDayKey();
   const megaLogin = asText(settings.megaLogin);
   const megaPassword = asText(settings.megaPassword);
-  let megaCredentials = String(settings.megaCredentials ?? "").replace(/\r\n|\r/g, "\n").trim();
-  if (!megaCredentials && megaLogin && megaPassword) {
-    megaCredentials = `${megaLogin}:${megaPassword}`;
-  }
-  const megaDebridAccountIds = getMegaDebridAccountIds(megaCredentials);
   const megaDebridPreferApi = settings.megaDebridPreferApi !== undefined ? Boolean(settings.megaDebridPreferApi) : true;
   const hasMegaCreds = Boolean(megaLogin && megaPassword);
   const megaDebridApiEnabled = settings.megaDebridApiEnabled !== undefined
@@ -391,7 +321,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     realDebridUseWebLogin: Boolean(settings.realDebridUseWebLogin),
     megaLogin,
     megaPassword,
-    megaCredentials,
     megaDebridApiEnabled,
     megaDebridWebEnabled,
     megaDebridPreferApi,
@@ -421,8 +350,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     packageName: asText(settings.packageName),
     autoExtract: Boolean(settings.autoExtract),
     autoRename4sf4sj: Boolean(settings.autoRename4sf4sj),
-    keepGermanAudioOnly: Boolean(settings.keepGermanAudioOnly),
-    germanAudioMode: settings.germanAudioMode === "first" ? "first" : "tag",
     extractDir: normalizeAbsoluteDir(settings.extractDir, defaults.extractDir),
     collectMkvToLibrary: Boolean(settings.collectMkvToLibrary),
     mkvLibraryDir: normalizeAbsoluteDir(settings.mkvLibraryDir, defaults.mkvLibraryDir),
@@ -448,9 +375,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     clipboardWatch: Boolean(settings.clipboardWatch),
     minimizeToTray: Boolean(settings.minimizeToTray),
     collapseNewPackages: settings.collapseNewPackages !== undefined ? Boolean(settings.collapseNewPackages) : defaults.collapseNewPackages,
-    historyRetentionMode: VALID_HISTORY_RETENTION_MODES.has(settings.historyRetentionMode)
-      ? settings.historyRetentionMode
-      : defaults.historyRetentionMode,
     accountListShowDetailedDebridLinkKeys: settings.accountListShowDetailedDebridLinkKeys !== undefined
       ? Boolean(settings.accountListShowDetailedDebridLinkKeys)
       : defaults.accountListShowDetailedDebridLinkKeys,
@@ -458,10 +382,8 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     autoSkipExtracted: settings.autoSkipExtracted !== undefined ? Boolean(settings.autoSkipExtracted) : defaults.autoSkipExtracted,
     hideExtractedItems: settings.hideExtractedItems !== undefined ? Boolean(settings.hideExtractedItems) : defaults.hideExtractedItems,
     confirmDeleteSelection: settings.confirmDeleteSelection !== undefined ? Boolean(settings.confirmDeleteSelection) : defaults.confirmDeleteSelection,
-    backupIncludeDownloads: settings.backupIncludeDownloads !== undefined ? Boolean(settings.backupIncludeDownloads) : defaults.backupIncludeDownloads,
     totalDownloadedAllTime: typeof settings.totalDownloadedAllTime === "number" && settings.totalDownloadedAllTime >= 0 ? settings.totalDownloadedAllTime : defaults.totalDownloadedAllTime,
     totalCompletedFilesAllTime: typeof settings.totalCompletedFilesAllTime === "number" && settings.totalCompletedFilesAllTime >= 0 ? settings.totalCompletedFilesAllTime : defaults.totalCompletedFilesAllTime,
-    totalRuntimeAllTimeMs: typeof settings.totalRuntimeAllTimeMs === "number" && settings.totalRuntimeAllTimeMs >= 0 ? settings.totalRuntimeAllTimeMs : defaults.totalRuntimeAllTimeMs,
     theme: VALID_THEMES.has(settings.theme) ? settings.theme : defaults.theme,
     bandwidthSchedules: normalizeBandwidthSchedules(settings.bandwidthSchedules),
     columnOrder: normalizeColumnOrder(settings.columnOrder),
@@ -479,13 +401,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     debridLinkApiKeyDailyLimitBytes,
     debridLinkApiKeyDailyUsageBytes: providerDailyUsageDay === currentUsageDay ? debridLinkApiKeyDailyUsageBytes : {},
     debridLinkApiKeyTotalUsageBytes,
-    megaDebridDisabledAccountIds: normalizeStringList(settings.megaDebridDisabledAccountIds, megaDebridAccountIds),
-    megaDebridAccountDailyLimitBytes: normalizeNamedByteMap(settings.megaDebridAccountDailyLimitBytes, megaDebridAccountIds),
-    megaDebridAccountDailyUsageBytes: providerDailyUsageDay === currentUsageDay
-      ? normalizeNamedByteMap(settings.megaDebridAccountDailyUsageBytes, megaDebridAccountIds)
-      : {},
-    megaDebridAccountTotalUsageBytes: normalizeNamedByteMap(settings.megaDebridAccountTotalUsageBytes, megaDebridAccountIds),
-    debridAccountStatuses: normalizeDebridAccountStatuses(settings.debridAccountStatuses, megaDebridAccountIds, debridLinkApiKeyIds),
     providerDailyUsageDay: providerDailyUsageDay === currentUsageDay ? providerDailyUsageDay : currentUsageDay,
     scheduledStartEpochMs: clampNumber(settings.scheduledStartEpochMs, defaults.scheduledStartEpochMs, 0, Number.MAX_SAFE_INTEGER)
   };
@@ -534,7 +449,6 @@ function sanitizeCredentialPersistence(settings: AppSettings): AppSettings {
     realDebridUseWebLogin: settings.realDebridUseWebLogin,
     megaLogin: "",
     megaPassword: "",
-    megaCredentials: "",
     bestToken: "",
     bestDebridUseWebLogin: settings.bestDebridUseWebLogin,
     allDebridToken: "",
@@ -564,22 +478,7 @@ export function createStoragePaths(baseDir: string): StoragePaths {
 }
 
 function ensureBaseDir(baseDir: string): void {
-  try {
   fs.mkdirSync(baseDir, { recursive: true });
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException)?.code || "";
-    if (code === "EACCES" || code === "EPERM") {
-      logger.error(`AppData-Ordner kann nicht erstellt werden (${code}): ${baseDir} - pruefe Schreibrechte fuer Benutzer ${process.env.USERNAME || process.env.USER || "?"}`);
-    }
-    throw error;
-  }
-}
-
-function safeJsonReplacer(_key: string, value: unknown): unknown {
-  if (typeof value === "number" && !Number.isFinite(value)) {
-    return null;
-  }
-  return value;
 }
 
 function asRecord(value: unknown): Record<string, unknown> | null {
@@ -597,14 +496,7 @@ function readSettingsFile(filePath: string): AppSettings | null {
       ...parsed
     });
     return sanitizeCredentialPersistence(merged);
-  } catch (error) {
+  } catch {
-    const code = (error as NodeJS.ErrnoException)?.code || "";
-    if (code === "ENOENT") {
-    } else if (code === "EACCES" || code === "EPERM") {
-      logger.error(`Settings-Datei nicht zugreifbar (${code}): ${filePath} - pruefe Datei-/Ordner-Berechtigungen fuer Benutzer ${process.env.USERNAME || process.env.USER || "?"}`);
-    } else {
-      logger.warn(`Settings-Datei nicht lesbar: ${filePath}: ${String(error)}`);
-    }
     return null;
   }
 }
@@ -624,8 +516,8 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
     if (!item) {
       continue;
     }
-    const id = normalizeSessionId(item.id) || normalizeSessionId(entryId);
+    const id = asText(item.id) || entryId;
-    const packageId = normalizeSessionId(item.packageId);
+    const packageId = asText(item.packageId);
     const url = asText(item.url);
     if (!id || !packageId || !url) {
       continue;
@@ -670,7 +562,7 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
     if (!pkg) {
       continue;
     }
-    const id = normalizeSessionId(pkg.id) || normalizeSessionId(entryId);
+    const id = asText(pkg.id) || entryId;
     if (!id) {
       continue;
     }
@@ -684,44 +576,21 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
       extractDir: asText(pkg.extractDir),
       status,
       itemIds: rawItemIds
-        .map((value) => normalizeSessionId(value))
+        .map((value) => asText(value))
         .filter((value) => value.length > 0),
       cancelled: Boolean(pkg.cancelled),
       enabled: pkg.enabled === undefined ? true : Boolean(pkg.enabled),
       priority: VALID_PACKAGE_PRIORITIES.has(asText(pkg.priority)) ? asText(pkg.priority) as PackagePriority : "normal",
-      downloadStartedAt: clampNumber(pkg.downloadStartedAt, 0, 0, Number.MAX_SAFE_INTEGER),
-      downloadCompletedAt: clampNumber(pkg.downloadCompletedAt, 0, 0, Number.MAX_SAFE_INTEGER),
       createdAt: clampNumber(pkg.createdAt, now, 0, Number.MAX_SAFE_INTEGER),
       updatedAt: clampNumber(pkg.updatedAt, now, 0, Number.MAX_SAFE_INTEGER)
     };
   }
 
-  let orphanedItemCount = 0;
   for (const [itemId, item] of Object.entries(itemsById)) {
     if (!packagesById[item.packageId]) {
-      orphanedItemCount += 1;
       delete itemsById[itemId];
     }
   }
-  if (orphanedItemCount > 0) {
-    logger.warn(`normalizeLoadedSession: ${orphanedItemCount} verwaiste Items entfernt (fehlende Pakete)`);
-  }
-
-  let droppedUnsafeTargetPathCount = 0;
-  for (const item of Object.values(itemsById)) {
-    const pkg = packagesById[item.packageId];
-    if (!pkg) {
-      continue;
-    }
-    const safeTargetPath = normalizeSessionTargetPath(item.targetPath, pkg.outputDir);
-    if (!safeTargetPath && asText(item.targetPath)) {
-      droppedUnsafeTargetPathCount += 1;
-    }
-    item.targetPath = safeTargetPath;
-  }
-  if (droppedUnsafeTargetPathCount > 0) {
-    logger.warn(`normalizeLoadedSession: ${droppedUnsafeTargetPathCount} unsichere targetPath-Eintraege verworfen`);
-  }
 
   for (const pkg of Object.values(packagesById)) {
     pkg.itemIds = pkg.itemIds.filter((itemId) => {
@@ -733,7 +602,7 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
   const rawOrder = Array.isArray(parsed.packageOrder) ? parsed.packageOrder : [];
   const seenOrder = new Set<string>();
   const packageOrder = rawOrder
-    .map((entry) => normalizeSessionId(entry))
+    .map((entry) => asText(entry))
     .filter((id) => {
       if (!(id in packagesById) || seenOrder.has(id)) {
         return false;
@@ -780,11 +649,12 @@ export function loadSettings(paths: StoragePaths): AppSettings {
   if (backupLoaded) {
     logger.warn("Konfiguration defekt, Backup-Datei wird verwendet");
     try {
-      const payload = JSON.stringify(backupLoaded, safeJsonReplacer, 2);
+      const payload = JSON.stringify(backupLoaded, null, 2);
       const tempPath = `${paths.configFile}.tmp`;
       fs.writeFileSync(tempPath, payload, "utf8");
       syncRenameWithExdevFallback(tempPath, paths.configFile);
     } catch {
+      // ignore restore write failure
     }
     return backupLoaded;
   }
@@ -815,15 +685,18 @@ function sessionBackupPath(sessionFile: string): string {
 }
 
 export function normalizeLoadedSessionTransientFields(session: SessionState): SessionState {
+  // Reset transient fields that may be stale from a previous crash
   const ACTIVE_STATUSES = new Set(["downloading", "validating", "extracting", "integrity_check", "paused", "reconnect_wait"]);
   for (const item of Object.values(session.items)) {
     if (ACTIVE_STATUSES.has(item.status)) {
       item.status = "queued";
       item.lastError = "";
     }
+    // Always clear stale speed values
     item.speedBps = 0;
   }
 
+  // Reset package-level active statuses to queued (mirrors item reset above)
   const ACTIVE_PKG_STATUSES = new Set(["downloading", "validating", "extracting", "integrity_check", "paused", "reconnect_wait"]);
   for (const pkg of Object.values(session.packages)) {
     if (ACTIVE_PKG_STATUSES.has(pkg.status)) {
@@ -832,6 +705,7 @@ export function normalizeLoadedSessionTransientFields(session: SessionState): Se
     pkg.postProcessLabel = undefined;
   }
 
+  // Clear stale session-level running/paused flags
   session.running = false;
   session.paused = false;
 
@@ -840,39 +714,37 @@ export function normalizeLoadedSessionTransientFields(session: SessionState): Se
 
 function readSessionFile(filePath: string): SessionState | null {
   try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8")) as unknown;
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw) as unknown;
     const session = normalizeLoadedSessionTransientFields(normalizeLoadedSession(parsed));
     const pkgCount = Object.keys(session.packages).length;
     const itemCount = Object.keys(session.items).length;
-    logger.info(`Session geladen: ${filePath} (${pkgCount} Pakete, ${itemCount} Items)`);
+    logger.info(`Session geladen: ${filePath} (${pkgCount} Pakete, ${itemCount} Items, ${raw.length} Bytes)`);
     return session;
   } catch (error) {
-    const code = (error as NodeJS.ErrnoException)?.code || "";
-    if (code === "EACCES" || code === "EPERM") {
-      logger.error(`Session-Datei nicht zugreifbar (${code}): ${filePath} - pruefe Datei-/Ordner-Berechtigungen fuer Benutzer ${process.env.USERNAME || process.env.USER || "?"}`);
-    } else {
     logger.error(`Session-Datei nicht lesbar: ${filePath}: ${String(error)}`);
-    }
     return null;
   }
 }
 
 export function saveSettings(paths: StoragePaths, settings: AppSettings): void {
   ensureBaseDir(paths.baseDir);
+  // Create a backup of the existing config before overwriting
   if (fs.existsSync(paths.configFile)) {
     try {
       fs.copyFileSync(paths.configFile, `${paths.configFile}.bak`);
     } catch {
+      // Best-effort backup; proceed even if it fails
     }
   }
   const persisted = sanitizeCredentialPersistence(normalizeSettings(settings));
-  const payload = JSON.stringify(persisted, safeJsonReplacer, 2);
+  const payload = JSON.stringify(persisted, null, 2);
   const tempPath = `${paths.configFile}.tmp`;
   try {
     fs.writeFileSync(tempPath, payload, "utf8");
     syncRenameWithExdevFallback(tempPath, paths.configFile);
   } catch (error) {
-    try { fs.rmSync(tempPath, { force: true }); } catch {  }
+    try { fs.rmSync(tempPath, { force: true }); } catch { /* ignore */ }
     throw error;
   }
 }
@@ -900,7 +772,7 @@ async function writeSettingsPayload(paths: StoragePaths, payload: string): Promi
 
 export async function saveSettingsAsync(paths: StoragePaths, settings: AppSettings): Promise<void> {
   const persisted = sanitizeCredentialPersistence(normalizeSettings(settings));
-  const payload = JSON.stringify(persisted, safeJsonReplacer, 2);
+  const payload = JSON.stringify(persisted, null, 2);
   if (asyncSettingsSaveRunning) {
     asyncSettingsSaveQueued = { paths, settings };
     return;
@@ -939,21 +811,15 @@ export function emptySession(): SessionState {
 
 export function loadSession(paths: StoragePaths): SessionState {
   ensureBaseDir(paths.baseDir);
-  const backupFile = sessionBackupPath(paths.sessionFile);
+  if (!fs.existsSync(paths.sessionFile)) {
-  const primaryExists = fs.existsSync(paths.sessionFile);
-  if (!primaryExists) {
-    const hasRecoverable = fs.existsSync(backupFile)
-      || fs.existsSync(sessionTempPath(paths.sessionFile, "sync"))
-      || fs.existsSync(sessionTempPath(paths.sessionFile, "async"));
-    if (!hasRecoverable) {
     logger.info("Keine Session-Datei vorhanden, starte mit leerer Session");
     return emptySession();
   }
-    logger.warn("Session-Primaerdatei fehlt, aber Backup/Temp vorhanden — Wiederherstellung wird versucht");
-  }
 
-  const primary = primaryExists ? readSessionFile(paths.sessionFile) : null;
+  const primary = readSessionFile(paths.sessionFile);
+  const backupFile = sessionBackupPath(paths.sessionFile);
 
+  // If primary loaded but is empty, check if backup has packages (safety net)
   if (primary) {
     const primaryPkgCount = Object.keys(primary.packages).length;
     if (primaryPkgCount === 0 && fs.existsSync(backupFile)) {
@@ -963,11 +829,12 @@ export function loadSession(paths: StoragePaths): SessionState {
         if (backupPkgCount > 0) {
           logger.warn(`Session-Datei ist leer (0 Pakete), aber Backup hat ${backupPkgCount} Pakete — verwende Backup`);
           try {
-            const payload = JSON.stringify({ ...backup, updatedAt: Date.now() }, safeJsonReplacer);
+            const payload = JSON.stringify({ ...backup, updatedAt: Date.now() });
             const tempPath = sessionTempPath(paths.sessionFile, "sync");
             fs.writeFileSync(tempPath, payload, "utf8");
             syncRenameWithExdevFallback(tempPath, paths.sessionFile);
           } catch {
+            // ignore restore write failure
           }
           return backup;
         }
@@ -980,32 +847,17 @@ export function loadSession(paths: StoragePaths): SessionState {
   if (backup) {
     logger.warn("Session defekt, Backup-Datei wird verwendet");
     try {
-      const payload = JSON.stringify({ ...backup, updatedAt: Date.now() }, safeJsonReplacer);
+      const payload = JSON.stringify({ ...backup, updatedAt: Date.now() });
       const tempPath = sessionTempPath(paths.sessionFile, "sync");
       fs.writeFileSync(tempPath, payload, "utf8");
       syncRenameWithExdevFallback(tempPath, paths.sessionFile);
     } catch {
+      // ignore restore write failure
     }
     return backup;
   }
 
-  for (const kind of ["sync", "async"] as const) {
+  logger.error("Session konnte nicht geladen werden (auch Backup fehlgeschlagen)");
-    const tmpPath = sessionTempPath(paths.sessionFile, kind);
-    if (fs.existsSync(tmpPath)) {
-      const tmpSession = readSessionFile(tmpPath);
-      if (tmpSession && Object.keys(tmpSession.packages).length > 0) {
-        logger.warn(`Session aus temporaerer Datei wiederhergestellt: ${tmpPath} (${Object.keys(tmpSession.packages).length} Pakete)`);
-        try {
-          const payload = JSON.stringify({ ...tmpSession, updatedAt: Date.now() }, safeJsonReplacer);
-          fs.writeFileSync(paths.sessionFile, payload, "utf8");
-        } catch {
-        }
-        return tmpSession;
-      }
-    }
-  }
-
-  logger.error("Session konnte nicht geladen werden (Primary, Backup und Temp-Dateien fehlgeschlagen)");
   return emptySession();
 }
 
@@ -1016,21 +868,22 @@ export function saveSession(paths: StoragePaths, session: SessionState): void {
     try {
       fs.copyFileSync(paths.sessionFile, sessionBackupPath(paths.sessionFile));
     } catch {
+      // Best-effort backup; proceed even if it fails
     }
   }
-  const payload = JSON.stringify({ ...session, updatedAt: Date.now() }, safeJsonReplacer);
+  const payload = JSON.stringify({ ...session, updatedAt: Date.now() });
   const tempPath = sessionTempPath(paths.sessionFile, "sync");
   try {
     fs.writeFileSync(tempPath, payload, "utf8");
     syncRenameWithExdevFallback(tempPath, paths.sessionFile);
   } catch (error) {
-    try { fs.rmSync(tempPath, { force: true }); } catch {  }
+    try { fs.rmSync(tempPath, { force: true }); } catch { /* ignore */ }
     throw error;
   }
 }
 
 let asyncSaveRunning = false;
-let asyncSaveQueued: { paths: StoragePaths; payload: string; generation: number } | null = null;
+let asyncSaveQueued: { paths: StoragePaths; payload: string } | null = null;
 let syncSaveGeneration = 0;
 
 async function writeSessionPayload(paths: StoragePaths, payload: string, generation: number): Promise<void> {
@@ -1038,6 +891,7 @@ async function writeSessionPayload(paths: StoragePaths, payload: string, generat
   await fsp.copyFile(paths.sessionFile, sessionBackupPath(paths.sessionFile)).catch(() => {});
   const tempPath = sessionTempPath(paths.sessionFile, "async");
   await fsp.writeFile(tempPath, payload, "utf8");
+  // If a synchronous save occurred after this async save started, discard the stale write
   if (generation < syncSaveGeneration) {
     await fsp.rm(tempPath, { force: true }).catch(() => {});
     return;
@@ -1059,14 +913,15 @@ async function writeSessionPayload(paths: StoragePaths, payload: string, generat
   }
 }
 
-async function saveSessionPayloadAsync(paths: StoragePaths, payload: string, generation: number): Promise<void> {
+async function saveSessionPayloadAsync(paths: StoragePaths, payload: string): Promise<void> {
   if (asyncSaveRunning) {
-    asyncSaveQueued = { paths, payload, generation };
+    asyncSaveQueued = { paths, payload };
     return;
   }
   asyncSaveRunning = true;
+  const gen = syncSaveGeneration;
   try {
-    await writeSessionPayload(paths, payload, generation);
+    await writeSessionPayload(paths, payload, gen);
   } catch (error) {
     logger.error(`Async Session-Save fehlgeschlagen: ${String(error)}`);
   } finally {
@@ -1074,7 +929,7 @@ async function saveSessionPayloadAsync(paths: StoragePaths, payload: string, gen
     if (asyncSaveQueued) {
       const queued = asyncSaveQueued;
       asyncSaveQueued = null;
-      void saveSessionPayloadAsync(queued.paths, queued.payload, queued.generation);
+      void saveSessionPayloadAsync(queued.paths, queued.payload);
     }
   }
 }
@@ -1086,9 +941,8 @@ export function cancelPendingAsyncSaves(): void {
 }
 
 export async function saveSessionAsync(paths: StoragePaths, session: SessionState): Promise<void> {
-  const generation = syncSaveGeneration;
+  const payload = JSON.stringify({ ...session, updatedAt: Date.now() });
-  const payload = JSON.stringify({ ...session, updatedAt: Date.now() }, safeJsonReplacer);
+  await saveSessionPayloadAsync(paths, payload);
-  await saveSessionPayloadAsync(paths, payload, generation);
 }
 
 const MAX_HISTORY_ENTRIES = 500;
@@ -1140,13 +994,13 @@ export function loadHistory(paths: StoragePaths): HistoryEntry[] {
 export function saveHistory(paths: StoragePaths, entries: HistoryEntry[]): void {
   ensureBaseDir(paths.baseDir);
   const trimmed = entries.slice(0, MAX_HISTORY_ENTRIES);
-  const payload = JSON.stringify(trimmed, safeJsonReplacer, 2);
+  const payload = JSON.stringify(trimmed, null, 2);
   const tempPath = `${paths.historyFile}.tmp`;
   try {
     fs.writeFileSync(tempPath, payload, "utf8");
     syncRenameWithExdevFallback(tempPath, paths.historyFile);
   } catch (error) {
-    try { fs.rmSync(tempPath, { force: true }); } catch {  }
+    try { fs.rmSync(tempPath, { force: true }); } catch { /* ignore */ }
     throw error;
   }
 }
@@ -1158,24 +1012,6 @@ export function addHistoryEntry(paths: StoragePaths, entry: HistoryEntry): Histo
   return updated;
 }
 
-export function loadHistoryForRetention(paths: StoragePaths, retentionMode: HistoryRetentionMode): HistoryEntry[] {
-  return retentionMode === "never" ? [] : loadHistory(paths);
-}
-
-export function addHistoryEntryForRetention(paths: StoragePaths, retentionMode: HistoryRetentionMode, entry: HistoryEntry): HistoryEntry[] {
-  if (retentionMode === "never") {
-    return [];
-  }
-  return addHistoryEntry(paths, entry);
-}
-
-export function resetHistoryForRetention(paths: StoragePaths, retentionMode: HistoryRetentionMode): void {
-  if (retentionMode === "permanent") {
-    return;
-  }
-  clearHistory(paths);
-}
-
 export function removeHistoryEntry(paths: StoragePaths, entryId: string): HistoryEntry[] {
   const existing = loadHistory(paths);
   const updated = existing.filter(e => e.id !== entryId);
@@ -1189,6 +1025,7 @@ export function clearHistory(paths: StoragePaths): void {
     try {
       fs.unlinkSync(paths.historyFile);
     } catch {
+      // ignore
     }
   }
 }

src/main/support-bundle.ts

@@ -1,210 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import AdmZip from "adm-zip";
-import { APP_VERSION } from "./constants";
-import { getAuditLogPath } from "./audit-log";
-import { getDebugSetupCheck } from "./debug-setup";
-import { getLogFilePath } from "./logger";
-import { getRecentErrors } from "./error-ring";
-import { getPackageLogPath } from "./package-log";
-import { getRenameLogPath } from "./rename-log";
-import { getDesktopRenameLogPath } from "./desktop-rename-log";
-import { getSessionLogPath } from "./session-log";
-import { createStoragePaths, loadHistory, loadSettings } from "./storage";
-import { buildAccountSummary, buildRedactedSettingsPayload, buildStatsPayload, summarizeHistoryEntry } from "./support-data";
-import { getTraceConfig, getTraceConfigPath, getTraceLogPath } from "./trace-log";
-import { getCachedWindowsHostDiagnostics, getWindowsHostDiagnostics } from "./windows-host-diagnostics";
-import type { DownloadManager } from "./download-manager";
-
-const AI_MANIFEST_FILE = "debug_ai_manifest.json";
-
-function safeReadJson(filePath: string): unknown {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf8")) as unknown;
-  } catch {
-    return null;
-  }
-}
-
-function addJson(zip: AdmZip, zipPath: string, value: unknown): void {
-  zip.addFile(zipPath, Buffer.from(`${JSON.stringify(value, null, 2)}\n`, "utf8"));
-}
-
-function addFileIfExists(zip: AdmZip, sourcePath: string | null, zipPath: string): void {
-  if (!sourcePath || !fs.existsSync(sourcePath)) {
-    return;
-  }
-  zip.addLocalFile(sourcePath, path.posix.dirname(zipPath), path.posix.basename(zipPath));
-}
-
-function addDirectoryIfExists(zip: AdmZip, dirPath: string, zipRoot: string): void {
-  if (!fs.existsSync(dirPath)) {
-    return;
-  }
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-    const zipPath = path.posix.join(zipRoot, entry.name);
-    if (entry.isDirectory()) {
-      addDirectoryIfExists(zip, fullPath, zipPath);
-      continue;
-    }
-    zip.addLocalFile(fullPath, path.posix.dirname(zipPath), path.posix.basename(zipPath));
-  }
-}
-
-function addRecentDirectoryFiles(zip: AdmZip, dirPath: string, zipRoot: string, maxAgeMs: number): number {
-  if (!fs.existsSync(dirPath)) {
-    return 0;
-  }
-  const cutoff = Date.now() - maxAgeMs;
-  let added = 0;
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const fullPath = path.join(dirPath, entry.name);
-    try {
-      if (fs.statSync(fullPath).mtimeMs >= cutoff) {
-        zip.addLocalFile(fullPath, zipRoot, entry.name);
-        added += 1;
-      }
-    } catch {  }
-  }
-  return added;
-}
-
-function formatTimestampForFileName(date: Date): string {
-  const y = date.getFullYear();
-  const mo = String(date.getMonth() + 1).padStart(2, "0");
-  const d = String(date.getDate()).padStart(2, "0");
-  const h = String(date.getHours()).padStart(2, "0");
-  const mi = String(date.getMinutes()).padStart(2, "0");
-  const s = String(date.getSeconds()).padStart(2, "0");
-  return `${y}-${mo}-${d}_${h}-${mi}-${s}`;
-}
-
-export function getSupportBundleDefaultFileName(): string {
-  return `rd-support-bundle-${formatTimestampForFileName(new Date())}.zip`;
-}
-
-type HostDiagnosticsMode = "full" | "cached" | "none";
-
-interface BuildSupportBundleOptions {
-  hostDiagnosticsMode?: HostDiagnosticsMode;
-}
-
-function createDeferredHostDiagnostics(reason: string): unknown {
-  return {
-    collectedAt: new Date().toISOString(),
-    supported: process.platform === "win32",
-    platform: process.platform,
-    crashControl: null,
-    recentKernelPower: [],
-    recentWerKernel: [],
-    recentKernelDump: [],
-    recentAppCrashes: [],
-    recentMinidumps: [],
-    assessmentHints: [
-      reason
-    ],
-    errors: []
-  };
-}
-
-function resolveHostDiagnostics(mode: HostDiagnosticsMode): unknown {
-  if (mode === "none") {
-    return createDeferredHostDiagnostics("Host-Diagnose wurde fuer diesen Bundle-Export deaktiviert.");
-  }
-  if (mode === "cached") {
-    const cached = getCachedWindowsHostDiagnostics();
-    if (cached) {
-      return cached;
-    }
-    return createDeferredHostDiagnostics("Host-Diagnose wurde uebersprungen, um den Export nicht zu blockieren. Fuer eine Voll-Diagnose /host/diagnostics nutzen.");
-  }
-  return getWindowsHostDiagnostics();
-}
-
-export function buildSupportBundle(manager: DownloadManager, baseDir: string, options: BuildSupportBundleOptions = {}): Buffer {
-  const zip = new AdmZip();
-  const hostDiagnosticsMode = options.hostDiagnosticsMode || "full";
-  const storagePaths = createStoragePaths(baseDir);
-  const settings = loadSettings(storagePaths);
-  const history = loadHistory(storagePaths);
-  const snapshot = manager.getSnapshot();
-  const packageIds = Object.keys(snapshot.session.packages);
-  const itemIds = Object.keys(snapshot.session.items);
-  const debugSetup = getDebugSetupCheck(baseDir);
-
-  addJson(zip, "overview/meta.json", {
-    appVersion: APP_VERSION,
-    generatedAt: new Date().toISOString(),
-    runtimeBaseDir: baseDir,
-    packageCount: packageIds.length,
-    itemCount: itemIds.length
-  });
-  addJson(zip, "overview/status.json", snapshot.session);
-  addJson(zip, "overview/settings.json", buildRedactedSettingsPayload(settings));
-  addJson(zip, "overview/accounts.json", buildAccountSummary(settings));
-  addJson(zip, "overview/stats.json", {
-    ...buildStatsPayload(snapshot),
-    allTime: {
-      totalDownloadedAllTime: settings.totalDownloadedAllTime,
-      totalCompletedFilesAllTime: settings.totalCompletedFilesAllTime,
-      totalRuntimeAllTimeMs: settings.totalRuntimeAllTimeMs
-    }
-  });
-  addJson(zip, "overview/debug-setup.json", debugSetup);
-  addJson(zip, "overview/self-check.json", debugSetup);
-  addJson(zip, "overview/history.json", {
-    total: history.length,
-    entries: history.map((entry) => summarizeHistoryEntry(entry))
-  });
-  addJson(zip, "overview/packages.json", {
-    count: packageIds.length,
-    packages: packageIds.map((packageId) => snapshot.session.packages[packageId]).filter(Boolean)
-  });
-  addJson(zip, "overview/items.json", {
-    count: itemIds.length,
-    items: itemIds.map((itemId) => snapshot.session.items[itemId]).filter(Boolean)
-  });
-  addJson(zip, "overview/host-diagnostics.json", resolveHostDiagnostics(hostDiagnosticsMode));
-  addJson(zip, "overview/trace-config.json", getTraceConfig());
-  const recentErrors = getRecentErrors();
-  addJson(zip, "overview/recent-errors.json", { count: recentErrors.length, entries: recentErrors });
-
-  addFileIfExists(zip, path.join(baseDir, AI_MANIFEST_FILE), `runtime/${AI_MANIFEST_FILE}`);
-  addFileIfExists(zip, path.join(baseDir, "debug_host.txt"), "runtime/debug_host.txt");
-  addFileIfExists(zip, path.join(baseDir, "debug_port.txt"), "runtime/debug_port.txt");
-  addFileIfExists(zip, getTraceConfigPath(), "runtime/trace_config.json");
-
-  addFileIfExists(zip, getLogFilePath(), "logs/rd_downloader.log");
-  addFileIfExists(zip, `${getLogFilePath()}.old`, "logs/rd_downloader.log.old");
-  addFileIfExists(zip, getAuditLogPath(), "logs/audit.log");
-  addFileIfExists(zip, getAuditLogPath() ? `${getAuditLogPath()}.old` : null, "logs/audit.log.old");
-  addFileIfExists(zip, getRenameLogPath(), "logs/rename.log");
-  addFileIfExists(zip, getRenameLogPath() ? `${getRenameLogPath()}.old` : null, "logs/rename.log.old");
-  addFileIfExists(zip, getDesktopRenameLogPath(), "logs/rename-session-desktop.txt");
-  addFileIfExists(zip, getSessionLogPath(), "logs/session.log");
-  addFileIfExists(zip, getTraceLogPath(), "logs/trace.log");
-  addFileIfExists(zip, getTraceLogPath() ? `${getTraceLogPath()}.old` : null, "logs/trace.log.old");
-
-  const SUPPORT_BUNDLE_LOG_WINDOW_MS = 8 * 60 * 60 * 1000;
-  addDirectoryIfExists(zip, path.join(baseDir, "session-logs"), "logs/session-logs");
-  addRecentDirectoryFiles(zip, path.join(baseDir, "package-logs"), "logs/package-logs", SUPPORT_BUNDLE_LOG_WINDOW_MS);
-  addRecentDirectoryFiles(zip, path.join(baseDir, "item-logs"), "logs/item-logs", SUPPORT_BUNDLE_LOG_WINDOW_MS);
-
-  for (const packageId of packageIds) {
-    addFileIfExists(zip, manager.getPackageLogPath(packageId) || getPackageLogPath(packageId), `logs/live/package-${packageId}.txt`);
-  }
-  for (const itemId of itemIds) {
-    addFileIfExists(zip, manager.getItemLogPath(itemId), `logs/live/item-${itemId}.txt`);
-  }
-
-  const aiManifest = safeReadJson(path.join(baseDir, AI_MANIFEST_FILE));
-  if (aiManifest) {
-    addJson(zip, "overview/ai-manifest.json", aiManifest);
-  }
-
-  return zip.toBuffer();
-}

src/main/support-data.ts

@@ -1,179 +0,0 @@
-import { getDebridLinkApiKeyIds } from "../shared/debrid-link-keys";
-import type { AppSettings, HistoryEntry, UiSnapshot } from "../shared/types";
-
-function hasText(value: unknown): boolean {
-  return String(value || "").trim().length > 0;
-}
-
-export function buildAccountSummary(settings: AppSettings): Record<string, unknown> {
-  const debridLinkKeyIds = getDebridLinkApiKeyIds(settings.debridLinkApiKeys);
-  const disabledDebridLinkIds = new Set(settings.debridLinkDisabledKeyIds || []);
-
-  return {
-    realDebrid: {
-      configured: hasText(settings.token) || settings.realDebridUseWebLogin,
-      tokenConfigured: hasText(settings.token),
-      webLoginEnabled: settings.realDebridUseWebLogin,
-      rememberToken: settings.rememberToken
-    },
-    megaDebrid: {
-      configured: (hasText(settings.megaLogin) && hasText(settings.megaPassword))
-        || settings.megaDebridApiEnabled
-        || settings.megaDebridWebEnabled,
-      loginConfigured: hasText(settings.megaLogin) && hasText(settings.megaPassword),
-      apiEnabled: settings.megaDebridApiEnabled,
-      webEnabled: settings.megaDebridWebEnabled,
-      preferApi: settings.megaDebridPreferApi
-    },
-    bestDebrid: {
-      configured: hasText(settings.bestToken) || settings.bestDebridUseWebLogin,
-      tokenConfigured: hasText(settings.bestToken),
-      webLoginEnabled: settings.bestDebridUseWebLogin
-    },
-    allDebrid: {
-      configured: hasText(settings.allDebridToken) || settings.allDebridUseWebLogin,
-      tokenConfigured: hasText(settings.allDebridToken),
-      webLoginEnabled: settings.allDebridUseWebLogin
-    },
-    ddownload: {
-      configured: hasText(settings.ddownloadLogin) && hasText(settings.ddownloadPassword)
-    },
-    oneFichier: {
-      configured: hasText(settings.oneFichierApiKey)
-    },
-    debridLink: {
-      configured: debridLinkKeyIds.length > 0,
-      keyCount: debridLinkKeyIds.length,
-      enabledKeyCount: debridLinkKeyIds.filter((id) => !disabledDebridLinkIds.has(id)).length,
-      disabledKeyCount: debridLinkKeyIds.filter((id) => disabledDebridLinkIds.has(id)).length
-    },
-    linkSnappy: {
-      configured: hasText(settings.linkSnappyLogin) && hasText(settings.linkSnappyPassword)
-    },
-    disabledProviders: [...(settings.disabledProviders || [])]
-  };
-}
-
-export function diffAccountSummary(previous: AppSettings, next: AppSettings): Record<string, unknown> {
-  const before = buildAccountSummary(previous);
-  const after = buildAccountSummary(next);
-  const changes: Record<string, unknown> = {};
-  for (const key of Object.keys(after)) {
-    const beforeJson = JSON.stringify(before[key]);
-    const afterJson = JSON.stringify(after[key]);
-    if (beforeJson !== afterJson) {
-      changes[key] = after[key];
-    }
-  }
-  return changes;
-}
-
-export function buildRedactedSettingsPayload(settings: AppSettings): Record<string, unknown> {
-  return {
-    paths: {
-      outputDir: settings.outputDir,
-      extractDir: settings.extractDir,
-      mkvLibraryDir: settings.mkvLibraryDir
-    },
-    providers: {
-      providerOrder: settings.providerOrder,
-      providerPrimary: settings.providerPrimary,
-      providerSecondary: settings.providerSecondary,
-      providerTertiary: settings.providerTertiary,
-      autoProviderFallback: settings.autoProviderFallback,
-      disabledProviders: settings.disabledProviders,
-      hosterRouting: settings.hosterRouting
-    },
-    extraction: {
-      autoExtract: settings.autoExtract,
-      autoExtractWhenStopped: settings.autoExtractWhenStopped,
-      hybridExtract: settings.hybridExtract,
-      createExtractSubfolder: settings.createExtractSubfolder,
-      cleanupMode: settings.cleanupMode,
-      extractConflictMode: settings.extractConflictMode,
-      removeLinkFilesAfterExtract: settings.removeLinkFilesAfterExtract,
-      removeSamplesAfterExtract: settings.removeSamplesAfterExtract,
-      enableIntegrityCheck: settings.enableIntegrityCheck,
-      archivePasswordCount: String(settings.archivePasswordList || "")
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .length,
-      extractCpuPriority: settings.extractCpuPriority,
-      maxParallelExtract: settings.maxParallelExtract
-    },
-    downloads: {
-      maxParallel: settings.maxParallel,
-      retryLimit: settings.retryLimit,
-      autoResumeOnStart: settings.autoResumeOnStart,
-      autoReconnect: settings.autoReconnect,
-      reconnectWaitSeconds: settings.reconnectWaitSeconds,
-      autoSkipExtracted: settings.autoSkipExtracted,
-      completedCleanupPolicy: settings.completedCleanupPolicy
-    },
-    ui: {
-      packageName: settings.packageName,
-      theme: settings.theme,
-      collapseNewPackages: settings.collapseNewPackages,
-      hideExtractedItems: settings.hideExtractedItems,
-      confirmDeleteSelection: settings.confirmDeleteSelection,
-      clipboardWatch: settings.clipboardWatch,
-      minimizeToTray: settings.minimizeToTray,
-      columnOrder: settings.columnOrder
-    },
-    bandwidth: {
-      speedLimitEnabled: settings.speedLimitEnabled,
-      speedLimitKbps: settings.speedLimitKbps,
-      speedLimitMode: settings.speedLimitMode,
-      bandwidthSchedules: settings.bandwidthSchedules
-    },
-    updates: {
-      updateRepo: settings.updateRepo,
-      autoUpdateCheck: settings.autoUpdateCheck
-    },
-    statistics: {
-      totalDownloadedAllTime: settings.totalDownloadedAllTime,
-      totalCompletedFilesAllTime: settings.totalCompletedFilesAllTime,
-      totalRuntimeAllTimeMs: settings.totalRuntimeAllTimeMs,
-      providerDailyLimitBytes: settings.providerDailyLimitBytes,
-      providerDailyUsageBytes: settings.providerDailyUsageBytes,
-      providerTotalUsageBytes: settings.providerTotalUsageBytes,
-      debridLinkApiKeyDailyLimitBytes: settings.debridLinkApiKeyDailyLimitBytes,
-      debridLinkApiKeyDailyUsageBytes: settings.debridLinkApiKeyDailyUsageBytes,
-      debridLinkApiKeyTotalUsageBytes: settings.debridLinkApiKeyTotalUsageBytes,
-      providerDailyUsageDay: settings.providerDailyUsageDay
-    },
-    accounts: buildAccountSummary(settings)
-  };
-}
-
-export function buildStatsPayload(snapshot: UiSnapshot): Record<string, unknown> {
-  return {
-    session: snapshot.stats,
-    totals: {
-      totalPackages: Object.keys(snapshot.session.packages).length,
-      totalItems: Object.keys(snapshot.session.items).length,
-      speedText: snapshot.speedText,
-      etaText: snapshot.etaText,
-      canStart: snapshot.canStart,
-      canStop: snapshot.canStop,
-      canPause: snapshot.canPause
-    }
-  };
-}
-
-export function summarizeHistoryEntry(entry: HistoryEntry): Record<string, unknown> {
-  return {
-    id: entry.id,
-    name: entry.name,
-    status: entry.status,
-    provider: entry.provider,
-    fileCount: entry.fileCount,
-    totalBytes: entry.totalBytes,
-    downloadedBytes: entry.downloadedBytes,
-    durationSeconds: entry.durationSeconds,
-    completedAt: entry.completedAt,
-    outputDir: entry.outputDir,
-    urlCount: Array.isArray(entry.urls) ? entry.urls.length : 0
-  };
-}

src/main/trace-log.ts

@@ -1,312 +0,0 @@
-import fs from "node:fs";
-import { logTimestamp } from "./log-timestamp";
-import path from "node:path";
-import { addLogListener, removeLogListener } from "./logger";
-import type { SupportTraceConfig } from "../shared/types";
-
-type TraceLevel = "INFO" | "WARN" | "ERROR";
-
-const TRACE_LOG_FLUSH_INTERVAL_MS = 200;
-const TRACE_CONFIG_FILE = "trace_config.json";
-const TRACE_LOG_MAX_FILE_BYTES = Number(process.env.RD_TRACE_LOG_MAX_BYTES || 10 * 1024 * 1024);
-const TRACE_LOG_RETENTION_DAYS = Number(process.env.RD_TRACE_LOG_RETENTION_DAYS || 30);
-const TRACE_DEFAULT_AUTO_DISABLE_MS = Number(process.env.RD_TRACE_AUTO_DISABLE_MS || 2 * 60 * 60 * 1000);
-
-const DEFAULT_TRACE_CONFIG: SupportTraceConfig = {
-  enabled: false,
-  includeMainLog: true,
-  includeAudit: true,
-  logDebugRequests: true,
-  autoDisableAt: null,
-  updatedAt: new Date(0).toISOString()
-};
-
-let traceLogPath: string | null = null;
-let traceConfigPath: string | null = null;
-let traceConfig: SupportTraceConfig = { ...DEFAULT_TRACE_CONFIG };
-let pendingLines: string[] = [];
-let flushTimer: NodeJS.Timeout | null = null;
-let autoDisableTimer: NodeJS.Timeout | null = null;
-
-function sanitizeFieldValue(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value.replace(/\r?\n/g, "\\n");
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value).replace(/\r?\n/g, "\\n");
-  } catch {
-    return String(value);
-  }
-}
-
-function formatFields(fields?: Record<string, unknown>): string {
-  if (!fields) {
-    return "";
-  }
-  const parts = Object.entries(fields)
-    .filter(([, value]) => value !== undefined && value !== null && sanitizeFieldValue(value) !== "")
-    .map(([key, value]) => `${key}=${sanitizeFieldValue(value)}`);
-  return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
-}
-
-function flushPending(): void {
-  if (!traceLogPath || pendingLines.length === 0) {
-    return;
-  }
-  const chunk = pendingLines.join("");
-  pendingLines = [];
-  try {
-    fs.appendFileSync(traceLogPath, chunk, "utf8");
-  } catch {
-  }
-}
-
-function rotateIfNeeded(filePath: string): void {
-  try {
-    const stat = fs.statSync(filePath);
-    if (stat.size < TRACE_LOG_MAX_FILE_BYTES) {
-      return;
-    }
-    const backup = `${filePath}.old`;
-    try {
-      fs.rmSync(backup, { force: true });
-    } catch {
-    }
-    fs.renameSync(filePath, backup);
-  } catch {
-  }
-}
-
-function cleanupOldBackup(filePath: string): void {
-  const backup = `${filePath}.old`;
-  try {
-    const stat = fs.statSync(backup);
-    const cutoff = Date.now() - TRACE_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    if (stat.mtimeMs < cutoff) {
-      fs.rmSync(backup, { force: true });
-    }
-  } catch {
-  }
-}
-
-function scheduleFlush(): void {
-  if (flushTimer) {
-    return;
-  }
-  flushTimer = setTimeout(() => {
-    flushTimer = null;
-    flushPending();
-  }, TRACE_LOG_FLUSH_INTERVAL_MS);
-}
-
-function appendTraceLine(line: string): void {
-  if (!traceLogPath) {
-    return;
-  }
-  rotateIfNeeded(traceLogPath);
-  if (!fs.existsSync(traceLogPath)) {
-    try {
-      fs.writeFileSync(traceLogPath, "", "utf8");
-    } catch {
-      return;
-    }
-  }
-  pendingLines.push(line);
-  scheduleFlush();
-}
-
-function normalizeTraceConfig(raw: unknown): SupportTraceConfig {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return { ...DEFAULT_TRACE_CONFIG };
-  }
-  const value = raw as Partial<SupportTraceConfig>;
-  return {
-    enabled: Boolean(value.enabled),
-    includeMainLog: value.includeMainLog === undefined ? DEFAULT_TRACE_CONFIG.includeMainLog : Boolean(value.includeMainLog),
-    includeAudit: value.includeAudit === undefined ? DEFAULT_TRACE_CONFIG.includeAudit : Boolean(value.includeAudit),
-    logDebugRequests: value.logDebugRequests === undefined ? DEFAULT_TRACE_CONFIG.logDebugRequests : Boolean(value.logDebugRequests),
-    autoDisableAt: typeof value.autoDisableAt === "string" && value.autoDisableAt.trim()
-      ? value.autoDisableAt
-      : null,
-    updatedAt: typeof value.updatedAt === "string" && value.updatedAt.trim()
-      ? value.updatedAt
-      : DEFAULT_TRACE_CONFIG.updatedAt
-  };
-}
-
-function loadTraceConfig(): SupportTraceConfig {
-  if (!traceConfigPath) {
-    return { ...DEFAULT_TRACE_CONFIG };
-  }
-  try {
-    const parsed = JSON.parse(fs.readFileSync(traceConfigPath, "utf8")) as unknown;
-    return normalizeTraceConfig(parsed);
-  } catch {
-    return { ...DEFAULT_TRACE_CONFIG };
-  }
-}
-
-function persistTraceConfig(): void {
-  if (!traceConfigPath) {
-    return;
-  }
-  try {
-    fs.writeFileSync(traceConfigPath, `${JSON.stringify(traceConfig, null, 2)}\n`, "utf8");
-  } catch {
-  }
-}
-
-const mainLogListener = (line: string): void => {
-  if (!traceConfig.enabled || !traceConfig.includeMainLog) {
-    return;
-  }
-  appendTraceLine(line);
-};
-
-function clearAutoDisableTimer(): void {
-  if (autoDisableTimer) {
-    clearTimeout(autoDisableTimer);
-    autoDisableTimer = null;
-  }
-}
-
-function disableTraceDueToExpiry(): void {
-  clearAutoDisableTimer();
-  if (!traceConfig.enabled) {
-    return;
-  }
-  traceConfig = normalizeTraceConfig({
-    ...traceConfig,
-    enabled: false,
-    autoDisableAt: null,
-    updatedAt: logTimestamp()
-  });
-  persistTraceConfig();
-  appendTraceLine(`${logTimestamp()} [INFO] [trace] Support-Trace automatisch deaktiviert | reason=expired\n`);
-}
-
-function scheduleAutoDisable(): void {
-  clearAutoDisableTimer();
-  if (!traceConfig.enabled || !traceConfig.autoDisableAt) {
-    return;
-  }
-  const until = Date.parse(traceConfig.autoDisableAt);
-  if (!Number.isFinite(until)) {
-    return;
-  }
-  const remainingMs = until - Date.now();
-  if (remainingMs <= 0) {
-    disableTraceDueToExpiry();
-    return;
-  }
-  autoDisableTimer = setTimeout(() => {
-    autoDisableTimer = null;
-    disableTraceDueToExpiry();
-  }, Math.min(remainingMs, 2_147_483_647));
-}
-
-export function initTraceLog(baseDir: string): void {
-  traceLogPath = path.join(baseDir, "trace.log");
-  traceConfigPath = path.join(baseDir, TRACE_CONFIG_FILE);
-  try {
-    fs.mkdirSync(baseDir, { recursive: true });
-    cleanupOldBackup(traceLogPath);
-    if (!fs.existsSync(traceLogPath)) {
-      fs.writeFileSync(traceLogPath, "", "utf8");
-    }
-    rotateIfNeeded(traceLogPath);
-    if (!fs.existsSync(traceLogPath)) {
-      fs.writeFileSync(traceLogPath, "", "utf8");
-    }
-    traceConfig = loadTraceConfig();
-    persistTraceConfig();
-    fs.appendFileSync(traceLogPath, `=== Trace-Log Start: ${logTimestamp()} ===\n`, "utf8");
-  } catch {
-    traceLogPath = null;
-    traceConfigPath = null;
-    traceConfig = { ...DEFAULT_TRACE_CONFIG };
-    return;
-  }
-  addLogListener(mainLogListener);
-  scheduleAutoDisable();
-}
-
-export function getTraceLogPath(): string | null {
-  if (!traceLogPath) {
-    return null;
-  }
-  return fs.existsSync(traceLogPath) ? traceLogPath : null;
-}
-
-export function getTraceConfigPath(): string | null {
-  if (!traceConfigPath) {
-    return null;
-  }
-  return fs.existsSync(traceConfigPath) ? traceConfigPath : null;
-}
-
-export function getTraceConfig(): SupportTraceConfig {
-  return { ...traceConfig };
-}
-
-export function updateTraceConfig(patch: Partial<SupportTraceConfig>): SupportTraceConfig {
-  traceConfig = normalizeTraceConfig({
-    ...traceConfig,
-    ...patch,
-    updatedAt: logTimestamp()
-  });
-  persistTraceConfig();
-  scheduleAutoDisable();
-  appendTraceLine(`${logTimestamp()} [INFO] [trace] Konfiguration aktualisiert${formatFields(traceConfig as unknown as Record<string, unknown>)}\n`);
-  return getTraceConfig();
-}
-
-export function setTraceEnabled(enabled: boolean, note = "", durationMs: number = TRACE_DEFAULT_AUTO_DISABLE_MS): SupportTraceConfig {
-  const autoDisableAt = enabled && durationMs > 0
-    ? new Date(Date.now() + durationMs).toISOString()
-    : null;
-  const next = updateTraceConfig({ enabled, autoDisableAt });
-  appendTraceLine(`${logTimestamp()} [INFO] [trace] Support-Trace ${enabled ? "aktiviert" : "deaktiviert"}${formatFields({ note, autoDisableAt })}\n`);
-  return next;
-}
-
-export function logTraceEvent(
-  level: TraceLevel,
-  category: string,
-  message: string,
-  fields?: Record<string, unknown>
-): void {
-  if (!traceConfig.enabled) {
-    return;
-  }
-  if (category === "audit" && !traceConfig.includeAudit) {
-    return;
-  }
-  appendTraceLine(`${logTimestamp()} [${level}] [${category}] ${message}${formatFields(fields)}\n`);
-}
-
-export function shutdownTraceLog(): void {
-  removeLogListener(mainLogListener);
-  clearAutoDisableTimer();
-  if (!traceLogPath) {
-    return;
-  }
-  if (flushTimer) {
-    clearTimeout(flushTimer);
-    flushTimer = null;
-  }
-  flushPending();
-  try {
-    fs.appendFileSync(traceLogPath, `=== Trace-Log Ende: ${logTimestamp()} ===\n`, "utf8");
-  } catch {
-  }
-  traceLogPath = null;
-  traceConfigPath = null;
-  traceConfig = { ...DEFAULT_TRACE_CONFIG };
-}

src/main/utils.ts

@@ -201,31 +201,19 @@ export function parsePackagesFromLinksText(rawText: string, defaultPackageName:
   const packages: ParsedPackageInput[] = [];
   let currentName = String(defaultPackageName || "").trim();
   let currentLinks: string[] = [];
-  let currentFileNames: string[] = [];
-  let pendingFileName = "";
 
   const flush = (): void => {
     const links = uniquePreserveOrder(currentLinks.filter((line) => isHttpLink(line)));
     if (links.length > 0) {
       const normalizedCurrentName = String(currentName || "").trim();
-      const fileNames = links.map((link) => {
+      packages.push({
-        const firstIndex = currentLinks.findIndex((currentLink) => currentLink === link);
-        return firstIndex >= 0 ? currentFileNames[firstIndex] || "" : "";
-      });
-      const nextPackage: ParsedPackageInput = {
         name: normalizedCurrentName
           ? sanitizeFilename(normalizedCurrentName)
           : inferPackageNameFromLinks(links),
         links
-      };
+      });
-      if (fileNames.some((fileName) => fileName.trim().length > 0)) {
-        nextPackage.fileNames = fileNames;
-      }
-      packages.push(nextPackage);
     }
     currentLinks = [];
-    currentFileNames = [];
-    pendingFileName = "";
   };
 
   for (const line of lines) {
@@ -237,20 +225,9 @@ export function parsePackagesFromLinksText(rawText: string, defaultPackageName:
     if (marker) {
       flush();
       currentName = String(marker[1] || "").trim();
-      pendingFileName = "";
-      continue;
-    }
-    const fileMarker = text.match(/^#\s*file\s*:\s*(.+)$/i);
-    if (fileMarker) {
-      pendingFileName = sanitizeFilename(String(fileMarker[1] || "").trim());
-      continue;
-    }
-    if (!isHttpLink(text)) {
       continue;
     }
     currentLinks.push(text);
-    currentFileNames.push(pendingFileName);
-    pendingFileName = "";
   }
 
   flush();
@@ -271,26 +248,8 @@ export function nowMs(): number {
   return Date.now();
 }
 
-export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
-    if (signal?.aborted) {
-      reject(new Error(String(signal.reason || "aborted")));
-      return;
-    }
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, ms);
-    const onAbort = (): void => {
-      clearTimeout(timer);
-      cleanup();
-      reject(new Error(String(signal?.reason || "aborted")));
-    };
-    const cleanup = (): void => {
-      signal?.removeEventListener("abort", onAbort);
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
 }
 
 export function formatEta(seconds: number): string {

src/main/video-processor.ts

@@ -1,510 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import crypto from "node:crypto";
-import { spawn } from "node:child_process";
-
-// Removes only-German audio handling for "Dual Language" (.DL.) scene releases.
-// Mirrors the user's ffmpeg script but adds: language-tag detection (with safe
-// fallbacks), disk-space pre-check, atomic temp->replace, mtime preservation,
-// abort-into-child, and "never destroy the only usable audio" safety.
-//
-// The ffmpeg/ffprobe-specific logic lives here so it is mockable in isolation;
-// the per-package iteration + filename/.DL. rename + logging stays in
-// download-manager.ts (its existing domain).
-
-export type GermanAudioMode = "tag" | "first";
-
-export interface ProbedAudioStream {
-  language: string;
-  title: string;
-}
-
-export type AudioTrackDecision =
-  | { action: "remux"; audioRelIndex: number; reason: string }
-  | { action: "single"; audioRelIndex: 0; reason: string }
-  | { action: "skip"; reason: string };
-
-export type VideoProcessAction =
-  | "remuxed"
-  | "kept-single"
-  | "skipped-no-german"
-  | "skipped-no-audio"
-  | "skipped-no-space"
-  | "skipped-no-tool"
-  | "error"
-  | "aborted";
-
-export interface VideoProcessResult {
-  action: VideoProcessAction;
-  reason: string;
-  keptTrackIndex?: number;
-  totalAudioTracks?: number;
-  audioLanguages?: string[];
-  error?: string;
-}
-
-export interface ProcessVideoOptions {
-  mode: GermanAudioMode;
-  cpuPriority?: string;
-  signal?: AbortSignal;
-}
-
-// Injection seam so the irreversible file-mutating body (temp -> replace ->
-// utimes -> rm-on-failure) can be exercised in tests with a fake ffmpeg/ffprobe
-// runner, without spawning real processes. Production passes nothing.
-export interface ProcessVideoDeps {
-  resolveTooling?: () => Promise<{ ffmpeg: string; ffprobe: string } | null>;
-  runProcess?: typeof runVideoProcess;
-  // Seam for the atomic-replace rename so its failure/recovery path is testable
-  // without provoking a real OS file lock. Production uses renameWithRetry.
-  rename?: (from: string, to: string) => Promise<void>;
-}
-
-const VIDEO_REMUX_EXTENSIONS = new Set([".mkv", ".mp4"]);
-const PROBE_TIMEOUT_MS = 60_000;
-const STDOUT_CAP = 2 * 1024 * 1024;
-const STDERR_CAP = 64 * 1024;
-
-// ---------------------------------------------------------------------------
-// Pure helpers (no fs / no process) — unit-tested in isolation.
-// ---------------------------------------------------------------------------
-
-// "X.German.DL.720p.mkv" -> "X.German.720p.mkv"; "X.DL.mkv" -> "X.mkv".
-export function stripDualLangMarker(fileName: string): string {
-  const ext = path.extname(fileName);
-  const base = ext ? fileName.slice(0, -ext.length) : fileName;
-  const stripped = base.replace(/\.DL\./gi, ".").replace(/\.DL$/i, "");
-  return stripped + ext;
-}
-
-export function hasDualLangMarker(fileName: string): boolean {
-  return stripDualLangMarker(fileName) !== fileName;
-}
-
-export function isRemuxableVideoFile(fileName: string): boolean {
-  return VIDEO_REMUX_EXTENSIONS.has(path.extname(fileName).toLowerCase());
-}
-
-// True when the release name explicitly marks it as a German release. Used in
-// tag mode to fall back to the first audio track (German-first scene convention)
-// when the audio language tags are wrong (a German dub mislabeled "eng"), instead
-// of skipping. Deliberately requires an explicit german/deutsch token — the
-// ".DL." marker alone (present on every processed file) is not enough, and a bare
-// "dubbed" can mean an Italian/French dub, so it must NOT flag a German release.
-export function looksLikeGermanRelease(fileName: string): boolean {
-  return /(^|[._\s-])(german|deutsch)([._\s-]|$)/i.test(fileName);
-}
-
-function isGermanStream(stream: ProbedAudioStream): boolean {
-  const lang = (stream.language || "").toLowerCase().trim();
-  if (["ger", "deu", "de", "german", "deutsch"].includes(lang)) {
-    return true;
-  }
-  // Free-text title fallback (used when the language tag is missing). Full words
-  // only — the 2-3 letter codes ger/deu are too ambiguous in a title and would
-  // pick the wrong track to keep (which then deletes the real German one).
-  const title = (stream.title || "").toLowerCase();
-  return /\b(german|deutsch)\b/.test(title);
-}
-
-// Decide which audio track to keep. Safety invariant: only ever choose to remux
-// (which destroys the original) when we are confident; otherwise skip untouched.
-export function pickAudioTrack(streams: ProbedAudioStream[], mode: GermanAudioMode, germanRelease = false): AudioTrackDecision {
-  const total = streams.length;
-  if (total === 0) {
-    return { action: "skip", reason: "no-audio" };
-  }
-  if (mode === "first") {
-    return total === 1
-      ? { action: "single", audioRelIndex: 0, reason: "single-audio" }
-      : { action: "remux", audioRelIndex: 0, reason: "first-audio" };
-  }
-  // tag mode
-  const germanPos = streams.findIndex(isGermanStream);
-  if (germanPos >= 0) {
-    return total === 1
-      ? { action: "single", audioRelIndex: 0, reason: "single-german" }
-      : { action: "remux", audioRelIndex: germanPos, reason: "german-tag" };
-  }
-  const anyTagged = streams.some((s) => (s.language || "").trim().length > 0);
-  if (!anyTagged) {
-    // No language metadata at all -> fall back to the script's behavior.
-    return total === 1
-      ? { action: "single", audioRelIndex: 0, reason: "single-untagged" }
-      : { action: "remux", audioRelIndex: 0, reason: "fallback-first-untagged" };
-  }
-  if (germanRelease) {
-    // Tagged, no German track found, but the release name explicitly says German
-    // -> the dub is mislabeled (German audio tagged "eng"). Trust the German-first
-    // scene convention rather than skipping.
-    return total === 1
-      ? { action: "single", audioRelIndex: 0, reason: "single-german-mislabeled" }
-      : { action: "remux", audioRelIndex: 0, reason: "fallback-first-german-release" };
-  }
-  // Tagged, no German track, and nothing says German -> never guess-delete.
-  return { action: "skip", reason: "no-german-track" };
-}
-
-export function parseFfprobeAudioStreams(jsonText: string): ProbedAudioStream[] {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(jsonText);
-  } catch {
-    return [];
-  }
-  const streams = (parsed as { streams?: unknown }).streams;
-  if (!Array.isArray(streams)) {
-    return [];
-  }
-  return streams.map((raw) => {
-    const tags = (raw && typeof raw === "object" ? (raw as { tags?: unknown }).tags : undefined) as
-      | { language?: unknown; title?: unknown }
-      | undefined;
-    return {
-      language: typeof tags?.language === "string" ? tags.language : "",
-      title: typeof tags?.title === "string" ? tags.title : ""
-    };
-  });
-}
-
-export function buildFfprobeArgs(input: string): string[] {
-  return [
-    "-v", "error",
-    "-select_streams", "a",
-    "-show_entries", "stream=index:stream_tags=language,title",
-    "-of", "json",
-    input
-  ];
-}
-
-export function buildFfmpegRemuxArgs(opts: { input: string; output: string; audioRelIndex: number; keepSubs?: boolean }): string[] {
-  const args = ["-i", opts.input, "-map", "0:v:0", "-map", `0:a:${opts.audioRelIndex}`];
-  if (opts.keepSubs) {
-    // Optional (not enabled by current settings): keep German subtitle tracks only.
-    args.push("-map", "0:s:m:language:ger?", "-map", "0:s:m:language:deu?");
-  }
-  // Stream-copy and keep metadata (so the kept track's language tag survives;
-  // unlike the original script's -map_metadata -1 which dropped it).
-  args.push("-c", "copy", "-disposition:a:0", "default", "-y", opts.output);
-  return args;
-}
-
-// Stream-copy remux is disk-bound; generous budget scaled by size, clamped.
-export function computeRemuxTimeoutMs(bytes: number): number {
-  const perBytes = Math.ceil((Number(bytes) || 0) / (10 * 1024 * 1024)) * 1000;
-  return Math.max(120_000, Math.min(60 * 60 * 1000, 120_000 + perBytes));
-}
-
-// ---------------------------------------------------------------------------
-// Tooling discovery (system PATH + RD_FFMPEG_BIN/RD_FFPROBE_BIN env override).
-// Lazy probe + cache, mirroring the extractor's 7z/Java resolution convention.
-// ---------------------------------------------------------------------------
-
-interface VideoTooling {
-  ffmpeg: string;
-  ffprobe: string;
-}
-
-let cachedTooling: VideoTooling | null | undefined;
-let cachedToolingNullSince = 0;
-const TOOLING_NULL_TTL_MS = 5 * 60 * 1000;
-
-function ffmpegCandidate(): string {
-  return String(process.env.RD_FFMPEG_BIN || "").trim() || "ffmpeg";
-}
-
-function ffprobeCandidate(): string {
-  return String(process.env.RD_FFPROBE_BIN || "").trim() || "ffprobe";
-}
-
-async function probeVersion(command: string): Promise<boolean> {
-  const result = await runVideoProcess(command, ["-version"], { timeoutMs: 10_000 });
-  return result.ok && !result.missing;
-}
-
-export async function resolveVideoTooling(): Promise<VideoTooling | null> {
-  if (cachedTooling) {
-    return cachedTooling;
-  }
-  if (cachedTooling === null && Date.now() - cachedToolingNullSince < TOOLING_NULL_TTL_MS) {
-    return null;
-  }
-  const ffmpeg = ffmpegCandidate();
-  const ffprobe = ffprobeCandidate();
-  const [ffmpegOk, ffprobeOk] = await Promise.all([probeVersion(ffmpeg), probeVersion(ffprobe)]);
-  if (ffmpegOk && ffprobeOk) {
-    cachedTooling = { ffmpeg, ffprobe };
-    return cachedTooling;
-  }
-  cachedTooling = null;
-  cachedToolingNullSince = Date.now();
-  return null;
-}
-
-export function resetVideoToolingCache(): void {
-  cachedTooling = undefined;
-  cachedToolingNullSince = 0;
-}
-
-// ---------------------------------------------------------------------------
-// Process spawning (ffmpeg/ffprobe). ffmpeg/ffprobe exit conventions: 0 = ok,
-// anything else = real failure (NOT 7-Zip's "exit 1 = warning" semantics).
-// ---------------------------------------------------------------------------
-
-export interface VideoSpawnResult {
-  ok: boolean;
-  aborted: boolean;
-  timedOut: boolean;
-  missing: boolean;
-  exitCode: number | null;
-  stdout: string;
-  stderr: string;
-}
-
-function appendCapped(buffer: string, text: string, cap: number): string {
-  const next = buffer + text;
-  return next.length > cap ? next.slice(next.length - cap) : next;
-}
-
-function applyChildPriority(pid: number | undefined, cpuPriority?: string): void {
-  if (process.platform !== "win32") {
-    return;
-  }
-  const numeric = Number(pid || 0);
-  if (!Number.isFinite(numeric) || numeric <= 0) {
-    return;
-  }
-  try {
-    const level = cpuPriority === "high" ? os.constants.priority.PRIORITY_NORMAL : os.constants.priority.PRIORITY_BELOW_NORMAL;
-    os.setPriority(numeric, level);
-  } catch {
-  }
-}
-
-function killChildTree(child: { pid?: number; kill: () => void }): void {
-  const pid = Number(child.pid || 0);
-  if (process.platform === "win32" && Number.isFinite(pid) && pid > 0) {
-    try {
-      const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
-      killer.on("error", () => { try { child.kill(); } catch {} });
-      return;
-    } catch {
-    }
-  }
-  try {
-    child.kill();
-  } catch {
-  }
-}
-
-export function runVideoProcess(
-  command: string,
-  args: string[],
-  opts: { signal?: AbortSignal; timeoutMs?: number; cpuPriority?: string } = {}
-): Promise<VideoSpawnResult> {
-  const { signal, timeoutMs, cpuPriority } = opts;
-  if (signal?.aborted) {
-    return Promise.resolve({ ok: false, aborted: true, timedOut: false, missing: false, exitCode: null, stdout: "", stderr: "" });
-  }
-  return new Promise((resolve) => {
-    let settled = false;
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    let aborted = false;
-    let timeoutId: NodeJS.Timeout | null = null;
-
-    const child = spawn(command, args, { windowsHide: true });
-    applyChildPriority(child.pid, cpuPriority);
-
-    const onAbort = (): void => {
-      aborted = true;
-      killChildTree(child);
-    };
-
-    const finish = (result: VideoSpawnResult): void => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
-      }
-      if (signal) {
-        signal.removeEventListener("abort", onAbort);
-      }
-      resolve(result);
-    };
-
-    if (timeoutMs && timeoutMs > 0) {
-      timeoutId = setTimeout(() => {
-        timedOut = true;
-        killChildTree(child);
-        finish({ ok: false, aborted: false, timedOut: true, missing: false, exitCode: null, stdout, stderr });
-      }, timeoutMs);
-    }
-    if (signal) {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-
-    child.stdout?.on("data", (chunk) => { stdout = appendCapped(stdout, String(chunk || ""), STDOUT_CAP); });
-    child.stderr?.on("data", (chunk) => { stderr = appendCapped(stderr, String(chunk || ""), STDERR_CAP); });
-
-    child.on("error", (error) => {
-      const text = String(error || "");
-      finish({ ok: false, aborted: false, timedOut: false, missing: text.toLowerCase().includes("enoent"), exitCode: null, stdout, stderr: stderr || text });
-    });
-
-    child.on("close", (code) => {
-      if (aborted) {
-        finish({ ok: false, aborted: true, timedOut: false, missing: false, exitCode: code, stdout, stderr });
-        return;
-      }
-      if (timedOut) {
-        finish({ ok: false, aborted: false, timedOut: true, missing: false, exitCode: code, stdout, stderr });
-        return;
-      }
-      finish({ ok: code === 0, aborted: false, timedOut: false, missing: false, exitCode: code, stdout, stderr });
-    });
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Per-file orchestration: probe -> decide -> (disk check) -> remux -> atomic
-// replace -> preserve mtime. Operates IN PLACE (same filename); the .DL. rename
-// + companion handling + logging is done by the caller (download-manager).
-// ---------------------------------------------------------------------------
-
-async function getFreeSpaceBytes(dir: string): Promise<number | null> {
-  try {
-    const stat = await fs.promises.statfs(dir);
-    return Number(stat.bavail) * Number(stat.bsize);
-  } catch {
-    return null;
-  }
-}
-
-const RENAME_RETRY_DELAYS_MS = [200, 500, 1000];
-const RENAME_RETRYABLE_CODES = new Set(["EBUSY", "EACCES", "EPERM", "EEXIST"]);
-
-function delayMs(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// Windows file locks from antivirus, the search indexer, or a media scanner are
-// transient: a rename that hits EBUSY/EACCES/EPERM/EEXIST often succeeds a moment
-// later. Retry with backoff before giving up so a momentary lock doesn't abort
-// the atomic replace and leave the file unprocessed.
-export async function renameWithRetry(from: string, to: string): Promise<void> {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      await fs.promises.rename(from, to);
-      return;
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException)?.code;
-      if (!code || !RENAME_RETRYABLE_CODES.has(code) || attempt >= RENAME_RETRY_DELAYS_MS.length) {
-        throw error;
-      }
-      await delayMs(RENAME_RETRY_DELAYS_MS[attempt]);
-    }
-  }
-}
-
-// Short, unique, same-directory sidecar name (never longer than the original file
-// name) so concurrent packages / retries never collide on a fixed temp name and a
-// long scene filename + suffix cannot push the path past Windows MAX_PATH.
-function uniqueTempPath(filePath: string): string {
-  const ext = path.extname(filePath);
-  const token = `${process.pid.toString(36)}${crypto.randomBytes(3).toString("hex")}`;
-  return path.join(path.dirname(filePath), `~rd${token}${ext}`);
-}
-
-export async function processVideoFile(filePath: string, opts: ProcessVideoOptions, deps: ProcessVideoDeps = {}): Promise<VideoProcessResult> {
-  const resolveTool = deps.resolveTooling || resolveVideoTooling;
-  const run = deps.runProcess || runVideoProcess;
-  if (opts.signal?.aborted) {
-    return { action: "aborted", reason: "aborted" };
-  }
-  const tooling = await resolveTool();
-  if (!tooling) {
-    return { action: "skipped-no-tool", reason: "ffmpeg/ffprobe nicht gefunden (PATH oder RD_FFMPEG_BIN)" };
-  }
-
-  const probe = await run(tooling.ffprobe, buildFfprobeArgs(filePath), { signal: opts.signal, timeoutMs: PROBE_TIMEOUT_MS });
-  if (probe.aborted) {
-    return { action: "aborted", reason: "aborted" };
-  }
-  if (!probe.ok) {
-    return { action: "error", reason: "ffprobe fehlgeschlagen", error: probe.stderr || `exit ${String(probe.exitCode)}` };
-  }
-
-  const streams = parseFfprobeAudioStreams(probe.stdout);
-  const audioLanguages = streams.map((s) => (s.language || "").trim() || "und");
-  const decision = pickAudioTrack(streams, opts.mode, looksLikeGermanRelease(path.basename(filePath)));
-  if (decision.action === "skip") {
-    return {
-      action: decision.reason === "no-german-track" ? "skipped-no-german" : "skipped-no-audio",
-      reason: decision.reason,
-      totalAudioTracks: streams.length,
-      audioLanguages
-    };
-  }
-  if (decision.action === "single") {
-    return { action: "kept-single", reason: decision.reason, totalAudioTracks: streams.length, audioLanguages, keptTrackIndex: 0 };
-  }
-
-  // remux path
-  let originalStat: fs.Stats;
-  try {
-    originalStat = await fs.promises.stat(filePath);
-  } catch (error) {
-    return { action: "error", reason: "stat fehlgeschlagen", error: String(error), audioLanguages };
-  }
-  const free = await getFreeSpaceBytes(path.dirname(filePath));
-  if (free !== null && free < Math.ceil(originalStat.size * 1.05)) {
-    return { action: "skipped-no-space", reason: "zu wenig freier Speicher fuer Remux", totalAudioTracks: streams.length, audioLanguages };
-  }
-
-  const tempPath = uniqueTempPath(filePath);
-  await fs.promises.rm(tempPath, { force: true }).catch(() => {});
-
-  const remux = await run(
-    tooling.ffmpeg,
-    buildFfmpegRemuxArgs({ input: filePath, output: tempPath, audioRelIndex: decision.audioRelIndex, keepSubs: false }),
-    { signal: opts.signal, timeoutMs: computeRemuxTimeoutMs(originalStat.size), cpuPriority: opts.cpuPriority }
-  );
-  if (remux.aborted) {
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
-    return { action: "aborted", reason: "aborted" };
-  }
-  if (!remux.ok) {
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
-    return { action: "error", reason: "ffmpeg remux fehlgeschlagen", error: remux.stderr || `exit ${String(remux.exitCode)}`, totalAudioTracks: streams.length, audioLanguages, keptTrackIndex: decision.audioRelIndex };
-  }
-
-  const tempStat = await fs.promises.stat(tempPath).catch(() => null);
-  if (!tempStat || tempStat.size <= 0) {
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
-    return { action: "error", reason: "Remux ergab leere Datei", totalAudioTracks: streams.length, audioLanguages };
-  }
-
-  const renameOp = deps.rename || renameWithRetry;
-  try {
-    // Atomic replace-over: libuv maps fs.rename to MoveFileEx(REPLACE_EXISTING) on
-    // Windows and rename(2) on POSIX, both atomic on the same volume, so filePath
-    // holds either the full original or the full remux at every instant. Retried
-    // for transient locks. We must NEVER rm the original first (the old fallback
-    // did): an rm-then-failed-rename left zero copies of the file on disk.
-    await renameOp(tempPath, filePath);
-    // Preserve original mtime so freshness gates (hybrid collect) don't skip it.
-    await fs.promises.utimes(filePath, originalStat.atime, originalStat.mtime).catch(() => {});
-  } catch (error) {
-    // Replace failed -> the original is untouched at filePath. Drop the temp only.
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
-    return { action: "error", reason: "Ersetzen der Datei fehlgeschlagen", error: String(error), totalAudioTracks: streams.length, audioLanguages };
-  }
-
-  return { action: "remuxed", reason: decision.reason, keptTrackIndex: decision.audioRelIndex, totalAudioTracks: streams.length, audioLanguages };
-}

src/main/windows-host-diagnostics.ts

@@ -1,325 +0,0 @@
-import fs from "node:fs";
-import { spawnSync } from "node:child_process";
-
-export interface WindowsHostEvent {
-  timeCreated: string;
-  id: number;
-  providerName: string;
-  levelDisplayName: string;
-  message: string;
-  bugcheckCode?: string;
-  bugcheckCodeHex?: string;
-  reportId?: string;
-}
-
-export interface WindowsHostDumpFile {
-  name: string;
-  fullName: string;
-  length: number;
-  lastWriteTime: string;
-}
-
-export interface WindowsCrashControlInfo {
-  crashDumpEnabled: number | null;
-  minidumpDir: string;
-  dumpFile: string;
-  overwrite: number | null;
-  logEvent: number | null;
-  autoReboot: number | null;
-}
-
-export interface WindowsHostDiagnostics {
-  collectedAt: string;
-  supported: boolean;
-  platform: string;
-  crashControl: WindowsCrashControlInfo | null;
-  recentKernelPower: WindowsHostEvent[];
-  recentWerKernel: WindowsHostEvent[];
-  recentKernelDump: WindowsHostEvent[];
-  recentAppCrashes: WindowsHostEvent[];
-  recentMinidumps: WindowsHostDumpFile[];
-  assessmentHints: string[];
-  errors: string[];
-}
-
-const CACHE_TTL_MS = 15_000;
-
-let cachedAt = 0;
-let cachedValue: WindowsHostDiagnostics | null = null;
-
-function createEmptyDiagnostics(): WindowsHostDiagnostics {
-  return {
-    collectedAt: new Date().toISOString(),
-    supported: process.platform === "win32",
-    platform: process.platform,
-    crashControl: null,
-    recentKernelPower: [],
-    recentWerKernel: [],
-    recentKernelDump: [],
-    recentAppCrashes: [],
-    recentMinidumps: [],
-    assessmentHints: [],
-    errors: []
-  };
-}
-
-function runPowerShellJson(script: string): unknown {
-  const result = spawnSync(
-    process.env.ComSpec && process.env.ComSpec.toLowerCase().includes("pwsh") ? process.env.ComSpec : "powershell.exe",
-    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script],
-    {
-      encoding: "utf8",
-      timeout: 20_000,
-      windowsHide: true,
-      stdio: ["ignore", "pipe", "pipe"]
-    }
-  );
-
-  if (result.status !== 0) {
-    const errorText = String(result.stderr || result.stdout || "").trim() || `PowerShell exited with code ${result.status}`;
-    throw new Error(errorText);
-  }
-
-  const text = String(result.stdout || "").trim();
-  if (!text) {
-    return null;
-  }
-  return JSON.parse(text) as unknown;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  return value as Record<string, unknown>;
-}
-
-function asString(value: unknown): string {
-  return typeof value === "string" ? value : value === undefined || value === null ? "" : String(value);
-}
-
-function asNumber(value: unknown): number | null {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function normalizeEvent(value: unknown): WindowsHostEvent | null {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  return {
-    timeCreated: asString(record.TimeCreated),
-    id: asNumber(record.Id) || 0,
-    providerName: asString(record.ProviderName),
-    levelDisplayName: asString(record.LevelDisplayName),
-    message: asString(record.Message),
-    bugcheckCode: asString(record.BugcheckCode),
-    bugcheckCodeHex: asString(record.BugcheckCodeHex),
-    reportId: asString(record.ReportId)
-  };
-}
-
-function normalizeDumpFile(value: unknown): WindowsHostDumpFile | null {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  return {
-    name: asString(record.Name),
-    fullName: asString(record.FullName),
-    length: asNumber(record.Length) || 0,
-    lastWriteTime: asString(record.LastWriteTime)
-  };
-}
-
-function normalizeCrashControl(value: unknown): WindowsCrashControlInfo | null {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  return {
-    crashDumpEnabled: asNumber(record.CrashDumpEnabled),
-    minidumpDir: asString(record.MinidumpDir),
-    dumpFile: asString(record.DumpFile),
-    overwrite: asNumber(record.Overwrite),
-    logEvent: asNumber(record.LogEvent),
-    autoReboot: asNumber(record.AutoReboot)
-  };
-}
-
-function pushHints(diagnostics: WindowsHostDiagnostics): void {
-  if (diagnostics.recentKernelPower.some((entry) => String(entry.bugcheckCode || "").trim() === "0")) {
-    diagnostics.assessmentHints.push("Kernel-Power 41 mit BugcheckCode 0 deutet eher auf Freeze, Watchdog oder harten Reset als auf einen sauber erfassten klassischen BSOD hin.");
-  }
-  if (diagnostics.recentWerKernel.some((entry) => /watchdog/i.test(entry.message))) {
-    diagnostics.assessmentHints.push("WER-Kernel meldet WATCHDOG-Live-Dumps. Das spricht eher fuer Kernel-, Treiber- oder Hardware-Stalls als fuer einen normalen User-Mode-App-Crash.");
-  }
-  if (diagnostics.recentAppCrashes.length === 0) {
-    diagnostics.assessmentHints.push("Keine passenden Application-Error- oder Windows-Error-Reporting-Eintraege fuer den Downloader/Electron in den letzten Tagen gefunden.");
-  }
-  if (diagnostics.recentMinidumps.length === 0) {
-    diagnostics.assessmentHints.push("Keine aktuellen Minidumps gefunden. Falls der Server erneut abstuerzt, sollte geprueft werden, ob Windows den Dump wirklich schreiben darf.");
-  }
-}
-
-function loadFromPowerShell(): WindowsHostDiagnostics {
-  const script = String.raw`
-$ErrorActionPreference = "SilentlyContinue"
-
-function Convert-EventRecord($eventRecord) {
-  $map = @{}
-  try {
-    [xml]$xml = $eventRecord.ToXml()
-    foreach ($node in $xml.Event.EventData.Data) {
-      if ($node.Name) {
-        $map[$node.Name] = [string]$node.'#text'
-      }
-    }
-  } catch {
-  }
-
-  $reportId = ""
-  if ([string]$eventRecord.Message -match "ReportId\s+([^,\r\n]+)") {
-    $reportId = $Matches[1]
-  }
-
-  [PSCustomObject]@{
-    TimeCreated = if ($eventRecord.TimeCreated) { $eventRecord.TimeCreated.ToUniversalTime().ToString("o") } else { "" }
-    Id = [int]$eventRecord.Id
-    ProviderName = [string]$eventRecord.ProviderName
-    LevelDisplayName = [string]$eventRecord.LevelDisplayName
-    Message = [string]$eventRecord.Message
-    BugcheckCode = if ($map.ContainsKey("BugcheckCode")) { [string]$map["BugcheckCode"] } else { "" }
-    BugcheckCodeHex = if ($map.ContainsKey("BugcheckCode") -and [int64]$map["BugcheckCode"] -gt 0) { ("0x{0:X}" -f [int64]$map["BugcheckCode"]) } else { "" }
-    ReportId = $reportId
-  }
-}
-
-$startTime = (Get-Date).AddDays(-7)
-$crashControl = Get-ItemProperty "HKLM:\SYSTEM\CurrentControlSet\Control\CrashControl"
-
-$kernelPower = @(
-  Get-WinEvent -FilterHashtable @{ LogName = "System"; Id = 41; StartTime = $startTime } -MaxEvents 5 |
-    ForEach-Object { Convert-EventRecord $_ }
-)
-
-$werKernel = @(
-  Get-WinEvent -FilterHashtable @{ LogName = "Microsoft-Windows-WerKernel/Operational"; StartTime = $startTime } -MaxEvents 30 |
-    Where-Object { $_.Message -match "WATCHDOG|dump|bugcheck|blue|memory" } |
-    Select-Object -First 10 |
-    ForEach-Object { Convert-EventRecord $_ }
-)
-
-$kernelDump = @(
-  Get-WinEvent -FilterHashtable @{ LogName = "Microsoft-Windows-Kernel-Dump/Operational"; StartTime = $startTime } -MaxEvents 20 |
-    Select-Object -First 10 |
-    ForEach-Object { Convert-EventRecord $_ }
-)
-
-$appCrashes = @(
-  Get-WinEvent -FilterHashtable @{ LogName = "Application"; StartTime = $startTime } -MaxEvents 100 |
-    Where-Object {
-      ($_.ProviderName -eq "Application Error" -or $_.ProviderName -eq "Windows Error Reporting") -and
-      ($_.Message -match "Real-Debrid-Downloader|electron|node\.exe|main\.js")
-    } |
-    Select-Object -First 10 |
-    ForEach-Object { Convert-EventRecord $_ }
-)
-
-$dumpFiles = @()
-foreach ($dir in @("C:\Windows\Minidump", "C:\Windows\Minidumps")) {
-  if (Test-Path $dir) {
-    $dumpFiles += Get-ChildItem -Path $dir -File |
-      Sort-Object LastWriteTime -Descending |
-      Select-Object -First 10 |
-      ForEach-Object {
-        [PSCustomObject]@{
-          Name = $_.Name
-          FullName = $_.FullName
-          Length = [int64]$_.Length
-          LastWriteTime = $_.LastWriteTimeUtc.ToString("o")
-        }
-      }
-  }
-}
-
-[PSCustomObject]@{
-  CrashControl = [PSCustomObject]@{
-    CrashDumpEnabled = if ($null -ne $crashControl.CrashDumpEnabled) { [int]$crashControl.CrashDumpEnabled } else { $null }
-    MinidumpDir = [string]$crashControl.MinidumpDir
-    DumpFile = [string]$crashControl.DumpFile
-    Overwrite = if ($null -ne $crashControl.Overwrite) { [int]$crashControl.Overwrite } else { $null }
-    LogEvent = if ($null -ne $crashControl.LogEvent) { [int]$crashControl.LogEvent } else { $null }
-    AutoReboot = if ($null -ne $crashControl.AutoReboot) { [int]$crashControl.AutoReboot } else { $null }
-  }
-  RecentKernelPower = @($kernelPower)
-  RecentWerKernel = @($werKernel)
-  RecentKernelDump = @($kernelDump)
-  RecentAppCrashes = @($appCrashes)
-  RecentMinidumps = @($dumpFiles)
-} | ConvertTo-Json -Depth 6 -Compress
-`;
-
-  const raw = runPowerShellJson(script);
-  const parsed = asRecord(raw);
-  const diagnostics = createEmptyDiagnostics();
-  diagnostics.crashControl = normalizeCrashControl(parsed?.CrashControl ?? null);
-  diagnostics.recentKernelPower = Array.isArray(parsed?.RecentKernelPower) ? parsed!.RecentKernelPower.map(normalizeEvent).filter(Boolean) as WindowsHostEvent[] : [];
-  diagnostics.recentWerKernel = Array.isArray(parsed?.RecentWerKernel) ? parsed!.RecentWerKernel.map(normalizeEvent).filter(Boolean) as WindowsHostEvent[] : [];
-  diagnostics.recentKernelDump = Array.isArray(parsed?.RecentKernelDump) ? parsed!.RecentKernelDump.map(normalizeEvent).filter(Boolean) as WindowsHostEvent[] : [];
-  diagnostics.recentAppCrashes = Array.isArray(parsed?.RecentAppCrashes) ? parsed!.RecentAppCrashes.map(normalizeEvent).filter(Boolean) as WindowsHostEvent[] : [];
-  diagnostics.recentMinidumps = Array.isArray(parsed?.RecentMinidumps) ? parsed!.RecentMinidumps.map(normalizeDumpFile).filter(Boolean) as WindowsHostDumpFile[] : [];
-  diagnostics.collectedAt = new Date().toISOString();
-  pushHints(diagnostics);
-  return diagnostics;
-}
-
-export function getWindowsHostDiagnostics(forceRefresh = false): WindowsHostDiagnostics {
-  if (!forceRefresh && cachedValue && Date.now() - cachedAt < CACHE_TTL_MS) {
-    return cachedValue;
-  }
-
-  const diagnostics = createEmptyDiagnostics();
-  if (process.platform !== "win32") {
-    diagnostics.assessmentHints.push("Windows-Host-Diagnose ist nur unter Windows verfuegbar.");
-    cachedAt = Date.now();
-    cachedValue = diagnostics;
-    return diagnostics;
-  }
-
-  try {
-    const loaded = loadFromPowerShell();
-    cachedAt = Date.now();
-    cachedValue = loaded;
-    return loaded;
-  } catch (error) {
-    diagnostics.errors.push(String(error instanceof Error ? error.message : error));
-    diagnostics.assessmentHints.push("Host-Diagnose konnte nicht vollstaendig geladen werden.");
-    cachedAt = Date.now();
-    cachedValue = diagnostics;
-    return diagnostics;
-  }
-}
-
-export function getCachedWindowsHostDiagnostics(): WindowsHostDiagnostics | null {
-  return cachedValue;
-}
-
-export function resetWindowsHostDiagnosticsCache(): void {
-  cachedAt = 0;
-  cachedValue = null;
-}
-
-export function hasRecentWindowsMinidumps(): boolean {
-  for (const dir of ["C:\\Windows\\Minidump", "C:\\Windows\\Minidumps"]) {
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      if (entries.some((entry) => entry.isFile())) {
-        return true;
-      }
-    } catch {
-    }
-  }
-  return false;
-}

src/preload/preload.ts

@@ -3,13 +3,11 @@ import {
   AddLinksPayload,
   AllDebridHostInfo,
   AppSettings,
-  DebridAccountStatus,
   DebridLinkHostLimitInfo,
   DebridProvider,
   DuplicatePolicy,
   HistoryEntry,
   PackagePriority,
-  RendererErrorReport,
   SessionStats,
   StartConflictEntry,
   StartConflictResolutionResult,
@@ -46,8 +44,6 @@ const api: ElectronApi = {
   reorderPackages: (packageIds: string[]): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.REORDER_PACKAGES, packageIds),
   removeItem: (itemId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.REMOVE_ITEM, itemId),
   togglePackage: (packageId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.TOGGLE_PACKAGE, packageId),
-  exportPackageSelection: (packageIds: string[]) => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_PACKAGE_SELECTION, packageIds),
-  exportItemSelection: (itemIds: string[]) => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_ITEM_SELECTION, itemIds),
   exportQueue: (): Promise<{ saved: boolean }> => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_QUEUE),
   importQueue: (json: string): Promise<{ addedPackages: number; addedLinks: number }> => ipcRenderer.invoke(IPC_CHANNELS.IMPORT_QUEUE, json),
   toggleClipboard: (): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.TOGGLE_CLIPBOARD),
@@ -59,26 +55,15 @@ const api: ElectronApi = {
   restart: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.RESTART),
   quit: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.QUIT),
   exportBackup: (): Promise<{ saved: boolean }> => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_BACKUP),
-  importBackup: (): Promise<{ restored: boolean; relaunch: boolean; message: string }> => ipcRenderer.invoke(IPC_CHANNELS.IMPORT_BACKUP),
+  importBackup: (): Promise<{ restored: boolean; message: string }> => ipcRenderer.invoke(IPC_CHANNELS.IMPORT_BACKUP),
-  exportSupportBundle: (): Promise<{ saved: boolean; filePath?: string }> => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_SUPPORT_BUNDLE),
   openLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_LOG),
-  openAuditLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_AUDIT_LOG),
-  openRenameLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_RENAME_LOG),
   openSessionLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_SESSION_LOG),
-  openTraceLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_TRACE_LOG),
   openPackageLog: (packageId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_PACKAGE_LOG, packageId),
-  openItemLog: (itemId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_ITEM_LOG, itemId),
-  getDebugSetupCheck: () => ipcRenderer.invoke(IPC_CHANNELS.GET_DEBUG_SETUP_CHECK),
-  getTraceConfig: () => ipcRenderer.invoke(IPC_CHANNELS.GET_TRACE_CONFIG),
-  setTraceEnabled: (enabled: boolean, note?: string, durationMinutes?: number) => ipcRenderer.invoke(IPC_CHANNELS.SET_TRACE_ENABLED, enabled, note, durationMinutes),
-  rotateDebugToken: (): Promise<{ path: string }> => ipcRenderer.invoke(IPC_CHANNELS.ROTATE_DEBUG_TOKEN),
   openRealDebridLogin: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_REALDEBRID_LOGIN),
   openAllDebridLogin: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_ALLDEBRID_LOGIN),
   importBestDebridCookies: (): Promise<number> => ipcRenderer.invoke(IPC_CHANNELS.IMPORT_BESTDEBRID_COOKIES),
   getAllDebridHostInfo: (): Promise<AllDebridHostInfo> => ipcRenderer.invoke(IPC_CHANNELS.GET_ALLDEBRID_HOST_INFO),
   getDebridLinkHostLimits: (): Promise<DebridLinkHostLimitInfo[]> => ipcRenderer.invoke(IPC_CHANNELS.GET_DEBRIDLINK_HOST_LIMITS),
-  checkDebridAccounts: (): Promise<DebridAccountStatus[]> => ipcRenderer.invoke(IPC_CHANNELS.CHECK_DEBRID_ACCOUNTS),
-  checkMegaDebridAccount: (login: string, password: string): Promise<DebridAccountStatus | null> => ipcRenderer.invoke(IPC_CHANNELS.CHECK_MEGA_DEBRID_ACCOUNT, login, password),
   retryExtraction: (packageId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.RETRY_EXTRACTION, packageId),
   extractNow: (packageId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.EXTRACT_NOW, packageId),
   resetPackage: (packageId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.RESET_PACKAGE, packageId),
@@ -89,7 +74,6 @@ const api: ElectronApi = {
   skipItems: (itemIds: string[]): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.SKIP_ITEMS, itemIds),
   resetItems: (itemIds: string[]): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.RESET_ITEMS, itemIds),
   startItems: (itemIds: string[]): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.START_ITEMS, itemIds),
-  reportRendererError: (report: RendererErrorReport): void => ipcRenderer.send(IPC_CHANNELS.LOG_RENDERER_ERROR, report),
   onStateUpdate: (callback: (snapshot: UiSnapshot) => void): (() => void) => {
     const listener = (_event: unknown, snapshot: UiSnapshot): void => callback(snapshot);
     ipcRenderer.on(IPC_CHANNELS.STATE_UPDATE, listener);

src/renderer/error-boundary.tsx

@@ -1,94 +0,0 @@
-import React from "react";
-
-interface ErrorBoundaryProps {
-  children: React.ReactNode;
-}
-
-interface ErrorBoundaryState {
-  hasError: boolean;
-  message: string;
-}
-
-// Catches render-time errors in the component tree so a crash shows a minimal
-// recovery surface instead of a silent white screen, and forwards the error to
-// the main process log. Kept deliberately dead-simple and state-independent: an
-// error inside the error path is how you get a second white screen or a loop.
-export class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
-  constructor(props: ErrorBoundaryProps) {
-    super(props);
-    this.state = { hasError: false, message: "" };
-  }
-
-  static getDerivedStateFromError(error: unknown): ErrorBoundaryState {
-    return { hasError: true, message: error instanceof Error ? error.message : String(error) };
-  }
-
-  componentDidCatch(error: unknown, info: React.ErrorInfo): void {
-    try {
-      window.rd?.reportRendererError({
-        kind: "react",
-        message: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : undefined,
-        componentStack: info?.componentStack || undefined
-      });
-    } catch {
-    }
-  }
-
-  private handleReload = (): void => {
-    window.location.reload();
-  };
-
-  render(): React.ReactNode {
-    if (!this.state.hasError) {
-      return this.props.children;
-    }
-    const overlay: React.CSSProperties = {
-      position: "fixed",
-      inset: 0,
-      display: "flex",
-      flexDirection: "column",
-      alignItems: "center",
-      justifyContent: "center",
-      gap: 16,
-      padding: 32,
-      background: "#070b14",
-      color: "#e6edf6",
-      fontFamily: "Segoe UI, system-ui, sans-serif",
-      textAlign: "center"
-    };
-    const pre: React.CSSProperties = {
-      maxWidth: 640,
-      maxHeight: 200,
-      overflow: "auto",
-      padding: 12,
-      background: "#0d1422",
-      border: "1px solid #243049",
-      borderRadius: 6,
-      color: "#ff9a8c",
-      fontSize: 12,
-      whiteSpace: "pre-wrap",
-      textAlign: "left"
-    };
-    const button: React.CSSProperties = {
-      padding: "8px 20px",
-      background: "#2d5cff",
-      color: "#fff",
-      border: "none",
-      borderRadius: 6,
-      cursor: "pointer",
-      fontSize: 14
-    };
-    return (
-      <div style={overlay}>
-        <h1 style={{ margin: 0, fontSize: 20 }}>Die Oberfläche hat einen Fehler ausgelöst</h1>
-        <p style={{ margin: 0, maxWidth: 560, color: "#9aa7bd" }}>
-          Die Anzeige wurde gestoppt, um Datenverlust zu vermeiden. Die laufenden Downloads im
-          Hintergrund sind nicht betroffen. Der Fehler wurde ins Log geschrieben.
-        </p>
-        <pre style={pre}>{this.state.message}</pre>
-        <button type="button" style={button} onClick={this.handleReload}>Oberfläche neu laden</button>
-      </div>
-    );
-  }
-}

src/renderer/main.tsx

@@ -1,39 +1,8 @@
 import React from "react";
 import { createRoot } from "react-dom/client";
 import { App } from "./App";
-import { ErrorBoundary } from "./error-boundary";
 import "./styles.css";
 
-// Forward otherwise-silent renderer failures (uncaught errors, unhandled promise
-// rejections) to the main process log. Without this, a renderer crash leaves no
-// trace anywhere on an unattended server.
-function reportRendererError(report: Parameters<typeof window.rd.reportRendererError>[0]): void {
-  try {
-    window.rd?.reportRendererError(report);
-  } catch {
-  }
-}
-
-window.addEventListener("error", (event) => {
-  reportRendererError({
-    kind: "error",
-    message: event.message || String(event.error || "Unbekannter Fehler"),
-    stack: event.error instanceof Error ? event.error.stack : undefined,
-    source: event.filename || undefined,
-    line: typeof event.lineno === "number" ? event.lineno : undefined,
-    column: typeof event.colno === "number" ? event.colno : undefined
-  });
-});
-
-window.addEventListener("unhandledrejection", (event) => {
-  const reason = event.reason;
-  reportRendererError({
-    kind: "unhandledrejection",
-    message: reason instanceof Error ? reason.message : String(reason),
-    stack: reason instanceof Error ? reason.stack : undefined
-  });
-});
-
 const rootElement = document.getElementById("root");
 if (!rootElement) {
   throw new Error("Root element fehlt");
@@ -41,8 +10,6 @@ if (!rootElement) {
 
 createRoot(rootElement).render(
   <React.StrictMode>
-    <ErrorBoundary>
     <App />
-    </ErrorBoundary>
   </React.StrictMode>
 );

src/renderer/package-order.ts

@@ -36,26 +36,38 @@ export function sortPackagesForDisplay(
     return packages;
   }
 
-  const active: PackageEntry[] = [];
+  const active: Array<{ pkg: PackageEntry; index: number; completedRatio: number; downloadedBytes: number }> = [];
   const rest: PackageEntry[] = [];
 
-  // Float packages that have an active item to the top, but keep BOTH groups in
+  packages.forEach((pkg, index) => {
-  // their original (queue) order. Earlier this sorted the active group by live
+    const items = pkg.itemIds
-  // completedRatio/downloadedBytes — which change on every progress tick (every
+      .map((id) => itemsById[id])
-  // 150-700ms), so active packages visibly reshuffled the whole time. A package
+      .filter((item): item is DownloadItem => Boolean(item));
-  // entering/leaving the active bucket is a real, discrete event (start/finish);
+    const hasActive = items.some((item) => ACTIVE_PACKAGE_STATUSES.has(item.status));
-  // ranking *within* the bucket by live bytes was pure jitter nobody needs.
+    if (!hasActive) {
-  for (const pkg of packages) {
+      rest.push(pkg);
-    const hasActive = pkg.itemIds.some((id) => {
+      return;
-      const item = itemsById[id];
-      return item != null && ACTIVE_PACKAGE_STATUSES.has(item.status);
-    });
-    (hasActive ? active : rest).push(pkg);
     }
+    const completedRatio = items.length > 0
+      ? items.filter((item) => item.status === "completed").length / items.length
+      : 0;
+    const downloadedBytes = items.reduce((sum, item) => sum + (item.downloadedBytes || 0), 0);
+    active.push({ pkg, index, completedRatio, downloadedBytes });
+  });
 
   if (active.length === 0 || active.length === packages.length) {
     return packages;
   }
 
-  return [...active, ...rest];
+  active.sort((a, b) => {
+    if (a.completedRatio !== b.completedRatio) {
+      return b.completedRatio - a.completedRatio;
+    }
+    if (a.downloadedBytes !== b.downloadedBytes) {
+      return b.downloadedBytes - a.downloadedBytes;
+    }
+    return a.index - b.index;
+  });
+
+  return [...active.map((entry) => entry.pkg), ...rest];
 }

src/renderer/selection.ts

@@ -1,27 +0,0 @@
-import type { SessionState } from "../shared/types";
-
-/**
- * Drop selected ids whose package OR item no longer exists in the session.
- * The selection set mixes package and item ids; when entries vanish (delta
- * removal, backup-driven session swap, completed-cleanup) a stale id would
- * otherwise inflate the selection count and the "(N)" action labels and keep
- * "multi" styling alive for ghosts.
- *
- * Returns the SAME set instance when nothing changed, so callers can use it
- * directly as a React state updater without forcing a re-render.
- */
-export function pruneSelection(
-  selected: ReadonlySet<string>,
-  session: Pick<SessionState, "packages" | "items">
-): Set<string> {
-  if (selected.size === 0) {
-    return selected as Set<string>;
-  }
-  const next = new Set<string>();
-  for (const id of selected) {
-    if (session.packages[id] || session.items[id]) {
-      next.add(id);
-    }
-  }
-  return next.size === selected.size ? (selected as Set<string>) : next;
-}

src/renderer/styles.css

@@ -1,16 +1,15 @@
 :root {
   font-family: "Manrope", "Segoe UI Variable", "Segoe UI", sans-serif;
-  --bg: #050810;
+  --bg: #040912;
-  --bg-glow: #1e1730;
+  --bg-glow: #10203b;
-  --surface: #0c1322;
+  --surface: #0b1424;
-  --card: #12192c;
+  --card: #101d31;
-  --field: #090f1c;
+  --field: #081120;
-  --border: #283447;
+  --border: #233954;
-  --text: #ece6dd;
+  --text: #e2e8f0;
-  --muted: #a59c8e;
+  --muted: #90a4bf;
-  --accent: #f2942d;
+  --accent: #38bdf8;
-  --accent-2: #ff7a5c;
+  --danger: #f43f5e;
-  --danger: #f4564b;
   --button-bg: #0d1a2c;
   --button-bg-hover: #12243d;
   --tab-bg: #0b1321;
@@ -34,9 +33,8 @@
   --field: #ffffff;
   --border: #c7d5ea;
   --text: #0f223d;
-  --muted: #6b6052;
+  --muted: #4e6482;
-  --accent: #c2701a;
+  --accent: #1168d9;
-  --accent-2: #d9542b;
   --danger: #c0392b;
   --button-bg: #f3f7ff;
   --button-bg-hover: #e6efff;
@@ -70,6 +68,8 @@ body,
   gap: 8px;
 }
 
+/* ── Menu Bar ───────────────────────────────────────────────── */
+
 .menu-bar {
   display: flex;
   align-items: center;
@@ -276,6 +276,8 @@ body,
   white-space: nowrap;
 }
 
+
+
 .control-strip {
   display: flex;
   justify-content: space-between;
@@ -470,9 +472,9 @@ body,
 }
 
 .btn.accent {
-  background: linear-gradient(180deg, #f9a948, #e9881f);
+  background: linear-gradient(180deg, #56d6ff, #33b9f4);
-  color: #1c1206;
+  color: #07111c;
-  border-color: #f0982f;
+  border-color: #41c6f9;
 }
 
 .btn.danger {
@@ -656,7 +658,7 @@ body,
 
 .pkg-column-header {
   display: grid;
-
+  /* grid-template-columns set via inline style from columnOrder */
   gap: 8px;
   padding: 4px 10px;
   background: color-mix(in srgb, var(--card) 58%, transparent);
@@ -695,7 +697,7 @@ body,
 
 .pkg-columns {
   display: grid;
-
+  /* grid-template-columns set via inline style from columnOrder */
   gap: 8px;
   align-items: center;
   min-width: 0;
@@ -751,7 +753,7 @@ body,
   top: 0;
   left: 0;
   height: 100%;
-  background: linear-gradient(90deg, #f2942d, #ff7a5c);
+  background: linear-gradient(90deg, #3bc9ff, #22d3ee);
   border-radius: 4px;
   transition: width 0.15s ease;
 }
@@ -1487,6 +1489,7 @@ body,
   margin: -2px 0 10px;
 }
 
+
 .key-stats-popup {
   width: min(1360px, calc(100vw - 20px));
   max-width: min(1360px, calc(100vw - 20px));
@@ -1559,12 +1562,10 @@ body,
 
 .account-subkey-table-head .col-usage,
 .account-subkey-table-head .col-limit,
-.account-subkey-table-head .col-status,
 .account-subkey-table-head .col-traffic,
 .account-subkey-table-head .col-links,
 .account-subkey-table-row .col-usage,
 .account-subkey-table-row .col-limit,
-.account-subkey-table-row .col-status,
 .account-subkey-table-row .col-traffic,
 .account-subkey-table-row .col-links {
   text-align: right;
@@ -1614,10 +1615,6 @@ body,
   color: var(--muted);
 }
 
-.account-subkey-table-row .col-status {
-  text-align: center;
-}
-
 .account-subkey-table-row .col-traffic,
 .account-subkey-table-row .col-links {
   text-align: center;
@@ -1638,38 +1635,6 @@ body,
   font-size: 10px;
 }
 
-.status-pill {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 88px;
-  padding: 2px 8px;
-  border-radius: 999px;
-  font-size: 10px;
-  font-weight: 600;
-  letter-spacing: 0.02em;
-}
-
-.status-pill-ok {
-  color: #166534;
-  background: color-mix(in srgb, #22c55e 16%, transparent);
-}
-
-.status-pill-warn {
-  color: #92400e;
-  background: color-mix(in srgb, #f59e0b 18%, transparent);
-}
-
-.status-pill-bad {
-  color: #991b1b;
-  background: color-mix(in srgb, #ef4444 14%, transparent);
-}
-
-.status-pill-muted {
-  color: var(--muted);
-  background: color-mix(in srgb, var(--field) 80%, transparent);
-}
-
 .btn-sm {
   padding: 3px 8px;
   font-size: 11px;
@@ -2180,6 +2145,7 @@ body,
   color: #0a0f1a;
 }
 
+
 .pkg-toggle {
   display: inline-flex;
   align-items: center;
@@ -2264,7 +2230,7 @@ body,
 
 .progress-dl {
   height: 100%;
-  background: linear-gradient(90deg, #f2942d, #ff7a5c);
+  background: linear-gradient(90deg, #3bc9ff, #22d3ee);
 }
 
 .progress-ex {
@@ -2272,22 +2238,17 @@ body,
   background: linear-gradient(90deg, #22c55e, #4ade80);
 }
 
+/* History Tab */
 .history-view {
   display: flex;
   flex-direction: column;
   gap: 6px;
-  height: 100%;
-  min-height: 0;
-  overflow: auto;
-  padding-right: 2px;
 }
 
 .history-toolbar {
   display: flex;
   align-items: center;
-  flex-wrap: wrap;
   justify-content: space-between;
-  gap: 12px;
   padding: 5px 12px;
   background: var(--card);
   border: 1px solid var(--border);
@@ -2297,14 +2258,6 @@ body,
   color: var(--muted);
 }
 
-.history-toolbar-actions {
-  display: flex;
-  align-items: center;
-  justify-content: flex-end;
-  gap: 8px;
-  margin-left: auto;
-}
-
 .history-card {
   cursor: default;
 }
@@ -2372,7 +2325,7 @@ td {
 
 .item-row {
   display: grid;
-
+  /* grid-template-columns set via inline style from columnOrder */
   gap: 8px;
   align-items: center;
   margin: 0 -10px;
@@ -2434,12 +2387,6 @@ td {
   background: #f59e0b;
   box-shadow: 0 0 4px #f59e0b80;
 }
-/* Reserve the dot's footprint even before a status exists, so the filename does
-   not shift ~14px right when the online/offline/checking dot first appears. */
-.link-status-dot-empty {
-  background: transparent;
-  box-shadow: none;
-}
 
 .prio-high {
   color: #f59e0b !important;
@@ -2540,97 +2487,39 @@ td {
   margin-top: 10px;
 }
 
-.stats-sections {
-  display: flex;
-  flex-direction: column;
-  gap: 14px;
-  margin-top: 14px;
-}
-
-.stats-section {
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-}
-
-.stats-section-title {
-  color: var(--muted);
-  font-size: 11px;
-  font-weight: 700;
-  letter-spacing: 0.12em;
-  text-transform: uppercase;
-}
-
 .stats-grid {
   display: grid;
-  grid-template-columns: repeat(6, minmax(0, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
   gap: 12px;
+  margin-top: 8px;
 }
 
 .stat-item {
   display: flex;
   flex-direction: column;
-  justify-content: space-between;
+  gap: 4px;
-  gap: 12px;
+  padding: 10px 12px;
-  min-height: 96px;
-  min-width: 0;
-  padding: 12px 14px;
   background: var(--field);
   border-radius: 10px;
   border: 1px solid var(--border);
-  text-align: left;
 }
-
-.stat-button {
-  width: 100%;
-  font: inherit;
-  color: inherit;
-  appearance: none;
-  cursor: default;
-}
-
-.stat-top {
-  display: flex;
-  flex-direction: column;
-  gap: 3px;
-  min-width: 0;
-}
-
-.stat-eyebrow {
-  color: var(--muted);
-  font-size: 10px;
-  font-weight: 700;
-  letter-spacing: 0.1em;
-  text-transform: uppercase;
-}
-
 .stat-item.stat-item-clickable {
   cursor: pointer;
-  transition: border-color 0.15s, transform 0.15s ease;
+  transition: border-color 0.15s;
 }
 .stat-item.stat-item-clickable:hover {
   border-color: var(--danger, #e05555);
-  transform: translateY(-1px);
 }
 
 .stat-label {
-  color: var(--text);
+  color: var(--muted);
-  font-size: 14px;
+  font-size: 12px;
-  font-weight: 600;
-  line-height: 1.25;
 }
 
 .stat-value {
-  font-size: clamp(22px, 1.35vw, 30px);
+  font-size: 18px;
   font-weight: 700;
   font-variant-numeric: tabular-nums;
-  line-height: 1.1;
-  overflow-wrap: anywhere;
-}
-
-.stat-value.stat-value-compact {
-  font-size: clamp(18px, 1.05vw, 24px);
-  line-height: 1.2;
 }
 
 .stat-value.danger {
@@ -2710,7 +2599,7 @@ td {
 }
 
 .bar-fill.completed {
-  background: linear-gradient(90deg, #f2942d, #ff7a5c);
+  background: linear-gradient(90deg, #3bc9ff, #22d3ee);
 }
 
 .provider-detail {
@@ -2726,12 +2615,6 @@ td {
   font-size: 13px;
 }
 
-@media (max-width: 1680px) {
-  .stats-grid {
-    grid-template-columns: repeat(4, minmax(0, 1fr));
-  }
-}
-
 @media (max-width: 1100px) {
   .statistics-view {
     grid-template-columns: 1fr;
@@ -2743,23 +2626,7 @@ td {
   }
 
   .stats-grid {
-    grid-template-columns: repeat(3, minmax(0, 1fr));
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
-  }
-}
-
-@media (max-width: 760px) {
-  .stats-grid {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-  }
-
-  .stat-item {
-    min-height: 88px;
-  }
-}
-
-@media (max-width: 520px) {
-  .stats-grid {
-    grid-template-columns: 1fr;
   }
 }
 
@@ -3137,40 +3004,3 @@ td {
     grid-column: span 1;
   }
 }
-
-.account-board-header-actions { display: flex; gap: 8px; align-items: center; }
-.account-validity-badge {
-  display: inline-block;
-  margin-top: 4px;
-  padding: 2px 8px;
-  border-radius: 999px;
-  font-size: 11px;
-  font-weight: 600;
-  letter-spacing: 0.2px;
-  border: 1px solid transparent;
-  white-space: nowrap;
-}
-.account-validity-badge.ok { color: #1c1206; background: linear-gradient(90deg, #7bd88f, #4fb96a); border-color: #4fb96a; }
-.account-validity-badge.free { color: #2a2113; background: #f2c14e; border-color: #d9a72f; }
-.account-validity-badge.invalid { color: #fff; background: #d9534f; border-color: #c0392b; }
-.account-validity-badge.unknown { color: var(--muted, #a59c8e); background: transparent; border-color: var(--line, #4a4032); }
-
-.rotation-panel { display: flex; flex-direction: column; gap: 6px; max-height: 320px; overflow-y: auto; }
-.rotation-empty { color: var(--muted, #a59c8e); font-size: 12px; }
-.rotation-event {
-  display: grid;
-  grid-template-columns: 72px 1fr;
-  gap: 8px;
-  align-items: baseline;
-  padding: 4px 8px;
-  border-radius: 6px;
-  font-size: 12px;
-  border-left: 3px solid var(--line, #4a4032);
-  background: rgba(255,255,255,0.02);
-}
-.rotation-event.WARN { border-left-color: #f2c14e; }
-.rotation-event.ERROR { border-left-color: #d9534f; }
-.rotation-event.INFO { border-left-color: #4fb96a; }
-.rotation-event .rotation-time { color: var(--muted, #a59c8e); font-variant-numeric: tabular-nums; }
-.rotation-event .rotation-body strong { font-weight: 600; }
-.rotation-event .rotation-reason { color: var(--muted, #a59c8e); }

src/renderer/vite-env.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="vite/client" />
+
 import type { ElectronApi } from "../shared/preload-api";
 
 declare global {

src/shared/ipc.ts

@@ -22,8 +22,6 @@ export const IPC_CHANNELS = {
   REORDER_PACKAGES: "queue:reorder-packages",
   REMOVE_ITEM: "queue:remove-item",
   TOGGLE_PACKAGE: "queue:toggle-package",
-  EXPORT_PACKAGE_SELECTION: "queue:export-package-selection",
-  EXPORT_ITEM_SELECTION: "queue:export-item-selection",
   EXPORT_QUEUE: "queue:export",
   IMPORT_QUEUE: "queue:import",
   PICK_FOLDER: "dialog:pick-folder",
@@ -38,25 +36,14 @@ export const IPC_CHANNELS = {
   QUIT: "app:quit",
   EXPORT_BACKUP: "app:export-backup",
   IMPORT_BACKUP: "app:import-backup",
-  EXPORT_SUPPORT_BUNDLE: "app:export-support-bundle",
   OPEN_LOG: "app:open-log",
-  OPEN_AUDIT_LOG: "app:open-audit-log",
-  OPEN_RENAME_LOG: "app:open-rename-log",
   OPEN_SESSION_LOG: "app:open-session-log",
-  OPEN_TRACE_LOG: "app:open-trace-log",
   OPEN_PACKAGE_LOG: "app:open-package-log",
-  OPEN_ITEM_LOG: "app:open-item-log",
-  GET_DEBUG_SETUP_CHECK: "app:get-debug-setup-check",
-  GET_TRACE_CONFIG: "app:get-trace-config",
-  SET_TRACE_ENABLED: "app:set-trace-enabled",
-  ROTATE_DEBUG_TOKEN: "app:rotate-debug-token",
   OPEN_REALDEBRID_LOGIN: "app:open-realdebrid-login",
   OPEN_ALLDEBRID_LOGIN: "app:open-alldebrid-login",
   IMPORT_BESTDEBRID_COOKIES: "app:import-bestdebrid-cookies",
   GET_ALLDEBRID_HOST_INFO: "app:get-alldebrid-host-info",
   GET_DEBRIDLINK_HOST_LIMITS: "app:get-debridlink-host-limits",
-  CHECK_DEBRID_ACCOUNTS: "app:check-debrid-accounts",
-  CHECK_MEGA_DEBRID_ACCOUNT: "app:check-mega-debrid-account",
   RETRY_EXTRACTION: "queue:retry-extraction",
   EXTRACT_NOW: "queue:extract-now",
   RESET_PACKAGE: "queue:reset-package",
@@ -66,6 +53,5 @@ export const IPC_CHANNELS = {
   SET_PACKAGE_PRIORITY: "queue:set-package-priority",
   SKIP_ITEMS: "queue:skip-items",
   RESET_ITEMS: "queue:reset-items",
-  START_ITEMS: "queue:start-items",
+  START_ITEMS: "queue:start-items"
-  LOG_RENDERER_ERROR: "log:renderer-error"
 } as const;

src/shared/mega-debrid-accounts.ts

@@ -1,90 +0,0 @@
-export interface MegaDebridAccountEntry {
-  id: string;
-  login: string;
-  password: string;
-  index: number;
-  label: string;
-  maskedLogin: string;
-}
-
-const FNV64_OFFSET_BASIS = 0xcbf29ce484222325n;
-const FNV64_PRIME = 0x100000001b3n;
-const FNV64_MASK = 0xffffffffffffffffn;
-
-function fnv1a64(text: string): string {
-  let hash = FNV64_OFFSET_BASIS;
-  for (const char of text) {
-    hash ^= BigInt(char.codePointAt(0) || 0);
-    hash = (hash * FNV64_PRIME) & FNV64_MASK;
-  }
-  return hash.toString(36);
-}
-
-export function getMegaDebridAccountId(login: string): string {
-  return `mda_${fnv1a64(login.trim().toLowerCase())}`;
-}
-
-export function maskMegaDebridLogin(login: string): string {
-  const trimmed = login.trim();
-  if (!trimmed) {
-    return "Nicht hinterlegt";
-  }
-  if (trimmed.length <= 4) {
-    return `${trimmed[0]}${"*".repeat(trimmed.length - 1)}`;
-  }
-  return `${trimmed.slice(0, 2)}${"*".repeat(Math.max(3, trimmed.length - 4))}${trimmed.slice(-2)}`;
-}
-
-export function getMegaDebridAccountLabel(index: number): string {
-  return `Account ${index + 1}`;
-}
-
-export function parseMegaDebridAccounts(raw: string, legacyPassword = ""): MegaDebridAccountEntry[] {
-  const seen = new Set<string>();
-  const lines = String(raw || "")
-    .split(/\n+/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-
-  const entries: MegaDebridAccountEntry[] = [];
-  for (const line of lines) {
-    const colonIdx = line.indexOf(":");
-    let login: string;
-    let password: string;
-    if (colonIdx >= 0) {
-      login = line.slice(0, colonIdx).trim();
-      password = line.slice(colonIdx + 1).trim();
-    } else {
-      login = line;
-      password = legacyPassword;
-    }
-    if (!login || !password) {
-      continue;
-    }
-    const key = login.toLowerCase();
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    entries.push({
-      id: getMegaDebridAccountId(login),
-      login,
-      password,
-      index: entries.length,
-      label: getMegaDebridAccountLabel(entries.length),
-      maskedLogin: maskMegaDebridLogin(login)
-    });
-  }
-  return entries;
-}
-
-export function serializeMegaDebridAccounts(accounts: { login: string; password: string }[]): string {
-  return accounts
-    .filter((a) => a.login.trim() && a.password.trim())
-    .map((a) => `${a.login.trim()}:${a.password.trim()}`)
-    .join("\n");
-}
-
-export function getMegaDebridAccountIds(raw: string, legacyPassword = ""): string[] {
-  return parseMegaDebridAccounts(raw, legacyPassword).map((entry) => entry.id);
-}

src/shared/preload-api.ts

@@ -2,18 +2,14 @@ import type {
   AddLinksPayload,
   AllDebridHostInfo,
   AppSettings,
-  DebridAccountStatus,
-  DebugSetupCheckResult,
   DebridLinkHostLimitInfo,
   DebridProvider,
   DuplicatePolicy,
   HistoryEntry,
   PackagePriority,
-  RendererErrorReport,
   SessionStats,
   StartConflictEntry,
   StartConflictResolutionResult,
-  SupportTraceConfig,
   UiSnapshot,
   UpdateCheckResult,
   UpdateInstallProgress,
@@ -43,8 +39,6 @@ export interface ElectronApi {
   reorderPackages: (packageIds: string[]) => Promise<void>;
   removeItem: (itemId: string) => Promise<void>;
   togglePackage: (packageId: string) => Promise<void>;
-  exportPackageSelection: (packageIds: string[]) => Promise<{ saved: boolean; packageCount: number; linkCount: number; filePath?: string }>;
-  exportItemSelection: (itemIds: string[]) => Promise<{ saved: boolean; packageCount: number; linkCount: number; filePath?: string }>;
   exportQueue: () => Promise<{ saved: boolean }>;
   importQueue: (json: string) => Promise<{ addedPackages: number; addedLinks: number }>;
   toggleClipboard: () => Promise<boolean>;
@@ -56,26 +50,15 @@ export interface ElectronApi {
   restart: () => Promise<void>;
   quit: () => Promise<void>;
   exportBackup: () => Promise<{ saved: boolean }>;
-  importBackup: () => Promise<{ restored: boolean; relaunch: boolean; message: string }>;
+  importBackup: () => Promise<{ restored: boolean; message: string }>;
-  exportSupportBundle: () => Promise<{ saved: boolean; filePath?: string }>;
   openLog: () => Promise<void>;
-  openAuditLog: () => Promise<void>;
-  openRenameLog: () => Promise<void>;
   openSessionLog: () => Promise<void>;
-  openTraceLog: () => Promise<void>;
   openPackageLog: (packageId: string) => Promise<void>;
-  openItemLog: (itemId: string) => Promise<void>;
-  getDebugSetupCheck: () => Promise<DebugSetupCheckResult>;
-  getTraceConfig: () => Promise<SupportTraceConfig>;
-  setTraceEnabled: (enabled: boolean, note?: string, durationMinutes?: number) => Promise<SupportTraceConfig>;
-  rotateDebugToken: () => Promise<{ path: string }>;
   openRealDebridLogin: () => Promise<void>;
   openAllDebridLogin: () => Promise<void>;
   importBestDebridCookies: () => Promise<number>;
   getAllDebridHostInfo: () => Promise<AllDebridHostInfo>;
   getDebridLinkHostLimits: () => Promise<DebridLinkHostLimitInfo[]>;
-  checkDebridAccounts: () => Promise<DebridAccountStatus[]>;
-  checkMegaDebridAccount: (login: string, password: string) => Promise<DebridAccountStatus | null>;
   retryExtraction: (packageId: string) => Promise<void>;
   extractNow: (packageId: string) => Promise<void>;
   resetPackage: (packageId: string) => Promise<void>;
@@ -86,7 +69,6 @@ export interface ElectronApi {
   skipItems: (itemIds: string[]) => Promise<void>;
   resetItems: (itemIds: string[]) => Promise<void>;
   startItems: (itemIds: string[]) => Promise<void>;
-  reportRendererError: (report: RendererErrorReport) => void;
   onStateUpdate: (callback: (snapshot: UiSnapshot) => void) => () => void;
   onClipboardDetected: (callback: (links: string[]) => void) => () => void;
   onUpdateInstallProgress: (callback: (progress: UpdateInstallProgress) => void) => () => void;

src/shared/provider-daily-limits.ts

@@ -5,13 +5,11 @@ export type DebridLinkKeyByteMap = Record<string, number>;
 
 type ProviderDailySettings =
   Pick<AppSettings, "providerDailyLimitBytes" | "providerDailyUsageBytes" | "providerDailyUsageDay">
-  & Partial<Pick<AppSettings, "debridLinkApiKeyDailyLimitBytes" | "debridLinkApiKeyDailyUsageBytes">>
+  & Partial<Pick<AppSettings, "debridLinkApiKeyDailyLimitBytes" | "debridLinkApiKeyDailyUsageBytes">>;
-  & Partial<Pick<AppSettings, "megaDebridDisabledAccountIds" | "megaDebridAccountDailyLimitBytes" | "megaDebridAccountDailyUsageBytes">>;
 
 type ProviderUsageSettings =
   ProviderDailySettings
-  & Partial<Pick<AppSettings, "providerTotalUsageBytes" | "debridLinkApiKeyTotalUsageBytes">>
+  & Partial<Pick<AppSettings, "providerTotalUsageBytes" | "debridLinkApiKeyTotalUsageBytes">>;
-  & Partial<Pick<AppSettings, "megaDebridAccountTotalUsageBytes">>;
 
 function normalizePositiveBytes(value: unknown): number {
   const numeric = Number(value);
@@ -249,81 +247,3 @@ export function addDebridLinkApiKeyTotalUsageBytes(
     debridLinkApiKeyTotalUsageBytes: currentUsageBytes
   };
 }
-
-export function isMegaDebridAccountDisabled(settings: ProviderDailySettings, accountId: string): boolean {
-  return Array.isArray(settings.megaDebridDisabledAccountIds) && settings.megaDebridDisabledAccountIds.includes(accountId);
-}
-
-export function getMegaDebridAccountDailyLimitBytes(settings: ProviderDailySettings, accountId: string): number {
-  return normalizePositiveBytes(settings.megaDebridAccountDailyLimitBytes?.[accountId]);
-}
-
-export function getMegaDebridAccountDailyUsageBytes(
-  settings: ProviderDailySettings,
-  accountId: string,
-  epochMs = Date.now()
-): number {
-  if (settings.providerDailyUsageDay !== getProviderUsageDayKey(epochMs)) {
-    return 0;
-  }
-  return normalizePositiveBytes(settings.megaDebridAccountDailyUsageBytes?.[accountId]);
-}
-
-export function isMegaDebridAccountDailyLimitReached(
-  settings: ProviderDailySettings,
-  accountId: string,
-  epochMs = Date.now()
-): boolean {
-  const limit = getMegaDebridAccountDailyLimitBytes(settings, accountId);
-  return limit > 0 && getMegaDebridAccountDailyUsageBytes(settings, accountId, epochMs) >= limit;
-}
-
-export function getMegaDebridAccountTotalUsageBytes(settings: ProviderUsageSettings, accountId: string): number {
-  return normalizePositiveBytes(settings.megaDebridAccountTotalUsageBytes?.[accountId]);
-}
-
-export function addMegaDebridAccountDailyUsageBytes(
-  settings: ProviderDailySettings,
-  accountId: string,
-  byteDelta: number,
-  epochMs = Date.now()
-): Pick<AppSettings, "providerDailyUsageDay" | "megaDebridAccountDailyUsageBytes"> {
-  const increment = normalizePositiveBytes(byteDelta);
-  const dayKey = getProviderUsageDayKey(epochMs);
-  const currentUsageBytes = settings.providerDailyUsageDay === dayKey
-    ? { ...(settings.megaDebridAccountDailyUsageBytes || {}) }
-    : {};
-  if (increment <= 0) {
-    return {
-      providerDailyUsageDay: dayKey,
-      megaDebridAccountDailyUsageBytes: currentUsageBytes
-    };
-  }
-
-  currentUsageBytes[accountId] = normalizePositiveBytes(currentUsageBytes[accountId]) + increment;
-
-  return {
-    providerDailyUsageDay: dayKey,
-    megaDebridAccountDailyUsageBytes: currentUsageBytes
-  };
-}
-
-export function addMegaDebridAccountTotalUsageBytes(
-  settings: ProviderUsageSettings,
-  accountId: string,
-  byteDelta: number
-): Pick<AppSettings, "megaDebridAccountTotalUsageBytes"> {
-  const increment = normalizePositiveBytes(byteDelta);
-  const currentUsageBytes = { ...(settings.megaDebridAccountTotalUsageBytes || {}) };
-  if (increment <= 0) {
-    return {
-      megaDebridAccountTotalUsageBytes: currentUsageBytes
-    };
-  }
-
-  currentUsageBytes[accountId] = normalizePositiveBytes(currentUsageBytes[accountId]) + increment;
-
-  return {
-    megaDebridAccountTotalUsageBytes: currentUsageBytes
-  };
-}

src/shared/types.ts

@@ -29,7 +29,6 @@ export type DebridFallbackProvider = DebridProvider | "none";
 export type AppTheme = "dark" | "light";
 export type PackagePriority = "high" | "normal" | "low";
 export type ExtractCpuPriority = "high" | "middle" | "low";
-export type HistoryRetentionMode = "never" | "session" | "permanent";
 
 export interface BandwidthScheduleEntry {
   id: string;
@@ -42,28 +41,10 @@ export interface BandwidthScheduleEntry {
 export interface DownloadStats {
   totalDownloaded: number;
   totalDownloadedAllTime: number;
-  totalFiles?: number;
   totalFilesSession: number;
   totalFilesAllTime: number;
   totalPackages: number;
   sessionStartedAt: number;
-  appSessionStartedAt: number;
-  sessionRuntimeMs: number;
-  totalRuntimeMs: number;
-  runtimeMeasuredAt: number;
-}
-
-export interface DebridAccountStatus {
-  accountId: string;
-  provider: "megadebrid" | "debridlink";
-  label: string;
-  maskedLogin: string;
-  valid: boolean;
-  isPremium: boolean;
-  premiumUntilMs: number | null;
-  email?: string;
-  message: string;
-  checkedAt: number;
 }
 
 export interface AppSettings {
@@ -71,7 +52,6 @@ export interface AppSettings {
   realDebridUseWebLogin: boolean;
   megaLogin: string;
   megaPassword: string;
-  megaCredentials: string;
   megaDebridApiEnabled: boolean;
   megaDebridWebEnabled: boolean;
   megaDebridPreferApi: boolean;
@@ -88,7 +68,7 @@ export interface AppSettings {
   linkSnappyPassword: string;
   archivePasswordList: string;
   rememberToken: boolean;
-  providerOrder: readonly DebridProvider[];
+  providerOrder: DebridProvider[];
   providerPrimary: DebridProvider;
   providerSecondary: DebridFallbackProvider;
   providerTertiary: DebridFallbackProvider;
@@ -97,8 +77,6 @@ export interface AppSettings {
   packageName: string;
   autoExtract: boolean;
   autoRename4sf4sj: boolean;
-  keepGermanAudioOnly: boolean;
-  germanAudioMode: "tag" | "first";
   extractDir: string;
   collectMkvToLibrary: boolean;
   mkvLibraryDir: string;
@@ -125,16 +103,13 @@ export interface AppSettings {
   minimizeToTray: boolean;
   theme: AppTheme;
   collapseNewPackages: boolean;
-  historyRetentionMode: HistoryRetentionMode;
   accountListShowDetailedDebridLinkKeys: boolean;
   autoSortPackagesByProgress: boolean;
   autoSkipExtracted: boolean;
   hideExtractedItems: boolean;
   confirmDeleteSelection: boolean;
-  backupIncludeDownloads: boolean;
   totalDownloadedAllTime: number;
   totalCompletedFilesAllTime: number;
-  totalRuntimeAllTimeMs: number;
   bandwidthSchedules: BandwidthScheduleEntry[];
   columnOrder: string[];
   extractCpuPriority: ExtractCpuPriority;
@@ -147,11 +122,6 @@ export interface AppSettings {
   debridLinkApiKeyDailyLimitBytes: Record<string, number>;
   debridLinkApiKeyDailyUsageBytes: Record<string, number>;
   debridLinkApiKeyTotalUsageBytes: Record<string, number>;
-  megaDebridDisabledAccountIds: string[];
-  megaDebridAccountDailyLimitBytes: Record<string, number>;
-  megaDebridAccountDailyUsageBytes: Record<string, number>;
-  megaDebridAccountTotalUsageBytes: Record<string, number>;
-  debridAccountStatuses: Record<string, DebridAccountStatus>;
   providerDailyUsageDay: string;
   scheduledStartEpochMs: number;
 }
@@ -190,10 +160,8 @@ export interface PackageEntry {
   itemIds: string[];
   cancelled: boolean;
   enabled: boolean;
-  priority?: PackagePriority;
+  priority: PackagePriority;
   postProcessLabel?: string;
-  downloadStartedAt?: number;
-  downloadCompletedAt?: number;
   createdAt: number;
   updatedAt: number;
 }
@@ -234,19 +202,6 @@ export interface ContainerImportResult {
   source: "dlc";
 }
 
-export interface RotationEvent {
-  id: string;
-  at: number;
-  level: "INFO" | "WARN" | "ERROR";
-  provider: string;
-  accountLabel: string;
-  event: string;
-  reason?: string;
-  category?: string;
-  cooldownSec?: number;
-  next?: string;
-}
-
 export interface UiSnapshot {
   settings: AppSettings;
   session: SessionState;
@@ -260,10 +215,6 @@ export interface UiSnapshot {
   clipboardActive: boolean;
   reconnectSeconds: number;
   packageSpeedBps: Record<string, number>;
-  payloadKind?: "full" | "delta";
-  removedItemIds?: string[];
-  removedPackageIds?: string[];
-  rotationEvents?: RotationEvent[];
 }
 
 export interface AddLinksPayload {
@@ -330,8 +281,6 @@ export interface UpdateInstallProgress {
 
 export type AllDebridHostState = "up" | "down" | "not_tracked" | "unknown";
 export type AllDebridHostInfoSource = "api" | "web";
-export type DebridLinkHostState = "up" | "down" | "unknown";
-export type DebridLinkKeyState = "ready" | "cooldown" | "invalid" | "quota" | "rate_limit" | "error" | "unknown";
 
 export interface AllDebridHostInfo {
   host: string;
@@ -357,15 +306,6 @@ export interface DebridLinkHostLimitInfo {
   linksCurrent: number | null;
   linksMax: number | null;
   note: string;
-  state: DebridLinkKeyState;
-  stateLabel: string;
-  stateDetail: string;
-  cooldownUntil: number | null;
-  cooldownRemainingMs: number;
-  lastCheckedAt: number | null;
-  hostState: DebridLinkHostState;
-  hostStateLabel: string;
-  hostNote: string;
 }
 
 export interface ParsedHashEntry {
@@ -397,92 +337,6 @@ export interface SessionStats {
   queuedDownloads: number;
 }
 
-export interface SupportTraceConfig {
-  enabled: boolean;
-  includeMainLog: boolean;
-  includeAudit: boolean;
-  logDebugRequests: boolean;
-  autoDisableAt: string | null;
-  updatedAt: string;
-}
-
-export interface SupportFileSizeInfo {
-  path: string | null;
-  exists: boolean;
-  bytes: number;
-}
-
-export interface SupportDirectorySizeInfo {
-  path: string;
-  exists: boolean;
-  fileCount: number;
-  bytes: number;
-}
-
-export interface SupportDiskSpaceInfo {
-  path: string;
-  totalBytes: number | null;
-  freeBytes: number | null;
-  freePercent: number | null;
-}
-
-export interface SupportBundleEstimate {
-  estimatedBytes: number;
-  estimatedEntries: number;
-  duplicatedLiveLogBytes: number;
-  note: string;
-}
-
-export interface DebugSetupCheckResult {
-  status: "ok" | "warn";
-  enabled: boolean;
-  runtimeBaseDir: string;
-  host: string;
-  port: number;
-  localOnly: boolean;
-  tokenConfigured: boolean;
-  tokenPath: string;
-  aiManifestPath: string;
-  aiManifestPresent: boolean;
-  traceConfigPath: string | null;
-  traceLogPath: string | null;
-  traceEnabled: boolean;
-  traceAutoDisableAt: string | null;
-  diskSpace: {
-    runtime: SupportDiskSpaceInfo;
-    output: SupportDiskSpaceInfo;
-    extract: SupportDiskSpaceInfo;
-  };
-  logSummary: {
-    totalBytes: number;
-    main: SupportFileSizeInfo;
-    mainBackup: SupportFileSizeInfo;
-    audit: SupportFileSizeInfo;
-    auditBackup: SupportFileSizeInfo;
-    rename: SupportFileSizeInfo;
-    renameBackup: SupportFileSizeInfo;
-    session: SupportFileSizeInfo;
-    trace: SupportFileSizeInfo;
-    traceBackup: SupportFileSizeInfo;
-    sessionLogs: SupportDirectorySizeInfo;
-    packageLogs: SupportDirectorySizeInfo;
-    itemLogs: SupportDirectorySizeInfo;
-  };
-  supportBundle: SupportBundleEstimate;
-  warnings: string[];
-  notes: string[];
-  localUrls: {
-    health: string;
-    meta: string;
-    diagnostics: string;
-  };
-  remoteUrlTemplates: {
-    health: string;
-    meta: string;
-    diagnostics: string;
-  };
-}
-
 export interface HistoryEntry {
   id: string;
   name: string;
@@ -501,13 +355,3 @@ export interface HistoryState {
   entries: HistoryEntry[];
   maxEntries: number;
 }
-
-export interface RendererErrorReport {
-  kind: "error" | "unhandledrejection" | "react";
-  message: string;
-  stack?: string;
-  source?: string;
-  line?: number;
-  column?: number;
-  componentStack?: string;
-}

tasks/lessons.md

@@ -1,335 +0,0 @@
-# Lessons
-
-## 2026-05-31 — Fix-Diagnose EMPIRISCH bestätigen, bevor man released (Timeout ≠ Account-Hänger)
-
-**Muster:** "acc2/acc3 nie versucht" wurde als "acc1 hängt → Per-Account-Timeout +
-Rotation" diagnostiziert und als v1.7.168 released. Falsch: Mega-Debrid-**Web** ist eine
-180s-Polling-Schleife (`mega-web-fallback.ts`) — acc1 *pollte* legitim, der 60s-Global-
-Timeout (nicht "Hängen") schnitt es ab. Mein 25s-Per-Account-Cap machte es SCHLIMMER
-(endlose 25s-Rotation, Datei nie aufgelöst). Erst der User-Log + Lesen der Provider-
-Impl deckte es auf. Revert v1.7.169.
-
-**Regel:**
-- Ein Timeout bei einem langsam-pollenden Provider ist KEIN Account-Fehler → darf keine
-  Rotation/kein Skippen auslösen. Vor "Account hängt"-Annahmen die Provider-Impl lesen
-  (Polling? internes Ceiling? wie lange dauert ein Erfolg legitim?).
-- Bei zwei gegensätzlichen Diagnosen (hier: Timeout-zu-kurz vs. IP-Block — stand in der
-  EIGENEN Memory!) NICHT die bequeme wählen + releasen. Erst empirisch diskriminieren
-  (Env-Var auf Server, Beobachtung, oder gezielte User-Frage). Ein Symptom, das BEIDE
-  Hypothesen gleich gut erklärt ("Timeout nach Xs"), beweist keine.
-- NICHT lokal "verifizieren" wenn das Problem umgebungsspezifisch ist (geblockte
-  Server-IP) — lokaler Erfolg ist falsch-positiv.
-
-## 2026-05-30 — Abgestürzten/„aufgehängten" Chat fortsetzen: zuerst reflog lesen
-
-**Muster:** User bat, einen anderen, aufgehängten Chat-Strang „zu Ende zu bringen".
-Der Working Tree sah harmlos aus (nur untracked), aber der eigentliche Fortschritt lag
-in einem per `reset --hard HEAD~1` weggesetzten Commit, der nur noch im **reflog**
-(dangling) lebte.
-
-**Regel:** Bei „mach weiter wo es hing":
-1. `git reflog` + `git log --oneline -20` zuerst — Ground Truth, NICHT der
-   (evtl. stale) gitStatus-Snapshot oder Konversations-interne Annahmen.
-2. Reset-weggesetzte/dangling Commits (`git fsck --lost-found`, reflog) inspizieren
-   (`git show <sha>`) — dort steckt oft die unfertige Arbeit.
-3. **Verstehen WARUM weggesetzt**, bevor man blind cherry-picked: hier brach ein
-   bestehender Test (`.toBe(signal)`-Identitätscheck), den der Fix zwingend ändert.
-   Der Reset war die Reaktion darauf, nicht „Fix war falsch". Erst die Reset-Ursache
-   beheben (Test auf Verhalten umstellen), dann den Fix recovern.
-4. Eigene Memory (`project_*`) lesen — sie dokumentierte Bug + intendierten Fix exakt.
-
-## 2026-05-30 — Release verifizieren BEVOR "fertig" gesagt wird; curl -F mit Leerzeichen im Pfad
-
-**Muster A (Edit ins Leere + trotzdem released):** Ein Edit schlug fehl ("String not
-found"), ich habe es übersehen, committet und v1.7.165 released — die Datei enthielt
-das Feature NICHT. Erst der nächste Blick zeigte es.
-**Regel:** Nach jedem Feature-Edit VOR dem Release `git show HEAD:datei | grep <marker>`
-— bestätigen dass der Code wirklich im Release-Commit ist, nicht nur dass `git commit`
-durchlief.
-
-**Muster B (Gitea UNIQUE constraint):** `npm run release:gitea` pusht erst den Tag,
-dann erstellt es den Release. Gitea legt beim Tag-Push automatisch einen Tag-Release-
-Eintrag an (name=null). `fetchExistingRelease` im Script matcht den nicht → POST create
-→ `UNIQUE constraint failed: release.repo_id, release.tag_name`. Commit + Tag sind dann
-schon gepusht, nur der Release+Assets fehlen.
-**Recovery:** `GET /api/v1/repos/.../releases/tags/<tag>` → id holen → `PATCH releases/<id>`
-mit name/body/draft:false → Assets per `POST releases/<id>/assets?name=<url-encoded>` hochladen.
-
-**Muster C (curl -F Datei mit Leerzeichen):** `curl -F "attachment=@release/Datei mit
-Leerzeichen.exe.blockmap"` lädt FALSCHEN Inhalt hoch (Server-Size != lokale Size).
-**Regel:** Datei mit Leerzeichen im Namen erst nach `/tmp/leerzeichenfrei` kopieren,
-DAS hochladen, Asset-Name über `?name=<url-encoded>` setzen. Danach Server-Size gegen
-lokale Size prüfen.
-
-
-
-## 2026-05-30 — Nicht in chaotische Parallel-Tool-Batches verfallen (User-Korrektur: "bist du in nem endless loop")
-
-**Muster:** Bei einem großen Multi-File-Edit habe ich Dutzende Tool-Calls (Bash-Probes,
-Reads, Edits, Python-Inline-Skripte, mehrfache tsc-Läufe) in EINEN Message-Block gepackt.
-Resultat: Ein einzelner Fehler/Cancel hat die ganze parallele Kette abgebrochen, Edits
-landeten halb, ich verlor den Überblick welche Änderung wirklich auf Disk war, und es
-wirkte wie eine Endlosschleife. Dazu: wegwerf-`scripts/_*.py`/`_*.txt` als Workaround
-gegen Output-Encoding statt der dedizierten Tools.
-
-**Regel:**
-- Edits über mehrere Dateien **sequenziell, einer nach dem anderen**, mit kurzer
-  Verifikation dazwischen — nicht 20 spekulative Calls auf einmal.
-- Nach jedem Edit, der fehlschlagen kann (Anchor evtl. nicht eindeutig), das Ergebnis
-  lesen, bevor der nächste folgt. Edit/Write erroren laut — darauf vertrauen.
-- KEINE Wegwerf-Python-Skripte ins Repo schreiben, um Shell-Output zu parsen. `Grep`/
-  `Read`/`Edit` nutzen. Wenn doch ein Temp nötig ist: nach `os.tmpdir()`, nie nach
-  `scripts/`, und sofort wieder löschen.
-- Verifikation gebündelt am ENDE (1× tsc, 1× build, 1× vitest), nicht 10× zwischendrin.
-
-
-## 2026-05-28 — Analyse-Befund gegen beobachtete Realität gaten (Advisor-Korrektur)
-
-**Muster:** Meine Analyse sagte einen *häufigen* Bug voraus (jede letzte Datei im
-Standard-Modus + jede Nested-Datei landet unbenannt), während der User nur "1-2 pro
-Staffel" meldete. Ich habe die Diskrepanz bemerkt ("zu schwer um unbemerkt zu bleiben")
-und sie mit weiterem Timing-Argument wegrationalisiert.
-
-**Regel:** Wenn die eigene Analyse etwas vorhersagt, das der beobachteten Realität
-widerspricht, NICHT die bequeme Lesart wählen — **mit einem Reproduktions-Test gaten**,
-bevor man fixt. Failing Test gegen den Ist-Stand zuerst (TDD/systematic-debugging Phase 4):
-- reproduziert → Bug bestätigt, mit Sicherheit fixen.
-- reproduziert nicht → Analyse hat eine Mitigation übersehen, kein Fix für Nicht-Bug.
-
-## 2026-05-28 — Crash-Debris im Working Tree: stashen, nicht verwerfen
-
-**Muster:** Eine abgestürzte Session (API 400) hinterließ ein uncommittetes Working Tree,
-das drei releaste Commits revertierte. Verlockung: `git checkout`/discard, um clean HEAD
-zu bekommen.
-
-**Regel:** Fremde/unverstandene uncommittete Änderungen **`git stash`** (non-destruktiv,
-recoverable), nie blind verwerfen. Gibt clean HEAD, nichts geht verloren, kein Stall auf
-User-Rückfrage. Danach dem User sagen WAS gestasht wurde und WARUM.
-
-## Wiring-Lock vs. Mechanism-Test
-
-Ein Test, der eine Hilfsfunktion mit dem richtigen Flag direkt aufruft, beweist nur, dass
-das Flag funktioniert — NICHT, dass der Produktionspfad das Flag setzt. Für echte
-Absicherung einen End-to-End-Test durch den realen Einstiegspunkt fahren und per
-Negativ-Gate (Flag temporär entfernen → Test muss fallen) verifizieren.
-
-## 2026-05-31 — Log-Symptom ≠ User-Wortlaut: greppen, bevor man auf eine Meldung triggert
-
-**Muster:** User meldete Mega-Debrid-Tageslimit als „Kein Server für diesen Hoster". Ich
-wollte den Fix an genau diese Meldung (`MEGA_DEBRID_NO_SERVER_RE`) hängen. Der Advisor
-stoppte: der Screenshot zeigte als Cooldown-Grund **„Antwort leer"**, nicht „Kein Server".
-
-**Beweis (Support-Bundle gegrept):** „Kein Server"/„Erreur"/„aucun serveur" = **0** Treffer
-im ganzen Bundle, „Antwort leer" = **20.861** Treffer. Der limitierte Account liefert im
-Web-Pfad NIE eine unterscheidbare Meldung — `generate()` findet ohne `processDebrid`-Code
-keinen Code → `return null` → der Aufrufer macht daraus „Antwort leer". Ein Trigger auf
-„Kein Server" wäre toter Code gewesen (= die v1.7.172-Falle, zum 2. Mal fast getreten).
-
-**Regel:** Bevor man einen Fix an einen bestimmten Meldungstext hängt, in den ECHTEN Logs
-greppen, ob dieser Text dort überhaupt vorkommt (`count`-Mode, alt-Text vs. Ist-Text). Sind
-zwei Fälle auf Message-Ebene nicht unterscheidbar (Tageslimit vs. transienter Blip → beide
-„Antwort leer"), nicht raten — über ein **Verhaltens-Signal** klassifizieren: hier eine
-Streak (3× hintereinander leer → geparkt), nicht der einmalige Wortlaut.
-
-**Wiring-Test nicht vergessen** (eigene Lesson): die Helfer-Unit-Tests beweisen nur den
-Zähler. Ein E2E-Test muss eine ECHTE leere Antwort durch den realen Einstiegspunkt
-(`unrestrictWithAccounts` → `classifyAccountFailure` → catch → Park) treiben, sonst bleibt
-unbewiesen, dass der Produktionspfad das Signal überhaupt setzt.
-
-## 2026-06-01 — Ein Verifizierer muss dieselbe Pfad-Normalisierung nutzen wie die verifizierte Operation
-
-**Muster:** Neues Renaming-Logging sollte nach jedem Rename verifizieren, ob die Datei
-wirklich unter dem Zielnamen liegt. `verifyRename` machte statSync/readdirSync auf den
-ROHEN Pfaden — der echte Rename lief aber über `toWindowsLongPathIfNeeded` (\?\-Prefix
-ab >=248 Zeichen). Bei langen Scene-Release-Pfaden (genau das, was die App routinemäßig
-umbenennt) scheiterten die rohen fs-Calls → falsches „Ziel nicht gefunden" UND — schlimmer —
-die Quell-Prüfung scheiterte ebenfalls → `sourceGone` fälschlich true → **falsches „OK"**,
-das einen halb-fertigen Verschiebevorgang maskiert. Der Diagnose-Log hätte genau die
-schwersten Fälle vergiftet. (Adversarialer Review-Workflow fand es, Confidence 0.8.)
-
-**Regel:** Wenn Code eine Operation VERIFIZIERT, muss er exakt dieselbe Pfad-/Encoding-/
-Normalisierung verwenden wie die Operation selbst (hier: \?\-Long-Path-Prefix). Sonst
-mis-reportet der Verifizierer still — und am verlässlichsten bei den Edge-Cases, die man
-eigentlich fangen wollte. Ein falsches OK in einem Diagnose-Log ist schlimmer als ein
-falsches ERROR. Zusatz: readdir-Fehler darf nicht zu „Schreibweise ok" degradieren
-(stilles False-OK) → eigenes WARN-Level „nicht verifizierbar".
-
-**Meta:** Bei einem Feature, dessen ganzer Zweck Beobachtbarkeit/Verifikation ist, lohnt
-ein adversarialer Review mit Fokus „würde die Verifikation auf der ECHTEN Last (lange
-Pfade, case-insensitive FS, EXDEV) korrekt urteilen?" — nicht nur „kompiliert + Happy-Path-Test".
-
-## 2026-06-03 — Renaming „nie 100%": entkoppelte Scans + Namens-Fabrikation aus token-losen Ordnern
-
-**Symptom (aus dem Desktop-Rename-Log diagnostiziert):** 17 Dateien landeten ROH in der
-Library ("tvarchiv...s07e12-720.mkv", "4sf-...s04e01.mkv"). KEINE [ERROR]-Zeile — alle [INFO],
-weil die Verifikation nur „liegt die Datei am Zielnamen?" prüft, nicht „ist der Zielname
-sinnvoll?". Das Logging hat den Bug sichtbar gemacht (genau sein Zweck).
-
-**Root Cause 1 (entkoppelte Scans):** Auto-Rename (scannt nur extractDir, nur present-and-
-stable Dateien, Freshness-Gate loggt nur via logger.info → keine Session-Spur) und
-collectMkvFilesToLibrary (verschiebt JEDE .mkv, behielt den rohen Basename) sind getrennte
-Scans. Eine von Auto-Rename verpasste Datei (verpasster Zyklus ODER lag in „Downloader
-Unfertig" außerhalb extractDir) wurde von collect roh weggeschoben. **Fix:** collect leitet
-den sauberen Namen SELBST ab — über dieselbe Funktion wie Auto-Rename (decideAutoRenameBaseName,
-single source of truth) → Race wird egal, beide Pfade können nicht mehr divergieren.
-
-**Root Cause 2 (latente Fabrikation, vom Advisor gefunden):** decideAutoRenameBaseName
-fabrizierte „Mega-Direct-Pack.S01E01" für einen generischen Paketordner, weil
-`hasSceneGroupSuffix("Mega-Direct-Pack")` auf „-Pack" falsch-positiv matcht und Guard B dann
-die Quell-Episode an einen token-losen Ordner anhängt. Das hätte AUTO-RENAME genauso getroffen
-(nur dormant, weil echte Releases saubere Ordner haben). **Fix an der Wurzel:** Rename nur,
-wenn IRGENDEIN folderCandidate einen echten Season-/Episode-Token trägt — ein token-loser
-Ordner kann keine Episode autoritativ benennen.
-
-**Meta-Lektionen:**
-1. Bei „X nie 100%": die Fehler aus dem ECHTEN Log ziehen (greppen), nicht raten. Hier:
-   „Kein Server" 0×, „Antwort leer" 20k×; und 17 vs vermutete 12 (5 begannen mit Ziffer „4").
-2. Symptom-Fix vs Wurzel-Fix: ein collect-seitiger Guard (Quell-Auflösung+Codec) hätte das
-   Symptom kaschiert + eine Restlücke gelassen; der Wurzel-Fix in der gemeinsamen Funktion
-   schließt BEIDE Pfade + ermöglicht ehrliches 100%.
-3. Wenn ein (Sub-)Agent eine empirische Behauptung aufstellt, die der beobachteten Realität
-   widerspricht (Review: „liefert no-target" vs Test: „benennt um"), NICHT raten — mit einem
-   Wegwerf-Diagnose-Test die echte Rückgabe sichtbar machen, DANN entscheiden.
-4. „raw-keep ist der Boden" als Guard-Prinzip: ein Rename darf nie einen schlechteren Namen
-   erzeugen als der Originalname.
-
-## 2026-06-03 (2) — Renaming „verschlimmbessert" guten Quellnamen (Scene-Gruppe mit Unterstrich)
-
-**Symptom (neues Desktop-Log):** `castle.s08e02.german.dl.720p.web.h264-idtv_int.mkv` (bereits
-SAUBER) im Ordner `Castle.S08E02.GERMAN.DL.720p.WEB.H264-idTV_iNT` (Paket `scn2-cstl7`) wurde zu
-`scn2-cstl7.S08E02.mkv` — also GUTER Name → obfuskierter Paketname. Andere Klasse als die 17
-(roh→nicht-angefasst); hier gut→schlechter.
-
-**Ursache (reproduziert, kein Raten):** `hasSceneGroupSuffix("...H264-idTV_iNT")` = false, weil
-`SCENE_GROUP_SUFFIX_RE`/`_FALLBACK_RE` Unterstriche im Gruppen-Suffix verbieten. → buildAutoRenameBaseName
-verwarf den sauberen Episoden-Ordner (return null) → fiel auf den Paketordner `scn2-cstl7` zurück
-→ Episode angehängt = `scn2-cstl7.S08E02`. Guard A (Quelle-besser) griff nicht, weil
-`hasMeaningfulSeriesPrefix("scn2-cstl7.S08E02")=true` (Gruppe sieht aus wie Serien-Prefix).
-**Fix:** `extractFlexibleSceneGroupSuffix` (existierte, war nicht verdrahtet) in hasSceneGroupSuffix
-einbinden → Unterstrich-Gruppen erkannt → sauberer Ordner gewinnt → idealer Name.
-
-**Meta-Lektionen:**
-1. „100%" gilt nur fuer die DATEN, die man hatte. Mein lueckenloser Check des 2026-06-02-Logs war
-   korrekt — aber ein NEUER Download (Castle/idTV_iNT) brachte eine Gruppen-Form, die im alten Log
-   nicht vorkam. Bei „nie 100%" ehrlich sagen: „fuer die bekannten Faelle 100%, neue Muster brauchen
-   neue Logs". Das Desktop-Log liefert genau diese neuen Muster.
-2. Reproduzieren statt raten: ein 3-Zeilen-Diagnose-Test (buildAutoRenameBaseName pro Ordner +
-   decideAutoRenameBaseName) zeigte sofort, WELCHER Ordner verworfen wird und warum — nicht spekulieren.
-3. Offener Backstop-Gedanke fuer echte Robustheit: ein generelles Guard "ersetze nie einen bereits
-   VOLLSTAENDIGEN Quellnamen (Serie+Episode+Aufloesung+Codec) durch einen, der die Serien-Identitaet
-   verliert" wuerde KUENFTIGE unbekannte Gruppen-Formate abfangen — riskanter Eingriff in Guard A,
-   nur mit Tests + auf User-Wunsch.
-
-## 2026-06-03 (3) — Renaming-Klasse „Junk-Quellname + sauberer Release-Ordner" (Folge-Nummer statt SxxExx)
-
-**Symptom (Log 18-18):** „Kreuzfahrt ins Glück" — 25 Folgen `bet_kig_01_hdt.mkv` (obfuskiert, KEIN
-SxxExx-Token) im sauberen Episoden-Ordner `Kreuzfahrt.ins.Glueck.01.Hochzeitsreise.nach.Burma.2007.
-German.720p.HDTV.x264-BET` (Episode als bloße „01"). Auto-Rename: „kein Zielname" → 25× roh in die
-Library. Diesmal SICHTBAR als 25 [WARN] (vorher 0 WARN) — das Log zeigt die Klasse direkt.
-
-**Ursache (reproduziert):** `buildAutoRenameBaseName` gibt null zurück, sobald die QUELLE keinen
-SxxExx-Token hat (Z.1288) — egal wie sauber der Ordner ist. Das „Folge 01"-Nummernformat (kein
-S01E01) wurde nie unterstuetzt. VORBESTEHEND, nicht meine v1.7.178/179.
-
-**Fix:** Fallback in decideAutoRenameBaseName — wenn kein Zielname UND Quelle hat keinen
-Episode-Token, den ersten folderCandidate nehmen, der ein VOLLSTAENDIGER Scene-Release-Ordner ist:
-`hasSceneGroupSuffix(f) && (RESOLUTION_RE.test(f) || CODEC_RE.test(f)) && !SCENE_SEASON_ONLY_RE.test(f)`.
-Greift NUR ohne Quell-Episode-Token → schliesst sich mit dem Fabrikations-Guard aus (Mega-Direct hat
-Quell-Token → unerreicht). note:"folder-as-is".
-
-**Advisor-Punkt (wichtig):** NICHT nur Aufloesung pruefen — alte deutsche TV-Serien gibt es als
-DVDRip/XviD OHNE 720p-Token. `RESOLUTION_RE ODER CODEC_RE` → sonst die naechste Runde. Pin-Test:
-DVDRip-Variante (kein 720p, nur x264).
-
-**Edge (Advisor):** Bonus/Sample muss VOR diesem Fallback gefiltert werden (sonst kriegt ein
-Featurette/Sample im Episoden-Ordner den Episodennamen). Bestaetigt: Auto-Rename-Loop (Sample-Size +
-BONUS_FILENAME_RE) und Collect filtern beide vor der Namensherleitung → gedeckt.
-
-**Meta:** 3. „anderes Format" in Folge — diese Klasse (Junk-Quelle + sauberer Ordner) ist die
-groesste verbleibende. Scene-Naming hat aber einen langen Schwanz: ehrlich „diese Klasse ist
-abgedeckt", nicht „jetzt 100%". Das Desktop-Log liefert jede neue Klasse sofort.
-
-## 2026-06-04 — KEINE „Claude/AI"-Spuren in oeffentlichen Releases (GitHub)
-**Korrektur:** „kein SCHAU MAL wie ich mit claude gearbeitet hab release … entfern alles was da drin
-steckt." Beim einmaligen GitHub-Sync (Sucukdeluxe/real-debrid-downloader) waren oeffentlich: `CLAUDE.md`,
-`design-mockups/`, `tasks/lessons.md`+`todo.md`, historisch `.claude/`, und **357 Commits mit
-`Co-Authored-By: Claude`-Trailer**.
-**Regel ab jetzt:** Fuer dieses Projekt KEINE `Co-Authored-By: Claude`-Trailer mehr an Commits
-(ueberschreibt die Default-Git-Anweisung — User-Wunsch hat Vorrang). Keine KI-Artefakte (CLAUDE.md,
-Mockups, lessons/todo, .claude/) in irgendetwas, das oeffentlich gepusht wird.
-**Wie sauber gemacht (ohne Gitea/lokal anzufassen):** isolierter `git clone` → `git filter-repo`
-(`--invert-paths --path …` + `--message-callback` der Trailer-Zeilen droppt) → Force-Push NUR main +
-v1.7.180 zu GitHub. Alte Tags NICHT geloescht, sondern via `.git/filter-repo/commit-map` auf ihre
-sauberen Commits **umgehaengt** (89 Tags, alle Releases bleiben erhalten) — besser als Loeschen.
-**Ehrliche Grenze (Advisor):** Force-Push säubert nur ref-erreichbare Historie. Verwaiste alte Commits
-bleiben per voller SHA erreichbar, bis GitHub GC'd ODER das Repo neu angelegt wird (nur der User kann
-das — Token hat kein `delete_repo`). Lokaler Klon verifiziert ≠ GitHub-Zustand: immer per `gh api`
-gegenpruefen (Datei 404 am Tag, Commit-Messages trailer-frei).
-**Methodik:** vor Force-Push Voll-Range-Secret-Scan (push-protection killt sonst mitten im Push) +
-Tree-Content-Grep auf `claude|anthropic` (filter-repo tilgt Pfad-NAMEN + Trailer, nicht Datei-INHALTE).
-
-## 2026-06-04 — Folge bleibt bei „Downloader Fertig" haengen: Episodentitel == Bonus-Wort
-**Symptom (User-Screenshot + rd-support-bundle):** `Revenge.2011.S04E19.Interview...mkv` extrahiert +
-korrekt umbenannt, aber NIE in die Library verschoben — kein Fehler. „selten, 4-5 Folgen pro 1,5TB".
-**Diagnose (Bundle):** Paket-Log zeigte 22/23 „MKV verschoben", E19 fehlte, KEIN WARN/ERROR. Im
-HAUPT-Log (`rd_downloader.log`) dann 5× `MKV-Sammelordner: Bonus-Datei uebersprungen: ...S04E19.Interview`.
-**Root Cause:** `BONUS_FILENAME_RE` enthaelt `interview` (+ outtakes/special/featurette/bloopers/...). Der
-Episodentitel „Interview" (UND der Episoden-Ordnername — `isInsideBonusDir` macht `.includes()` Substring)
-matchte → `collectMkvFilesToLibrary` stufte die echte Folge als Bonus/Extras ein und skippte sie. Trifft
-auch ganze Serien deren NAME ein Bonus-Wort ist. Skip war nur `logger.info` → im Paket-Log UNSICHTBAR
-(darum „silent orphan", nur via Forensik gefunden).
-**Fix:** neue exportierte `isBonusContent(filePath, packageDir, nameWithoutExt)` — eine Datei MIT echtem
-SxxExx-Token (`extractEpisodeToken`) ist eine nummerierte Episode, NIE Bonus (egal welches Titelwort).
-Echte Extras (kein Token / Extras-Subordner) bleiben gefiltert. Beide Call-Sites umgestellt (Auto-Rename
-~4312 + Collect ~5054). 2 Integrationstests (Interview wird gesammelt / Making.Of bleibt) + 5 Unit-Tests.
-**Diagnose-Lektion (Advisor-Gate):** „4-5 Folgen" plural → NICHT beim 1. Fund stoppen. Bundle-weit
-gegengeprueft: 0 Move-Fehler, nur 1 Bonus-Skip. 4 weitere „noch frisch"-Defers sahen wie Orphans aus,
-waren aber FALSE POSITIVES — Moves loggen NICHT ins Haupt-Log (nur Paket-Log), und deren Paket-Logs fehlten
-im Bundle. Per Code bewiesen: finaler Deferred-Collect laeuft fuer jedes fertige Paket (`success` =
-completed-Items, Z.11904) mit `deferFreshFiles=false` → faengt Frische-Defers. Also Frische orphan't NICHT;
-Bonus schon (Filter ignoriert deferFreshFiles, skippt in JEDEM Pass inkl. final). Lehre: bevor man „X ist
-Orphan" behauptet, pruefen ob der GEGENBEWEIS (Move) im verfuegbaren Log ueberhaupt sichtbar WAERE.
-
-## 2026-06-05 — Folge bleibt ROH: vollstaendiger Episoden-Ordner OHNE -GROUP-Suffix
-**Symptom (rename-session 2026-06-04):** `safari-fm-s04e08a.avi` / `...b.avi` landeten ROH in der Library
-(entpackt2). Log: `Auto-Rename übersprungen: kein Zielname`. Funktionierende S01E02 hatte Ordner
-`...XviD-SAFARi` (Gruppe), die kaputten S04E08a/b hatten `...SATRiP.XviD` (KEIN -GROUP).
-**Root Cause (Wegwerf-Diagnose, NICHT geraten):** Erste Hypothese „a/b-Token nicht erkannt" war FALSCH —
-`extractEpisodeToken("...s04e08a")`="S04E08" (das Lookahead `(?!\d)` verbietet nur Ziffern, nicht Buchstaben).
-Echte Ursache: das Gate in `buildAutoRenameBaseName` (`isLegacy4sf || isSceneGroupFolder`) lehnt einen
-vollstaendigen Episoden-Ordner OHNE -GROUP ab (endet auf bare Codec `.XviD`). Die QUELLE hat aber einen
-Token → der v1.7.180-Fallback (greift NUR ohne Quell-Token) feuert nicht → no-target → roh gemoved.
-**Fix:** Gate um `isCompleteEpisodeFolder` erweitert = echter Episoden-Token IM Ordner UND Codec-/
-Aufloesungs-Marker (neue Module-Consts `SCENE_RESOLUTION_MARKER_RE` / `SCENE_CODEC_MARKER_RE`, inkl.
-xvid/divx). Part-Buchstabe a/b bleibt erhalten (Ordnername dient unveraendert als Zielname; nur der
-RANGE-Zweig schreibt Token um, und a/b ist kein Range). Konservativ: bare „Show.S01E01" ohne Marker bleibt
-abgelehnt (kein Over-Firing). v1.7.180-Fallback nutzt jetzt dieselben Module-Consts (DRY). Greift in
-Auto-Rename UND Collect (beide via decideAutoRenameBaseName). 5 Unit- + 1 Collect-Integrationstest.
-**Methodik-Lektion:** Die naheliegende Hypothese (a/b-Suffix) per Diagnose-Test widerlegt, BEVOR gefixt —
-das Lookahead genau gelesen statt angenommen. Spart einen Fix am falschen Ort.
-
-## 2026-06-05 — Collect zerstoert fertigen S01E01-Namen via Episoden-Titel-Ordner (Miniserie)
-**Symptom (rename-session 2026-06-05):** Miniserie "Steven Spielbergs Taken" landete als
-"...E01.Hinter.dem.Himmel...-GTVG.S01E01.mkv" (Episodentitel + hinten angehaengtes S01E01) statt sauber
-"...S01E01...-GTVG.mkv". User: "keine Staffel, nur Episodentitel".
-**Root Cause (diagnostisch bewiesen):** Auto-Rename benannte korrekt zu "...S01E01...-GTVG.mkv" (kombiniert
-S01 aus dem Paket/Season-Ordner + E01 aus der Quelle). Der COLLECT (deriveCleanCollectFileName ->
-decideAutoRenameBaseName) leitet die Datei NEU ab — Quelle ist nun der schon-saubere Name. Der per-Episode-
-Ordner traegt aber nur einen Episode-only-Token + Titel ("...E01.Hinter.dem.Himmel...-GTVG", KEIN S01).
-buildAutoRenameBaseName nimmt den Ordner (Gruppen-Suffix -GTVG vorhanden). In Guard B `if (!targetEpisodeToken)`
-wird der Quell-Token an den Ordnernamen ANGEHAENGT (applyEpisodeTokenToFolderName) -> "...-GTVG.S01E01"
-(Token HINTER der Gruppe = verkrueppelt). Der Root-Guard greift NICHT, weil der Season-Ordner einen S01-Token
-liefert (anyFolderHasSeasonOrEpisode=true).
-**Fix:** In Guard B, im `!targetEpisodeToken`-Zweig VOR dem Anhaengen: ist die QUELLE ein NICHT
-obfuskierter Scene-Name (`!looksLikeObfuscatedSceneFileName(sourceName)`), dann
-`return {kind:"skip", reason:"source-better"}` -> Collect behaelt den fertigen Namen. In diesem Zweig
-traegt die Quelle den EINZIGEN SxxExx-Token (Ordner hat keinen) -> obfuskiert? -> Ordner gewinnt (Append),
-sauber? -> Quelle gewinnt. Greift NUR im `!targetEpisodeToken`-Zweig (Ordner ohne SxxExx); safari
-(Ordner MIT Token) unberuehrt. 4 Unit- + 1 Collect-Integrationstest. tsc 6 (Baseline), 700/700 gruen, Build gruen.
-**Methodik:** Erst Diagnose (decideAutoRenameBaseName mit Collect-Inputs) -> exakt der mangled Name
-reproduziert. Per User-Wunsch adversarial via Workflow gegengeprueft (ultracode, 3 Lenses + Synthese).
-**Adversarialer Befund (Workflow fing's):** Mein erster Guard hatte einen ZWEITEN Konjunkt
-`hasMeaningfulSeriesPrefix(sourceBaseName)` (>=3 Alpha vor S0x). Der ist sachfremd: KURZE Serien (ER, V,
-24, Yu) fallen durch -> selber verkrueppelter Name. Gestrichen -> nur `!obfuskiert` gaten. Lehre: ein
-zusaetzlicher "klingt-vernuenftig"-Konjunkt (Praefix-Laenge) kann eine ganze reale Klasse (Kurz-Titel)
-stumm ausschliessen; adversariale Verifikation mit konkretem Gegenbeispiel (ER.S01E01) hat's gefunden.

tasks/plan-german-audio-track.md

@@ -1,104 +0,0 @@
-# Plan: „Nur deutsche Tonspur behalten" (.DL.) als Tool-Funktion
-
-Quelle der Idee: User-Script `Remove Non German Audio.py` (ffmpeg `-map 0:v:0 -map 0:a:0
--c copy -map_metadata -1`, + `.DL.`→`.` Rename). Soll als **toggle­barer Post-Extract-Schritt**
-nach jedem Entpacken laufen, nur für **MKV/MP4 mit `.DL.` im Namen** (Dual-Language),
-und nur die **deutsche** Spur behalten. Fundiert per 6-Agent-Analyse + Advisor.
-
-## 1. Verhalten (Soll)
-- Läuft automatisch nach dem Entpacken eines Pakets (wenn Toggle an), bevor MKV-Collect.
-- Pro extrahierter Video-Datei mit `.DL.` im Namen (case-insensitive, nur .mkv/.mp4):
-  1. Audiospuren prüfen → deutsche/erste Spur bestimmen (Modus = User-Entscheidung, s.u.).
-  2. Wenn >1 Audiospur: remux (stream-copy, kein Re-Encode) → behält Video + 1 Audio
-     (+ optional dt. Untertitel) → Temp-Datei → atomar ersetzen.
-  3. `.DL.` aus dem Dateinamen strippen (`.DL.`→`.`, `.DL`→``), Companion-Dateien (Untertitel/.nfo) mitziehen.
-  4. Wenn nur 1 Audiospur: **kein** Remux (spart Neuschreiben großer Dateien), ABER `.DL.`-Strip trotzdem.
-- Status pro Item sichtbar (z.B. „Tonspur wird bereinigt" / „Deutsche Spur behalten").
-
-## 2. Architektur
-- **NEUES Modul `src/main/video-processor.ts`** (spiegelt `extractor.ts`: exportierte async-Funktion
-  + Options-Bag, KEINE DI-Klasse — es gibt keinen Constructor-Seam). Enthält:
-  - ffmpeg/ffprobe-Spawn nach dem `runExtractCommand`-Muster (extractor.ts:1296): `spawn(cmd,args,{windowsHide:true})`,
-    Promise-Wrapper, Timeout-Watchdog → `killProcessTree` (taskkill /T /F), **AbortSignal IN den Child** geben.
-  - **Pure exportierte Helfer** für Unit-Tests: `pickGermanAudioTrack(probeJson, mode)`, `stripDualLangMarker(name)`,
-    `buildFfmpegRemuxArgs(...)`, `computeRemuxTimeoutMs(bytes)`.
-  - ffmpeg-Exit-Codes ≠ 7-Zip (NICHT die „exit 1 = ok"-Logik kopieren — nur das Spawn/Await/Kill-Gerüst).
-  - ffprobe-JSON auf stdout NICHT durch den 48KB-Tail-Cap (`appendLimited`) — stdout separat voll puffern.
-- **ffmpeg-Discovery (Option a, empfohlen):** System-PATH + `RD_FFMPEG_BIN` env + lazy `ffmpeg -version`-Probe
-  gecacht (spiegelt `RD_7Z_BIN`, extractor.ts:1030-1083). **Nicht bündeln** (~80-150MB → triggert den
-  eigenen 150MB-Large-Bundle-Selfcheck debug-setup.ts:22 + GPL-Lizenzpflicht). Wenn ffmpeg fehlt → Schritt
-  überspringen + WARN loggen + (optional) in Health-Check/Errors surfacen. NIE Downloads blockieren.
-- **CPU-Priorität:** `lowerExtractProcessPriority(pid, priority)` + `extractOsPriority` wiederverwenden,
-  Priorität als **expliziten Param** (nicht das Modul-Global `currentExtractCpuPriority` — Cross-Talk-Gefahr).
-  Honoriert `settings.extractCpuPriority`.
-
-## 3. Einhängepunkte (BEIDE Pfade — kritisch!)
-Post-Processing ist **pro Paket**, zwei Pfade; Hybrid-Pakete durchlaufen NIE den Deferred-Pass:
-- **Deferred** (download-manager.ts ~11614): nach `autoRenameExtractedVideoFiles`, VOR archive-cleanup/collect.
-- **Hybrid** (download-manager.ts ~10944): zwischen Rename und Collect im detached Block.
-- Beide: **innerhalb `chainPackageFileOp(pkg.id, ...)`** (serialisiert Datei-Ops pro Paket), nur auf
-  `pkg.extractDir` operieren — NIE im geteilten `mkvLibraryDir` (= der v1.7.107-revertierte Cross-Package-Crash;
-  autoRename bricht bei Overlap ab, 3905-3919).
-- **Gate:** neuen Flag in den Post-Process-Aggregator OR-en (~7078-7084), sonst läuft der Schritt nie
-  standalone. Hängt inhärent an `autoExtract` (braucht entpackte Dateien).
-- Datei-Enumeration: `collectVideoFiles(rootDir)` (rekursiv, SAMPLE_VIDEO_EXTENSIONS, constants.ts:28) — nur
-  .mkv/.mp4 verarbeiten; Sample/Bonus-Dateien per vorhandenem Skip-Prädikat auslassen.
-
-## 4. Der .DL.-Knoten (LÖST den „Feature no-op"-Fehler)
-- Selektion = „Datei hat `.DL.`"; der Schritt strippt `.DL.`. → KEIN früherer Schritt darf den Marker entfernen.
-- **autoRename NICHT ändern** (behält `.DL.` verbatim) → Marker überlebt bis zum Video-Schritt.
-- Video-Schritt läuft **nach** autoRename → sieht `.DL.` → remuxt + strippt `.DL.` atomar pro Datei.
-- **NUR `collectMkvFilesToLibrary.deriveCleanCollectFileName`** bekommt den `.DL.`-Strip als Post-Transform
-  (läuft NACH dem Video-Schritt → kann den Selektor nicht brechen, verhindert nur Re-Einführung aus dem
-  Ordner-Token). Companion-Files via `renameCompanionFiles`/`moveCompanionFiles` mitziehen.
-
-## 5. Sicherheitsmodell (Original NIE verlieren)
-- Remux → Temp-Datei → Größe > 0 (idealerweise ~plausibel) prüfen → erst dann atomar ersetzen/umbenennen
-  (`renamePathWithExdevFallback` + `verifyRenameAsync`). ffmpeg-Fehler/Abbruch → Temp löschen, Original bleibt.
-- **Disk-Space-Pre-Check**: vor Remux freien Platz ≥ Dateigröße (+Marge) prüfen, sonst skip+log
-  (Temp verdoppelt transient den Platz auf einer Platte, die grad entpackt hat / parallel lädt).
-- **AbortSignal in den ffmpeg-Child** (Deferred-/Hybrid-Controller) → Stop/Cancel/Reset killt laufenden Remux.
-- **mtime erhalten** (`fs.utimes` nach Remux) → sonst überspringt Hybrid-Collect (deferFreshFiles=true) die
-  frisch angefasste Datei.
-- **Sicherheits-Invariante (BEIDE Modi):** Original nur ersetzen, wenn die behaltene Spur sicher die richtige
-  ist. Bei Unsicherheit (keine Tags / kein Deutsch gefunden) → Datei UNANGETASTET lassen + loggen, statt
-  versehentlich die einzige brauchbare Spur zu löschen.
-- Dispositions-Flag der behaltenen Spur auf „default" setzen.
-- Best-effort pro Datei: ein Fehler markiert NICHT das Paket als failed und blockiert nicht den Collect anderer Dateien.
-
-## 6. ffmpeg/ffprobe-Aufrufe (Stream-Copy, schnell)
-- Probe (nur im Tag-Modus): `ffprobe -v error -select_streams a -show_entries stream=index:stream_tags=language,title -of json INPUT`
-- Remux erste Spur (Script-Parität): `ffmpeg -i INPUT -map 0:v:0 -map 0:a:0 [-map 0:s? je nach Untertitel-Option] -c copy -map_metadata -1 -disposition:a:0 default -y TEMP`
-- Remux deutsche Spur (Tag-Modus): `-map 0:v:0 -map 0:a:<dt-Index> ...` (Index aus ffprobe).
-
-## 7. Settings/UI-Wiring (5 Pflicht-Stellen, +1 optional)
-1. `src/shared/types.ts` AppSettings: `keepGermanAudioOnly: boolean` (+ ggf. `germanAudioMode`, `keepGermanSubs`, `ffmpegPath`).
-2. `src/main/constants.ts` defaultSettings: `keepGermanAudioOnly: false` etc.
-3. `src/main/storage.ts` normalizeSettings: `Boolean(...)` (Pfad: `asText`, NICHT normalizeAbsoluteDir → leer = System-ffmpeg).
-4. `src/renderer/App.tsx` Settings-Tab „entpacken" neben collectMkvToLibrary: Toggle + eingerückte Sub-Optionen (disabled wenn aus).
-5. `src/renderer/App.tsx` **emptySnapshot()-Literal** (~840-859) — sonst tsc-Fehler (Feld non-optional).
-6. (optional) `src/main/support-data.ts` ~95: Flag in Diagnose-Export spiegeln.
-
-## 8. Tests + Verifikations-Gate
-- ffmpeg in Tests **gemockt** (kein echter ffmpeg-Lauf): neues Modul via `vi.mock` in download-manager.test.ts
-  (assert: korrekt aufgerufen + Sequenz nach autoRename / vor collect, Deferred + Hybrid). KEIN blankes
-  `vi.mock("node:child_process")` in download-manager.test.ts (bricht echte Extractor-ZIP-Tests).
-- Separate `video-processor.test.ts`: `node:child_process` mocken → ffmpeg/ffprobe-ARGS asserten (Track-Wahl, Untertitel-Option).
-- Pure Helfer fs-frei testen (wie tests/auto-rename.test.ts): `pickGermanAudioTrack`, `stripDualLangMarker`.
-- Negativ-Test: Toggle aus → keine Verarbeitung. Edge: 1-Audio-`.DL.` → nur Rename, kein Remux. Kein-Deutsch → unangetastet.
-- **Gate:** tsc-Baseline = 6 vorbestehende Fehler (NICHT clean) → „keine NEUEN tsc-Fehler" + vitest 728→728+N grün + `npm run self-check` grün.
-
-## 9. OFFENE ENTSCHEIDUNGEN (vor Bau — per AskUserQuestion)
-- **A. Spurauswahl:** Script-Parität (immer erste Audiospur, kein ffprobe, validiertes Verhalten) vs.
-  Smart (deutsche Spur per Sprach-Tag, Fallback erste Spur, skip wenn kein Deutsch).
-- **B. Untertitel:** weglassen (wie Script) vs. deutsche Untertitel behalten.
-- **C. ffmpeg-Quelle:** nur System-PATH + `RD_FFMPEG_BIN` env vs. zusätzlich Settings-Pfad-Feld im UI.
-
-## 10. Umsetzungsreihenfolge (nach Entscheidungen)
-1. `video-processor.ts` + pure Helfer + deren Unit-Tests (TDD).
-2. ffmpeg/ffprobe-Discovery (probe+cache).
-3. Settings-Wiring (5 Stellen) + UI-Toggle.
-4. Einhängen in Deferred + Hybrid (in chainPackageFileOp), Gate OR-en.
-5. collect deriveCleanCollectFileName: `.DL.`-Strip-Safety-Net.
-6. Logging (logRenameProcess, neuer Stage 'audio-strip').
-7. Tests (download-manager mock + video-processor args + negativ/edge). Gate prüfen.

tasks/todo.md

@@ -1,164 +0,0 @@
-# Real-Debrid-Downloader — Tasks (Stand 2026-06-08)
-
-**Status:** Alle zugesagten Features erledigt+released (Archiv unten). Aktuell läuft ein
-**intensiver Bug-Audit** (User-Goal 2026-06-08, "schaue intensiv nach weiteren Bugs") —
-Fortschritt direkt unten.
-
----
-
-## 🔴 LAUFEND — Bug-Audit 2026-06-08 (Multi-Agent find→verify, 18 bestätigt)
-
-Advisor-Triage: **A = einzige echte Daten-Verlust-Notlage** (zerstört echte Datei auf Platte)
-→ zuerst, ALLEINE Release. **B verifiziert demoted:** applyRetroactiveCleanupPolicy/
-removePackageFromSession löschen KEINE Platten-Dateien (nur Session/Queue-Einträge + ggf.
-History-Eintrag) → Queue-Integrität, nicht Daten-Verlust → in v1.7.190-Batch.
-Sequenz: Release 1 (v1.7.189) = **A allein**; Release 2 (v1.7.190) = B/I,C,D/E,F,G,H,J,L,M,N,O,P,Q.
-Ein Commit pro Fix, jeder einzeln verifiziert. **K übersprungen** (auto-rename-Reorder,
-schlechtestes Risiko/Nutzen, kann für diesen User gar nicht feuern).
-
-### Release 1 — Daten-Verlust-Stopper (v1.7.189, A ALLEIN)
-- [x] **A** `video-processor.ts` atomic-replace zerstörte bei Windows-Lock BEIDE Kopien
-  (rm(original) VOR bestätigtem Replace + outer-catch rm(temp) → 0 Kopien). **GEFIXT:**
-  atomic replace-over + `renameWithRetry` (EBUSY/EACCES/EPERM/EEXIST, Backoff 200/500/1000ms),
-  rm-first-Fallback entfernt, **unique** Temp-Name (`~rd<pid><rand>`, löst auch C-Kollision).
-  Advisor bestätigt Ansatz besser als bak-dance (kein Missing-File-Window). 3 neue Tests
-  (Recovery + Retry-Pfad), 41 video-processor-Tests grün, tsc=6 (Baseline). Commit 189af22.
-
-### Release 2 — v1.7.190 (GEFIXT + verifiziert, ein Commit pro Fix)
-- [x] **L+M** video-processor.ts zu weite Deutsch-Erkennung. isGermanStream Titel-Fallback nur
-  ganze Wörter (ger/deu raus → konnten falsche Spur picken + echte dt. löschen); looksLikeGerman
-  Release 'dubbed' raus (ital./franz. Dub triggerte German-first). 2 Negativtests. Commit 272a41a.
-- [x] **H** logger.ts flushAsync slice-snapshot korrumpiert bei 1MB-Cap-Trim während await →
-  ungeschriebene Zeilen verloren. Move-snapshot (Buffer auf [] übernehmen) + Requeue bei
-  Schreibfehler. Commit 4432fa2.
-- [x] **J+Q** download-manager. J: runPackagePostProcessing finally löschte Map-Eintrag ohne
-  Identity-Guard → Abort+Neustart-Race riss neuen Task raus (Waise + Doppel-Lauf); jetzt nur
-  löschen wenn Map noch auf DIESEN Task/Controller zeigt (handle-Objekt wegen TS2454). Q:
-  collectFilesByExtensions filtert `~rd`-Temp-Präfix (crash-verwaiste Teil-Remuxe nie ins
-  Library). Commit 3c33b98.
-- [x] **P** extractor.ts nested-Resume-Keys (`nested:<name>`) bei jedem extractPackageArchives
-  gepurged → verschachtelte Archive beim Resume neu entpackt; `startsWith("nested:")` im Prune
-  übersprungen. Commit 61a8304.
-- [x] **B/I** app-controller.ts importBackup settings-only purgte LIVE-Queue (Dateien blieben auf
-  Platte) + rollte Usage-Zähler zurück. Fix: setSettings({suppressRetroactiveCleanup}) +
-  overlayLiveUsageCounters (extrahiert+wiederverwendet, inkl. Key-Filter). Commit dc05b51.
-
-### Verifiziert KEINE Bugs / bewusst NICHT angefasst (Advisor-Disziplin: erst belegen, dann ändern)
-- **G** dropItemContribution "subtrahiert Session-Totals nicht" → **KEIN Bug**: Test "keeps
-  cumulative session totals when completed items are removed" kodifiziert die Absicht (Session-
-  Zähler kumulativ, divergieren bewusst von der Item-Map; Retry-Pfad zieht ab, weil neu geladen
-  wird). Fix-Versuch ließ den Test failen → revertiert, Klarstellungs-Kommentar gesetzt.
-- **N** stripDualLangFromFileName "Kollision" → **bereits geguarded**: existsAsync-Skip verhindert
-  Überschreiben; Remux machte Inhalt eh deutsch-only; collect strippt `.DL.` downstream. Residual
-  = generischer Rename-TOCTOU (in JEDEM Rename-Pfad), kein spezifischer Bug hier.
-- **D/E** abort-Klassifizierung über signal.reason statt Text → **deferred (Robustheit, kein
-  Live-Bug auf User-Pfad)**. BELEGT: mega-web-fallback normalisiert JEDEN Abort (Timeout UND
-  Cancel) zu `new Error("aborted:mega-web")` → aktueller Guard `/aborted/i && !/timeout/i` FEUERT
-  → v1.7.187-Cooldown LÄUFT auf dem Web-Pfad (User-Pfad). Einzige Imperfektion: Cancel >8s wird
-  fälschlich gecooled (minor). Empirisch bestätigt: `AbortSignal.any([ac,timeout]).reason?.name===
-  'TimeoutError'` (timeout) vs string/AbortError (cancel) — falls je gebaut: signal.aborted-gaten,
-  reason.name nutzen, Text-Fallback behalten, reason-Test. Hoch-Risiko (kritischer Unrestrict-Pfad
-  JEDES Downloads) → nicht für Robustheit anfassen. API-Pfad-Abort-Text nicht erschöpfend geprüft.
-- **E** "API 'cancel'-Pfad umgeht" → **nicht real**: kein `'cancel'`-throw im Code gefunden.
-- **O** classifyAccountFailure abort-Branch tot → **stehen lassen**: tot NUR wegen aktueller
-  Text-Interception; ein signal.aborted-gated D/E würde ihn wiederbeleben. Kein Kosmetik-Churn.
-- **F** Mega-Web empty-streak Concurrency → **N-shaped, deferred**: Streak wird bei Erfolg (1956)
-  + Nicht-Limit-Fehler (2005) gecleart; "bis Neustart gesperrt" ist bewusste Tageslimit-Logik,
-  Restart-cleared; Mega-Web single-flight → Concurrency greift nicht. Keine fühlbare Schädigung
-  konstruierbar → keine Park-State-Maschinerie.
-- **C** → in A subsumiert (unique Temp-Name). **K** übersprungen (auto-rename-Reorder, Risiko≫Nutzen).
-
----
-
-## 🟢 OFFEN — Backlog (optional, nie begonnen)
-
-### ✅ Mega-Web Account-Rotation überspringt Account 3 — GEFIXT 2026-06-08 (v1.7.187)
-**Fix:** Ein Mega-Web-Account-Abbruch (geteiltes Timeout feuert während der Account lief)
-setzt jetzt einen 2-min-Cooldown auf den Account (nur wenn er ≥8s lief, sonst = User-Cancel,
-RD_MEGA_ABORT_MIN_RUN_MS env). Dadurch überspringt der download-manager-Retry diesen Account
-und rotiert zum nächsten (debrid.ts, abort-Handling im Rotations-catch, vor classifyAccountFailure).
-Log-Event `TIMEOUT_COOLDOWN` (gelb, "Timeout/Abbruch → nächster Account beim Retry") statt
-rotem "fataler Fehler" (App.tsx:1141 Label). 2 Regressionstests (Cooldown gesetzt → Call 2
-rotiert; Quick-Abbruch → kein Cooldown). EHRLICH: fixt Korrektheit, NICHT Latenz — Account 1
-brennt weiter ~60s ins Timeout bevor der Retry auf Account 2 wechselt (instant-Failover bräuchte
-per-Account-Timeout = größerer Eingriff, bewusst verschoben). Advisor-gegengeprüft.
-
-**(Ursprüngliche Analyse — Symptom & Mechanismus, zur Doku belassen)**
-**Symptom (User):** 3 Mega-Debrid-Web-Accounts aktiv, Rotation pendelt aber nur zwischen
-Account 1 ↔ 2 (bzw. nur Account 1), Account 3 (Su****xe) wird NIE probiert.
-
-**Verifizierter Mechanismus (Code):**
-- Rotationsschleife `debrid.ts:1898`. Account 1 → "Mega-Web Antwort leer" → Cooldown 20s →
-  weiter zu Account 2. Account 2 → `aborted:debrid`.
-- `classifyAccountFailure` (`debrid.ts:2036`) stuft JEDEN Abbruch als **fatal** ein →
-  `throw` (`debrid.ts:1991`) → Schleife bricht ab → **Account 3 nie erreicht.**
-- Account 2 bekommt beim Fatal-Abbruch **keinen Cooldown** (cooldownMs:0). Beim
-  download-manager-Retry wird Account 1 (Cooldown) übersprungen, aber Account 2 (kein
-  Cooldown) ERNEUT vor Account 3 probiert → bricht wieder ab → ewiges 1↔2.
-- Geteiltes 60s-Unrestrict-Timeout `download-manager.ts:8590` (`AbortSignal.any([taskAbort,
-  timeout(60s)])`) gilt für die GANZE Rotation, nicht pro Account. Mega-Web pollt intern bis
-  180s (`mega-web-fallback.ts:235` + Poll-Loop `:371`). Sobald das geteilte 60s feuert, bleibt
-  das kombinierte Signal aborted → KEIN späterer Account kriegt im selben Pass eine echte Chance.
-
-**BESTÄTIGT 2026-06-08 (zweite Screenshots):** Account 1 läuft 10x rasch "erfolgreich"
-(11:51:45–11:52:26), dann zwei "abgebrochen (aborted:debrid)" um 11:53:30 UND 11:54:30 —
-**exakt 60s auseinander** = das geteilte 60s-Unrestrict-Timeout feuert (kein User-Stop, der
-wiederholt sich nicht periodisch). Hier rotiert GAR NICHTS: Account 1 bricht ab → fatal →
-Rotation stoppt sofort bei idx=0 → Account 2 und 3 werden NIE probiert. Bug eindeutig
-bestätigt, elapsedMs nicht mehr nötig. Account 1 selbst ist gesund (10x ok) — Mega-Web hängt
-nur sporadisch (no-server-Poll) bis ins 60s-Timeout.
-
-**Fix-Design (wenn bestätigt):** Pro-Account-Timeout-Budget, abgekoppelt vom geteilten Cap.
-debrid.ts braucht das **cancel-only** Signal getrennt vom Timeout (kombiniertes Signal kann
-beides nicht unterscheiden). Minimal-invasiv: optionaler `opts`-Param an `unrestrictLink`
-({cancelSignal, perAttemptTimeoutMs}) — nur die Mega-Rotation liest ihn, andere Provider
-unberührt (kombiniertes Signal bleibt). Pro Account: `AbortSignal.any([cancelSignal,
-AbortSignal.timeout(perAttemptMs)])`. Abbruch-Logik: cancelSignal aborted → echter Stop;
-eigenes Account-Timer gefeuert → non-fatal, Cooldown, weiter zum nächsten Account (inkl. 3).
-**Regressionstest ZUERST** (3 Accounts, 1+2 failen/aborten → assert Account 3 kriegt TEST).
-**Advisor-Gate** vor Eingriff (kritischer Unrestrict-Pfad, betrifft jeden Download).
-Hinweis: Grundursache der leeren Antworten = Mega-Debrid Server/IP-Thema — Fix macht Rotation
-nur FAIRER (alle Accounts drankommen), bringt aber keinen busy Server zum Antworten.
-
-### Features / UX (nach ROI)
-App läuft headless auf Windows-Server → Nutzer sitzt nicht davor.
-
-1. [ ] **Push-Benachrichtigungen** (Discord/Telegram/ntfy) — S–M. Paket fertig/Fehler/Quota/Provider-down aufs Handy. Neuer `notifier.ts`, Hooks an Completion-Punkten. **Höchster ROI.**
-2. [ ] **Fernsteuerung über Debug-Server** (POST-Endpunkte) — S–M. Server hat HTTP + Token-Auth, aber nur GET. POST `/control/add-links`, `/start`, `/stop`.
-3. [ ] **URL-Duplikat-Erkennung beim Hinzufügen** — S. History-`urls` existiert, wird nie geprüft → versehentliche Re-Downloads. Warnen: "3 Links bereits geladen".
-4. [ ] **Pre-Flight-Check + Bulk-Skip toter Links** — M. Vor Start Größe/Name/Online für ganze Queue, "alle offline überspringen".
-5. [ ] **Speicherplatz-Vorabprüfung vor Start** — S. Aktuell keine Free-Space-Prüfung für Downloads → Abbruch mitten drin bei voller Platte.
-6. [ ] **Konsolidierte Fehler-Ansicht** — M. Alle fehlgeschlagenen Items flach + Fehlertext + "alle erneut versuchen". (Daten dafür liegen jetzt teils in der Error-Ring aus v1.7.185.)
-7. [ ] **Per-Provider-Statistik** — M. Rohdaten (`providerTotalUsageBytes`) existieren, werden nicht dargestellt. Welches Abo lohnt sich?
-8. [ ] **Auto-Retry fehlgeschlagener Pakete nach Wartezeit** — S–M. Quota/Cooldown-Fails am nächsten Tag automatisch neu.
-9. [ ] **Plex/Jellyfin Library-Refresh nach MKV-Move** — S. Gleicher Hook wie #1.
-10. [ ] **Watch-Folder für DLC/Link-Auto-Import** — M.
-
-### Design-Richtung (Entscheidung steht aus)
-4 Mockups in `design-mockups/` (index.html = Vergleich): **Aurora** (verfeinert dark, geringstes Risiko) · **Command** (Terminal/Ops, dicht) · **Vellum** (light editorial) · **Nebula** (neon).
-→ Richtung wählen. Siehe Memory: design-taste (Anti-KI-Look) + design-direction (Ember-Wärme, flach/ehrlich).
-
-### Alte Audit-Items (2026-04-04, Status ggf. veraltet — VOR Fix gegen aktuellen Code verifizieren)
-- [ ] Debrid-Link `maxDataHost` kühlt ganzen Key ab statt nur den Host
-- [ ] Debrid-Link `fileNotAvailable` setzt Key auf "error" statt temporär
-- [ ] AllDebrid: kein per-host-Cooldown für erschöpfte Quotas
-- [ ] LinkSnappy: keine Auth-Dedup (parallele Requests rufen beide authenticate())
-- [ ] Extractor password-cache race (parallele Worker mutieren `packageLearnedPasswords`)
-- [ ] Hybrid race: 1 Datei/Staffel evtl. beim MKV-Move nicht umbenannt (NUR per-package fixen — Post-MKV-Move-Scan ist tabu, v1.7.107 revertiert)
-
----
-
-## ✅ ERLEDIGT — Archiv (Details in git-History + Memory)
-
-- **Erweitertes Logging** → released **v1.7.185** (Crash-Handler, Renderer-Fehler-IPC, RD_DEBUG-Level, Error-Ring + `/errors`, ENOSPC-Klassifizierung, Memory-Heartbeat). → Memory: extended-logging
-- **Link-Prefetch** → untersucht (6-Agent) + **bewusst verworfen** (marginal bei maxParallel 8, Mega-Web single-flight). → Memory: link-prefetch-declined
-- **Backup nur Settings** → v1.7.184 (`backupIncludeDownloads`-Toggle + 4 Selektions/Flicker-Fixes). → Memory: backup-settings-only
-- **Account-Rotation-Overhaul** → v1.7.164–168 (Validity/Premium-Badges, Live-Panel, "Alle prüfen"). → Memory: account-rotation
-- **Mega-Debrid-Account deaktivieren (UI)** → erledigt (Toggle im Edit-Dialog, im Code verifiziert 2026-06-07)
-- **Bugs/Robustheit (Deferred-Pipeline H1/H2/H3/M1/M2/N1)** → v1.7.158/159; M3 bewusst übersprungen (Generation-Guard schützt Integrität bereits)
-- **Deferred-Pfad Rename-Gap** → gefixt v1.7.162+ (finaler Deferred-Pass benennt frische Dateien vor Collect um; Repro-Test grün)
-- **Repo-Privacy-Audit** → GitHub gelöscht+neu (saubere History), Gitea unberührt. → Memory: repo-privacy-audit
-
-### Bewusst NICHT angefasst (Crash-Debris / alte Experimente)
-- Gestashtes Crash-Debris `stash@{0}` (Revert von 08372f9/18eada9/98dc366 + log.old) — bei Bedarf recoverbar, sonst verwerfbar
-- Untracked `*-postprocess/` + `fix-library-renames.mjs` — alte Experimente (Apr/Mai)

tests/account-check.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { checkMegaDebridAccount, checkDebridLinkKey, checkAllDebridAccounts } from "../src/main/account-check";
-import type { MegaDebridAccountEntry } from "../src/shared/mega-debrid-accounts";
-import type { DebridLinkApiKeyEntry } from "../src/shared/debrid-link-keys";
-import type { AppSettings } from "../src/shared/types";
-
-function megaAccount(login = "user@example.com"): MegaDebridAccountEntry {
-  return { id: "mda_test", login, password: "pw", index: 0, label: "Account 1", maskedLogin: "us**le" };
-}
-
-function debridLinkKey(token = "tok_abcdef"): DebridLinkApiKeyEntry {
-  return { id: "dlk_test", token, index: 0, label: "Key 1", masked: "tok***def" };
-}
-
-function mockFetchOnce(status: number, body: unknown): void {
-  const text = typeof body === "string" ? body : JSON.stringify(body);
-  vi.stubGlobal("fetch", vi.fn(async () => ({
-    ok: status >= 200 && status < 300,
-    status,
-    text: async () => text
-  })) as unknown as typeof fetch);
-}
-
-const NOW = 1_700_000_000_000;
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("checkMegaDebridAccount", () => {
-  it("reports valid + premium from vip_end (future Unix ts)", async () => {
-    const futureSec = Math.floor(NOW / 1000) + 30 * 24 * 60 * 60;
-    mockFetchOnce(200, { response_code: "ok", response_text: "User logged", token: "t", vip_end: String(futureSec), email: "a@b.de" });
-    const st = await checkMegaDebridAccount(megaAccount(), undefined, NOW);
-    expect(st.valid).toBe(true);
-    expect(st.isPremium).toBe(true);
-    expect(st.premiumUntilMs).toBe(futureSec * 1000);
-    expect(st.email).toBe("a@b.de");
-    expect(st.message).toMatch(/Premium noch/);
-  });
-
-  it("reports valid but NOT premium when vip_end is in the past", async () => {
-    const pastSec = Math.floor(NOW / 1000) - 1000;
-    mockFetchOnce(200, { response_code: "ok", token: "t", vip_end: String(pastSec) });
-    const st = await checkMegaDebridAccount(megaAccount(), undefined, NOW);
-    expect(st.valid).toBe(true);
-    expect(st.isPremium).toBe(false);
-  });
-
-  it("reports valid but no premium when vip_end is 0/missing", async () => {
-    mockFetchOnce(200, { response_code: "ok", token: "t", vip_end: "0" });
-    const st = await checkMegaDebridAccount(megaAccount(), undefined, NOW);
-    expect(st.valid).toBe(true);
-    expect(st.isPremium).toBe(false);
-    expect(st.premiumUntilMs).toBe(0);
-    expect(st.message).toMatch(/Kein Premium/);
-  });
-
-  it("reports invalid login when response_code != ok", async () => {
-    mockFetchOnce(200, { response_code: "error", response_text: "bad login" });
-    const st = await checkMegaDebridAccount(megaAccount(), undefined, NOW);
-    expect(st.valid).toBe(false);
-    expect(st.isPremium).toBe(false);
-    expect(st.message).toMatch(/Ungueltiger Login/);
-  });
-
-  it("reports invalid on HTTP error", async () => {
-    mockFetchOnce(500, "server error");
-    const st = await checkMegaDebridAccount(megaAccount(), undefined, NOW);
-    expect(st.valid).toBe(false);
-  });
-
-  it("never throws on network error — returns a failed status", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("ECONNRESET"); }) as unknown as typeof fetch);
-    const st = await checkMegaDebridAccount(megaAccount(), undefined, NOW);
-    expect(st.valid).toBe(false);
-    expect(st.message).toMatch(/Pruefung fehlgeschlagen/);
-  });
-});
-
-describe("checkDebridLinkKey", () => {
-  it("reports valid + premium from premiumLeft seconds", async () => {
-    const premiumLeft = 60 * 24 * 60 * 60;
-    mockFetchOnce(200, { success: true, value: { username: "u", accountType: 1, premiumLeft } });
-    const st = await checkDebridLinkKey(debridLinkKey(), undefined, NOW);
-    expect(st.valid).toBe(true);
-    expect(st.isPremium).toBe(true);
-    expect(st.premiumUntilMs).toBe(NOW + premiumLeft * 1000);
-  });
-
-  it("reports valid but free (premiumLeft 0, accountType 0)", async () => {
-    mockFetchOnce(200, { success: true, value: { username: "u", accountType: 0, premiumLeft: 0 } });
-    const st = await checkDebridLinkKey(debridLinkKey(), undefined, NOW);
-    expect(st.valid).toBe(true);
-    expect(st.isPremium).toBe(false);
-    expect(st.message).toMatch(/Free/);
-  });
-
-  it("reports invalid key on HTTP 401", async () => {
-    mockFetchOnce(401, { success: false, error: "badToken" });
-    const st = await checkDebridLinkKey(debridLinkKey(), undefined, NOW);
-    expect(st.valid).toBe(false);
-    expect(st.message).toMatch(/Ungueltiger API-Key/);
-  });
-
-  it("reports invalid key when success=false", async () => {
-    mockFetchOnce(200, { success: false, error: "badToken" });
-    const st = await checkDebridLinkKey(debridLinkKey(), undefined, NOW);
-    expect(st.valid).toBe(false);
-  });
-});
-
-describe("checkAllDebridAccounts", () => {
-  it("returns empty array when nothing configured", async () => {
-    const settings = { megaCredentials: "", megaPassword: "", debridLinkApiKeys: "" } as unknown as AppSettings;
-    const result = await checkAllDebridAccounts(settings);
-    expect(result).toEqual([]);
-  });
-
-  it("checks every configured mega account + debrid-link key", async () => {
-    const futureSec = Math.floor(Date.now() / 1000) + 1000;
-    vi.stubGlobal("fetch", vi.fn(async (url: string) => {
-      if (String(url).includes("mega-debrid")) {
-        return { ok: true, status: 200, text: async () => JSON.stringify({ response_code: "ok", token: "t", vip_end: String(futureSec) }) };
-      }
-      return { ok: true, status: 200, text: async () => JSON.stringify({ success: true, value: { accountType: 1, premiumLeft: 1000 } }) };
-    }) as unknown as typeof fetch);
-
-    const settings = {
-      megaCredentials: "a@b.de:pw1\nc@d.de:pw2",
-      megaPassword: "",
-      debridLinkApiKeys: "key1\nkey2\nkey3"
-    } as unknown as AppSettings;
-
-    const result = await checkAllDebridAccounts(settings);
-    expect(result).toHaveLength(5);
-    expect(result.filter((r) => r.provider === "megadebrid")).toHaveLength(2);
-    expect(result.filter((r) => r.provider === "debridlink")).toHaveLength(3);
-    expect(result.every((r) => r.valid)).toBe(true);
-  });
-
-  it("caps concurrency (never more than 4 in flight) and preserves result order", async () => {
-    let inFlight = 0;
-    let maxInFlight = 0;
-    vi.stubGlobal("fetch", vi.fn(async () => {
-      inFlight += 1;
-      maxInFlight = Math.max(maxInFlight, inFlight);
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      inFlight -= 1;
-      return { ok: true, status: 200, text: async () => JSON.stringify({ success: true, value: { accountType: 1, premiumLeft: 1000 } }) };
-    }) as unknown as typeof fetch);
-
-    const keys = Array.from({ length: 9 }, (_, i) => `key_${i}`).join("\n");
-    const settings = { megaCredentials: "", megaPassword: "", debridLinkApiKeys: keys } as unknown as AppSettings;
-
-    const result = await checkAllDebridAccounts(settings);
-    expect(result).toHaveLength(9);
-    expect(maxInFlight).toBeLessThanOrEqual(4);
-    result.forEach((r, i) => expect(r.label).toBe(`Key ${i + 1}`));
-  });
-});

tests/account-rotation-log.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { logAccountRotation, runWithRotationItemSink, getRecentRotationEvents } from "../src/main/account-rotation-log";
-import type { RotationEvent } from "../src/shared/types";
-
-describe("rotation item-sink (AsyncLocalStorage)", () => {
-  it("routes the FULL rotation trail (incl. TEST) to the active item sink", async () => {
-    const captured: RotationEvent[] = [];
-    await runWithRotationItemSink((ev) => captured.push(ev), async () => {
-      logAccountRotation("INFO", "Mega-Debrid Web", "Account 1/3 (ab**xy)", "TEST", { link: "x" });
-      logAccountRotation("WARN", "Mega-Debrid Web", "Account 1/3 (ab**xy)", "FAILED", { reason: "Timeout", cooldownSec: 30, next: "Account 2/3 (cd**zw)" });
-      logAccountRotation("INFO", "Mega-Debrid Web", "Account 2/3 (cd**zw)", "TEST", { link: "x" });
-      logAccountRotation("INFO", "Mega-Debrid Web", "Account 2/3 (cd**zw)", "OK", { fileName: "f.mkv" });
-      await Promise.resolve();
-    });
-
-    const events = captured.map((e) => e.event);
-    expect(events).toEqual(["TEST", "FAILED", "TEST", "OK"]);
-    const failed = captured.find((e) => e.event === "FAILED");
-    expect(failed?.reason).toBe("Timeout");
-    expect(failed?.next).toBe("Account 2/3 (cd**zw)");
-  });
-
-  it("does not leak events to the sink outside the run() scope", () => {
-    const captured: RotationEvent[] = [];
-    logAccountRotation("INFO", "Debrid-Link", "Key 1/2 (k1)", "OK");
-    expect(captured).toHaveLength(0);
-  });
-
-  it("isolates two parallel item sinks (no cross-attribution)", async () => {
-    const a: RotationEvent[] = [];
-    const b: RotationEvent[] = [];
-    await Promise.all([
-      runWithRotationItemSink((ev) => a.push(ev), async () => {
-        logAccountRotation("INFO", "Mega-Debrid Web", "Account 1 (a)", "TEST");
-        await new Promise((r) => setTimeout(r, 10));
-        logAccountRotation("INFO", "Mega-Debrid Web", "Account 1 (a)", "OK");
-      }),
-      runWithRotationItemSink((ev) => b.push(ev), async () => {
-        logAccountRotation("INFO", "Debrid-Link", "Key 1 (b)", "TEST");
-        await new Promise((r) => setTimeout(r, 5));
-        logAccountRotation("WARN", "Debrid-Link", "Key 1 (b)", "FAILED", { reason: "badToken" });
-      })
-    ]);
-    expect(a.every((e) => e.provider === "Mega-Debrid Web")).toBe(true);
-    expect(b.every((e) => e.provider === "Debrid-Link")).toBe(true);
-    expect(a.map((e) => e.event)).toEqual(["TEST", "OK"]);
-    expect(b.map((e) => e.event)).toEqual(["TEST", "FAILED"]);
-  });
-
-  it("still feeds the global UI ring (outcomes only, TEST filtered)", () => {
-    logAccountRotation("INFO", "Mega-Debrid API", "Account 9 (zz)", "TEST");
-    logAccountRotation("INFO", "Mega-Debrid API", "Account 9 (zz)", "OK", { fileName: "ring.mkv" });
-    const ring = getRecentRotationEvents(10);
-    expect(ring.some((e) => e.event === "OK" && e.accountLabel === "Account 9 (zz)")).toBe(true);
-    expect(ring.some((e) => e.event === "TEST" && e.accountLabel === "Account 9 (zz)")).toBe(false);
-  });
-});

tests/audit-log.test.ts

@@ -1,48 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { getAuditLogPath, initAuditLog, logAuditEvent, shutdownAuditLog } from "../src/main/audit-log";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  shutdownAuditLog();
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("audit-log", () => {
-  it("writes audit events to the audit log", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-alog-"));
-    tempDirs.push(baseDir);
-
-    initAuditLog(baseDir);
-    logAuditEvent("INFO", "Settings changed", { changedKeys: ["token", "autoExtract"] });
-
-    const logPath = getAuditLogPath();
-    expect(logPath).not.toBeNull();
-    expect(fs.existsSync(logPath!)).toBe(true);
-    const content = fs.readFileSync(logPath!, "utf8");
-    expect(content).toContain("Audit-Log Start");
-    expect(content).toContain("Settings changed");
-    expect(content).toContain("changedKeys");
-  });
-
-  it("rotates oversized audit logs on startup", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-alog-rotate-"));
-    tempDirs.push(baseDir);
-
-    const oversizedPath = path.join(baseDir, "audit.log");
-    fs.mkdirSync(baseDir, { recursive: true });
-    fs.writeFileSync(oversizedPath, "x".repeat(10 * 1024 * 1024 + 256), "utf8");
-
-    initAuditLog(baseDir);
-
-    expect(fs.existsSync(oversizedPath)).toBe(true);
-    expect(fs.existsSync(`${oversizedPath}.old`)).toBe(true);
-    const content = fs.readFileSync(oversizedPath, "utf8");
-    expect(content).toContain("Audit-Log Start");
-  });
-});

tests/auto-rename.test.ts

@@ -6,223 +6,9 @@ import {
   ensureRepackToken,
   buildAutoRenameBaseName,
   buildAutoRenameBaseNameFromFolders,
-  buildAutoRenameBaseNameFromFoldersWithOptions,
+  buildAutoRenameBaseNameFromFoldersWithOptions
-  hasMeaningfulSeriesPrefix,
-  looksLikeObfuscatedSceneFileName,
-  decideAutoRenameBaseName,
-  isBonusContent
 } from "../src/main/download-manager";
 
-describe("decideAutoRenameBaseName (shared naming decision — used by auto-rename AND mkv-collect)", () => {
-
-  it("derives the clean name for a Herzflimmern episode from the per-episode folder (S07E12 — the reported failure)", () => {
-    const source = "tvarchiv.herzflimmern.die.klinik.am.see.s07e12-720.mkv";
-    const folders = [
-      "Herzflimmern.Die.Klinik.am.See.S07E12.German.720p.Webrip.x264-TVARCHiV",
-      "Herzflimmern.Die.Klinik.am.See.S07.German.720p.Webrip.x264-TVARCHiV"
-    ];
-    const decision = decideAutoRenameBaseName(
-      folders,
-      source,
-      "tvarchiv.herzflimmern.die.klinik.am.see.s07e12-720",
-      folders[0],
-      folders[1]
-    );
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe("Herzflimmern.Die.Klinik.am.See.S07E12.German.720p.Webrip.x264-TVARCHiV");
-  });
-
-  it("derives the clean name from a SEASON-only folder by injecting the source episode token (Herzflimmern S03E14)", () => {
-    const source = "tvarchiv.herzflimmern.die.klinik.am.see.s03e14-720.mkv";
-    const seasonFolder = "Herzflimmern.die.Klinik.am.See.S03.German.720p.Webrip.x264-TVARCHiV";
-    const decision = decideAutoRenameBaseName(
-      [seasonFolder],
-      source,
-      "tvarchiv.herzflimmern.die.klinik.am.see.s03e14-720",
-      seasonFolder,
-      seasonFolder
-    );
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe("Herzflimmern.die.Klinik.am.See.S03E14.German.720p.Webrip.x264-TVARCHiV");
-  });
-
-  it("derives the clean name for the Fritzie S04 files that sat raw in Downloader Unfertig (4sf- scene group, season folder)", () => {
-    const source = "4sf-fritzie.himmel.muss.warten.web.7p-s04e01.mkv";
-    const seasonFolder = "Fritzie.-.Der.Himmel.muss.warten.S04.GERMAN.720p.WEB.AVC-4SF";
-    const decision = decideAutoRenameBaseName(
-      [seasonFolder],
-      source,
-      "4sf-fritzie.himmel.muss.warten.web.7p-s04e01",
-      seasonFolder,
-      seasonFolder
-    );
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe("Fritzie.-.Der.Himmel.muss.warten.S04E01.GERMAN.720p.WEB.AVC-4SF");
-  });
-
-  it("is idempotent: an already-clean file in its clean folder derives to the same name (no worse-than-now)", () => {
-    const clean = "Herzflimmern.Die.Klinik.am.See.S07E02.German.720p.Webrip.x264-TVARCHiV";
-    const decision = decideAutoRenameBaseName(
-      [clean, "Herzflimmern.Die.Klinik.am.See.S07.German.720p.Webrip.x264-TVARCHiV"],
-      `${clean}.mkv`,
-      clean,
-      clean,
-      "Herzflimmern.Die.Klinik.am.See.S07.German.720p.Webrip.x264-TVARCHiV"
-    );
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe(clean);
-  });
-
-  it("GUARD: lets the parent folder token override an OBFUSCATED source filename (anti-piracy scramble)", () => {
-    const decision = decideAutoRenameBaseName(
-      ["Die.Thundermans.S02E01.Der.Thunder.Van.GERMAN.x264-aWake"],
-      "awa-diethundermans02e16hd.mkv",
-      "awa-diethundermans02e16hd",
-      "Die.Thundermans.S02E01.Der.Thunder.Van.GERMAN.x264-aWake",
-      "Die.Thundermans.S02.GERMAN.x264-aWake"
-    );
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toContain("S02E01");
-  });
-
-  it("GUARD: a CLEAN scene source is NEVER overridden by a mismatching folder token (folder is wrong, not the file)", () => {
-    const decision = decideAutoRenameBaseName(
-      ["The.Royals.2015.S01E08.German.DL.720p.BluRay.x264-iNTENTiON"],
-      "the.royals.2015.s01e09.german.dl.720p.bluray.x264-j4f.mkv",
-      "the.royals.2015.s01e09.german.dl.720p.bluray.x264-j4f",
-      "The.Royals.2015.S01E08.German.DL.720p.BluRay.x264-iNTENTiON",
-      "The.Royals.2015.S01.German.DL.720p.BluRay.x264-iNTENTiON"
-    );
-    expect(decision.kind).toBe("skip");
-    expect(decision.kind === "skip" && decision.reason).toBe("token-mismatch");
-  });
-
-  it("skips (no-target) when no folder candidate yields a usable scene name", () => {
-    const decision = decideAutoRenameBaseName(
-      ["random user folder", "another plain dir"],
-      "some.file.mkv",
-      "some.file",
-      "random user folder",
-      "another plain dir"
-    );
-    expect(decision.kind).toBe("skip");
-  });
-
-  it("uses the CLEAN per-episode folder (scene group WITH underscore, e.g. -idTV_iNT) — not the obfuscated package folder", () => {
-    const epFolder = "Castle.S08E02.GERMAN.DL.720p.WEB.H264-idTV_iNT";
-    const decision = decideAutoRenameBaseName(
-      [epFolder, "scn2-cstl7"],
-      "castle.s08e02.german.dl.720p.web.h264-idtv_int.mkv",
-      "castle.s08e02.german.dl.720p.web.h264-idtv_int",
-      epFolder,
-      "scn2-cstl7"
-    );
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe(epFolder);
-  });
-
-  it("uses the complete per-episode folder when the SOURCE has no SxxExx token (bare 'Folge 01' format)", () => {
-    const folders = [
-      "Kreuzfahrt.ins.Glueck.01.Hochzeitsreise.nach.Burma.2007.German.720p.HDTV.x264-BET",
-      "kig.hdtv.7p-001",
-      "Kreuzfahrt ins Glück S01"
-    ];
-    const decision = decideAutoRenameBaseName(folders, "bet_kig_01_hdt.mkv", "bet_kig_01_hdt", folders[0], folders[2]);
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe(folders[0]);
-  });
-
-  it("complete-folder fallback fires on CODEC alone (no resolution token — DVDRip/XviD class)", () => {
-    const folders = [
-      "Kreuzfahrt.ins.Glueck.01.Hochzeitsreise.nach.Burma.2007.German.DVDRip.x264-BET",
-      "Kreuzfahrt ins Glück S01"
-    ];
-    const decision = decideAutoRenameBaseName(folders, "bet_kig_01.mkv", "bet_kig_01", folders[0], folders[1]);
-    expect(decision.kind).toBe("rename");
-    expect(decision.kind === "rename" && decision.baseName).toBe(folders[0]);
-  });
-
-  it("complete-folder fallback does NOT fire when the source HAS an episode token (generic pack stays no-target)", () => {
-    const decision = decideAutoRenameBaseName(
-      ["Mega-Direct-Pack"],
-      "Direct.Show.S01E01.German.1080p.WEB.x264-DIRECT.mkv",
-      "Direct.Show.S01E01.German.1080p.WEB.x264-DIRECT",
-      "Mega-Direct-Pack",
-      "Mega-Direct-Pack"
-    );
-    expect(decision.kind).toBe("skip");
-  });
-});
-
-describe("hasMeaningfulSeriesPrefix", () => {
-  it("recognizes a real series name before the season token", () => {
-    expect(hasMeaningfulSeriesPrefix("Desperate.Housewives.S01.Synced.DL.720p.WEB-DL.AC3.h264")).toBe(true);
-    expect(hasMeaningfulSeriesPrefix("Die.Thundermans.S02E06.Tickets.und.Shreddy.GERMAN.WS.720p.HDTV.x264-aWake")).toBe(true);
-    expect(hasMeaningfulSeriesPrefix("Mistresses.2013.S02.GERMAN.DL.720p.WEB.x264-TSCC")).toBe(true);
-    expect(hasMeaningfulSeriesPrefix("show.name.s01e01.720p")).toBe(true);
-  });
-
-  it("rejects generic season-label folders without a series name", () => {
-    expect(hasMeaningfulSeriesPrefix("S01 Complete")).toBe(false);
-    expect(hasMeaningfulSeriesPrefix("S02")).toBe(false);
-    expect(hasMeaningfulSeriesPrefix("S01E01 Complete")).toBe(false);
-    expect(hasMeaningfulSeriesPrefix(".S01.bla")).toBe(false);
-  });
-
-  it("returns false when there is no season token at all", () => {
-    expect(hasMeaningfulSeriesPrefix("Some Random Folder")).toBe(false);
-    expect(hasMeaningfulSeriesPrefix("")).toBe(false);
-  });
-});
-
-describe("looksLikeObfuscatedSceneFileName", () => {
-  it("flags hoster-obfuscated names with no scene markers as obfuscated", () => {
-    expect(looksLikeObfuscatedSceneFileName("awa-diethundermans02e16hd.mkv")).toBe(true);
-    expect(looksLikeObfuscatedSceneFileName("scn-dthund7-S02E06.mkv")).toBe(true);
-    expect(looksLikeObfuscatedSceneFileName("4sj-blue-bloods-s08e21-720p.mkv")).toBe(true);
-  });
-
-  it("treats clean scene releases with multiple markers as NOT obfuscated", () => {
-    expect(looksLikeObfuscatedSceneFileName("the.royals.2015.s01e09.german.dl.720p.bluray.x264-j4f.mkv")).toBe(false);
-    expect(looksLikeObfuscatedSceneFileName("Die.Thundermans.S02E06.Tickets.und.Shreddy.GERMAN.WS.720p.HDTV.x264-aWake.mkv")).toBe(false);
-    expect(looksLikeObfuscatedSceneFileName("Desperate.Housewives.S01E01.German.Synced.DL.720p.WEB-DL.AC3.h264.mkv")).toBe(false);
-  });
-
-  it("handles edge cases (empty, very short)", () => {
-    expect(looksLikeObfuscatedSceneFileName("")).toBe(true);
-    expect(looksLikeObfuscatedSceneFileName("a.mkv")).toBe(true);
-  });
-
-  it("treats long dotted names as scene-style even with few markers", () => {
-    expect(looksLikeObfuscatedSceneFileName("Some.Show.With.Many.Tokens.S01E01.mkv")).toBe(false);
-  });
-});
-
-describe("extractEpisodeToken (extended formats)", () => {
-  it("recognizes the older xX format (capped at 2 episode digits)", () => {
-    expect(extractEpisodeToken("show.1x01.720p.mkv")).toBe("S01E01");
-    expect(extractEpisodeToken("show-2x05-hdtv.mkv")).toBe("S02E05");
-    expect(extractEpisodeToken("Show.Name.10x99.mkv")).toBe("S10E99");
-    expect(extractEpisodeToken("Show.Name.10x100.mkv")).toBeNull();
-    expect(extractEpisodeToken("Show.Name.S10E100.mkv")).toBe("S10E100");
-  });
-
-  it("does not falsely match resolution tokens like 1080x720", () => {
-    expect(extractEpisodeToken("show.1080p.mkv")).toBeNull();
-    expect(extractEpisodeToken("show.S01E01.1080p.mkv")).toBe("S01E01");
-  });
-
-  it("does not falsely match codec tokens like x264 / x265 (caps episode digits)", () => {
-    expect(extractEpisodeToken("Movie.x264-GROUP.mkv")).toBeNull();
-    expect(extractEpisodeToken("Movie.5x265.x265.mkv")).toBeNull();
-    expect(extractEpisodeToken("Show.S01E01.x265-GROUP.mkv")).toBe("S01E01");
-  });
-
-  it("does not falsely match common aspect ratios like 1920x1080", () => {
-    expect(extractEpisodeToken("Movie.1920x1080.mkv")).toBeNull();
-  });
-});
-
 describe("extractEpisodeToken", () => {
   it("extracts S01E01 from standard scene format", () => {
     expect(extractEpisodeToken("show.name.s01e01.720p")).toBe("S01E01");
@@ -467,6 +253,7 @@ describe("buildAutoRenameBaseName", () => {
     expect(result).toBeNull();
   });
 
+  // Edge cases
   it("handles 2160p quality token", () => {
     const result = buildAutoRenameBaseName("Show.S01.2160p-4sf", "show.s01e01.rp.2160p.mkv");
     expect(result).toBe("Show.S01E01.REPACK.2160p-4sf");
@@ -484,10 +271,12 @@ describe("buildAutoRenameBaseName", () => {
 
   it("handles high season and episode numbers", () => {
     const result = buildAutoRenameBaseName("Show.S99.720p-4sf", "show.s99e999.720p.mkv");
+    // SCENE_EPISODE_RE allows up to 3-digit episodes and 2-digit seasons
     expect(result).not.toBeNull();
     expect(result!).toContain("S99E999");
   });
 
+  // Real-world scene release patterns
   it("real-world: German series with dots", () => {
     const result = buildAutoRenameBaseName(
       "Der.Bergdoktor.S18.German.720p.WEB.x264-4SJ",
@@ -552,13 +341,18 @@ describe("buildAutoRenameBaseName", () => {
     expect(result).toBe("Cobra.Kai.S06E14.720p.NF.WEB-DL.DDP5.1.x264-4SF");
   });
 
+  // Bug-hunting edge cases
   it("source filename extension is not included in episode detection", () => {
+    // The sourceFileName passed to buildAutoRenameBaseName is the basename without extension
+    // so .mkv should not interfere, but let's verify with an actual extension
     const result = buildAutoRenameBaseName("Show.S01-4sf", "show.s01e01.mkv");
+    // "mkv" should not be treated as part of the filename match
     expect(result).not.toBeNull();
     expect(result!).toContain("S01E01");
   });
 
   it("does not match episode-like patterns in codec strings", () => {
+    // h.265 has digits but should not be confused with episode tokens
     const token = extractEpisodeToken("show.s01e01.h.265");
     expect(token).toBe("S01E01");
   });
@@ -576,19 +370,23 @@ describe("buildAutoRenameBaseName", () => {
       "Show.S01E05.720p-4sf",
       "show.s01e05.720p"
     );
+    // Must NOT produce "Show.S01E05.720p.S01E05-4sf" (double episode bug)
     expect(result).toBe("Show.S01E05.720p-4sf");
   });
 
   it("handles folder with only -4sf suffix (edge case)", () => {
     const result = buildAutoRenameBaseName("-4sf", "show.s01e01.mkv");
+    // Extreme edge case - sanitizeFilename trims leading dots
     expect(result).not.toBeNull();
     expect(result!).toContain("S01E01");
     expect(result!).toContain("-4sf");
-    expect(result!).not.toContain(".S01E01.S01E01");
+    expect(result!).not.toContain(".S01E01.S01E01"); // no duplication
   });
 
   it("sanitizes special characters from result", () => {
+    // sanitizeFilename should strip dangerous chars
     const result = buildAutoRenameBaseName("Show:Name.S01-4sf", "show.s01e01.mkv");
+    // The colon should be sanitized away
     expect(result).not.toBeNull();
     expect(result!).not.toContain(":");
   });
@@ -852,6 +650,7 @@ describe("buildAutoRenameBaseNameFromFolders", () => {
     expect(result).toBe("Mammon.S01E05E06.German.1080P.Bluray.x264-SMAHD");
   });
 
+  // Last-resort fallback: folder has season but no scene group suffix (user-renamed packages)
   it("renames when folder has season but no scene group suffix (Mystery Road case)", () => {
     const result = buildAutoRenameBaseNameFromFoldersWithOptions(
       ["Mystery Road S02"],
@@ -879,6 +678,7 @@ describe("buildAutoRenameBaseNameFromFolders", () => {
       "myst.road.de.dl.hdtv.7p-s02e05",
       { forceEpisodeForSeasonFolder: true }
     );
+    // Should use the scene-group folder (hrs), not the custom one
     expect(result).toBe("Mystery.Road.S02E05.GERMAN.DL.AC3.720p.HDTV.x264-hrs");
   });
 
@@ -962,128 +762,4 @@ describe("buildAutoRenameBaseNameFromFolders", () => {
     );
     expect(result).toBe("9JKL.S01E14.GERMAN.720p.WEB.x264-WvF");
   });
-
-  it("documents malformed package name (S01GERMAN) limitation", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      [
-        "3MH.web.7p-101",
-        "Drei.Meter.ueber.dem.Himmel.S01GERMAN.DL.720P.WEB.X264-WAYNE"
-      ],
-      "Drei.Meter.ueber.dem.Himmel.S01E01.GERMAN.DL.720P.WEB.X264-WAYNE",
-      { forceEpisodeForSeasonFolder: true }
-    );
-    if (result !== null) {
-      expect(typeof result).toBe("string");
-    }
-  });
-});
-
-describe("isBonusContent (numbered episodes are never bonus)", () => {
-  const pkgDir = "/pkg/Show.S04.GERMAN.DL.720p.WEB.x264-GRP";
-
-  it("does NOT treat a numbered episode as bonus even when its TITLE is a bonus word", () => {
-    const name = "Revenge.2011.S04E19.Interview.GERMAN.DL.720p.WEB.x264-TSCC";
-    const fp = `${pkgDir}/${name}/${name}.mkv`;
-    expect(isBonusContent(fp, pkgDir, name)).toBe(false);
-  });
-
-  it("covers further bonus-word episode titles with a token", () => {
-    for (const title of ["Special", "Featurette", "Outtakes", "Bloopers", "Making.Of"]) {
-      const name = `Show.S04E07.${title}.GERMAN.720p.WEB.x264-GRP`;
-      expect(isBonusContent(`${pkgDir}/${name}.mkv`, pkgDir, name)).toBe(false);
-    }
-  });
-
-  it("STILL treats genuine extras WITHOUT an episode token as bonus", () => {
-    for (const name of [
-      "Show.Making.Of.GERMAN.720p.WEB.x264-GRP",
-      "Show.Behind.The.Scenes.GERMAN-GRP",
-      "Some.Interview.With.Cast"
-    ]) {
-      expect(isBonusContent(`${pkgDir}/${name}.mkv`, pkgDir, name)).toBe(true);
-    }
-  });
-
-  it("a token-bearing file inside an Extras subfolder is still kept (numbered episode wins)", () => {
-    const name = "Show.S04E19.Interview.GROUP";
-    const fp = `${pkgDir}/Extras/${name}/${name}.mkv`;
-    expect(isBonusContent(fp, pkgDir, name)).toBe(false);
-  });
-
-  it("a token-less file inside an Extras subfolder is bonus", () => {
-    const fp = `${pkgDir}/Extras/Making.Of.mkv`;
-    expect(isBonusContent(fp, pkgDir, "Making.Of")).toBe(true);
-  });
-});
-
-describe("complete episode folder WITHOUT group suffix (codec/resolution only)", () => {
-  const hash = "c284d9d9072eaf3ac314d05f951dd115";
-
-  it("uses the clean folder name when it has an episode token + codec but no -GROUP (safari S04E08a)", () => {
-    const folder = "Fluss-Monster.S04E08a.Am.Essequibo.Teil.1.German.DOKU.SATRiP.XviD";
-    const decision = decideAutoRenameBaseName([folder, hash], "safari-fm-s04e08a.avi", "safari-fm-s04e08a", hash, hash);
-    expect(decision).toEqual({ kind: "rename", baseName: folder });
-  });
-
-  it("keeps multi-part letters a/b distinct (Teil.1 vs Teil.2 do NOT collide)", () => {
-    const fa = "Fluss-Monster.S04E08a.Am.Essequibo.Teil.1.German.DOKU.SATRiP.XviD";
-    const fb = "Fluss-Monster.S04E08b.Am.Essequibo.Teil.2.German.DOKU.SATRiP.XviD";
-    const da = decideAutoRenameBaseName([fa, hash], "safari-fm-s04e08a.avi", "safari-fm-s04e08a", hash, hash);
-    const db = decideAutoRenameBaseName([fb, hash], "safari-fm-s04e08b.avi", "safari-fm-s04e08b", hash, hash);
-    expect(da).toEqual({ kind: "rename", baseName: fa });
-    expect(db).toEqual({ kind: "rename", baseName: fb });
-    expect((da as any).baseName).not.toBe((db as any).baseName);
-  });
-
-  it("the previously-working group-suffix folder still works (no regression)", () => {
-    const folder = "Fluss-Monster.S01E02.Auf.der.Suche.nach.dem.Killer-Wels.German.DOKU.SATRiP.XviD-SAFARi";
-    const decision = decideAutoRenameBaseName([folder, hash], "safari-fm-s01e02.avi", "safari-fm-s01e02", hash, hash);
-    expect(decision).toEqual({ kind: "rename", baseName: folder });
-  });
-
-  it("does NOT use a bare episode folder WITHOUT any codec/resolution marker (stays conservative)", () => {
-    const decision = decideAutoRenameBaseName(["Show.S01E01", hash], "abc-s01e01.avi", "abc-s01e01", hash, hash);
-    expect(decision.kind).toBe("skip");
-  });
-
-  it("does NOT fabricate a name from a token-LESS folder (Mega-Direct guard intact)", () => {
-    const decision = decideAutoRenameBaseName(["Mega-Direct-Pack", hash], "Direct.Show.S01E01.DIRECT.mkv", "Direct.Show.S01E01.DIRECT", hash, hash);
-    expect(decision.kind).toBe("skip");
-  });
-});
-
-describe("collect must not mangle an already-clean SxxExx name via an episode-title folder", () => {
-  const hash = "c284d9d9072eaf3ac314d05f951dd115";
-  const epFolder = "Steven.Spielbergs.Taken.E01.Hinter.dem.Himmel.German.720p.HDTV.x264-GTVG";
-  const pkgFolder = "Steven.Spielbergs.Taken.S01.German.720p.HDTV.x264-GTVG";
-  const cleanSource = "Steven.Spielbergs.Taken.S01E01.German.720p.HDTV.x264-GTVG";
-
-  it("keeps the clean source (skip) instead of appending the token to the episode-title folder", () => {
-    const decision = decideAutoRenameBaseName([epFolder, pkgFolder], cleanSource + ".mkv", cleanSource, epFolder, pkgFolder);
-    expect(decision.kind).toBe("skip");
-    expect(JSON.stringify(decision)).not.toContain("GTVG.S01E01");
-  });
-
-  it("still cleans a JUNK/obfuscated source via an episode-title folder (append path intact, no skip)", () => {
-    const epFolder = "Show.E05.Die.Sache.German.720p.HDTV.x264-GRP";
-    const seasonFolder = "Show.S01.German.720p.HDTV.x264-GRP";
-    const decision = decideAutoRenameBaseName([epFolder, seasonFolder], "scn-show7-S01E05.mkv", "scn-show7-S01E05", epFolder, seasonFolder);
-    expect(decision.kind).toBe("rename");
-    expect(extractEpisodeToken((decision as any).baseName)).toBe("S01E05");
-  });
-
-  it("does NOT affect a folder that already carries an SxxExx token (safari S04E08a stays a rename)", () => {
-    const folder = "Fluss-Monster.S04E08a.Am.Essequibo.Teil.1.German.DOKU.SATRiP.XviD";
-    const decision = decideAutoRenameBaseName([folder, hash], "safari-fm-s04e08a.avi", "safari-fm-s04e08a", hash, hash);
-    expect(decision).toEqual({ kind: "rename", baseName: folder });
-  });
-
-  it("keeps a clean SHORT-prefix series source (ER) instead of the crippled token append", () => {
-    const epFolder = "ER.E01.Tag.und.Nacht.German.720p.HDTV.x264-GROUP";
-    const seasonFolder = "ER.S01.German.720p.HDTV.x264-GROUP";
-    const cleanSource = "ER.S01E01.German.720p.HDTV.x264-GROUP";
-    const decision = decideAutoRenameBaseName([epFolder, seasonFolder], cleanSource + ".mkv", cleanSource, epFolder, seasonFolder);
-    expect(decision.kind).toBe("skip");
-    expect(JSON.stringify(decision)).not.toContain("GROUP.S01E01");
-  });
 });

tests/backup-crypto.test.ts

@@ -20,6 +20,7 @@ describe("backup-crypto", () => {
     const plaintext = JSON.stringify({ settings: { token: secret } });
     const encrypted = encryptBackup(plaintext);
 
+    // The encrypted buffer should NOT contain the secret in plaintext
     expect(encrypted.toString("utf8")).not.toContain(secret);
     expect(encrypted.toString("latin1")).not.toContain(secret);
   });
@@ -33,7 +34,9 @@ describe("backup-crypto", () => {
     const plaintext = "same input data";
     const a = encryptBackup(plaintext);
     const b = encryptBackup(plaintext);
+    // IVs are different, so full buffers must differ
     expect(a.equals(b)).toBe(false);
+    // But both decrypt to the same plaintext
     expect(decryptBackup(a)).toBe(plaintext);
     expect(decryptBackup(b)).toBe(plaintext);
   });
@@ -46,6 +49,7 @@ describe("backup-crypto", () => {
 
   it("throws on corrupted ciphertext", () => {
     const encrypted = encryptBackup("test data");
+    // Flip a byte in the ciphertext area
     const corrupted = Buffer.from(encrypted);
     corrupted[corrupted.length - 1] ^= 0xff;
     expect(() => decryptBackup(corrupted)).toThrow();

tests/backup-payload.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildBackupPayload, planBackupImport } from "../src/main/backup-payload";
-import type { AppSettings, SessionState, HistoryEntry } from "../src/shared/types";
-
-function settings(overrides: Partial<AppSettings> = {}): AppSettings {
-  return { backupIncludeDownloads: false, token: "secret", outputDir: "C:\\dl" } as unknown as AppSettings;
-}
-
-const session: SessionState = {
-  version: 2, packageOrder: ["p1"], packages: { p1: {} as never }, items: { i1: {} as never },
-  runStartedAt: 0, totalDownloadedBytes: 0, summaryText: "", reconnectUntil: 0,
-  reconnectReason: "", paused: false, running: true, updatedAt: 0
-};
-const history: HistoryEntry[] = [{ id: "h1" } as unknown as HistoryEntry];
-
-const baseInput = { appVersion: "1.7.183", exportedAt: "2026-06-07T00:00:00Z", session, history };
-
-describe("buildBackupPayload — default is settings-only", () => {
-  it("omits session AND history when backupIncludeDownloads is false (default)", () => {
-    const p = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: false } as AppSettings });
-    expect(p.kind).toBe("settings-only");
-    expect(p.session).toBeUndefined();
-    expect(p.history).toBeUndefined();
-    expect(p.settings).toBeDefined();
-  });
-
-  it("includes session + history when backupIncludeDownloads is true", () => {
-    const p = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: true } as AppSettings });
-    expect(p.kind).toBe("full");
-    expect(p.session).toBe(session);
-    expect(p.history).toBe(history);
-  });
-
-  it("treats a missing flag as settings-only (safe default)", () => {
-    const p = buildBackupPayload({ ...baseInput, settings: {} as AppSettings });
-    expect(p.kind).toBe("settings-only");
-    expect(p.session).toBeUndefined();
-  });
-
-  it("ROUND-TRIP: toggle off -> exported payload carries the flag still false", () => {
-    // "Haken aus bleibt aus": the exported settings object preserves the flag,
-    // so importing it keeps the toggle off.
-    const p = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: false } as AppSettings });
-    expect((p.settings as AppSettings).backupIncludeDownloads).toBe(false);
-  });
-});
-
-describe("planBackupImport — decision follows the file, not the local toggle", () => {
-  it("settings-only backup (no session) -> restore settings only, no relaunch", () => {
-    const plan = planBackupImport({ version: 2, kind: "settings-only", settings: { theme: "dark" } });
-    expect(plan.valid).toBe(true);
-    expect(plan.restoreDownloads).toBe(false);
-    expect(plan.message).toMatch(/Einstellungen/);
-  });
-
-  it("full backup (with session) -> restore downloads + relaunch", () => {
-    const plan = planBackupImport({ version: 2, kind: "full", settings: { theme: "dark" }, session });
-    expect(plan.valid).toBe(true);
-    expect(plan.restoreDownloads).toBe(true);
-  });
-
-  it("rejects payloads without settings", () => {
-    expect(planBackupImport({ session }).valid).toBe(false);
-    expect(planBackupImport(null).valid).toBe(false);
-    expect(planBackupImport("nope").valid).toBe(false);
-    expect(planBackupImport({}).valid).toBe(false);
-  });
-
-  it("a settings-only export then import does NOT pull in the download list", () => {
-    // Build with toggle off, then plan the import of exactly that payload.
-    const exported = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: false } as AppSettings });
-    const plan = planBackupImport(JSON.parse(JSON.stringify(exported)));
-    expect(plan.restoreDownloads).toBe(false); // queue stays untouched
-  });
-
-  it("a full export then import DOES restore the download list", () => {
-    const exported = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: true } as AppSettings });
-    const plan = planBackupImport(JSON.parse(JSON.stringify(exported)));
-    expect(plan.restoreDownloads).toBe(true);
-  });
-});

tests/bestdebrid-web.test.ts

@@ -73,6 +73,7 @@ describe("bestdebrid-web", () => {
       try {
         fs.rmSync(filePath, { force: true });
       } catch {
+        // ignore temp cleanup failures
       }
     }
   });

tests/cleanup.test.ts

@@ -42,6 +42,7 @@ describe("cleanup", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-clean-"));
     tempDirs.push(dir);
 
+    // Create nested directory structure with archive files
     const sub1 = path.join(dir, "season1");
     const sub2 = path.join(dir, "season1", "extras");
     fs.mkdirSync(sub2, { recursive: true });
@@ -50,15 +51,17 @@ describe("cleanup", () => {
     fs.writeFileSync(path.join(sub1, "episode.part2.rar"), "x");
     fs.writeFileSync(path.join(sub2, "bonus.zip"), "x");
     fs.writeFileSync(path.join(sub2, "bonus.7z"), "x");
+    // Non-archive files should be kept
     fs.writeFileSync(path.join(sub1, "video.mkv"), "real content");
     fs.writeFileSync(path.join(sub2, "subtitle.srt"), "subtitle content");
 
     const removed = cleanupCancelledPackageArtifacts(dir);
-    expect(removed).toBe(4);
+    expect(removed).toBe(4); // 2 rar parts + zip + 7z
     expect(fs.existsSync(path.join(sub1, "episode.part1.rar"))).toBe(false);
     expect(fs.existsSync(path.join(sub1, "episode.part2.rar"))).toBe(false);
     expect(fs.existsSync(path.join(sub2, "bonus.zip"))).toBe(false);
     expect(fs.existsSync(path.join(sub2, "bonus.7z"))).toBe(false);
+    // Non-archives kept
     expect(fs.existsSync(path.join(sub1, "video.mkv"))).toBe(true);
     expect(fs.existsSync(path.join(sub2, "subtitle.srt"))).toBe(true);
   });
@@ -67,17 +70,23 @@ describe("cleanup", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-clean-"));
     tempDirs.push(dir);
 
+    // File with link-like name containing URLs should be removed
     fs.writeFileSync(path.join(dir, "download_links.txt"), "https://rapidgator.net/file/abc123\nhttps://uploaded.net/file/def456\n");
+    // File with link-like name but no URLs should be kept
     fs.writeFileSync(path.join(dir, "my_downloads.txt"), "Just some random text without URLs");
+    // Regular text file that doesn't match the link pattern should be kept
     fs.writeFileSync(path.join(dir, "readme.txt"), "https://example.com");
+    // .url files should always be removed
     fs.writeFileSync(path.join(dir, "bookmark.url"), "[InternetShortcut]\nURL=https://example.com");
+    // .dlc files should always be removed
     fs.writeFileSync(path.join(dir, "container.dlc"), "encrypted-data");
 
     const removed = await removeDownloadLinkArtifacts(dir);
-    expect(removed).toBeGreaterThanOrEqual(3);
+    expect(removed).toBeGreaterThanOrEqual(3); // download_links.txt + bookmark.url + container.dlc
     expect(fs.existsSync(path.join(dir, "download_links.txt"))).toBe(false);
     expect(fs.existsSync(path.join(dir, "bookmark.url"))).toBe(false);
     expect(fs.existsSync(path.join(dir, "container.dlc"))).toBe(false);
+    // Non-matching files should be kept
     expect(fs.existsSync(path.join(dir, "readme.txt"))).toBe(true);
   });
 

tests/container.test.ts

@@ -22,7 +22,9 @@ describe("container", () => {
     const oversizedFilePath = path.join(dir, "oversized.dlc");
     fs.writeFileSync(oversizedFilePath, Buffer.alloc((8 * 1024 * 1024) + 1, 1));
 
+    // Create a valid mockup DLC that would be skipped if an error was thrown
     const validFilePath = path.join(dir, "valid.dlc");
+    // Just needs to be short enough to pass file limits but fail parsing, triggering dcrypt fallback
     fs.writeFileSync(validFilePath, Buffer.from("Valid but not real DLC content..."));
 
     const fetchSpy = vi.fn(async (url: string | URL | Request) => {
@@ -36,6 +38,7 @@ describe("container", () => {
 
     const result = await importDlcContainers([oversizedFilePath, validFilePath]);
 
+    // Expect the oversized to be silently skipped, and valid to be parsed into 1 package with DLC filename
     expect(result).toHaveLength(1);
     expect(result[0].name).toBe("valid");
     expect(result[0].links).toEqual(["http://example.com/file1.rar", "http://example.com/file2.rar"]);
@@ -57,14 +60,17 @@ describe("container", () => {
     tempDirs.push(dir);
     const filePath = path.join(dir, "fallback.dlc");
 
+    // A file large enough to trigger local decryption attempt (needs > 89 bytes to pass the slice check)
     fs.writeFileSync(filePath, Buffer.alloc(100, 1).toString("base64"));
 
     const fetchSpy = vi.fn(async (url: string | URL | Request) => {
       const urlStr = String(url);
       if (urlStr.includes("service.jdownloader.org")) {
+        // Mock local RC service failure (returning 404)
         return new Response("", { status: 404 });
       }
       if (urlStr.includes("dcrypt.it/decrypt/upload")) {
+        // Mock dcrypt fallback success
         return new Response("http://fallback.com/1", { status: 200 });
       }
       return new Response("", { status: 404 });
@@ -75,6 +81,7 @@ describe("container", () => {
     expect(result).toHaveLength(1);
     expect(result[0].name).toBe("fallback");
     expect(result[0].links).toEqual(["http://fallback.com/1"]);
+    // Should have tried both!
     expect(fetchSpy).toHaveBeenCalledTimes(2);
   });
 
@@ -128,6 +135,7 @@ describe("container", () => {
     expect(result).toHaveLength(1);
     expect(result[0].name).toBe("big-dlc");
     expect(result[0].links).toEqual(["http://paste-fallback.com/file1.rar", "http://paste-fallback.com/file2.rar"]);
+    // local RC + upload + paste = 3 calls
     expect(fetchSpy).toHaveBeenCalledTimes(3);
   });
 

tests/debrid.test.ts

@@ -1,17 +1,14 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { defaultSettings, REQUEST_RETRIES } from "../src/main/constants";
 import { parseDebridLinkApiKeys } from "../src/shared/debrid-link-keys";
-import { getMegaDebridAccountId } from "../src/shared/mega-debrid-accounts";
 import { getProviderUsageDayKey } from "../src/shared/provider-daily-limits";
-import { clearMegaDebridEmptyResponseStreak, DebridService, extractRapidgatorFilenameFromHtml, fetchAllDebridHostInfo, fetchDebridLinkHostLimits, filenameFromRapidgatorUrlPath, getDebridLinkKeyRuntimeStateForTests, getMegaDebridAccountCooldownState, MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART, normalizeResolvedFilename, primeMegaDebridUntilRestartForTests, recordMegaDebridEmptyResponseStreak, resetDebridLinkRuntimeStateForTests, resetMegaDebridRuntimeStateForTests } from "../src/main/debrid";
+import { DebridService, extractRapidgatorFilenameFromHtml, fetchAllDebridHostInfo, fetchDebridLinkHostLimits, filenameFromRapidgatorUrlPath, normalizeResolvedFilename, resetDebridLinkRuntimeStateForTests } from "../src/main/debrid";
 
 const originalFetch = globalThis.fetch;
 
 afterEach(() => {
   globalThis.fetch = originalFetch;
   resetDebridLinkRuntimeStateForTests();
-  resetMegaDebridRuntimeStateForTests();
-  delete process.env.RD_MEGA_ABORT_MIN_RUN_MS;
   vi.restoreAllMocks();
 });
 
@@ -22,7 +19,6 @@ describe("debrid service", () => {
       token: "rd-token",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       bestToken: "",
       providerOrder: [] as const,
       providerPrimary: "realdebrid" as const,
@@ -62,7 +58,6 @@ describe("debrid service", () => {
       token: "rd-token",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       providerPrimary: "realdebrid" as const,
       providerSecondary: "megadebrid" as const,
       providerTertiary: "bestdebrid" as const,
@@ -390,135 +385,6 @@ describe("debrid service", () => {
     expect(result.directUrl).toBe("https://debrid-link.example/quota-ok.bin");
   });
 
-  it("scopes Debrid-Link maxDataHost cooldown to the (key, host) pair so the key stays usable for other hosters", async () => {
-    const settings = {
-      ...defaultSettings(),
-      debridLinkApiKeys: "dl-key-one\ndl-key-two",
-      providerOrder: ["debridlink"] as const,
-      providerPrimary: "debridlink" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: true
-    };
-
-    const unrestrictAuthHeaders: string[] = [];
-
-    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      const headers = init?.headers;
-      let authHeader = "";
-      if (headers instanceof Headers) {
-        authHeader = headers.get("Authorization") || "";
-      } else if (Array.isArray(headers)) {
-        authHeader = headers.find(([key]) => key.toLowerCase() === "authorization")?.[1] || "";
-      } else {
-        authHeader = String((headers as Record<string, unknown> | undefined)?.Authorization || "");
-      }
-
-      if (url.includes("debrid-link.com/api/v2/downloader/limits")) {
-        return new Response(JSON.stringify({
-          success: true,
-          value: { nextResetSeconds: { value: 900 } }
-        }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-
-      if (url.includes("/downloader/add")) {
-        unrestrictAuthHeaders.push(authHeader);
-        const bodyText = init?.body ? String(init.body) : "";
-        const isRapidgator = /rapidgator/i.test(bodyText);
-        if (authHeader === "Bearer dl-key-one" && isRapidgator) {
-          return new Response(JSON.stringify({
-            success: false,
-            error: "maxDataHost",
-            error_description: "host quota reached"
-          }), { status: 403, headers: { "Content-Type": "application/json" } });
-        }
-        return new Response(JSON.stringify({
-          success: true,
-          value: {
-            downloadUrl: `https://debrid-link.example/${authHeader.slice(-3)}-${isRapidgator ? "rg" : "ot"}.bin`,
-            name: "ok.bin",
-            size: 1024
-          }
-        }), { status: 200, headers: { "Content-Type": "application/json" } });
-      }
-
-      return new Response("not-found", { status: 404 });
-    }) as typeof fetch;
-
-    const service = new DebridService(settings);
-
-    const r1 = await service.unrestrictLink("https://rapidgator.net/file/first");
-    expect(r1.providerLabel).toContain("Key 2");
-
-    unrestrictAuthHeaders.length = 0;
-    const r2 = await service.unrestrictLink("https://rapidgator.net/file/second");
-    expect(unrestrictAuthHeaders).toEqual(["Bearer dl-key-two"]);
-    expect(r2.providerLabel).toContain("Key 2");
-
-    unrestrictAuthHeaders.length = 0;
-    const r3 = await service.unrestrictLink("https://uploaded.net/file/third");
-    expect(unrestrictAuthHeaders).toEqual(["Bearer dl-key-one"]);
-    expect(r3.providerLabel).toContain("Key 1");
-  });
-
-  it("does not mark Debrid-Link key as errored when the API returns fileNotAvailable (link-level, not key-level)", async () => {
-    const settings = {
-      ...defaultSettings(),
-      debridLinkApiKeys: "dl-key-one\ndl-key-two",
-      providerOrder: ["debridlink"] as const,
-      providerPrimary: "debridlink" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: true
-    };
-
-    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      const headers = init?.headers;
-      let authHeader = "";
-      if (headers instanceof Headers) {
-        authHeader = headers.get("Authorization") || "";
-      } else if (Array.isArray(headers)) {
-        authHeader = headers.find(([key]) => key.toLowerCase() === "authorization")?.[1] || "";
-      } else {
-        authHeader = String((headers as Record<string, unknown> | undefined)?.Authorization || "");
-      }
-
-      if (!url.includes("/downloader/add")) {
-        return new Response("not-found", { status: 404 });
-      }
-      if (authHeader === "Bearer dl-key-one") {
-        return new Response(JSON.stringify({
-          success: false,
-          error: "fileNotAvailable",
-          error_description: "link is currently not available"
-        }), { status: 403, headers: { "Content-Type": "application/json" } });
-      }
-      return new Response(JSON.stringify({
-        success: true,
-        value: {
-          downloadUrl: "https://debrid-link.example/ok.bin",
-          name: "ok.bin",
-          size: 1024
-        }
-      }), { status: 200, headers: { "Content-Type": "application/json" } });
-    }) as typeof fetch;
-
-    const key1Id = parseDebridLinkApiKeys("dl-key-one")[0].id;
-    const key2Id = parseDebridLinkApiKeys("dl-key-two")[0].id;
-
-    const service = new DebridService(settings);
-    const result = await service.unrestrictLink("https://rapidgator.net/file/example");
-    expect(result.providerLabel).toContain("Key 2");
-
-    expect(getDebridLinkKeyRuntimeStateForTests(key1Id)).not.toBe("error");
-    expect(getDebridLinkKeyRuntimeStateForTests(key2Id)).toBe("ready");
-  });
-
   it("treats bad Debrid-Link file passwords as fatal and does not rotate keys", async () => {
     const settings = {
       ...defaultSettings(),
@@ -593,70 +459,7 @@ describe("debrid service", () => {
     expect(addCalls).toBe(2);
   });
 
-  it("returns an invalid-all marker when all Debrid-Link keys are invalid", async () => {
+  it("fails fast on provider-wide Debrid-Link notDebrid errors without rotating through all keys", async () => {
-    const settings = {
-      ...defaultSettings(),
-      debridLinkApiKeys: "dl-key-one\ndl-key-two",
-      providerOrder: ["debridlink"] as const,
-      providerPrimary: "debridlink" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: true
-    };
-
-    const authHeaders: string[] = [];
-
-    globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-      const headers = init?.headers;
-      let authHeader = "";
-      if (headers instanceof Headers) {
-        authHeader = headers.get("Authorization") || "";
-      } else if (Array.isArray(headers)) {
-        authHeader = headers.find(([key]) => key.toLowerCase() === "authorization")?.[1] || "";
-      } else {
-        authHeader = String((headers as Record<string, unknown> | undefined)?.Authorization || "");
-      }
-      authHeaders.push(authHeader);
-      return new Response(JSON.stringify({
-        success: false,
-        error: "badToken",
-        error_description: "token expired"
-      }), {
-        status: 401,
-        headers: { "Content-Type": "application/json" }
-      });
-    }) as typeof fetch;
-
-    const service = new DebridService(settings);
-    await expect(service.unrestrictLink("https://hoster.example/all-invalid.bin")).rejects.toThrow(/debrid_link_invalid_all:/i);
-    expect(authHeaders).toEqual(["Bearer dl-key-one", "Bearer dl-key-two"]);
-  });
-
-  it("returns a clear error when all Debrid-Link keys are locally exhausted", async () => {
-    const keys = parseDebridLinkApiKeys("dl-key-one\ndl-key-two");
-    const settings = {
-      ...defaultSettings(),
-      debridLinkApiKeys: "dl-key-one\ndl-key-two",
-      providerOrder: ["debridlink"] as const,
-      providerPrimary: "debridlink" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      debridLinkApiKeyDailyLimitBytes: {
-        [keys[0].id]: 100,
-        [keys[1].id]: 100
-      },
-      debridLinkApiKeyDailyUsageBytes: {
-        [keys[0].id]: 100,
-        [keys[1].id]: 100
-      },
-      providerDailyUsageDay: getProviderUsageDayKey()
-    };
-
-    const service = new DebridService(settings);
-    await expect(service.unrestrictLink("https://hoster.example/no-key-left.bin")).rejects.toThrow(/debrid-link nicht verfuegbar|kein aktiver api-key/i);
-  });
-
-  it("stops rotation immediately on Debrid-Link notDebrid (provider-wide) — does NOT burn remaining keys", async () => {
     const settings = {
       ...defaultSettings(),
       debridLinkApiKeys: "dl-key-one\ndl-key-two",
@@ -682,7 +485,7 @@ describe("debrid service", () => {
     }) as typeof fetch;
 
     const service = new DebridService(settings);
-    await expect(service.unrestrictLink("https://hoster.example/not-debrid.bin")).rejects.toThrow(/debrid_link_cooldown.*notDebrid/);
+    await expect(service.unrestrictLink("https://hoster.example/not-debrid.bin")).rejects.toThrow("Link kann aktuell nicht generiert werden (notDebrid: notDebrid)");
     expect(authHeaders).toEqual(["Bearer dl-key-one"]);
   });
 
@@ -1022,90 +825,6 @@ describe("debrid service", () => {
     expect(calledUrls.some((url) => url.includes("/limits"))).toBe(true);
   });
 
-  it("includes Debrid-Link host and key state diagnostics in host limits", async () => {
-    globalThis.fetch = (async (input: RequestInfo | URL): Promise<Response> => {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      if (url.includes("debrid-link.com/api/v2/downloader/hosts")) {
-        return new Response(JSON.stringify({
-          success: true,
-          value: [
-            {
-              name: "rapidgator",
-              status: 1,
-              domains: ["rapidgator.net", "rg.to"]
-            }
-          ]
-        }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      if (url.includes("debrid-link.com/api/v2/downloader/limits/all")) {
-        return new Response(JSON.stringify({
-          success: true,
-          value: {
-            hosters: [
-              {
-                name: "rapidgator",
-                daySize: { current: 1024, value: 2048 },
-                dayCount: { current: 2, value: 5 }
-              }
-            ]
-          }
-        }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      return new Response("not-found", { status: 404 });
-    }) as typeof fetch;
-
-    const info = await fetchDebridLinkHostLimits("key-a", "rapidgator");
-    expect(info[0].state).toBe("ready");
-    expect(info[0].stateLabel).toBe("Bereit");
-    expect(info[0].hostState).toBe("up");
-    expect(info[0].hostStateLabel).toBe("Online");
-  });
-
-  it("returns invalid Debrid-Link key diagnostics instead of failing the whole popup request", async () => {
-    globalThis.fetch = (async (input: RequestInfo | URL): Promise<Response> => {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      if (url.includes("debrid-link.com/api/v2/downloader/hosts")) {
-        return new Response(JSON.stringify({
-          success: true,
-          value: [
-            {
-              name: "rapidgator",
-              status: 0,
-              domains: ["rapidgator.net"]
-            }
-          ]
-        }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      if (url.includes("debrid-link.com/api/v2/downloader/limits/all")) {
-        return new Response(JSON.stringify({
-          success: false,
-          error: "badToken",
-          error_description: "token expired"
-        }), {
-          status: 401,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      return new Response("not-found", { status: 404 });
-    }) as typeof fetch;
-
-    const info = await fetchDebridLinkHostLimits("key-a", "rapidgator");
-    expect(info).toHaveLength(1);
-    expect(info[0].state).toBe("invalid");
-    expect(info[0].cooldownRemainingMs).toBeGreaterThan(0);
-    expect(info[0].hostState).toBe("down");
-    expect(info[0].hostStateLabel).toBe("Offline");
-  });
-
   it("uses AllDebrid web path when enabled", async () => {
     const settings = {
       ...defaultSettings(),
@@ -1247,7 +966,6 @@ describe("debrid service", () => {
       allDebridToken: "",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       providerOrder: [] as const,
       providerPrimary: "megadebrid" as const,
       providerSecondary: "megadebrid" as const,
@@ -1255,6 +973,7 @@ describe("debrid service", () => {
       autoProviderFallback: true
     };
 
+    // API returns 404 for connectUser → API fails, falls back to web
     const fetchSpy = vi.fn(async () => new Response("not-found", { status: 404 }));
     globalThis.fetch = fetchSpy as unknown as typeof fetch;
 
@@ -1280,7 +999,6 @@ describe("debrid service", () => {
       allDebridToken: "",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       megaDebridApiEnabled: true,
       megaDebridWebEnabled: true,
       providerPrimary: "megadebrid-api" as const,
@@ -1311,7 +1029,6 @@ describe("debrid service", () => {
       allDebridToken: "",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       megaDebridApiEnabled: true,
       megaDebridWebEnabled: true,
       providerOrder: [] as const,
@@ -1345,7 +1062,6 @@ describe("debrid service", () => {
       allDebridToken: "",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       providerOrder: [] as const,
       providerPrimary: "megadebrid" as const,
       providerSecondary: "none" as const,
@@ -1353,6 +1069,7 @@ describe("debrid service", () => {
       autoProviderFallback: false
     };
 
+    // API connect fails fast → falls through to web fallback
     globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
 
     const megaWeb = vi.fn((_link: string, signal?: AbortSignal): Promise<never> => new Promise((_, reject) => {
@@ -1379,340 +1096,6 @@ describe("debrid service", () => {
     }
   });
 
-  it("rotates to the next Mega-Debrid account when one hits its daily limit (error-based)", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    let webCalls = 0;
-    const megaWeb = vi.fn(async (_link: string, _signal?: AbortSignal) => {
-      webCalls += 1;
-      if (webCalls <= 3) {
-        throw new Error("Mega-Web: daily limit reached (Tageslimit erreicht)");
-      }
-      return {
-        fileName: "rotated-to-acc2.rar",
-        directUrl: "https://mega-web.example/rotated-to-acc2.rar",
-        fileSize: null,
-        retriesUsed: 0
-      };
-    });
-
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const result = await service.unrestrictLink("https://rapidgator.net/file/limit-rotation-test");
-
-    expect(result.directUrl).toBe("https://mega-web.example/rotated-to-acc2.rar");
-    expect(webCalls).toBeGreaterThanOrEqual(4);
-  }, 30000);
-
-  it("skips a manually disabled Mega-Debrid account and uses the next one", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridDisabledAccountIds: [getMegaDebridAccountId("user1")],
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    const megaWeb = vi.fn(async () => ({
-      fileName: "from-acc2.rar",
-      directUrl: "https://mega-web.example/from-acc2.rar",
-      fileSize: null,
-      retriesUsed: 0
-    }));
-
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const result = await service.unrestrictLink("https://rapidgator.net/file/disabled-acc-test");
-
-    expect((result as { sourceAccountId?: string }).sourceAccountId).toBe(getMegaDebridAccountId("user2"));
-    expect(result.directUrl).toBe("https://mega-web.example/from-acc2.rar");
-    expect(megaWeb).toHaveBeenCalledTimes(1);
-  }, 20000);
-
-  it("fails fast on Mega-Debrid hoster quota ('Kein Server') and rotates to the next account", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    let calls = 0;
-    const megaWeb = vi.fn(async () => {
-      calls += 1;
-      if (calls === 1) {
-        throw new Error("Mega-Web: Kein Server für diesen Hoster verfügbar. Bitte versuchen Sie es später noch einmal.");
-      }
-      return { fileName: "acc2.rar", directUrl: "https://mega-web.example/acc2.rar", fileSize: null, retriesUsed: 0 };
-    });
-
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const result = await service.unrestrictLink("https://rapidgator.net/file/quota-rotate-test");
-
-    expect((result as { sourceAccountId?: string }).sourceAccountId).toBe(getMegaDebridAccountId("user2"));
-    expect(result.directUrl).toBe("https://mega-web.example/acc2.rar");
-    expect(calls).toBe(2);
-  }, 20000);
-
-  it("passes each account's OWN credentials to the Mega web unrestrict during rotation", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    const accountsSeen: Array<string | undefined> = [];
-    const megaWeb = vi.fn(async (_link: string, _signal: AbortSignal | undefined, account?: { login: string; password: string }) => {
-      accountsSeen.push(account?.login);
-      if (account?.login === "user1") {
-        throw new Error("Mega-Web: Kein Server für diesen Hoster verfügbar. Bitte versuchen Sie es später noch einmal.");
-      }
-      return { fileName: "ok.rar", directUrl: "https://mega-web.example/ok.rar", fileSize: null, retriesUsed: 0 };
-    });
-
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const result = await service.unrestrictLink("https://rapidgator.net/file/per-account-creds");
-
-    expect(accountsSeen).toContain("user1");
-    expect(accountsSeen).toContain("user2");
-    expect((result as { sourceAccountId?: string }).sourceAccountId).toBe(getMegaDebridAccountId("user2"));
-    expect(result.directUrl).toBe("https://mega-web.example/ok.rar");
-  }, 20000);
-
-  it("escalates a Mega-Debrid account to 'until restart' after the empty-response streak threshold", () => {
-    const key = `${getMegaDebridAccountId("user1")}:web`;
-    expect(MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART).toBe(3);
-    expect(recordMegaDebridEmptyResponseStreak(key)).toBe(1);
-    expect(recordMegaDebridEmptyResponseStreak(key)).toBe(2);
-    expect(recordMegaDebridEmptyResponseStreak(key)).toBe(3);
-    clearMegaDebridEmptyResponseStreak(key);
-    expect(recordMegaDebridEmptyResponseStreak(key)).toBe(1);
-  });
-
-  it("keeps an 'until restart' park active forever (never expires until process restart)", () => {
-    const key = `${getMegaDebridAccountId("user1")}:api`;
-    primeMegaDebridUntilRestartForTests(key);
-    const now = getMegaDebridAccountCooldownState(key);
-    expect(now?.untilRestart).toBe(true);
-    const farFuture = Date.now() + 100 * 24 * 60 * 60 * 1000;
-    expect(getMegaDebridAccountCooldownState(key, farFuture)?.untilRestart).toBe(true);
-  });
-
-  it("skips a Mega-Debrid account parked until restart and rotates to the next, without re-testing it", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    const user1 = getMegaDebridAccountId("user1");
-    primeMegaDebridUntilRestartForTests(`${user1}:api`);
-    primeMegaDebridUntilRestartForTests(`${user1}:web`);
-
-    const loginsSeen: Array<string | undefined> = [];
-    const megaWeb = vi.fn(async (_link: string, _signal: AbortSignal | undefined, account?: { login: string; password: string }) => {
-      loginsSeen.push(account?.login);
-      return { fileName: "acc2.rar", directUrl: "https://mega-web.example/acc2.rar", fileSize: null, retriesUsed: 0 };
-    });
-
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const result = await service.unrestrictLink("https://rapidgator.net/file/parked-skip-test");
-
-    expect(loginsSeen).not.toContain("user1");
-    expect(loginsSeen).toContain("user2");
-    expect((result as { sourceAccountId?: string }).sourceAccountId).toBe(getMegaDebridAccountId("user2"));
-  }, 20000);
-
-  it("fails terminally (no retry timer) when ALL Mega-Debrid accounts are parked until restart", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    for (const login of ["user1", "user2"]) {
-      const id = getMegaDebridAccountId(login);
-      primeMegaDebridUntilRestartForTests(`${id}:api`);
-      primeMegaDebridUntilRestartForTests(`${id}:web`);
-    }
-
-    const megaWeb = vi.fn(async () => ({ fileName: "x.rar", directUrl: "https://mega-web.example/x.rar", fileSize: null, retriesUsed: 0 }));
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-
-    await expect(service.unrestrictLink("https://rapidgator.net/file/all-parked-test")).rejects.toThrow(/bis Neustart gesperrt/i);
-    expect(megaWeb).not.toHaveBeenCalled();
-  }, 20000);
-
-  it("drives a real empty response through the full rotation into an until-restart park (wiring test)", async () => {
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    const key = `${getMegaDebridAccountId("user1")}:web`;
-    recordMegaDebridEmptyResponseStreak(key);
-    recordMegaDebridEmptyResponseStreak(key);
-    expect(getMegaDebridAccountCooldownState(key)?.untilRestart ?? false).toBe(false);
-
-    const megaWeb = vi.fn(async () => null);
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    await service.unrestrictLink("https://rapidgator.net/file/wiring").catch(() => undefined);
-
-    expect(megaWeb).toHaveBeenCalled();
-    expect(getMegaDebridAccountCooldownState(key)?.untilRestart).toBe(true);
-  }, 20000);
-
-  it("cools down a Mega-Web account that aborts (timeout) so the NEXT unrestrict rotates to the next account", async () => {
-    process.env.RD_MEGA_ABORT_MIN_RUN_MS = "0"; // treat the instant mock abort as a real timeout
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    const loginsSeen: Array<string | undefined> = [];
-    const megaWeb = vi.fn(async (_link: string, _signal: AbortSignal | undefined, account?: { login: string; password: string }) => {
-      loginsSeen.push(account?.login);
-      if (account?.login === "user1") {
-        throw new Error("aborted:debrid");
-      }
-      return { fileName: "acc2.rar", directUrl: "https://mega-web.example/acc2.rar", fileSize: null, retriesUsed: 0 };
-    });
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const user1Key = `${getMegaDebridAccountId("user1")}:web`;
-
-    // Call 1: account 1 aborts -> rotation stops this pass, account 2 NOT tried, but account 1 is cooled down.
-    await expect(service.unrestrictLink("https://rapidgator.net/file/abort-call-1")).rejects.toThrow();
-    expect(loginsSeen).toContain("user1");
-    expect(loginsSeen).not.toContain("user2");
-    expect(getMegaDebridAccountCooldownState(user1Key)).not.toBeNull();
-
-    // Call 2 (the retry, same state): account 1 is on cooldown -> skipped -> account 2 served.
-    loginsSeen.length = 0;
-    const result = await service.unrestrictLink("https://rapidgator.net/file/abort-call-2");
-    expect(loginsSeen).not.toContain("user1");
-    expect(loginsSeen).toContain("user2");
-    expect((result as { sourceAccountId?: string }).sourceAccountId).toBe(getMegaDebridAccountId("user2"));
-  }, 20000);
-
-  it("does NOT cool down a Mega-Web account on a quick abort (below the min-run threshold = user cancel)", async () => {
-    process.env.RD_MEGA_ABORT_MIN_RUN_MS = "99999"; // any realistic elapsed stays below -> no cooldown
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      bestToken: "",
-      allDebridToken: "",
-      megaLogin: "user1",
-      megaPassword: "pass1",
-      megaCredentials: "user1:pass1\nuser2:pass2",
-      megaDebridPreferApi: false,
-      providerOrder: [] as const,
-      providerPrimary: "megadebrid" as const,
-      providerSecondary: "none" as const,
-      providerTertiary: "none" as const,
-      autoProviderFallback: false
-    };
-    globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
-
-    const megaWeb = vi.fn(async () => { throw new Error("aborted:debrid"); });
-    const service = new DebridService(settings, { megaWebUnrestrict: megaWeb });
-    const user1Key = `${getMegaDebridAccountId("user1")}:web`;
-
-    await expect(service.unrestrictLink("https://rapidgator.net/file/quick-cancel")).rejects.toThrow();
-    expect(getMegaDebridAccountCooldownState(user1Key)).toBeNull();
-  }, 20000);
-
   it("respects provider selection and does not append hidden providers", async () => {
     const settings = {
       ...defaultSettings(),
@@ -1721,7 +1104,6 @@ describe("debrid service", () => {
       allDebridToken: "ad-token",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       providerPrimary: "megadebrid" as const,
       providerSecondary: "megadebrid" as const,
       providerTertiary: "megadebrid" as const,
@@ -1753,7 +1135,6 @@ describe("debrid service", () => {
       token: "",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       providerPrimary: "realdebrid" as const,
       providerSecondary: "megadebrid" as const,
       providerTertiary: "none" as const,
@@ -1778,7 +1159,6 @@ describe("debrid service", () => {
       token: "rd-token",
       megaLogin: "user",
       megaPassword: "pass",
-      megaCredentials: "user:pass",
       providerPrimary: "realdebrid" as const,
       providerSecondary: "none" as const,
       providerTertiary: "none" as const,
@@ -2083,9 +1463,11 @@ describe("normalizeResolvedFilename", () => {
   });
 
   it("strips HTML tags and collapses whitespace", () => {
+    // Tags are replaced by spaces, then multiple spaces collapsed
     const result = normalizeResolvedFilename("<b>Show.S01E01</b>.part01.rar");
     expect(result).toBe("Show.S01E01 .part01.rar");
 
+    // Entity decoding happens before tag removal, so &lt;...&gt; becomes <...> then gets stripped
     const entityTagResult = normalizeResolvedFilename("File&lt;Tag&gt;.part1.rar");
     expect(entityTagResult).toBe("File .part1.rar");
   });
@@ -2108,6 +1490,7 @@ describe("normalizeResolvedFilename", () => {
   });
 
   it("handles combined transforms", () => {
+    // "Download file" prefix stripped, &amp; decoded to &, "- Rapidgator" suffix stripped
     expect(normalizeResolvedFilename("Download file Show.S01E01.part01.rar - Rapidgator"))
       .toBe("Show.S01E01.part01.rar");
   });

tests/debug-server.test.ts

@@ -1,538 +0,0 @@
-import fs from "node:fs";
-import http from "node:http";
-import os from "node:os";
-import path from "node:path";
-import { once } from "node:events";
-import AdmZip from "adm-zip";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("../src/main/windows-host-diagnostics", () => ({
-  getWindowsHostDiagnostics: () => ({
-    collectedAt: "2026-03-09T00:00:03.000Z",
-    supported: true,
-    platform: "win32",
-    crashControl: {
-      crashDumpEnabled: 3,
-      minidumpDir: "C:\\Windows\\Minidumps",
-      dumpFile: "C:\\Windows\\MEMORY.DMP",
-      overwrite: 1,
-      logEvent: 1,
-      autoReboot: 1
-    },
-    recentKernelPower: [
-      {
-        timeCreated: "2026-03-09T00:00:04.000Z",
-        id: 41,
-        providerName: "Microsoft-Windows-Kernel-Power",
-        levelDisplayName: "Critical",
-        message: "unexpected restart",
-        bugcheckCode: "0",
-        bugcheckCodeHex: "",
-        reportId: ""
-      }
-    ],
-    recentWerKernel: [],
-    recentKernelDump: [],
-    recentAppCrashes: [],
-    recentMinidumps: [],
-    assessmentHints: ["watchdog hint"],
-    errors: []
-  })
-}));
-
-import { defaultSettings } from "../src/main/constants";
-import { getAuditLogPath, initAuditLog, logAuditEvent, shutdownAuditLog } from "../src/main/audit-log";
-import { startDebugServer, stopDebugServer } from "../src/main/debug-server";
-import { ensureItemLog, initItemLogs, shutdownItemLogs } from "../src/main/item-log";
-import { configureLogger, getLogFilePath, logger } from "../src/main/logger";
-import { ensurePackageLog, initPackageLogs, shutdownPackageLogs } from "../src/main/package-log";
-import { getRenameLogPath, initRenameLog, logRenameEvent, shutdownRenameLog } from "../src/main/rename-log";
-import { getSessionLogPath, initSessionLog, shutdownSessionLog } from "../src/main/session-log";
-import { createStoragePaths, saveHistory, saveSettings } from "../src/main/storage";
-import { getTraceConfigPath, getTraceLogPath, initTraceLog, logTraceEvent, setTraceEnabled, shutdownTraceLog } from "../src/main/trace-log";
-import { getDebridLinkApiKeyIds } from "../src/shared/debrid-link-keys";
-import type { DownloadManager } from "../src/main/download-manager";
-import type { UiSnapshot } from "../src/shared/types";
-
-const tempDirs: string[] = [];
-
-async function getFreePort(): Promise<number> {
-  const probe = http.createServer();
-  probe.listen(0, "127.0.0.1");
-  await once(probe, "listening");
-  const address = probe.address();
-  if (!address || typeof address === "string") {
-    throw new Error("port probe failed");
-  }
-  probe.close();
-  await once(probe, "close");
-  return address.port;
-}
-
-async function waitForReady(url: string): Promise<void> {
-  const deadline = Date.now() + 5000;
-  while (Date.now() < deadline) {
-    try {
-      const response = await fetch(url);
-      if (response.ok) {
-        return;
-      }
-    } catch {
-    }
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  }
-  throw new Error(`debug server not ready: ${url}`);
-}
-
-function buildSnapshot(baseDir: string): UiSnapshot {
-  const settings = {
-    ...defaultSettings(),
-    outputDir: path.join(baseDir, "downloads"),
-    extractDir: path.join(baseDir, "extract")
-  };
-
-  return {
-    settings,
-    session: {
-      version: 1,
-      packageOrder: ["pkg-1"],
-      packages: {
-        "pkg-1": {
-          id: "pkg-1",
-          name: "server-package",
-          outputDir: path.join(baseDir, "downloads", "server-package"),
-          extractDir: path.join(baseDir, "extract", "server-package"),
-          status: "downloading",
-          itemIds: ["item-1", "item-2"],
-          cancelled: false,
-          enabled: true,
-          priority: "normal",
-          postProcessLabel: "",
-          createdAt: Date.now() - 30_000,
-          updatedAt: Date.now()
-        }
-      },
-      items: {
-        "item-1": {
-          id: "item-1",
-          packageId: "pkg-1",
-          url: "https://hoster.example/file-1",
-          provider: "realdebrid",
-          providerLabel: "Real-Debrid",
-          status: "downloading",
-          retries: 1,
-          speedBps: 8 * 1024 * 1024,
-          downloadedBytes: 64 * 1024 * 1024,
-          totalBytes: 256 * 1024 * 1024,
-          progressPercent: 25,
-          fileName: "episode.part1.rar",
-          targetPath: path.join(baseDir, "downloads", "server-package", "episode.part1.rar"),
-          resumable: true,
-          attempts: 1,
-          lastError: "",
-          fullStatus: "Download läuft (Real-Debrid)",
-          createdAt: Date.now() - 30_000,
-          updatedAt: Date.now()
-        },
-        "item-2": {
-          id: "item-2",
-          packageId: "pkg-1",
-          url: "https://hoster.example/file-2",
-          provider: "realdebrid",
-          providerLabel: "Real-Debrid",
-          status: "failed",
-          retries: 3,
-          speedBps: 0,
-          downloadedBytes: 0,
-          totalBytes: null,
-          progressPercent: 0,
-          fileName: "episode.part2.rar",
-          targetPath: path.join(baseDir, "downloads", "server-package", "episode.part2.rar"),
-          resumable: false,
-          attempts: 3,
-          lastError: "hoster unavailable",
-          fullStatus: "Fehler: hoster unavailable",
-          createdAt: Date.now() - 30_000,
-          updatedAt: Date.now()
-        }
-      },
-      runStartedAt: Date.now() - 30_000,
-      totalDownloadedBytes: 64 * 1024 * 1024,
-      summaryText: "",
-      reconnectUntil: 0,
-      reconnectReason: "",
-      paused: false,
-      running: true,
-      updatedAt: Date.now()
-    },
-    summary: null,
-    stats: {
-      totalDownloaded: 64 * 1024 * 1024,
-      totalDownloadedAllTime: 128 * 1024 * 1024,
-      totalFilesSession: 0,
-      totalFilesAllTime: 0,
-      totalPackages: 1,
-      sessionStartedAt: Date.now() - 30_000,
-      appSessionStartedAt: Date.now() - 60_000,
-      sessionRuntimeMs: 60_000,
-      totalRuntimeMs: 3 * 60_000,
-      runtimeMeasuredAt: Date.now()
-    },
-    speedText: "8.0 MB/s",
-    etaText: "ETA: 00:25",
-    canStart: false,
-    canStop: true,
-    canPause: true,
-    clipboardActive: false,
-    reconnectSeconds: 0,
-    packageSpeedBps: {
-      "pkg-1": 8 * 1024 * 1024
-    }
-  };
-}
-
-async function createFixture() {
-  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-debug-"));
-  tempDirs.push(baseDir);
-  const token = "debug-secret";
-  const port = await getFreePort();
-  const snapshot = buildSnapshot(baseDir);
-  const storagePaths = createStoragePaths(baseDir);
-
-  fs.writeFileSync(path.join(baseDir, "debug_token.txt"), token, "utf8");
-  fs.writeFileSync(path.join(baseDir, "debug_port.txt"), String(port), "utf8");
-  fs.writeFileSync(path.join(baseDir, "debug_host.txt"), "0.0.0.0", "utf8");
-  const debridLinkApiKeys = "key-a\nkey-b";
-  const debridLinkKeyIds = getDebridLinkApiKeyIds(debridLinkApiKeys);
-
-  saveSettings(storagePaths, {
-    ...snapshot.settings,
-    token: "rd-secret-token",
-    realDebridUseWebLogin: true,
-    debridLinkApiKeys,
-    debridLinkDisabledKeyIds: debridLinkKeyIds[1] ? [debridLinkKeyIds[1]] : [],
-    totalDownloadedAllTime: 128 * 1024 * 1024,
-    totalCompletedFilesAllTime: 12,
-    totalRuntimeAllTimeMs: 5 * 60_000
-  });
-  saveHistory(storagePaths, [
-    {
-      id: "hist-1",
-      name: "server-package",
-      totalBytes: 123,
-      downloadedBytes: 123,
-      fileCount: 2,
-      provider: "realdebrid",
-      completedAt: Date.now() - 5_000,
-      durationSeconds: 42,
-      status: "completed",
-      outputDir: path.join(baseDir, "downloads", "server-package"),
-      urls: ["https://hoster.example/file-1"]
-    }
-  ]);
-
-  configureLogger(baseDir);
-  fs.writeFileSync(getLogFilePath(), "2026-03-09T00:00:00.000Z [INFO] MAIN-LINE\n", "utf8");
-  initAuditLog(baseDir);
-  const auditLogPath = getAuditLogPath();
-  if (!auditLogPath) {
-    throw new Error("audit log path missing");
-  }
-  logAuditEvent("INFO", "AUDIT-LINE", { scope: "settings" });
-
-  initRenameLog(baseDir);
-  logRenameEvent("INFO", "RENAME-LINE", { stage: "auto-rename", sourcePath: "C:\\extract\\old.mkv" });
-
-  initTraceLog(baseDir);
-  setTraceEnabled(true, "test-fixture");
-  logTraceEvent("INFO", "support", "TRACE-EVENT", { scope: "fixture" });
-
-  initSessionLog(baseDir);
-  const sessionLogPath = getSessionLogPath();
-  if (!sessionLogPath) {
-    throw new Error("session log path missing");
-  }
-  fs.appendFileSync(sessionLogPath, "2026-03-09T00:00:01.000Z [INFO] SESSION-LINE\n", "utf8");
-  logger.info("TRACE-MAIN-LINE");
-
-  initPackageLogs(baseDir);
-  initItemLogs(baseDir);
-  const packageLogPath = ensurePackageLog({
-    packageId: "pkg-1",
-    name: "server-package",
-    outputDir: snapshot.session.packages["pkg-1"]!.outputDir,
-    extractDir: snapshot.session.packages["pkg-1"]!.extractDir
-  });
-  if (!packageLogPath) {
-    throw new Error("package log path missing");
-  }
-  fs.appendFileSync(packageLogPath, "2026-03-09T00:00:02.000Z [INFO] PACKAGE-LINE\n", "utf8");
-  const itemLogPath = ensureItemLog({
-    itemId: "item-2",
-    packageId: "pkg-1",
-    packageName: "server-package",
-    fileName: "episode.part2.rar",
-    targetPath: snapshot.session.items["item-2"]!.targetPath
-  });
-  if (!itemLogPath) {
-    throw new Error("item log path missing");
-  }
-  fs.appendFileSync(itemLogPath, "2026-03-09T00:00:03.000Z [ERROR] ITEM-LINE\n", "utf8");
-
-  const manager = {
-    getSnapshot: () => snapshot,
-    getPackageLogPath: (packageId: string) => packageId === "pkg-1" ? packageLogPath : null,
-    getItemLogPath: (itemId: string) => itemId === "item-2" ? itemLogPath : null
-  } as unknown as DownloadManager;
-
-  startDebugServer(manager, baseDir);
-  const baseUrl = `http://127.0.0.1:${port}`;
-  await waitForReady(`${baseUrl}/health?token=${token}`);
-  await new Promise((resolve) => setTimeout(resolve, 300));
-
-  return {
-    baseUrl,
-    token,
-    baseDir
-  };
-}
-
-afterEach(() => {
-  stopDebugServer();
-  shutdownSessionLog();
-  shutdownPackageLogs();
-  shutdownItemLogs();
-  shutdownRenameLog();
-  shutdownTraceLog();
-  shutdownAuditLog();
-  while (tempDirs.length > 0) {
-    const dir = tempDirs.pop();
-    if (!dir) {
-      continue;
-    }
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-});
-
-describe("debug-server", () => {
-  it("serves diagnostics with main, session, and package log tails", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/diagnostics?token=${fixture.token}&package=server-package&lines=20`);
-    expect(response.ok).toBe(true);
-    const payload = await response.json() as Record<string, any>;
-
-    expect(payload.meta?.appVersion).toBeTruthy();
-    expect(payload.meta?.debugServer?.host).toBe("0.0.0.0");
-    expect(payload.status?.running).toBe(true);
-    expect(payload.host?.platform).toBe("win32");
-    expect(payload.host?.recentKernelPower?.[0]?.id).toBe(41);
-    expect(payload.selectedPackage?.name).toBe("server-package");
-    expect((payload.logs?.main?.lines || []).join("\n")).toContain("MAIN-LINE");
-    expect((payload.logs?.audit?.lines || []).join("\n")).toContain("AUDIT-LINE");
-    expect((payload.logs?.rename?.lines || []).join("\n")).toContain("RENAME-LINE");
-    expect((payload.logs?.trace?.lines || []).join("\n")).toContain("TRACE-EVENT");
-    expect((payload.logs?.session?.lines || []).join("\n")).toContain("SESSION-LINE");
-    expect((payload.logs?.package?.lines || []).join("\n")).toContain("PACKAGE-LINE");
-    expect(payload.accounts?.realDebrid?.configured).toBe(true);
-    expect(payload.history?.total).toBe(1);
-  });
-
-  it("writes a machine-readable AI support manifest into the runtime folder", async () => {
-    const fixture = await createFixture();
-    const manifestPath = path.join(fixture.baseDir, "debug_ai_manifest.json");
-    expect(fs.existsSync(manifestPath)).toBe(true);
-
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as Record<string, any>;
-    expect(manifest.appVersion).toBeTruthy();
-    expect(manifest.debugServer?.port).toBeGreaterThan(0);
-    expect(manifest.debugServer?.remoteBaseUrlTemplate).toContain("<SERVER_IP_OR_DNS>");
-    expect(manifest.quickstart?.[1]).toContain("server IP");
-    expect(manifest.setupCheckEndpoint).toBe("/debug/setup");
-    expect(manifest.selfCheckEndpoint).toBe("/self-check");
-    expect(manifest.runtimeFiles?.tokenFile).toContain("debug_token.txt");
-    expect(manifest.endpoints?.some((entry: Record<string, any>) => entry.path === "/diagnostics")).toBe(true);
-    expect(JSON.stringify(manifest)).not.toContain(fixture.token);
-
-    const metaResponse = await fetch(`${fixture.baseUrl}/meta?token=${fixture.token}`);
-    expect(metaResponse.ok).toBe(true);
-    const metaPayload = await metaResponse.json() as Record<string, any>;
-    expect(metaPayload.supportFiles?.aiManifest).toBe(manifestPath);
-    expect(metaPayload.supportFiles?.traceConfig).toBe(getTraceConfigPath());
-    expect(metaPayload.supportFiles?.traceLog).toBe(getTraceLogPath());
-    expect(metaPayload.logPaths?.rename).toBe(getRenameLogPath());
-    expect(metaPayload.supportChecks?.setup).toBe("/debug/setup");
-    expect(metaPayload.supportChecks?.selfCheck).toBe("/self-check");
-  });
-
-  it("serves a debug setup check with trace expiry details", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/debug/setup?token=${fixture.token}`);
-    expect(response.ok).toBe(true);
-    const payload = await response.json() as Record<string, any>;
-
-    expect(payload.enabled).toBe(true);
-    expect(payload.status).toBe("ok");
-    expect(payload.runtimeBaseDir).toBe(fixture.baseDir);
-    expect(payload.host).toBe("0.0.0.0");
-    expect(payload.localOnly).toBe(false);
-    expect(payload.tokenConfigured).toBe(true);
-    expect(payload.aiManifestPresent).toBe(true);
-    expect(payload.traceEnabled).toBe(true);
-    expect(payload.traceAutoDisableAt).toBeTruthy();
-    expect(payload.diskSpace?.runtime?.freeBytes).toBeGreaterThan(0);
-    expect(payload.diskSpace?.output?.freeBytes).toBeGreaterThan(0);
-    expect(payload.diskSpace?.extract?.freeBytes).toBeGreaterThan(0);
-    expect(payload.logSummary?.totalBytes).toBeGreaterThan(0);
-    expect(payload.logSummary?.rename?.bytes).toBeGreaterThan(0);
-    expect(payload.logSummary?.packageLogs?.fileCount).toBe(1);
-    expect(payload.logSummary?.itemLogs?.fileCount).toBe(1);
-    expect(payload.supportBundle?.estimatedBytes).toBeGreaterThan(0);
-    expect(payload.remoteUrlTemplates?.health).toContain("<SERVER_IP_OR_DNS>");
-    expect(Array.isArray(payload.notes)).toBe(true);
-  });
-
-  it("serves the self-check alias", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/self-check?token=${fixture.token}`);
-    expect(response.ok).toBe(true);
-    const payload = await response.json() as Record<string, any>;
-    expect(payload.status).toBe("ok");
-    expect(payload.supportBundle?.estimatedEntries).toBeGreaterThan(0);
-  });
-
-  it("writes the client IP into the debug trace log", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/health?token=${fixture.token}`, {
-      headers: {
-        "X-Forwarded-For": "159.195.63.46"
-      }
-    });
-    expect(response.ok).toBe(true);
-
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    const traceLogPath = getTraceLogPath();
-    expect(traceLogPath).toBeTruthy();
-    const traceText = fs.readFileSync(traceLogPath!, "utf8");
-    expect(traceText).toContain("clientIp=159.195.63.46");
-  });
-
-  it("serves package details and package log by package query", async () => {
-    const fixture = await createFixture();
-
-    const packagesResponse = await fetch(`${fixture.baseUrl}/packages?token=${fixture.token}&package=server&includeItems=1`);
-    expect(packagesResponse.ok).toBe(true);
-    const packagesPayload = await packagesResponse.json() as Record<string, any>;
-    expect(packagesPayload.count).toBe(1);
-    expect(packagesPayload.packages?.[0]?.items?.length).toBe(2);
-
-    const logResponse = await fetch(`${fixture.baseUrl}/logs/package?token=${fixture.token}&package=server-package&lines=20`);
-    expect(logResponse.ok).toBe(true);
-    const logPayload = await logResponse.json() as Record<string, any>;
-    expect(logPayload.package?.name).toBe("server-package");
-    expect((logPayload.lines || []).join("\n")).toContain("PACKAGE-LINE");
-  });
-
-  it("serves item log by item query", async () => {
-    const fixture = await createFixture();
-
-    const response = await fetch(`${fixture.baseUrl}/logs/item?token=${fixture.token}&item=episode.part2.rar&lines=20`);
-    expect(response.ok).toBe(true);
-    const payload = await response.json() as Record<string, any>;
-    expect(payload.item?.id).toBe("item-2");
-    expect(payload.item?.fileName).toBe("episode.part2.rar");
-    expect((payload.lines || []).join("\n")).toContain("ITEM-LINE");
-  });
-
-  it("serves host diagnostics separately", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/host/diagnostics?token=${fixture.token}`);
-    expect(response.ok).toBe(true);
-    const payload = await response.json() as Record<string, any>;
-    expect(payload.platform).toBe("win32");
-    expect(payload.crashControl?.crashDumpEnabled).toBe(3);
-    expect(payload.assessmentHints?.[0]).toContain("watchdog");
-  });
-
-  it("serves audit log, settings, accounts, stats, and history", async () => {
-    const fixture = await createFixture();
-
-    const auditResponse = await fetch(`${fixture.baseUrl}/logs/audit?token=${fixture.token}&lines=20`);
-    expect(auditResponse.ok).toBe(true);
-    const auditPayload = await auditResponse.json() as Record<string, any>;
-    expect((auditPayload.lines || []).join("\n")).toContain("AUDIT-LINE");
-
-    const renameResponse = await fetch(`${fixture.baseUrl}/logs/rename?token=${fixture.token}&lines=20`);
-    expect(renameResponse.ok).toBe(true);
-    const renamePayload = await renameResponse.json() as Record<string, any>;
-    expect((renamePayload.lines || []).join("\n")).toContain("RENAME-LINE");
-
-    const traceResponse = await fetch(`${fixture.baseUrl}/logs/trace?token=${fixture.token}&lines=50`);
-    expect(traceResponse.ok).toBe(true);
-    const tracePayload = await traceResponse.json() as Record<string, any>;
-    expect((tracePayload.lines || []).join("\n")).toContain("TRACE-EVENT");
-    expect((tracePayload.lines || []).join("\n")).toContain("TRACE-MAIN-LINE");
-
-    const traceConfigResponse = await fetch(`${fixture.baseUrl}/trace/config?token=${fixture.token}&enable=0&note=test`);
-    expect(traceConfigResponse.ok).toBe(true);
-    const traceConfigPayload = await traceConfigResponse.json() as Record<string, any>;
-    expect(traceConfigPayload.config?.enabled).toBe(false);
-
-    const settingsResponse = await fetch(`${fixture.baseUrl}/settings?token=${fixture.token}`);
-    expect(settingsResponse.ok).toBe(true);
-    const settingsPayload = await settingsResponse.json() as Record<string, any>;
-    expect(settingsPayload.accounts?.realDebrid?.configured).toBe(true);
-    expect(settingsPayload.extraction?.archivePasswordCount).toBe(0);
-    expect(JSON.stringify(settingsPayload)).not.toContain("rd-secret-token");
-    expect(JSON.stringify(settingsPayload)).not.toContain("key-a");
-    expect(JSON.stringify(settingsPayload)).not.toContain("key-b");
-
-    const accountsResponse = await fetch(`${fixture.baseUrl}/accounts?token=${fixture.token}`);
-    expect(accountsResponse.ok).toBe(true);
-    const accountsPayload = await accountsResponse.json() as Record<string, any>;
-    expect(accountsPayload.debridLink?.keyCount).toBe(2);
-    expect(accountsPayload.debridLink?.disabledKeyCount).toBe(1);
-
-    const statsResponse = await fetch(`${fixture.baseUrl}/stats?token=${fixture.token}`);
-    expect(statsResponse.ok).toBe(true);
-    const statsPayload = await statsResponse.json() as Record<string, any>;
-    expect(statsPayload.session?.totalDownloaded).toBeGreaterThan(0);
-    expect(statsPayload.allTime?.totalDownloadedAllTime).toBeGreaterThan(0);
-
-    const historyResponse = await fetch(`${fixture.baseUrl}/history?token=${fixture.token}&limit=10`);
-    expect(historyResponse.ok).toBe(true);
-    const historyPayload = await historyResponse.json() as Record<string, any>;
-    expect(historyPayload.total).toBe(1);
-    expect(historyPayload.entries?.[0]?.name).toBe("server-package");
-    expect(historyPayload.entries?.[0]?.urlCount).toBe(1);
-  });
-
-  it("downloads a support bundle zip", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/support/bundle?token=${fixture.token}`);
-    expect(response.ok).toBe(true);
-    expect(response.headers.get("content-type")).toContain("application/zip");
-
-    const buffer = Buffer.from(await response.arrayBuffer());
-    const zip = new AdmZip(buffer);
-    const entries = zip.getEntries().map((entry) => entry.entryName);
-    expect(entries).toContain("overview/settings.json");
-    expect(entries).toContain("overview/accounts.json");
-    expect(entries).toContain("overview/debug-setup.json");
-    expect(entries).toContain("overview/self-check.json");
-    expect(entries).toContain("overview/trace-config.json");
-    expect(entries).toContain("logs/audit.log");
-    expect(entries).toContain("logs/rename.log");
-    expect(entries).toContain("logs/trace.log");
-    expect(entries).toContain("runtime/debug_ai_manifest.json");
-    expect(entries).not.toContain("runtime/debug_token.txt");
-  });
-
-  it("rejects unauthenticated requests", async () => {
-    const fixture = await createFixture();
-    const response = await fetch(`${fixture.baseUrl}/status`);
-    expect(response.status).toBe(401);
-  });
-});

tests/desktop-rename-log.test.ts

@@ -1,124 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  getDesktopRenameLogPath,
-  initDesktopRenameLog,
-  logDesktopRename,
-  shutdownDesktopRenameLog,
-  verifyRename
-} from "../src/main/desktop-rename-log";
-
-const createdTmpDirs: string[] = [];
-
-function tmpDesktop(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-rename-log-"));
-  createdTmpDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  shutdownDesktopRenameLog();
-  for (const dir of createdTmpDirs) {
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  createdTmpDirs.length = 0;
-});
-
-describe("desktop-rename-log", () => {
-  it("creates the Downloader-Log folder + session file on init and appends formatted lines", () => {
-    const desktop = tmpDesktop();
-    initDesktopRenameLog(desktop);
-
-    const logPath = getDesktopRenameLogPath();
-    expect(logPath).toBeTruthy();
-    expect(path.dirname(logPath as string).endsWith("Downloader-Log")).toBe(true);
-    expect(fs.existsSync(logPath as string)).toBe(true);
-
-    logDesktopRename("INFO", "Test-Rename", { source: "a.mkv", requested: "b.mkv" });
-    const content = fs.readFileSync(logPath as string, "utf8");
-    expect(content).toContain("Rename-Session gestartet");
-    expect(content).toContain("Test-Rename");
-    expect(content).toContain("source=a.mkv");
-    expect(content).toContain("requested=b.mkv");
-    expect(content).toMatch(/\[INFO\]/);
-  });
-
-  it("self-heals: recreates the whole Downloader-Log FOLDER and file if it is deleted mid-session", () => {
-    const desktop = tmpDesktop();
-    initDesktopRenameLog(desktop);
-    const logPath = getDesktopRenameLogPath() as string;
-    logDesktopRename("INFO", "ZeileA");
-
-    fs.rmSync(path.join(desktop, "Downloader-Log"), { recursive: true, force: true });
-    expect(fs.existsSync(logPath)).toBe(false);
-
-    logDesktopRename("INFO", "ZeileB");
-    expect(fs.existsSync(path.join(desktop, "Downloader-Log"))).toBe(true);
-    expect(fs.existsSync(logPath)).toBe(true);
-
-    const content = fs.readFileSync(logPath, "utf8");
-    expect(content).toContain("Rename-Session gestartet");
-    expect(content).toContain("ZeileB");
-  });
-
-  it("is a silent no-op when initialized without a desktop path (never throws)", () => {
-    initDesktopRenameLog("");
-    expect(getDesktopRenameLogPath()).toBeNull();
-    expect(() => logDesktopRename("INFO", "egal")).not.toThrow();
-  });
-
-  it("verifyRename: ok when the target exists under the exact name and the source is gone", () => {
-    const dir = tmpDesktop();
-    const source = path.join(dir, "scn-xyz.part1.rar");
-    const target = path.join(dir, "Movie.2024.German.1080p.part1.rar");
-    fs.writeFileSync(target, "data");
-
-    const v = verifyRename(source, target);
-    expect(v.ok).toBe(true);
-    expect(v.level).toBe("INFO");
-    expect(v.targetExists).toBe(true);
-    expect(v.onDiskName).toBe("Movie.2024.German.1080p.part1.rar");
-    expect(v.nameMatches).toBe(true);
-    expect(v.sourceGone).toBe(true);
-    expect(v.targetSize).toBe(4);
-  });
-
-  it("verifyRename: FAILS when the target is missing although rename reported success", () => {
-    const dir = tmpDesktop();
-    const v = verifyRename(path.join(dir, "src.rar"), path.join(dir, "never-created.rar"));
-    expect(v.ok).toBe(false);
-    expect(v.level).toBe("ERROR");
-    expect(v.targetExists).toBe(false);
-    expect(v.reason).toMatch(/nicht gefunden/i);
-  });
-
-  it("verifyRename: FAILS (half-done move) when the source still exists next to the target", () => {
-    const dir = tmpDesktop();
-    const source = path.join(dir, "src.rar");
-    const target = path.join(dir, "dst.rar");
-    fs.writeFileSync(source, "x");
-    fs.writeFileSync(target, "x");
-
-    const v = verifyRename(source, target);
-    expect(v.ok).toBe(false);
-    expect(v.level).toBe("ERROR");
-    expect(v.sourceGone).toBe(false);
-    expect(v.reason).toMatch(/Quelldatei existiert noch/i);
-  });
-
-  it("verifyRename: an in-place rename (same path) is ok and does not flag a lingering source", () => {
-    const dir = tmpDesktop();
-    const p = path.join(dir, "file.mkv");
-    fs.writeFileSync(p, "x");
-
-    const v = verifyRename(p, p);
-    expect(v.ok).toBe(true);
-    expect(v.targetExists).toBe(true);
-    expect(v.nameMatches).toBe(true);
-  });
-});

tests/download-completion.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { planDownloadCompletion, validateDownloadedFileCompletion } from "../src/main/download-completion";
-
-describe("download-completion", () => {
-  describe("planDownloadCompletion", () => {
-    it("uses content-length when present", () => {
-      const plan = planDownloadCompletion({
-        existingBytes: 0, responseStatus: 200, contentLength: 1000,
-        totalFromRange: null, knownTotal: null, correctedTotal: null
-      });
-      expect(plan.source).toBe("content-length");
-      expect(plan.expectedTotal).toBe(1000);
-    });
-    it("falls back to stream-end when no size info is available", () => {
-      const plan = planDownloadCompletion({
-        existingBytes: 0, responseStatus: 200, contentLength: 0,
-        totalFromRange: null, knownTotal: null, correctedTotal: null
-      });
-      expect(plan.source).toBe("stream-end");
-      expect(plan.expectedTotal).toBeNull();
-    });
-  });
-
-  describe("validateDownloadedFileCompletion", () => {
-    const streamEnd = { expectedTotal: null, source: "stream-end" as const, canFinishEarly: false };
-    const contentLength = (n: number) => ({ expectedTotal: n, source: "content-length" as const, canFinishEarly: true });
-    const providerMeta = (n: number) => ({ expectedTotal: n, source: "provider-metadata" as const, canFinishEarly: false });
-
-    it("rejects a 0-byte stream-end download (H3)", () => {
-      const result = validateDownloadedFileCompletion({ actualBytes: 0, plan: streamEnd });
-      expect(result.ok).toBe(false);
-      expect(result.error).toContain("download_underflow");
-    });
-
-    it("accepts a non-empty stream-end download", () => {
-      const result = validateDownloadedFileCompletion({ actualBytes: 5_000_000, plan: streamEnd });
-      expect(result.ok).toBe(true);
-      expect(result.totalBytes).toBe(5_000_000);
-    });
-
-    it("rejects an underflowing content-length download", () => {
-      const result = validateDownloadedFileCompletion({ actualBytes: 400, plan: contentLength(1000), toleranceBytes: 0 });
-      expect(result.ok).toBe(false);
-    });
-
-    it("accepts a complete content-length download", () => {
-      const result = validateDownloadedFileCompletion({ actualBytes: 1000, plan: contentLength(1000) });
-      expect(result.ok).toBe(true);
-    });
-
-    it("rejects a 0-byte download even with known provider size", () => {
-      const result = validateDownloadedFileCompletion({ actualBytes: 0, plan: providerMeta(2000) });
-      expect(result.ok).toBe(false);
-    });
-
-    it("accepts provider-metadata download and flags size mismatch", () => {
-      const result = validateDownloadedFileCompletion({ actualBytes: 1900, plan: providerMeta(2000), toleranceBytes: 0 });
-      expect(result.ok).toBe(false);
-    });
-  });
-});

tests/error-ring.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createErrorRing } from "../src/main/error-ring";
-
-describe("createErrorRing", () => {
-  it("keeps entries in insertion order", () => {
-    const ring = createErrorRing(10);
-    ring.push({ ts: "t1", level: "ERROR", message: "a" });
-    ring.push({ ts: "t2", level: "WARN", message: "b" });
-    expect(ring.snapshot().map((e) => e.message)).toEqual(["a", "b"]);
-    expect(ring.size()).toBe(2);
-  });
-
-  it("caps at capacity by dropping the oldest", () => {
-    const ring = createErrorRing(3);
-    for (const m of ["a", "b", "c", "d", "e"]) {
-      ring.push({ ts: m, level: "ERROR", message: m });
-    }
-    expect(ring.snapshot().map((e) => e.message)).toEqual(["c", "d", "e"]);
-    expect(ring.size()).toBe(3);
-  });
-
-  it("snapshot returns a copy, not the live buffer", () => {
-    const ring = createErrorRing(5);
-    ring.push({ ts: "t", level: "WARN", message: "x" });
-    const snap = ring.snapshot();
-    snap.push({ ts: "t2", level: "ERROR", message: "injected" });
-    expect(ring.snapshot().map((e) => e.message)).toEqual(["x"]);
-  });
-
-  it("clear empties the ring", () => {
-    const ring = createErrorRing(5);
-    ring.push({ ts: "t", level: "ERROR", message: "x" });
-    ring.clear();
-    expect(ring.snapshot()).toEqual([]);
-    expect(ring.size()).toBe(0);
-  });
-
-  it("coerces a non-positive capacity to at least 1", () => {
-    const ring = createErrorRing(0);
-    ring.push({ ts: "t1", level: "ERROR", message: "a" });
-    ring.push({ ts: "t2", level: "ERROR", message: "b" });
-    expect(ring.snapshot().map((e) => e.message)).toEqual(["b"]);
-  });
-});

tests/extractor-jvm.test.ts

@@ -74,6 +74,7 @@ describe.skipIf(!hasJavaRuntime() || !hasJvmExtractorRuntime())("extractor jvm b
     const targetDir = path.join(root, "out");
     fs.mkdirSync(packageDir, { recursive: true });
 
+    // Create a ZIP with some content to trigger progress
     const zipPath = path.join(packageDir, "progress-test.zip");
     const zip = new AdmZip();
     zip.addFile("file1.txt", Buffer.from("Hello World ".repeat(100)));
@@ -107,16 +108,20 @@ describe.skipIf(!hasJavaRuntime() || !hasJvmExtractorRuntime())("extractor jvm b
     expect(result.extracted).toBe(1);
     expect(result.failed).toBe(0);
 
+    // Should have at least preparing, extracting, and done phases
     const phases = new Set(progressUpdates.map((u) => u.phase));
     expect(phases.has("preparing")).toBe(true);
     expect(phases.has("extracting")).toBe(true);
 
+    // Extracting phase should include the archive name
     const extracting = progressUpdates.filter((u) => u.phase === "extracting" && u.archiveName === "progress-test.zip");
     expect(extracting.length).toBeGreaterThan(0);
 
+    // Should end at 100%
     const lastExtracting = extracting[extracting.length - 1];
     expect(lastExtracting.archivePercent).toBe(100);
 
+    // Files should exist
     expect(fs.existsSync(path.join(targetDir, "file1.txt"))).toBe(true);
     expect(fs.existsSync(path.join(targetDir, "file2.txt"))).toBe(true);
   });
@@ -130,6 +135,7 @@ describe.skipIf(!hasJavaRuntime() || !hasJvmExtractorRuntime())("extractor jvm b
     const targetDir = path.join(root, "out");
     fs.mkdirSync(packageDir, { recursive: true });
 
+    // Create two separate ZIP archives
     const zip1 = new AdmZip();
     zip1.addFile("episode01.txt", Buffer.from("ep1 content"));
     zip1.writeZip(path.join(packageDir, "archive1.zip"));
@@ -156,8 +162,10 @@ describe.skipIf(!hasJavaRuntime() || !hasJvmExtractorRuntime())("extractor jvm b
 
     expect(result.extracted).toBe(2);
     expect(result.failed).toBe(0);
+    // Both archive names should have appeared in progress
     expect(archiveNames.has("archive1.zip")).toBe(true);
     expect(archiveNames.has("archive2.zip")).toBe(true);
+    // Both files extracted
     expect(fs.existsSync(path.join(targetDir, "episode01.txt"))).toBe(true);
     expect(fs.existsSync(path.join(targetDir, "episode02.txt"))).toBe(true);
   });

tests/extractor.test.ts

@@ -12,7 +12,6 @@ import {
   archiveFilenamePasswords,
   detectArchiveSignature,
   classifyExtractionError,
-  shouldSerialRetryParallelFailures,
   findArchiveCandidates,
   orderExtractorCandidatesForArchive,
   resolveExtractorBackendModeForArchive,
@@ -865,6 +864,7 @@ describe("extractor", () => {
       const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-sig-"));
       tempDirs.push(root);
       const filePath = path.join(root, "test.rar");
+      // RAR5 signature: 52 61 72 21 1A 07
       fs.writeFileSync(filePath, Buffer.from("526172211a0700", "hex"));
       const sig = await detectArchiveSignature(filePath);
       expect(sig).toBe("rar");
@@ -941,6 +941,7 @@ describe("extractor", () => {
       const candidates = await findArchiveCandidates(packageDir);
       const names = candidates.map((c) => path.basename(c));
       expect(names).toContain("movie.001");
+      // .002 should NOT be in candidates (only .001 is the entry point)
       expect(names).not.toContain("movie.002");
     });
 
@@ -955,6 +956,7 @@ describe("extractor", () => {
 
       const candidates = await findArchiveCandidates(packageDir);
       const names = candidates.map((c) => path.basename(c));
+      // .zip.001 should appear once from zipSplit detection, not duplicated by genericSplit
       expect(names.filter((n) => n === "movie.zip.001")).toHaveLength(1);
     });
 
@@ -1046,19 +1048,6 @@ describe("extractor", () => {
     });
   });
 
-  describe("shouldSerialRetryParallelFailures", () => {
-    it("keeps serial recovery enabled after mixed parallel results", () => {
-      expect(shouldSerialRetryParallelFailures(1, ["wrong_password"])).toBe(true);
-      expect(shouldSerialRetryParallelFailures(2, ["missing_parts"])).toBe(true);
-    });
-
-    it("only retries a total parallel wipe-out for contention-like failures", () => {
-      expect(shouldSerialRetryParallelFailures(0, ["crc_error", "wrong_password", "unknown"])).toBe(true);
-      expect(shouldSerialRetryParallelFailures(0, ["missing_parts"])).toBe(false);
-      expect(shouldSerialRetryParallelFailures(0, ["unsupported_format", "crc_error"])).toBe(false);
-    });
-  });
-
   describe("password discovery", () => {
     it("reports per-archive failures through onArchiveFailure", async () => {
       const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-extract-failure-"));
@@ -1097,6 +1086,7 @@ describe("extractor", () => {
       const targetDir = path.join(root, "out");
       fs.mkdirSync(packageDir, { recursive: true });
 
+      // Create 3 zip archives
       for (const name of ["ep01.zip", "ep02.zip", "ep03.zip"]) {
         const zip = new AdmZip();
         zip.addFile(`${name}.txt`, Buffer.from(name));
@@ -1123,6 +1113,7 @@ describe("extractor", () => {
 
       expect(result.extracted).toBe(3);
       expect(result.failed).toBe(0);
+      // First archive should be ep01 (natural order, extracted serially for discovery)
       expect(seenOrder[0]).toBe("ep01.zip");
     });
 
@@ -1139,6 +1130,7 @@ describe("extractor", () => {
         zip.writeZip(path.join(packageDir, name));
       }
 
+      // No passwordList → only empty string → length=1 → no discovery phase
       const result = await extractPackageArchives({
         packageDir,
         targetDir,

tests/fs-error.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { classifyDiskError } from "../src/main/fs-error";
-import { isDebugFlagEnabled } from "../src/main/logger";
-
-describe("classifyDiskError", () => {
-  it("maps ENOSPC from an error code to a disk-full reason", () => {
-    const err = Object.assign(new Error("write ENOSPC"), { code: "ENOSPC" });
-    expect(classifyDiskError(err)).toMatch(/Festplatte voll/);
-  });
-
-  it("maps EACCES from a code to a permission reason", () => {
-    const err = Object.assign(new Error("nope"), { code: "EACCES" });
-    expect(classifyDiskError(err)).toMatch(/Zugriff verweigert/);
-  });
-
-  it("lower-case codes are normalized", () => {
-    const err = Object.assign(new Error("x"), { code: "enospc" });
-    expect(classifyDiskError(err)).toMatch(/ENOSPC/);
-  });
-
-  it("falls back to scanning the message text when no code is present", () => {
-    expect(classifyDiskError(new Error("operation failed: ENOSPC on volume"))).toMatch(/Festplatte voll/);
-  });
-
-  it("handles a plain string error", () => {
-    expect(classifyDiskError("EROFS: read-only file system")).toMatch(/schreibgeschützt/);
-  });
-
-  it("returns null for an unrelated error", () => {
-    expect(classifyDiskError(new Error("write_drain_timeout"))).toBeNull();
-    expect(classifyDiskError(new Error("premature close"))).toBeNull();
-    expect(classifyDiskError(null)).toBeNull();
-    expect(classifyDiskError(undefined)).toBeNull();
-  });
-});
-
-describe("isDebugFlagEnabled", () => {
-  it("is true for affirmative values", () => {
-    for (const v of ["1", "true", "TRUE", "yes", "on", " on "]) {
-      expect(isDebugFlagEnabled(v)).toBe(true);
-    }
-  });
-
-  it("is false for empty/negative/garbage values", () => {
-    for (const v of [undefined, "", "0", "false", "off", "no", "maybe"]) {
-      expect(isDebugFlagEnabled(v)).toBe(false);
-    }
-  });
-});

tests/german-audio-integration.test.ts

@@ -1,150 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-// Mock only processVideoFile (the ffmpeg boundary); keep the real pure helpers
-// (stripDualLangMarker / hasDualLangMarker / isRemuxableVideoFile) so the
-// download-manager's selection + .DL.-rename wiring is exercised for real.
-vi.mock("../src/main/video-processor", async (importActual) => {
-  const actual = await importActual<typeof import("../src/main/video-processor")>();
-  return { ...actual, processVideoFile: vi.fn(), resolveVideoTooling: vi.fn() };
-});
-
-import { DownloadManager } from "../src/main/download-manager";
-import { defaultSettings } from "../src/main/constants";
-import { createStoragePaths, emptySession } from "../src/main/storage";
-import { shutdownItemLogs } from "../src/main/item-log";
-import { shutdownPackageLogs } from "../src/main/package-log";
-import { shutdownRenameLog } from "../src/main/rename-log";
-import { processVideoFile, resolveVideoTooling, type VideoProcessResult } from "../src/main/video-processor";
-
-const mockedProcess = processVideoFile as unknown as ReturnType<typeof vi.fn>;
-const mockedTooling = resolveVideoTooling as unknown as ReturnType<typeof vi.fn>;
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  mockedProcess.mockReset();
-  mockedTooling.mockReset();
-  shutdownItemLogs();
-  shutdownPackageLogs();
-  shutdownRenameLog();
-  for (const dir of tempDirs.splice(0)) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-  }
-});
-
-function setup(keepGermanAudioOnly: boolean): { extractDir: string; manager: DownloadManager; pkg: any } {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-ga-"));
-  tempDirs.push(root);
-  const extractDir = path.join(root, "extract");
-  const stateDir = path.join(root, "state");
-  fs.mkdirSync(extractDir, { recursive: true });
-  fs.mkdirSync(stateDir, { recursive: true });
-  const manager = new DownloadManager(
-    {
-      ...defaultSettings(),
-      token: "rd-token",
-      keepGermanAudioOnly,
-      germanAudioMode: "tag",
-      autoRename4sf4sj: false,
-      outputDir: path.join(root, "out"),
-      extractDir,
-      mkvLibraryDir: path.join(stateDir, "_mkv")
-    },
-    emptySession(),
-    createStoragePaths(stateDir)
-  );
-  const pkg: any = {
-    id: "ga-pkg-1",
-    name: "Test.Show.S01.GERMAN.DL.720p",
-    outputDir: path.join(root, "out", "Test.Show"),
-    extractDir,
-    status: "completed",
-    itemIds: [],
-    cancelled: false,
-    enabled: true,
-    priority: "normal",
-    createdAt: 0,
-    updatedAt: 0
-  };
-  // Default: ffmpeg/ffprobe "available" so the step proceeds to the (mocked)
-  // processVideoFile. Tests that need the no-tool path override this.
-  mockedTooling.mockResolvedValue({ ffmpeg: "ffmpeg", ffprobe: "ffprobe" });
-  return { extractDir, manager, pkg };
-}
-
-const DL_MKV = "Show.S01E01.German.DL.720p.x264.mkv";
-const PLAIN_MKV = "Show.S01E02.German.1080p.x264.mkv";
-const SAMPLE_DL = "Show.sample.DL.mkv";
-const DL_AVI = "Show.S01E03.German.DL.avi";
-
-function stage(extractDir: string): void {
-  for (const f of [DL_MKV, PLAIN_MKV, SAMPLE_DL, DL_AVI]) {
-    fs.writeFileSync(path.join(extractDir, f), "x");
-  }
-}
-
-describe("keepGermanAudioOnly integration", () => {
-  it("processes only .DL. mkv/mp4 and strips .DL. after a successful remux", async () => {
-    const { extractDir, manager, pkg } = setup(true);
-    stage(extractDir);
-    mockedProcess.mockResolvedValue({ action: "remuxed", reason: "german-tag", totalAudioTracks: 2, keptTrackIndex: 0 } as VideoProcessResult);
-
-    const n = await (manager as any).keepGermanAudioOnlyImpl(extractDir, pkg);
-
-    expect(mockedProcess).toHaveBeenCalledTimes(1);
-    expect(mockedProcess.mock.calls[0][0]).toBe(path.join(extractDir, DL_MKV));
-    expect(n).toBe(1);
-
-    const files = fs.readdirSync(extractDir);
-    expect(files).toContain("Show.S01E01.German.720p.x264.mkv"); // .DL. stripped
-    expect(files).not.toContain(DL_MKV);
-    expect(files).toContain(PLAIN_MKV); // non-.DL. untouched
-    expect(files).toContain(SAMPLE_DL); // sample skipped
-    expect(files).toContain(DL_AVI); // avi not remuxable, skipped
-  });
-
-  it("does nothing when the setting is off", async () => {
-    const { extractDir, manager, pkg } = setup(false);
-    stage(extractDir);
-    const n = await (manager as any).keepGermanAudioOnlyImpl(extractDir, pkg);
-    expect(n).toBe(0);
-    expect(mockedProcess).not.toHaveBeenCalled();
-    expect(fs.readdirSync(extractDir)).toContain(DL_MKV); // untouched
-  });
-
-  it("leaves the file fully untouched (name included) when no German track is found", async () => {
-    const { extractDir, manager, pkg } = setup(true);
-    stage(extractDir);
-    mockedProcess.mockResolvedValue({ action: "skipped-no-german", reason: "no-german-track", totalAudioTracks: 2 } as VideoProcessResult);
-
-    await (manager as any).keepGermanAudioOnlyImpl(extractDir, pkg);
-
-    expect(mockedProcess).toHaveBeenCalledTimes(1);
-    expect(fs.readdirSync(extractDir)).toContain(DL_MKV); // NOT renamed -> stays visible as unprocessed
-  });
-
-  it("still strips .DL. for a single-audio file (no remux needed)", async () => {
-    const { extractDir, manager, pkg } = setup(true);
-    stage(extractDir);
-    mockedProcess.mockResolvedValue({ action: "kept-single", reason: "single-german", totalAudioTracks: 1, keptTrackIndex: 0 } as VideoProcessResult);
-
-    const n = await (manager as any).keepGermanAudioOnlyImpl(extractDir, pkg);
-
-    expect(n).toBe(0); // not counted as a remux
-    expect(fs.readdirSync(extractDir)).toContain("Show.S01E01.German.720p.x264.mkv");
-  });
-
-  it("skips up front (no processVideoFile calls) and leaves files untouched when ffmpeg is missing", async () => {
-    const { extractDir, manager, pkg } = setup(true);
-    stage(extractDir);
-    mockedTooling.mockResolvedValue(null); // ffmpeg/ffprobe not found
-
-    const n = await (manager as any).keepGermanAudioOnlyImpl(extractDir, pkg);
-
-    expect(n).toBe(0);
-    expect(mockedProcess).not.toHaveBeenCalled(); // bailed before touching any file
-    expect(fs.readdirSync(extractDir)).toContain(DL_MKV); // untouched
-  });
-});

tests/integrity.test.ts

@@ -34,20 +34,25 @@ describe("integrity", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-int-"));
     tempDirs.push(dir);
 
+    // Create a .md5 manifest that exceeds the 5MB limit
     const largeContent = "d41d8cd98f00b204e9800998ecf8427e  sample.bin\n".repeat(200000);
     const manifestPath = path.join(dir, "hashes.md5");
     fs.writeFileSync(manifestPath, largeContent, "utf8");
 
+    // Verify the file is actually > 5MB
     const stat = fs.statSync(manifestPath);
     expect(stat.size).toBeGreaterThan(5 * 1024 * 1024);
 
+    // readHashManifest should skip the oversized file
     const manifest = readHashManifest(dir);
     expect(manifest.size).toBe(0);
   });
 
   it("does not parse SHA256 (64-char hex) as valid hash", () => {
+    // SHA256 is 64 chars - parseHashLine only supports 32 (MD5) and 40 (SHA1)
     const sha256Line = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  emptyfile.bin";
     const result = parseHashLine(sha256Line);
+    // 64-char hex should not match the MD5 (32) or SHA1 (40) pattern
     expect(result).toBeNull();
   });
 

tests/item-log.test.ts

@@ -1,85 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { ensureItemLog, getItemLogPath, initItemLogs, logItemEvent, shutdownItemLogs } from "../src/main/item-log";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  shutdownItemLogs();
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("item-log", () => {
-  it("creates a persistent item log file", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-ilog-"));
-    tempDirs.push(baseDir);
-
-    initItemLogs(baseDir);
-    const logPath = ensureItemLog({
-      itemId: "item-1",
-      packageId: "pkg-1",
-      packageName: "Test Paket",
-      fileName: "episode.part2.rar",
-      targetPath: "C:\\downloads\\Test Paket\\episode.part2.rar"
-    });
-
-    expect(logPath).not.toBeNull();
-    expect(fs.existsSync(logPath!)).toBe(true);
-
-    const content = fs.readFileSync(logPath!, "utf8");
-    expect(content).toContain("Item-Log Start");
-    expect(content).toContain("episode.part2.rar");
-  });
-
-  it("writes detail events into the item log", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-ilog-"));
-    tempDirs.push(baseDir);
-
-    initItemLogs(baseDir);
-    ensureItemLog({
-      itemId: "item-2",
-      packageId: "pkg-2",
-      packageName: "Detail Paket",
-      fileName: "episode.part2.rar",
-      targetPath: "C:\\downloads\\Detail Paket\\episode.part2.rar"
-    });
-
-    logItemEvent("item-2", "ERROR", "Entpack-Fehler", {
-      archive: "episode.part2.rar",
-      code: "missing_parts",
-      detail: "Unexpected end of archive"
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 350));
-
-    const logPath = getItemLogPath("item-2");
-    expect(logPath).not.toBeNull();
-    const content = fs.readFileSync(logPath!, "utf8");
-    expect(content).toContain("Entpack-Fehler");
-    expect(content).toContain("archive=episode.part2.rar");
-    expect(content).toContain("code=missing_parts");
-  });
-
-  it("keeps traversal-like item ids inside the item log directory", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-ilog-"));
-    tempDirs.push(baseDir);
-
-    initItemLogs(baseDir);
-    const logPath = ensureItemLog({
-      itemId: "..\\..\\outside",
-      packageId: "pkg-traversal",
-      packageName: "Traversal Paket",
-      fileName: "episode.part2.rar",
-      targetPath: "C:\\downloads\\Traversal Paket\\episode.part2.rar"
-    });
-
-    expect(logPath).not.toBeNull();
-    const logsDir = path.resolve(path.join(baseDir, "item-logs"));
-    const resolvedLogPath = path.resolve(logPath!);
-    expect(resolvedLogPath === logsDir || resolvedLogPath.startsWith(`${logsDir}${path.sep}`)).toBe(true);
-  });
-});

tests/link-export.test.ts

@@ -1,153 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildLinkExportSelection, serializeLinkExportText } from "../src/main/link-export";
-import { parseCollectorInput } from "../src/main/link-parser";
-import type { UiSnapshot } from "../src/shared/types";
-
-function buildSnapshot(): UiSnapshot {
-  return {
-    settings: {} as UiSnapshot["settings"],
-    session: {
-      version: 1,
-      packageOrder: ["pkg-1", "pkg-2"],
-      packages: {
-        "pkg-1": {
-          id: "pkg-1",
-          name: "Dave Staffel 1",
-          outputDir: "C:\\Downloads\\Dave Staffel 1",
-          extractDir: "C:\\Extract\\Dave Staffel 1",
-          status: "queued",
-          itemIds: ["item-1", "item-2"],
-          cancelled: false,
-          enabled: true,
-          priority: "normal",
-          createdAt: 1,
-          updatedAt: 1
-        },
-        "pkg-2": {
-          id: "pkg-2",
-          name: "Andere Staffel",
-          outputDir: "C:\\Downloads\\Andere Staffel",
-          extractDir: "C:\\Extract\\Andere Staffel",
-          status: "queued",
-          itemIds: ["item-3"],
-          cancelled: false,
-          enabled: true,
-          priority: "normal",
-          createdAt: 1,
-          updatedAt: 1
-        }
-      },
-      items: {
-        "item-1": {
-          id: "item-1",
-          packageId: "pkg-1",
-          url: "https://example.com/e01",
-          provider: null,
-          status: "queued",
-          retries: 0,
-          speedBps: 0,
-          downloadedBytes: 0,
-          totalBytes: null,
-          progressPercent: 0,
-          fileName: "Dave.S01E01.rar",
-          targetPath: "",
-          resumable: true,
-          attempts: 0,
-          lastError: "",
-          fullStatus: "Wartet",
-          createdAt: 1,
-          updatedAt: 1
-        },
-        "item-2": {
-          id: "item-2",
-          packageId: "pkg-1",
-          url: "https://example.com/e02",
-          provider: null,
-          status: "queued",
-          retries: 0,
-          speedBps: 0,
-          downloadedBytes: 0,
-          totalBytes: null,
-          progressPercent: 0,
-          fileName: "Dave.S01E02.rar",
-          targetPath: "",
-          resumable: true,
-          attempts: 0,
-          lastError: "",
-          fullStatus: "Wartet",
-          createdAt: 1,
-          updatedAt: 1
-        },
-        "item-3": {
-          id: "item-3",
-          packageId: "pkg-2",
-          url: "https://example.com/other",
-          provider: null,
-          status: "queued",
-          retries: 0,
-          speedBps: 0,
-          downloadedBytes: 0,
-          totalBytes: null,
-          progressPercent: 0,
-          fileName: "Andere.S01E01.rar",
-          targetPath: "",
-          resumable: true,
-          attempts: 0,
-          lastError: "",
-          fullStatus: "Wartet",
-          createdAt: 1,
-          updatedAt: 1
-        }
-      },
-      runStartedAt: 0,
-      totalDownloadedBytes: 0,
-      summaryText: "",
-      reconnectUntil: 0,
-      reconnectReason: "",
-      paused: false,
-      running: false,
-      updatedAt: 1
-    },
-    summary: null,
-    stats: {
-      totalDownloaded: 0,
-      totalDownloadedAllTime: 0,
-      totalFilesSession: 0,
-      totalFilesAllTime: 0,
-      totalPackages: 2,
-      sessionStartedAt: 0,
-      appSessionStartedAt: 0,
-      sessionRuntimeMs: 0,
-      totalRuntimeMs: 0,
-      runtimeMeasuredAt: 0
-    },
-    speedText: "",
-    etaText: "",
-    canStart: true,
-    canStop: false,
-    canPause: false,
-    clipboardActive: false,
-    reconnectSeconds: 0,
-    packageSpeedBps: {}
-  };
-}
-
-describe("link-export", () => {
-  it("keeps original package names when exporting selected items", () => {
-    const selection = buildLinkExportSelection(buildSnapshot(), [], ["item-1", "item-3"]);
-    expect(selection.packageCount).toBe(2);
-    expect(selection.linkCount).toBe(2);
-    expect(selection.packages.map((pkg) => pkg.name)).toEqual(["Dave Staffel 1", "Andere Staffel"]);
-  });
-
-  it("roundtrips exported text back into parsed package inputs", () => {
-    const selection = buildLinkExportSelection(buildSnapshot(), [], ["item-1", "item-2"]);
-    const text = serializeLinkExportText(selection.packages);
-    const reparsed = parseCollectorInput(text, "");
-
-    expect(reparsed).toHaveLength(1);
-    expect(reparsed[0]?.name).toBe("Dave Staffel 1");
-    expect(reparsed[0]?.links).toEqual(["https://example.com/e01", "https://example.com/e02"]);
-    expect(reparsed[0]?.fileNames).toEqual(["Dave.S01E01.rar", "Dave.S01E02.rar"]);
-  });
-});

tests/link-parser.test.ts

@@ -8,15 +8,15 @@ describe("link-parser", () => {
         { name: "Package A", links: ["http://link1", "http://link2"] },
         { name: "Package B", links: ["http://link3"] },
         { name: "Package A", links: ["http://link4", "http://link1"] },
-        { name: "", links: ["http://link5"] }
+        { name: "", links: ["http://link5"] } // empty name will be inferred
       ];
 
       const result = mergePackageInputs(input);
       
-      expect(result).toHaveLength(3);
+      expect(result).toHaveLength(3); // Package A, Package B, and inferred 'Paket'
       
       const pkgA = result.find(p => p.name === "Package A");
-      expect(pkgA?.links).toEqual(["http://link1", "http://link2", "http://link4"]);
+      expect(pkgA?.links).toEqual(["http://link1", "http://link2", "http://link4"]); // link1 deduplicated
       
       const pkgB = result.find(p => p.name === "Package B");
       expect(pkgB?.links).toEqual(["http://link3"]);
@@ -30,20 +30,9 @@ describe("link-parser", () => {
 
       const result = mergePackageInputs(input);
       
+      // "Valid?Name*" becomes "Valid Name " -> trimmed to "Valid Name"
       expect(result.map(p => p.name).sort()).toEqual(["Valid Name", "Valid_Name"]);
     });
-
-    it("preserves file name hints when merging packages", () => {
-      const input = [
-        { name: "Package A", links: ["http://link1", "http://link2"], fileNames: ["one.rar", "two.rar"] },
-        { name: "Package A", links: ["http://link3", "http://link1"], fileNames: ["three.rar", "ignored.rar"] }
-      ];
-
-      const result = mergePackageInputs(input);
-      expect(result).toHaveLength(1);
-      expect(result[0]?.links).toEqual(["http://link1", "http://link2", "http://link3"]);
-      expect(result[0]?.fileNames).toEqual(["one.rar", "two.rar", "three.rar"]);
-    });
   });
 
   describe("parseCollectorInput", () => {
@@ -66,6 +55,7 @@ describe("link-parser", () => {
 
       const result = parseCollectorInput(rawText, "DefaultFallback");
       
+      // Should have 2 packages: "DefaultFallback" and "Custom_Name"
       expect(result).toHaveLength(2);
       
       const defaultPkg = result.find(p => p.name === "DefaultFallback");
@@ -74,7 +64,7 @@ describe("link-parser", () => {
         "http://example.com/part2.rar"
       ]);
       
-      const customPkg = result.find(p => p.name === "Custom_Name");
+      const customPkg = result.find(p => p.name === "Custom_Name"); // sanitized!
       expect(customPkg?.links).toEqual([
         "http://other.com/file1",
         "http://other.com/file2"

tests/log-timestamp.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { logTimestamp } from "../src/main/log-timestamp";
-
-describe("logTimestamp", () => {
-  it("formats local time with an explicit UTC offset (ISO 8601), not a UTC 'Z' string", () => {
-    const instant = new Date("2026-05-31T17:29:43.605Z");
-    const formatted = logTimestamp(instant);
-
-    expect(formatted).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}$/);
-    expect(formatted.endsWith("Z")).toBe(false);
-  });
-
-  it("is parseable back to the exact same instant (offset keeps it unambiguous)", () => {
-    const instant = new Date("2026-05-31T17:29:43.605Z");
-    expect(new Date(logTimestamp(instant)).getTime()).toBe(instant.getTime());
-  });
-
-  it("shows the LOCAL wall-clock hour (machine-timezone-independent assertion)", () => {
-    const instant = new Date("2026-05-31T17:29:43.605Z");
-    const formatted = logTimestamp(instant);
-    expect(formatted.slice(11, 13)).toBe(String(instant.getHours()).padStart(2, "0"));
-  });
-});

tests/mega-public-api.test.ts

@@ -1,178 +0,0 @@
-import crypto from "node:crypto";
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import {
-  decryptMegaAttributes,
-  isMegaFileUrl,
-  parseMegaUrl,
-  resolveMegaFilename
-} from "../src/main/mega-public-api";
-
-function base64Url(buf: Buffer): string {
-  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-function makeRandomFileKey(): Buffer {
-  return crypto.randomBytes(32);
-}
-
-function encryptAttributes(jsonAttrs: Record<string, unknown>, aesKey: Buffer): string {
-  const plain = "MEGA" + JSON.stringify(jsonAttrs);
-  const padded = Buffer.from(plain, "utf8");
-  const padLen = (16 - (padded.length % 16)) % 16;
-  const buf = Buffer.concat([padded, Buffer.alloc(padLen, 0)]);
-  const cipher = crypto.createCipheriv("aes-128-cbc", aesKey, Buffer.alloc(16));
-  cipher.setAutoPadding(false);
-  const enc = Buffer.concat([cipher.update(buf), cipher.final()]);
-  return base64Url(enc);
-}
-
-describe("mega-public-api", () => {
-  describe("isMegaFileUrl", () => {
-    it("recognizes new format", () => {
-      expect(isMegaFileUrl("https://mega.nz/file/pZl1wBRQ#BFx-HachDy4o9EgKy90IiLMsw3idHFGaDoJhajK5zzo")).toBe(true);
-    });
-    it("recognizes legacy format", () => {
-      expect(isMegaFileUrl("https://mega.nz/#!abc123!def456")).toBe(true);
-    });
-    it("recognizes mega.co.nz", () => {
-      expect(isMegaFileUrl("https://mega.co.nz/file/abc#xyz")).toBe(true);
-    });
-    it("rejects folder URLs", () => {
-      expect(isMegaFileUrl("https://mega.nz/folder/abc#xyz")).toBe(false);
-    });
-    it("rejects non-mega URLs", () => {
-      expect(isMegaFileUrl("https://example.com/file/abc#xyz")).toBe(false);
-    });
-    it("rejects garbage", () => {
-      expect(isMegaFileUrl("")).toBe(false);
-      expect(isMegaFileUrl("foo")).toBe(false);
-    });
-  });
-
-  describe("parseMegaUrl", () => {
-    it("parses new-format URL into id + 32-byte key", () => {
-      const url = "https://mega.nz/file/pZl1wBRQ#BFx-HachDy4o9EgKy90IiLMsw3idHFGaDoJhajK5zzo";
-      const parsed = parseMegaUrl(url);
-      expect(parsed).not.toBeNull();
-      expect(parsed?.id).toBe("pZl1wBRQ");
-      expect(parsed?.rawKey.length).toBe(32);
-    });
-    it("parses legacy-format URL", () => {
-      const id = "abcDEF12";
-      const key = makeRandomFileKey();
-      const url = `https://mega.nz/#!${id}!${base64Url(key)}`;
-      const parsed = parseMegaUrl(url);
-      expect(parsed?.id).toBe(id);
-      expect(parsed?.rawKey.equals(key)).toBe(true);
-    });
-    it("rejects URL with folder key (16 bytes)", () => {
-      const url = `https://mega.nz/file/abc#${base64Url(crypto.randomBytes(16))}`;
-      expect(parseMegaUrl(url)).toBeNull();
-    });
-    it("rejects malformed URLs", () => {
-      expect(parseMegaUrl("not-a-url")).toBeNull();
-      expect(parseMegaUrl("https://mega.nz/file/abc")).toBeNull();
-    });
-  });
-
-  describe("decryptMegaAttributes", () => {
-    it("round-trips encrypted Mega attributes", () => {
-      const aesKey = crypto.randomBytes(16);
-      const original = { n: "Test.S01E01.German.1080p.WEB.x264-DEMO.mkv", c: "ignored" };
-      const enc = encryptAttributes(original, aesKey);
-      const decoded = Buffer.from(enc + "=".repeat((4 - (enc.length % 4)) % 4), "base64");
-      const decrypted = decryptMegaAttributes(decoded, aesKey);
-      expect(decrypted).not.toBeNull();
-      expect(decrypted?.n).toBe(original.n);
-    });
-    it("returns null for wrong key", () => {
-      const aesKey = crypto.randomBytes(16);
-      const wrongKey = crypto.randomBytes(16);
-      const enc = encryptAttributes({ n: "x" }, aesKey);
-      const decoded = Buffer.from(enc + "=".repeat((4 - (enc.length % 4)) % 4), "base64");
-      expect(decryptMegaAttributes(decoded, wrongKey)).toBeNull();
-    });
-    it("returns null for non-multiple-of-16 input", () => {
-      const aesKey = crypto.randomBytes(16);
-      expect(decryptMegaAttributes(Buffer.alloc(15), aesKey)).toBeNull();
-    });
-    it("returns null for wrong key length", () => {
-      expect(decryptMegaAttributes(Buffer.alloc(16), Buffer.alloc(8))).toBeNull();
-    });
-  });
-
-  describe("resolveMegaFilename (mocked fetch)", () => {
-    let originalFetch: typeof fetch;
-
-    beforeEach(() => {
-      originalFetch = global.fetch;
-    });
-
-    afterEach(() => {
-      global.fetch = originalFetch;
-      vi.restoreAllMocks();
-    });
-
-    it("returns filename + size for a valid Mega response", async () => {
-      const fileKey = makeRandomFileKey();
-      const aesKey = fileKey.subarray(0, 16);
-      const url = `https://mega.nz/file/testId12#${base64Url(fileKey)}`;
-      const encrypted = encryptAttributes(
-        { n: "Direct.Show.S01E01.German.1080p.WEB.x264-DIRECT.mkv" },
-        aesKey
-      );
-
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        async json() {
-          return [{ s: 1234567890, at: encrypted, msd: 1 }];
-        }
-      } as unknown as Response);
-
-      const result = await resolveMegaFilename(url);
-      expect(result).not.toBeNull();
-      expect(result?.name).toBe("Direct.Show.S01E01.German.1080p.WEB.x264-DIRECT.mkv");
-      expect(result?.size).toBe(1234567890);
-    });
-
-    it("returns null when Mega returns numeric error", async () => {
-      const fileKey = makeRandomFileKey();
-      const url = `https://mega.nz/file/blockedId#${base64Url(fileKey)}`;
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        async json() {
-          return -9;
-        }
-      } as unknown as Response);
-
-      expect(await resolveMegaFilename(url)).toBeNull();
-    });
-
-    it("returns null when response is array with error code", async () => {
-      const fileKey = makeRandomFileKey();
-      const url = `https://mega.nz/file/blockedId#${base64Url(fileKey)}`;
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        async json() {
-          return [-16];
-        }
-      } as unknown as Response);
-
-      expect(await resolveMegaFilename(url)).toBeNull();
-    });
-
-    it("returns null when fetch throws", async () => {
-      const fileKey = makeRandomFileKey();
-      const url = `https://mega.nz/file/networkFail#${base64Url(fileKey)}`;
-      global.fetch = vi.fn().mockRejectedValue(new Error("network down"));
-      expect(await resolveMegaFilename(url)).toBeNull();
-    });
-
-    it("returns null for non-mega URL without making any fetch call", async () => {
-      const fetchSpy = vi.fn();
-      global.fetch = fetchSpy as unknown as typeof fetch;
-      expect(await resolveMegaFilename("https://example.com/file/abc#xyz")).toBeNull();
-      expect(fetchSpy).not.toHaveBeenCalled();
-    });
-  });
-});

tests/mega-web-fallback.test.ts

@@ -33,6 +33,7 @@ describe("mega-web-fallback", () => {
         }
         
         if (urlStr.includes("form=debrid")) {
+          // The POST to generate the code
           return new Response(`
             <div class="acp-box">
               <h3>Link: https://mega.debrid/link1</h3>
@@ -42,6 +43,7 @@ describe("mega-web-fallback", () => {
         }
         
         if (urlStr.includes("ajax=debrid")) {
+          // Polling endpoint
           return new Response(JSON.stringify({ link: "https://mega.direct/123" }), { status: 200 });
         }
         
@@ -54,98 +56,15 @@ describe("mega-web-fallback", () => {
       expect(result).not.toBeNull();
       expect(result?.directUrl).toBe("https://mega.direct/123");
       expect(result?.fileName).toBe("link1");
+      // Calls: 1. Login POST, 2. Verify GET, 3. Generate POST, 4. Polling POST
       expect(fetchCallCount).toBe(4);
     });
 
-    it("fails fast on 'Kein Server für diesen Hoster' (account hoster quota) instead of re-login + re-poll", async () => {
-      let ajaxCalls = 0;
-      globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-        const urlStr = String(url);
-        if (urlStr.includes("form=login")) {
-          const headers = new Headers();
-          headers.append("set-cookie", "session=goodcookie; path=/");
-          return new Response("", { headers, status: 200 });
-        }
-        if (urlStr.includes("page=debrideur")) {
-          return new Response('<form id="debridForm"></form>', { status: 200 });
-        }
-        if (urlStr.includes("form=debrid")) {
-          return new Response(`<div class="acp-box"><h3>Link: https://mega.debrid/l1</h3><a href="javascript:processDebrid(1,'code1',0)">d</a></div>`, { status: 200 });
-        }
-        if (urlStr.includes("ajax=debrid")) {
-          ajaxCalls += 1;
-          return new Response(JSON.stringify({ link: "", text: "Erreur : Kein Server für diesen Hoster verfügbar. Bitte versuchen Sie es später noch einmal." }), { status: 200 });
-        }
-        return new Response("Not found", { status: 404 });
-      }) as unknown as typeof fetch;
-
-      const fallback = new MegaWebFallback(() => ({ login: "user", password: "pwd" }));
-      await expect(fallback.unrestrict("https://mega.debrid/l1")).rejects.toThrow(/kein server für diesen hoster/i);
-      expect(ajaxCalls).toBe(1);
-    });
-
-    it("surfaces 'Kein Server für diesen Hoster' from the debrid PAGE (daily limit, no debrid code) instead of empty", async () => {
-      let ajaxCalls = 0;
-      globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-        const urlStr = String(url);
-        if (urlStr.includes("form=login")) {
-          const headers = new Headers();
-          headers.append("set-cookie", "session=goodcookie; path=/");
-          return new Response("", { headers, status: 200 });
-        }
-        if (urlStr.includes("page=debrideur")) {
-          return new Response('<form id="debridForm"></form>', { status: 200 });
-        }
-        if (urlStr.includes("form=debrid")) {
-          return new Response('<div class="error">Erreur : Kein Server für diesen Hoster verfügbar. Bitte versuchen Sie es später noch einmal.</div>', { status: 200 });
-        }
-        if (urlStr.includes("ajax=debrid")) {
-          ajaxCalls += 1;
-          return new Response(JSON.stringify({ link: "https://should.not/happen" }), { status: 200 });
-        }
-        return new Response("Not found", { status: 404 });
-      }) as unknown as typeof fetch;
-
-      const fallback = new MegaWebFallback(() => ({ login: "user", password: "pwd" }));
-      await expect(fallback.unrestrict("https://mega.debrid/l1")).rejects.toThrow(/kein server für diesen hoster/i);
-      expect(ajaxCalls).toBe(0);
-    });
-
-    it("logs in with the per-account credentials passed to unrestrict, not the default", async () => {
-      const loginsUsed: string[] = [];
-      globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: { body?: unknown }) => {
-        const urlStr = String(url);
-        if (urlStr.includes("form=login")) {
-          const params = new URLSearchParams(String(opts?.body ?? ""));
-          loginsUsed.push(params.get("login") || "");
-          const headers = new Headers();
-          headers.append("set-cookie", "session=goodcookie; path=/");
-          return new Response("", { headers, status: 200 });
-        }
-        if (urlStr.includes("page=debrideur")) {
-          return new Response('<form id="debridForm"></form>', { status: 200 });
-        }
-        if (urlStr.includes("form=debrid")) {
-          return new Response(`<div class="acp-box"><h3>Link: https://mega.debrid/l1</h3><a href="javascript:processDebrid(1,'code1',0)">d</a></div>`, { status: 200 });
-        }
-        if (urlStr.includes("ajax=debrid")) {
-          return new Response(JSON.stringify({ link: "https://mega.direct/ok" }), { status: 200 });
-        }
-        return new Response("Not found", { status: 404 });
-      }) as unknown as typeof fetch;
-
-      const fallback = new MegaWebFallback(() => ({ login: "defaultacc", password: "defpw" }));
-      const result = await fallback.unrestrict("https://mega.debrid/l1", undefined, { login: "account2", password: "pw2" });
-      expect(result?.directUrl).toBe("https://mega.direct/ok");
-      expect(loginsUsed).toContain("account2");
-      expect(loginsUsed).not.toContain("defaultacc");
-    });
-
     it("throws if login fails to set cookie", async () => {
       globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
         const urlStr = String(url);
         if (urlStr.includes("form=login")) {
-          const headers = new Headers();
+          const headers = new Headers(); // No cookie
           return new Response("", { headers, status: 200 });
         }
         return new Response("Not found", { status: 404 });
@@ -166,6 +85,7 @@ describe("mega-web-fallback", () => {
           return new Response("", { headers, status: 200 });
         }
         if (urlStr.includes("page=debrideur")) {
+          // Missing form!
           return new Response('<html><body>Nothing here</body></html>', { status: 200 });
         }
         return new Response("Not found", { status: 404 });
@@ -191,6 +111,7 @@ describe("mega-web-fallback", () => {
           return new Response('<form id="debridForm"></form>', { status: 200 });
         }
         if (urlStr.includes("form=debrid")) {
+          // The generate POST returns HTML without any codes
           return new Response(`<div>No links here</div>`, { status: 200 });
         }
         return new Response("Not found", { status: 404 });
@@ -199,6 +120,7 @@ describe("mega-web-fallback", () => {
       const fallback = new MegaWebFallback(() => ({ login: "a", password: "b" }));
       const result = await fallback.unrestrict("http://mega.debrid/file");
       
+      // Generation fails -> resets cookie -> tries again -> fails again -> returns null
       expect(result).toBeNull();
     });
 

tests/package-log.test.ts

@@ -61,22 +61,4 @@ describe("package-log", () => {
     expect(content).toContain("archive=episode.part1.rar");
     expect(content).toContain("password=\"secret\"");
   });
-
-  it("keeps traversal-like package ids inside the package log directory", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-plog-"));
-    tempDirs.push(baseDir);
-
-    initPackageLogs(baseDir);
-    const logPath = ensurePackageLog({
-      packageId: "..\\..\\outside",
-      name: "Traversal Paket",
-      outputDir: "C:\\downloads\\Traversal Paket",
-      extractDir: "C:\\extract\\Traversal Paket"
-    });
-
-    expect(logPath).not.toBeNull();
-    const logsDir = path.resolve(path.join(baseDir, "package-logs"));
-    const resolvedLogPath = path.resolve(logPath!);
-    expect(resolvedLogPath === logsDir || resolvedLogPath.startsWith(`${logsDir}${path.sep}`)).toBe(true);
-  });
 });

tests/package-order.test.ts

@@ -44,50 +44,23 @@ function createItem(id: string, packageId: string, status: DownloadItem["status"
 }
 
 describe("sortPackagesForDisplay", () => {
-  it("floats active packages to the top, keeping queue order within each group", () => {
+  it("moves active packages with more progress to the top when auto sort is enabled", () => {
-    // pkg-a and pkg-b both have an active (downloading) item -> both float up in
-    // their original queue order; pkg-c (queued only) sinks below.
     const packages = [
       createPackage("pkg-a", ["a1", "a2"]),
-      createPackage("pkg-c", ["c1"]),
+      createPackage("pkg-b", ["b1", "b2"]),
-      createPackage("pkg-b", ["b1", "b2"])
+      createPackage("pkg-c", ["c1"])
     ];
     const items: Record<string, DownloadItem> = {
       a1: createItem("a1", "pkg-a", "downloading", 250),
       a2: createItem("a2", "pkg-a", "completed", 500),
-      c1: createItem("c1", "pkg-c", "queued", 0),
       b1: createItem("b1", "pkg-b", "downloading", 800),
-      b2: createItem("b2", "pkg-b", "completed", 900)
+      b2: createItem("b2", "pkg-b", "completed", 900),
+      c1: createItem("c1", "pkg-c", "queued", 0)
     };
 
     const sorted = sortPackagesForDisplay(packages, items, true, true);
 
-    // active group [pkg-a, pkg-b] in queue order, then rest [pkg-c]
+    expect(sorted.map((pkg) => pkg.id)).toEqual(["pkg-b", "pkg-a", "pkg-c"]);
-    expect(sorted.map((pkg) => pkg.id)).toEqual(["pkg-a", "pkg-b", "pkg-c"]);
-  });
-
-  it("does NOT reshuffle active packages when only their progress changes (anti-flicker)", () => {
-    const packages = [
-      createPackage("pkg-a", ["a1"]),
-      createPackage("pkg-b", ["b1"])
-    ];
-    // Both active. pkg-b initially has more bytes than pkg-a.
-    const before: Record<string, DownloadItem> = {
-      a1: createItem("a1", "pkg-a", "downloading", 100),
-      b1: createItem("b1", "pkg-b", "downloading", 900)
-    };
-    const orderBefore = sortPackagesForDisplay(packages, before, true, true).map((p) => p.id);
-
-    // A progress tick: pkg-a overtakes pkg-b in bytes. Order must NOT change —
-    // both are still active, so they keep queue order. (Old code swapped them.)
-    const after: Record<string, DownloadItem> = {
-      a1: createItem("a1", "pkg-a", "downloading", 5000),
-      b1: createItem("b1", "pkg-b", "downloading", 950)
-    };
-    const orderAfter = sortPackagesForDisplay(packages, after, true, true).map((p) => p.id);
-
-    expect(orderBefore).toEqual(["pkg-a", "pkg-b"]);
-    expect(orderAfter).toEqual(orderBefore);
   });
 
   it("keeps package order untouched when auto sort is disabled", () => {

tests/rename-log.test.ts

@@ -1,52 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { getRenameLogPath, initRenameLog, logRenameEvent, shutdownRenameLog } from "../src/main/rename-log";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  shutdownRenameLog();
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("rename-log", () => {
-  it("writes rename events to the rename log", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-rlog-"));
-    tempDirs.push(baseDir);
-
-    initRenameLog(baseDir);
-    logRenameEvent("INFO", "Auto-Rename durchgeführt", {
-      packageName: "Test Paket",
-      sourcePath: "C:\\extract\\old.mkv",
-      targetPath: "C:\\extract\\new.mkv"
-    });
-
-    const logPath = getRenameLogPath();
-    expect(logPath).not.toBeNull();
-    expect(fs.existsSync(logPath!)).toBe(true);
-    const content = fs.readFileSync(logPath!, "utf8");
-    expect(content).toContain("Rename-Log Start");
-    expect(content).toContain("Auto-Rename durchgeführt");
-    expect(content).toContain("sourcePath=C:\\extract\\old.mkv");
-  });
-
-  it("rotates oversized rename logs on startup", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-rlog-rotate-"));
-    tempDirs.push(baseDir);
-
-    const oversizedPath = path.join(baseDir, "rename.log");
-    fs.mkdirSync(baseDir, { recursive: true });
-    fs.writeFileSync(oversizedPath, "x".repeat(10 * 1024 * 1024 + 256), "utf8");
-
-    initRenameLog(baseDir);
-
-    expect(fs.existsSync(oversizedPath)).toBe(true);
-    expect(fs.existsSync(`${oversizedPath}.old`)).toBe(true);
-    const content = fs.readFileSync(oversizedPath, "utf8");
-    expect(content).toContain("Rename-Log Start");
-  });
-});

tests/resolve-archive-items.test.ts

@@ -17,6 +17,7 @@ function makeItems(names: string[]): MinimalItem[] {
 }
 
 describe("resolveArchiveItemsFromList", () => {
+  // ── Multipart RAR (.partN.rar) ──
 
   it("matches multipart .part1.rar archives", () => {
     const items = makeItems([
@@ -45,6 +46,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(3);
   });
 
+  // ── Old-style RAR (.rar + .r00, .r01, etc.) ──
+
   it("matches old-style .rar + .rNN volumes", () => {
     const items = makeItems([
       "Archive.rar",
@@ -57,6 +60,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(4);
   });
 
+  // ── Single RAR ──
+
   it("matches a single .rar file", () => {
     const items = makeItems(["SingleFile.rar", "Other.mkv"]);
     const result = resolveArchiveItemsFromList("SingleFile.rar", items as any);
@@ -64,6 +69,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect((result[0] as any).fileName).toBe("SingleFile.rar");
   });
 
+  // ── Split ZIP ──
+
   it("matches split .zip.NNN files", () => {
     const items = makeItems([
       "Data.zip",
@@ -75,6 +82,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(4);
   });
 
+  // ── Split 7z ──
+
   it("matches split .7z.NNN files", () => {
     const items = makeItems([
       "Backup.7z.001",
@@ -84,6 +93,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(2);
   });
 
+  // ── Generic .NNN splits ──
+
   it("matches generic .NNN split files", () => {
     const items = makeItems([
       "video.001",
@@ -94,6 +105,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(3);
   });
 
+  // ── Exact filename match ──
+
   it("matches a single .zip by exact name", () => {
     const items = makeItems(["myarchive.zip", "other.rar"]);
     const result = resolveArchiveItemsFromList("myarchive.zip", items as any);
@@ -101,6 +114,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect((result[0] as any).fileName).toBe("myarchive.zip");
   });
 
+  // ── Case insensitivity ──
+
   it("matches case-insensitively", () => {
     const items = makeItems([
       "MOVIE.PART1.RAR",
@@ -110,26 +125,40 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(2);
   });
 
+  // ── Stem-based fallback ──
+
   it("uses stem-based fallback when exact patterns fail", () => {
+    // Simulate a debrid service that renames "Movie.part1.rar" to "Movie.part1_dl.rar"
+    // but the disk file is "Movie.part1.rar"
     const items = makeItems([
       "Movie.rar",
     ]);
+    // The archive on disk is "Movie.part1.rar" but there's no item matching the
+    // .partN pattern. The stem "movie" should match "Movie.rar" via fallback.
     const result = resolveArchiveItemsFromList("Movie.part1.rar", items as any);
+    // stem fallback: "movie" starts with "movie" and ends with .rar
     expect(result).toHaveLength(1);
   });
 
+  // ── Single item fallback ──
+
   it("returns single archive item when no pattern matches", () => {
     const items = makeItems(["totally-different-name.rar"]);
     const result = resolveArchiveItemsFromList("Original.rar", items as any);
+    // Single item in list with archive extension → return it
     expect(result).toHaveLength(1);
   });
 
+  // ── Empty when no match ──
+
   it("returns empty when items have no archive extensions", () => {
     const items = makeItems(["video.mkv", "subtitle.srt"]);
     const result = resolveArchiveItemsFromList("Archive.rar", items as any);
     expect(result).toHaveLength(0);
   });
 
+  // ── Items without targetPath ──
+
   it("falls back to fileName when targetPath is missing", () => {
     const items = [
       { fileName: "Movie.part1.rar", id: "1", status: "completed" },
@@ -139,6 +168,8 @@ describe("resolveArchiveItemsFromList", () => {
     expect(result).toHaveLength(2);
   });
 
+  // ── Multiple archives, should not cross-match ──
+
   it("does not cross-match different archive groups", () => {
     const items = makeItems([
       "Episode.S01E01.part1.rar",

tests/selection.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { pruneSelection } from "../src/renderer/selection";
-import type { SessionState } from "../src/shared/types";
-
-function session(packageIds: string[], itemIds: string[]): Pick<SessionState, "packages" | "items"> {
-  const packages: Record<string, never> = {};
-  const items: Record<string, never> = {};
-  for (const id of packageIds) packages[id] = {} as never;
-  for (const id of itemIds) items[id] = {} as never;
-  return { packages, items };
-}
-
-describe("pruneSelection", () => {
-  it("drops ids whose package/item no longer exists", () => {
-    const sel = new Set(["p1", "i1", "ghost-p", "ghost-i"]);
-    const next = pruneSelection(sel, session(["p1"], ["i1"]));
-    expect([...next].sort()).toEqual(["i1", "p1"]);
-  });
-
-  it("returns the SAME set instance when nothing changed (no needless re-render)", () => {
-    const sel = new Set(["p1", "i1"]);
-    const next = pruneSelection(sel, session(["p1"], ["i1"]));
-    expect(next).toBe(sel);
-  });
-
-  it("returns the same instance for an empty selection", () => {
-    const sel = new Set<string>();
-    expect(pruneSelection(sel, session(["p1"], ["i1"]))).toBe(sel);
-  });
-
-  it("prunes everything when the whole session was swapped out", () => {
-    const sel = new Set(["p1", "i1"]);
-    const next = pruneSelection(sel, session([], []));
-    expect(next.size).toBe(0);
-    expect(next).not.toBe(sel);
-  });
-
-  it("keeps a mixed package+item selection when both survive", () => {
-    const sel = new Set(["p1", "p2", "i1"]);
-    const next = pruneSelection(sel, session(["p1", "p2"], ["i1", "i2"]));
-    expect([...next].sort()).toEqual(["i1", "p1", "p2"]);
-    expect(next).toBe(sel); // unchanged → same instance
-  });
-});

tests/session-log.test.ts

@@ -8,7 +8,9 @@ import { setLogListener } from "../src/main/logger";
 const tempDirs: string[] = [];
 
 afterEach(() => {
+  // Ensure session log is shut down between tests
   shutdownSessionLog();
+  // Ensure listener is cleared between tests
   setLogListener(null);
   for (const dir of tempDirs.splice(0)) {
     fs.rmSync(dir, { recursive: true, force: true });
@@ -40,9 +42,11 @@ describe("session-log", () => {
     initSessionLog(baseDir);
     const logPath = getSessionLogPath()!;
 
+    // Simulate a log line via the listener
     const { logger } = await import("../src/main/logger");
     logger.info("Test-Nachricht für Session-Log");
 
+    // Wait for flush (200ms interval + margin)
     await new Promise((resolve) => setTimeout(resolve, 500));
 
     const content = fs.readFileSync(logPath, "utf8");
@@ -73,6 +77,7 @@ describe("session-log", () => {
 
     shutdownSessionLog();
 
+    // Log after shutdown - should NOT appear in session log
     const { logger } = await import("../src/main/logger");
     logger.info("Nach-Shutdown-Nachricht");
 
@@ -89,16 +94,21 @@ describe("session-log", () => {
     const logsDir = path.join(baseDir, "session-logs");
     fs.mkdirSync(logsDir, { recursive: true });
 
+    // Create a fake old session log
     const oldFile = path.join(logsDir, "session_2020-01-01_00-00-00.txt");
     fs.writeFileSync(oldFile, "old session");
+    // Set mtime to 30 days ago
     const oldTime = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
     fs.utimesSync(oldFile, oldTime, oldTime);
 
+    // Create a recent file
     const newFile = path.join(logsDir, "session_2099-01-01_00-00-00.txt");
     fs.writeFileSync(newFile, "new session");
 
+    // initSessionLog triggers cleanup
     initSessionLog(baseDir);
 
+    // Wait for async cleanup
     await new Promise((resolve) => setTimeout(resolve, 300));
 
     expect(fs.existsSync(oldFile)).toBe(false);
@@ -114,6 +124,7 @@ describe("session-log", () => {
     const logsDir = path.join(baseDir, "session-logs");
     fs.mkdirSync(logsDir, { recursive: true });
 
+    // Create a file from 2 days ago (should be kept)
     const recentFile = path.join(logsDir, "session_2025-12-01_00-00-00.txt");
     fs.writeFileSync(recentFile, "recent session");
     const recentTime = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
@@ -136,6 +147,7 @@ describe("session-log", () => {
     const path1 = getSessionLogPath();
     shutdownSessionLog();
 
+    // Small delay to ensure different timestamp
     await new Promise((resolve) => setTimeout(resolve, 1100));
 
     initSessionLog(baseDir);

tests/session-restart-loss.test.ts

@@ -1,132 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { DownloadItem, PackageEntry, SessionState } from "../src/shared/types";
-import {
-  cancelPendingAsyncSaves,
-  createStoragePaths,
-  emptySession,
-  loadSession,
-  saveSession,
-  saveSessionAsync
-} from "../src/main/storage";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-function makePackage(id: string, itemId: string): PackageEntry {
-  return {
-    id,
-    name: `Package ${id}`,
-    outputDir: "C:/tmp/out",
-    extractDir: "C:/tmp/extract",
-    status: "queued",
-    itemIds: [itemId],
-    cancelled: false,
-    enabled: true,
-    downloadStartedAt: 0,
-    downloadCompletedAt: 0,
-    createdAt: 1,
-    updatedAt: 1
-  };
-}
-
-function makeItem(id: string, packageId: string): DownloadItem {
-  return {
-    id,
-    packageId,
-    url: `https://example.com/${id}`,
-    provider: null,
-    status: "queued",
-    retries: 0,
-    speedBps: 0,
-    downloadedBytes: 0,
-    totalBytes: null,
-    progressPercent: 0,
-    fileName: `${id}.rar`,
-    targetPath: "",
-    resumable: true,
-    attempts: 0,
-    lastError: "",
-    fullStatus: "Wartet",
-    createdAt: 1,
-    updatedAt: 1
-  };
-}
-
-function sessionWith(ids: string[]): SessionState {
-  const s = emptySession();
-  for (const id of ids) {
-    const itemId = `${id}-item`;
-    s.packageOrder.push(id);
-    s.packages[id] = makePackage(id, itemId);
-    s.items[itemId] = makeItem(itemId, id);
-  }
-  return s;
-}
-
-const settle = (ms = 250): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
-
-describe("session restart loss", () => {
-  it("does not let a queued stale async save clobber a newer synchronous save", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-loss-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-
-    cancelPendingAsyncSaves();
-    await settle(50);
-
-    saveSession(paths, sessionWith(["A", "B"]));
-
-    const inflight = saveSessionAsync(paths, sessionWith(["A", "B"]));
-    const queued = saveSessionAsync(paths, sessionWith(["A", "B"]));
-    saveSession(paths, sessionWith(["A", "B", "C"]));
-
-    await inflight;
-    await queued;
-    await settle();
-
-    const loaded = loadSession(paths);
-    expect(Object.keys(loaded.packages).sort()).toEqual(["A", "B", "C"]);
-  });
-
-  it("recovers packages from the backup when the primary session file is absent", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-loss-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-
-    fs.writeFileSync(`${paths.sessionFile}.bak`, JSON.stringify(sessionWith(["A", "B"])), "utf8");
-    expect(fs.existsSync(paths.sessionFile)).toBe(false);
-
-    const loaded = loadSession(paths);
-    expect(Object.keys(loaded.packages).sort()).toEqual(["A", "B"]);
-  });
-
-  it("still treats a truly fresh install (no primary, no backup, no temp) as empty", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-loss-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-
-    const loaded = loadSession(paths);
-    expect(Object.keys(loaded.packages)).toEqual([]);
-    expect(Object.keys(loaded.items)).toEqual([]);
-  });
-
-  it("recovers from the backup when the primary exists but is empty", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-loss-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-
-    fs.writeFileSync(paths.sessionFile, JSON.stringify(emptySession()), "utf8");
-    fs.writeFileSync(`${paths.sessionFile}.bak`, JSON.stringify(sessionWith(["A", "B"])), "utf8");
-
-    const loaded = loadSession(paths);
-    expect(Object.keys(loaded.packages).sort()).toEqual(["A", "B"]);
-  });
-});

tests/startup-health-check.test.ts

@@ -1,134 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defaultSettings } from "../src/main/constants";
-import { createStoragePaths } from "../src/main/storage";
-import { runStartupHealthCheck } from "../src/main/startup-health-check";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-});
-
-function makeTempBase(): { baseDir: string; outputDir: string; paths: ReturnType<typeof createStoragePaths> } {
-  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-health-"));
-  tempDirs.push(baseDir);
-  const outputDir = path.join(baseDir, "downloads");
-  fs.mkdirSync(outputDir, { recursive: true });
-  return {
-    baseDir: path.join(baseDir, "runtime"),
-    outputDir,
-    paths: createStoragePaths(path.join(baseDir, "runtime"))
-  };
-}
-
-describe("runStartupHealthCheck", () => {
-  it("flags missing download directory", () => {
-    const { outputDir, paths } = makeTempBase();
-    fs.mkdirSync(paths.baseDir, { recursive: true });
-
-    const settings = {
-      ...defaultSettings(),
-      token: "rd-token",
-      outputDir: path.join(outputDir, "does-not-exist-subdir")
-    };
-    const report = runStartupHealthCheck(settings, paths);
-    const codes = report.findings.map((f) => f.code);
-    expect(codes).toContain("outputDir_not_found");
-  });
-
-  it("flags no-provider-configured when all credentials are empty", () => {
-    const { outputDir, paths } = makeTempBase();
-    fs.mkdirSync(paths.baseDir, { recursive: true });
-
-    const settings = {
-      ...defaultSettings(),
-      token: "",
-      megaLogin: "",
-      megaPassword: "",
-      megaCredentials: "",
-      allDebridToken: "",
-      bestToken: "",
-      oneFichierApiKey: "",
-      debridLinkApiKeys: "",
-      outputDir
-    };
-    const report = runStartupHealthCheck(settings, paths);
-    const codes = report.findings.map((f) => f.code);
-    expect(codes).toContain("no_provider_configured");
-    expect(report.warnCount).toBeGreaterThanOrEqual(1);
-  });
-
-  it("reports configured providers when at least one credential is set", () => {
-    const { outputDir, paths } = makeTempBase();
-    fs.mkdirSync(paths.baseDir, { recursive: true });
-
-    const settings = {
-      ...defaultSettings(),
-      token: "rd-token-here",
-      debridLinkApiKeys: "dl-key-a\ndl-key-b",
-      outputDir
-    };
-    const report = runStartupHealthCheck(settings, paths);
-    const providersFinding = report.findings.find((f) => f.code === "providers_configured");
-    expect(providersFinding).toBeDefined();
-    expect(providersFinding?.message).toContain("Real-Debrid");
-    expect(providersFinding?.message).toContain("Debrid-Link");
-    expect(providersFinding?.message).toContain("2 Keys");
-  });
-
-  it("flags large state files", () => {
-    const { outputDir, paths } = makeTempBase();
-    fs.mkdirSync(paths.baseDir, { recursive: true });
-    fs.writeFileSync(paths.sessionFile, Buffer.alloc(60 * 1024 * 1024, 0));
-
-    const settings = {
-      ...defaultSettings(),
-      token: "rd-token",
-      outputDir
-    };
-    const report = runStartupHealthCheck(settings, paths);
-    const codes = report.findings.map((f) => f.code);
-    expect(codes).toContain("large_state_file");
-  });
-
-  it("flags missing base dir as ERROR", () => {
-    const { outputDir, paths } = makeTempBase();
-
-    const settings = {
-      ...defaultSettings(),
-      token: "rd-token",
-      outputDir
-    };
-    const report = runStartupHealthCheck(settings, paths);
-    const codes = report.findings.map((f) => f.code);
-    expect(codes).toContain("baseDir_missing");
-    expect(report.errorCount).toBeGreaterThanOrEqual(1);
-  });
-
-  it("passes cleanly when everything is healthy", () => {
-    const { outputDir, paths } = makeTempBase();
-    fs.mkdirSync(paths.baseDir, { recursive: true });
-
-    const settings = {
-      ...defaultSettings(),
-      token: "rd-token-here",
-      outputDir
-    };
-    const report = runStartupHealthCheck(settings, paths);
-    expect(report.errorCount).toBe(0);
-    const codes = report.findings.map((f) => f.code);
-    expect(codes).not.toContain("outputDir_not_found");
-    expect(codes).not.toContain("outputDir_not_writable");
-    expect(codes).not.toContain("no_provider_configured");
-    expect(codes).not.toContain("baseDir_missing");
-    expect(codes).not.toContain("baseDir_not_writable");
-  });
-});

tests/storage.test.ts

@@ -6,7 +6,7 @@ import { parseDebridLinkApiKeys } from "../src/shared/debrid-link-keys";
 import { getProviderUsageDayKey } from "../src/shared/provider-daily-limits";
 import { AppSettings } from "../src/shared/types";
 import { defaultSettings } from "../src/main/constants";
-import { addHistoryEntryForRetention, createStoragePaths, emptySession, loadHistory, loadHistoryForRetention, loadSession, loadSettings, normalizeSettings, resetHistoryForRetention, saveHistory, saveSession, saveSessionAsync, saveSettings } from "../src/main/storage";
+import { createStoragePaths, emptySession, loadSession, loadSettings, normalizeSettings, saveSession, saveSessionAsync, saveSettings } from "../src/main/storage";
 
 const tempDirs: string[] = [];
 
@@ -273,65 +273,6 @@ describe("settings storage", () => {
     expect(normalizedDisabled.allDebridUseWebLogin).toBe(false);
   });
 
-  it("defaults history retention to permanent and normalizes invalid values", () => {
-    expect(defaultSettings().historyRetentionMode).toBe("permanent");
-
-    const normalized = normalizeSettings({
-      ...defaultSettings(),
-      historyRetentionMode: "broken" as unknown as AppSettings["historyRetentionMode"]
-    });
-
-    expect(normalized.historyRetentionMode).toBe("permanent");
-  });
-
-  it("skips adding persisted history entries when history retention is never", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-
-    const result = addHistoryEntryForRetention(paths, "never", {
-      id: "hist-1",
-      name: "ignored",
-      totalBytes: 1024,
-      downloadedBytes: 1024,
-      fileCount: 1,
-      provider: "realdebrid",
-      completedAt: Date.now(),
-      durationSeconds: 12,
-      status: "completed",
-      outputDir: path.join(dir, "out"),
-      urls: ["https://example.com/file.rar"]
-    });
-
-    expect(result).toEqual([]);
-    expect(loadHistory(paths)).toEqual([]);
-    expect(loadHistoryForRetention(paths, "never")).toEqual([]);
-  });
-
-  it("clears persisted history for session retention mode", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-
-    saveHistory(paths, [{
-      id: "hist-2",
-      name: "kept",
-      totalBytes: 2048,
-      downloadedBytes: 2048,
-      fileCount: 1,
-      provider: "realdebrid",
-      completedAt: Date.now(),
-      durationSeconds: 20,
-      status: "completed",
-      outputDir: path.join(dir, "out"),
-      urls: ["https://example.com/file2.rar"]
-    }]);
-
-    resetHistoryForRetention(paths, "session");
-
-    expect(loadHistory(paths)).toEqual([]);
-  });
-
   it("assigns and preserves bandwidth schedule ids", () => {
     const normalized = normalizeSettings({
       ...defaultSettings(),
@@ -364,8 +305,6 @@ describe("settings storage", () => {
       itemIds: ["item1", "item2", "item3", "item4"],
       cancelled: false,
       enabled: true,
-      downloadStartedAt: 0,
-      downloadCompletedAt: 0,
       createdAt: Date.now(),
       updatedAt: Date.now()
     };
@@ -453,13 +392,19 @@ describe("settings storage", () => {
     saveSession(paths, session);
     const loaded = loadSession(paths);
 
+    // Active statuses (downloading, paused) should be reset to "queued"
     expect(loaded.items["item1"].status).toBe("queued");
     expect(loaded.items["item2"].status).toBe("queued");
+    // Speed should be cleared
     expect(loaded.items["item1"].speedBps).toBe(0);
+    // lastError should be cleared for reset items
     expect(loaded.items["item1"].lastError).toBe("");
+    // Completed and queued statuses should be preserved
     expect(loaded.items["item3"].status).toBe("completed");
     expect(loaded.items["item4"].status).toBe("queued");
+    // Downloaded bytes should be preserved
     expect(loaded.items["item1"].downloadedBytes).toBe(5000);
+    // Package data should be preserved
     expect(loaded.packages["pkg1"].name).toBe("Test Package");
   });
 
@@ -493,8 +438,6 @@ describe("settings storage", () => {
       itemIds: ["item-backup"],
       cancelled: false,
       enabled: true,
-      downloadStartedAt: 0,
-      downloadCompletedAt: 0,
       createdAt: Date.now(),
       updatedAt: Date.now()
     };
@@ -536,6 +479,7 @@ describe("settings storage", () => {
     tempDirs.push(dir);
     const paths = createStoragePaths(dir);
 
+    // Write invalid JSON to the config file
     fs.writeFileSync(paths.configFile, "{{{{not valid json!!!}", "utf8");
 
     const loaded = loadSettings(paths);
@@ -605,75 +549,6 @@ describe("settings storage", () => {
     expect(loaded.packageOrder).toEqual(["pkg-valid"]);
   });
 
-  it("drops unsafe session ids and target paths outside the package output directory", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
-    tempDirs.push(dir);
-    const paths = createStoragePaths(dir);
-    const outputDir = path.join(dir, "downloads", "safe");
-    const safeTargetPath = path.join(outputDir, "safe.bin");
-    const outsideTargetPath = path.join(dir, "outside.bin");
-
-    fs.writeFileSync(paths.sessionFile, JSON.stringify({
-      version: 2,
-      packageOrder: ["pkg-safe", "../pkg-evil"],
-      packages: {
-        "pkg-safe": {
-          id: "pkg-safe",
-          name: "Safe Package",
-          outputDir,
-          extractDir: path.join(dir, "extract", "safe"),
-          status: "queued",
-          itemIds: ["item-safe", "item-outside", "../item-evil"],
-          cancelled: false,
-          enabled: true
-        },
-        "../pkg-evil": {
-          id: "../pkg-evil",
-          name: "Unsafe Package",
-          outputDir,
-          extractDir: path.join(dir, "extract", "unsafe"),
-          status: "queued",
-          itemIds: ["item-evil"],
-          cancelled: false,
-          enabled: true
-        }
-      },
-      items: {
-        "item-safe": {
-          id: "item-safe",
-          packageId: "pkg-safe",
-          url: "https://example.com/safe",
-          status: "queued",
-          fileName: "safe.bin",
-          targetPath: safeTargetPath
-        },
-        "item-outside": {
-          id: "item-outside",
-          packageId: "pkg-safe",
-          url: "https://example.com/outside",
-          status: "queued",
-          fileName: "outside.bin",
-          targetPath: outsideTargetPath
-        },
-        "../item-evil": {
-          id: "../item-evil",
-          packageId: "pkg-safe",
-          url: "https://example.com/evil",
-          status: "queued",
-          fileName: "evil.bin",
-          targetPath: safeTargetPath
-        }
-      }
-    }), "utf8");
-
-    const loaded = loadSession(paths);
-    expect(Object.keys(loaded.packages)).toEqual(["pkg-safe"]);
-    expect(Object.keys(loaded.items).sort()).toEqual(["item-outside", "item-safe"]);
-    expect(loaded.packageOrder).toEqual(["pkg-safe"]);
-    expect(path.resolve(loaded.items["item-safe"]?.targetPath || "")).toBe(path.resolve(safeTargetPath));
-    expect(loaded.items["item-outside"]?.targetPath).toBe("");
-  });
-
   it("captures async session save payload before later mutations", async () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
     tempDirs.push(dir);
@@ -721,6 +596,7 @@ describe("settings storage", () => {
     tempDirs.push(dir);
     const paths = createStoragePaths(dir);
 
+    // Write a minimal config that simulates an old version missing newer fields
     fs.writeFileSync(
       paths.configFile,
       JSON.stringify({
@@ -734,9 +610,11 @@ describe("settings storage", () => {
     const loaded = loadSettings(paths);
     const defaults = defaultSettings();
 
+    // Old fields should be preserved
     expect(loaded.token).toBe("my-token");
     expect(loaded.outputDir).toBe(path.resolve("/custom/output"));
 
+    // Missing new fields should get default values
     expect(loaded.autoProviderFallback).toBe(defaults.autoProviderFallback);
     expect(loaded.hybridExtract).toBe(defaults.hybridExtract);
     expect(loaded.completedCleanupPolicy).toBe(defaults.completedCleanupPolicy);

tests/trace-log.test.ts

@@ -1,90 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { configureLogger, logger } from "../src/main/logger";
-import { getSessionLogPath, initSessionLog, shutdownSessionLog } from "../src/main/session-log";
-import { getTraceConfig, getTraceConfigPath, getTraceLogPath, initTraceLog, logTraceEvent, setTraceEnabled, shutdownTraceLog } from "../src/main/trace-log";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  shutdownSessionLog();
-  shutdownTraceLog();
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("trace-log", () => {
-  it("captures main log lines and explicit trace events when enabled", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-tlog-"));
-    tempDirs.push(baseDir);
-
-    configureLogger(baseDir);
-    initTraceLog(baseDir);
-    initSessionLog(baseDir);
-    setTraceEnabled(true, "test");
-
-    logger.info("TRACE-MAIN-CAPTURE");
-    logTraceEvent("INFO", "audit", "TRACE-AUDIT-CAPTURE", { source: "test" });
-
-    await new Promise((resolve) => setTimeout(resolve, 350));
-
-    const traceLogPath = getTraceLogPath();
-    const sessionLogPath = getSessionLogPath();
-    const traceConfigPath = getTraceConfigPath();
-    expect(traceLogPath).not.toBeNull();
-    expect(sessionLogPath).not.toBeNull();
-    expect(traceConfigPath).not.toBeNull();
-
-    const traceContent = fs.readFileSync(traceLogPath!, "utf8");
-    expect(traceContent).toContain("Trace-Log Start");
-    expect(traceContent).toContain("TRACE-MAIN-CAPTURE");
-    expect(traceContent).toContain("TRACE-AUDIT-CAPTURE");
-
-    const sessionContent = fs.readFileSync(sessionLogPath!, "utf8");
-    expect(sessionContent).toContain("TRACE-MAIN-CAPTURE");
-
-    const traceConfig = getTraceConfig();
-    expect(traceConfig.enabled).toBe(true);
-    expect(traceConfig.autoDisableAt).toBeTruthy();
-    expect(JSON.parse(fs.readFileSync(traceConfigPath!, "utf8")).enabled).toBe(true);
-  });
-
-  it("auto-disables support trace after the requested duration", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-tlog-expire-"));
-    tempDirs.push(baseDir);
-
-    configureLogger(baseDir);
-    initTraceLog(baseDir);
-    setTraceEnabled(true, "expire-test", 50);
-
-    await new Promise((resolve) => setTimeout(resolve, 350));
-
-    const traceConfig = getTraceConfig();
-    expect(traceConfig.enabled).toBe(false);
-    expect(traceConfig.autoDisableAt).toBeNull();
-
-    const traceLogPath = getTraceLogPath();
-    expect(traceLogPath).not.toBeNull();
-    const traceContent = fs.readFileSync(traceLogPath!, "utf8");
-    expect(traceContent).toContain("Support-Trace automatisch deaktiviert");
-  });
-
-  it("rotates oversized trace logs on startup", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-tlog-rotate-"));
-    tempDirs.push(baseDir);
-
-    const oversizedPath = path.join(baseDir, "trace.log");
-    fs.mkdirSync(baseDir, { recursive: true });
-    fs.writeFileSync(oversizedPath, "x".repeat(10 * 1024 * 1024 + 256), "utf8");
-
-    initTraceLog(baseDir);
-
-    expect(fs.existsSync(oversizedPath)).toBe(true);
-    expect(fs.existsSync(`${oversizedPath}.old`)).toBe(true);
-    const currentContent = fs.readFileSync(oversizedPath, "utf8");
-    expect(currentContent).toContain("Trace-Log Start");
-  });
-});