.claude/memory-bank.md

@@ -0,0 +1,126 @@
+# Memory Bank - Multi Debrid Downloader
+
+## Projekt-Überblick
+
+**Name:** Multi Debrid Downloader (MDD)  
+**Typ:** Electron Desktop App für Windows 10/11  
+**Repository:** 
+- Codeberg: https://codeberg.org/Sucukdeluxe/real-debrid-downloader.git
+- GitHub: https://github.com/Sucukdeluxe/real-debrid-downloader.git
+
+## Technologie-Stack
+
+- **Runtime:** Electron 31.x
+- **Frontend:** React 18.x + TypeScript 5.x
+- **Build:** Vite (Renderer) + tsup (Main/Preload)
+- **Tests:** Vitest (262+ Tests)
+- **Installer:** NSIS via electron-builder
+
+## Unterstützte Debrid-Provider
+
+| Provider | Auth | Priorität |
+|----------|------|-----------|
+| Real-Debrid | API Token | Primär |
+| Mega-Debrid | Login + Passwort | Fallback 1 |
+| BestDebrid | API Token | Fallback 2 |
+| AllDebrid | API Key | Fallback 3 |
+
+## Kernfeatures
+
+- **Queue-Management:** Package-basierte Organisation mit Drag & Drop
+- **Auto-Extract:** RAR, ZIP, 7z mit Passwortliste
+- **Auto-Rename:** Scene-Release Muster (4sf/4sj) → saubere Namen
+- **Integritätsprüfung:** CRC32, MD5, SHA1 via SFV-Dateien
+- **Provider-Fallback:** Automatischer Wechsel bei Fehlern/Fair-Use
+- **Session-Persistenz:** Queue überlebt App-Neustart
+- **Clipboard-Watcher:** Automatische Link-Erkennung
+- **System-Tray:** Minimize to Tray
+- **Speed-Limit:** Global oder per Download + Bandwidth-Schedules
+- **MKV-Sammelordner:** Automatisches Verschieben nach Paketabschluss
+- **Update-System:** Automatische Updates via Codeberg Releases
+
+## Projektstruktur
+
+```
+src/
+├── main/           # Electron Main Process
+│   ├── main.ts           # Entry Point, IPC Handler, Window Management
+│   ├── app-controller.ts # Koordiniert DownloadManager + Settings
+│   ├── download-manager.ts # Core: Queue, Downloads, Retry-Logic
+│   ├── debrid.ts         # Debrid-Service Abstraktion
+│   ├── realdebrid.ts     # Real-Debrid API Client
+│   ├── extractor.ts      # Archiv-Entpackung
+│   ├── integrity.ts      # CRC32/Hash-Validierung
+│   ├── storage.ts        # Session/Settings Persistenz
+│   ├── update.ts         # Update-Check & Installation
+│   └── ...
+├── renderer/       # React UI
+│   ├── App.tsx           # Hauptkomponente mit allen Tabs
+│   └── styles.css        # Styling
+├── preload/        # Preload Script (IPC Bridge)
+│   └── preload.ts
+└── shared/         # Geteilte Types
+    ├── types.ts          # Alle TypeScript Interfaces
+    ├── ipc.ts            # IPC Channel Konstanten
+    └── preload-api.ts    # window.rd API Definition
+```
+
+## Wichtige Types (src/shared/types.ts)
+
+- `DownloadItem`: Einzelner Download mit Status, Progress, Speed
+- `PackageEntry`: Gruppe von Downloads mit OutputDir, ExtractDir
+- `SessionState`: Gesamter Queue-Zustand (persistiert)
+- `AppSettings`: Alle Einstellungen
+- `UiSnapshot`: Kompletter UI-State für Renderer
+
+## IPC Channels (src/shared/ipc.ts)
+
+Hauptchannels für Renderer ↔ Main Kommunikation:
+- `GET_SNAPSHOT`, `STATE_UPDATE`: State-Sync
+- `ADD_LINKS`, `ADD_CONTAINERS`: Queue befüllen
+- `START`, `STOP`, `TOGGLE_PAUSE`: Download-Kontrolle
+- `UPDATE_SETTINGS`: Einstellungen ändern
+
+## Aktuelle Version
+
+**Version:** 1.5.27  
+**Letztes Release:** 1.4.68 (2026-03-01)
+
+### Letzte Änderungen (CHANGELOG)
+- Session-Backup für Queue-Zustand
+- Start-Konflikt-Behandlung verbessert
+- Mega-Web Unrestrict abort-fähig
+- DLC-Import gehärtet
+- Auto-Renamer erweitert
+
+## Offene Pläne
+
+1. **Native Menüleiste** (`.claude/plans/agile-watching-lampson.md`)
+   - JDownloader 2 Style Menü
+   - Electron Menu API nutzen
+   - Bestehende React Menu-Bar ersetzen
+
+## Coding-Conventions
+
+- TypeScript strict mode
+- Async/Await über Promises
+- Deutsche UI-Texte
+- Ausführliche Error-Logs via `logger`
+- Retry-Logic mit exponential backoff
+- AbortController für abbrechbare Operationen
+
+## Build & Release
+
+```bash
+npm run build        # TypeScript + Vite Build
+npm run dist         # electron-builder (NSIS + Portable)
+npm test             # Vitest Tests
+npm run self-check   # Vollständiger Check (Typecheck + Tests)
+```
+
+## Wichtige Dateien
+
+- `CHANGELOG.md` - Detaillierte Versionshistorie
+- `.claude/plans/` - Feature-Pläne
+- `tests/` - Umfangreiche Test-Suite
+- `installer/RealDebridDownloader.iss` - Inno Setup Script

.claude/plans/agile-watching-lampson.md

@@ -0,0 +1,66 @@
+# Native Menüleiste (JDownloader 2 Style)
+
+## Context
+Die App hat aktuell keine native Menüleiste (nur ein Tray-Kontextmenü). Der User möchte eine Menüleiste oben links wie bei JDownloader 2 mit Datei-Menü, Shortcuts und Sicherungs-Funktion.
+
+## Features
+
+### "Datei"-Menü (oben links)
+| Menüpunkt | Shortcut | Aktion |
+|-----------|----------|--------|
+| Text mit Links analysieren | Ctrl+L | Wechselt zum Linksammler-Tab |
+| Linkcontainer laden | Ctrl+O | Öffnet DLC-Dateiauswahl (existiert bereits) |
+| --- Separator --- | | |
+| Sicherung → Backup erstellen | | Exportiert Queue als JSON (existiert: `exportQueue`) |
+| Sicherung → Backup laden | | Importiert Queue-JSON (existiert: `importQueue`) |
+| --- Separator --- | | |
+| Neustart | Ctrl+Shift+R | `app.relaunch()` + `app.quit()` |
+| Beenden | Ctrl+Q | `app.quit()` |
+
+## Implementation
+
+### Step 1: Neue IPC-Channels
+**Datei:** `src/shared/ipc.ts`
+- `NAVIGATE_TAB: "app:navigate-tab"` — Renderer wechselt Tab
+- `RESTART: "app:restart"` — App neustarten
+- `SAVE_BACKUP: "dialog:save-backup"` — Save-Dialog + Export
+- `LOAD_BACKUP: "dialog:load-backup"` — Open-Dialog + Import
+
+### Step 2: Preload-API erweitern
+**Datei:** `src/shared/preload-api.ts` + `src/preload/preload.ts`
+- `onNavigateTab(callback)` — Event-Listener für Tab-Wechsel
+- `saveBackup()` — Backup über nativen Save-Dialog speichern
+- `loadBackup()` — Backup über nativen Open-Dialog laden
+
+### Step 3: Menüleiste erstellen
+**Datei:** `src/main/main.ts`
+
+Neue Funktion `createApplicationMenu()` nach `createTray()`:
+- Nutzt `Menu.buildFromTemplate()` + `Menu.setApplicationMenu()`
+- "Datei"-Menü mit allen Punkten aus der Tabelle
+- Accelerators für Shortcuts (Electron handelt die automatisch)
+- Menü-Clicks senden IPC-Events an den Renderer oder rufen direkt Main-Process-Funktionen auf
+
+**Backup erstellen:** `dialog.showSaveDialog()` → `controller.exportQueue()` → `fs.writeFile()`
+**Backup laden:** `dialog.showOpenDialog()` → `fs.readFile()` → `controller.importQueue()`
+**Neustart:** `app.relaunch()` → `app.quit()`
+**Beenden:** `app.quit()`
+**Linksammler/DLC:** IPC-Event an Renderer senden
+
+### Step 4: Renderer reagiert auf Menü-Events
+**Datei:** `src/renderer/App.tsx`
+- `onNavigateTab` Listener registrieren im `useEffect`
+- Bei `"collector"` → `setTab("collector")`
+- DLC-Import: `pickContainers` + `addContainers` (bestehendes Pattern)
+
+## Dateien
+- `src/shared/ipc.ts` — Neue Channels
+- `src/shared/preload-api.ts` — Neue API-Methoden
+- `src/preload/preload.ts` — IPC-Bridge
+- `src/main/main.ts` — Menüleiste + IPC-Handler + Backup-Logik
+- `src/renderer/App.tsx` — Tab-Navigation Listener
+
+## Verification
+1. `npm run build`
+2. `npx vitest run` (schnelle Tests)
+3. Manuell: App starten, Datei-Menü prüfen, Shortcuts testen

.claude/settings.json

@@ -0,0 +1,6 @@
+{
+  "enabledPlugins": {
+    "frontend-design@claude-plugins-official": true,
+    "code-review@claude-plugins-official": true
+  }
+}

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:github.com)"
+    ]
+  }
+}

.claude/worktrees/nifty-vaughan

@@ -0,0 +1 @@
+Subproject commit f1e132b2ed4717667fd7318ecab22e5ef52da0cc

.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Build and Release
+
+permissions:
+  contents: write
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Apply tag version
+        shell: pwsh
+        run: |
+          $version = "${{ github.ref_name }}".TrimStart('v')
+          node scripts/set_version_node.mjs $version
+
+      - name: Build app
+        run: npm run build
+
+      - name: Build Windows artifacts
+        run: npm run release:win
+
+      - name: Pack portable zip
+        shell: pwsh
+        run: |
+          Compress-Archive -Path "release\win-unpacked\*" -DestinationPath "Real-Debrid-Downloader-win64.zip" -Force
+
+      - name: Publish GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            Real-Debrid-Downloader-win64.zip
+            release/*.exe
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -17,23 +17,9 @@ rd_download_manifest.json
 _update_staging/
 apply_update.cmd
 
-.claude/
-.github/
-docs/plans/
-CHANGELOG.md
-
 node_modules/
 .vite/
 coverage/
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
-
-# Forgejo deployment runtime files
-deploy/forgejo/.env
-deploy/forgejo/forgejo/
-deploy/forgejo/postgres/
-deploy/forgejo/caddy/data/
-deploy/forgejo/caddy/config/
-deploy/forgejo/caddy/logs/
-deploy/forgejo/backups/

CHANGELOG.md

@@ -0,0 +1,223 @@
+# Changelog
+
+Alle nennenswerten Aenderungen werden in dieser Datei dokumentiert.
+
+## 1.5.28 - 2026-03-02
+
+UI-Verbesserung: Visuelle Fortschrittsanzeigen in der Download-Liste (JDownloader 2 Style).
+
+### Features
+
+- **Visuelle Fortschrittsbalken:**
+  - Paket-Fortschritt wird jetzt als grafische Progress-Bar in der Spalte "Fortschritt" angezeigt.
+  - Einzelne Items haben ebenfalls eine kleinere Progress-Bar.
+  - Grüner Gradient (#22c55e → #4ade80) für bessere Text-Lesbarkeit.
+  - Prozentanzeige als Overlay-Text auf der Bar.
+
+## 1.4.68 - 2026-03-01
+
+Stabilitaets-Hotfix fuer Session-Verlust nach Update/Neustart: Session-Dateien haben jetzt ein robustes Backup-/Restore-Fallback.
+
+### Fixes
+
+- Session-Backup fuer Queue-Zustand eingefuehrt:
+  - Vor jedem Session-Save wird die vorherige Session als `.bak` gesichert (sync + async Pfad).
+  - Schuetzt gegen defekte/trunkierte Session-Datei beim Start.
+- Session-Autorestore beim Laden:
+  - Wenn `rd_session_state.json` defekt ist, wird automatisch `rd_session_state.json.bak` geladen.
+  - Das Backup wird danach best-effort wieder als primäre Session-Datei hergestellt.
+- Klarere Fehlersignale im Log:
+  - Eindeutige Meldung, ob primäre Session defekt war und Backup verwendet wurde.
+
+### Tests
+
+- Neue Tests in `tests/storage.test.ts`:
+  - Laden aus Session-Backup bei defekter primärer Session.
+  - Backup-Erstellung vor sync- und async-Session-Overwrite.
+
+## 1.4.67 - 2026-03-01
+
+Hotfix fuer einen kritischen Start-Konflikt-Datenverlust und zusaetzliche Renamer-Haertung fuer reale Scene-Muster.
+
+### Fixes
+
+- Start-Konflikt `Überspringen` loescht keine Pakete/Items mehr:
+  - Bereits entpackte Dateien bleiben erhalten.
+  - Offene Downloads bleiben in der Queue und koennen normal fortgesetzt werden.
+  - Laufende Tasks werden dabei als Paket-Stop statt als Cancel behandelt.
+- Start-Konflikt-Dialogtext in der UI praezisiert:
+  - `Entpacktes überspringen` statt missverstaendlichem `Überspringen`.
+  - Klare Info, dass nur erneutes Entpacken uebersprungen wird.
+- Auto-Renamer verbessert:
+  - Erkennt jetzt auch Episode-only Tokens wie `e01`/`e02` mit Staffel-Hinweis aus dem Ordner.
+  - Akzeptiert lowercase Group-Suffixe wie `-tmsf`.
+  - Robuster bei Source-Formaten wie `4sf-bs-720p-s01e05`.
+
+### Tests
+
+- Neue/angepasste Tests in:
+  - `tests/download-manager.test.ts` (Start-Konflikt-Skip behaelt Paket + Partial-Queue)
+  - `tests/auto-rename.test.ts` (e01/e02, lowercase suffix, odd source order)
+
+## 1.4.66 - 2026-03-01
+
+Hotfix fuer haengende "Link wird umgewandelt"-Faelle (insbesondere Mega-Web-Pfad), bei denen nur ein App-Neustart geholfen hat.
+
+### Fixes
+
+- Mega-Web-Unrestrict ist jetzt komplett abort-/timeout-faehig:
+  - Abort-Signale werden bis in den Mega-Web-Fallback durchgereicht.
+  - Laufende Polling-/Fetch-Schritte respektieren Stop/Timeout sofort.
+  - Wartende Jobs in der exklusiven Mega-Web-Queue koennen bei Abort sauber abbrechen.
+- Download-Manager kann haengende Unrestrict-Phasen dadurch wieder automatisch per Timeout + Retry aufloesen, statt dauerhaft in "Link wird umgewandelt" zu bleiben.
+
+### Tests
+
+- Neue Tests sichern den Fix ab:
+  - Abort-Weitergabe bei Mega-Web-Unrestrict in `tests/debrid.test.ts`.
+  - Abort waehrend Mega-Web-Polling in `tests/mega-web-fallback.test.ts`.
+
+## 1.4.33 - 2026-03-02
+
+Hotfix-Release fuer zwei reale Produktionsprobleme: falsche Gesamt-Statistik bei leerer Queue und stilles DLC-Import-Failure bei Drag-and-Drop.
+
+### Fixes
+
+- **Stats-Anzeige korrigiert ("Gesamt" bei leerer Queue):**
+  - Wenn keine Pakete/Items mehr vorhanden sind, werden persistierte Run-Bytes und Run-Timestamps jetzt sauber auf 0 zurueckgesetzt.
+  - Dadurch verschwindet die Ghost-Anzeige wie z. B. `Gesamt: 19.99 GB` bei `Pakete: 0 / Dateien: 0`.
+  - Reset greift in den relevanten Pfaden (`getStats`, `clearAll`, Paket-Entfernung, Startup-Normalisierung).
+
+- **DLC Drag-and-Drop Import gehaertet:**
+  - Lokale DLC-Fehler wie `Ungültiges DLC-Padding` blockieren den Fallback zu dcrypt nicht mehr.
+  - Oversize/invalid-size DLCs werden weiterhin defensiv behandelt, aber valide Dateien im gleichen Batch werden nicht mehr still geschluckt.
+  - Wenn alle DLC-Imports fehlschlagen, wird jetzt ein klarer Fehler mit Ursache geworfen statt still `0 Paket(e), 0 Link(s)` zu melden.
+
+- **UI-Rueckmeldung verbessert:**
+  - Bei DLC-Import mit `0` Treffern zeigt die UI jetzt eine klare Meldung (`Keine gültigen Links in den DLC-Dateien gefunden`) statt eines irrefuehrenden Erfolgs-Toast.
+
+### Tests
+
+- Neue/erweiterte Tests fuer:
+  - Reset von `totalDownloadedBytes`/Stats bei leerer Queue.
+  - DLC-Fallback-Pfad bei lokalen Decrypt-Exceptions.
+  - Fehlerausgabe bei vollstaendig fehlgeschlagenem DLC-Import.
+- Validierung:
+  - `npx tsc --noEmit` erfolgreich
+  - `npm test` erfolgreich (`283/283`)
+  - `npm run self-check` erfolgreich
+
+## 1.4.32 - 2026-03-01
+
+Diese Version erweitert den Auto-Renamer stark fuer reale Scene-/TV-Release-Strukturen (nested und flat) und fuehrt eine intensive Renamer-Regression mit zusaetzlichen Edge-Case- und Stress-Checks ein.
+
+### Renamer (Download-Manager)
+
+- Erweiterte Mustererkennung fuer nested und flat Staffel-Ordner mit Group-Suffix (z. B. `-TMSF`, `-TVS`, `-TvR`, `-ZZGtv`, `-SunDry`).
+- Episode-Token kann jetzt auch aus kompakten Codes im Source-Namen abgeleitet werden (z. B. `301` -> `S03E01`, `211` -> `S02E11`, `101` -> `S01E01`), sofern Staffel-Hinweise vorhanden sind.
+- `Teil1/Teil2` bzw. `Part1/Part2` wird auf `SxxExx` gemappt, inklusive Staffel-Ableitung aus der Ordnerstruktur.
+- Repack-Handling ueber Dateiname und Ordnerstruktur vereinheitlicht (`rp`/`repack` -> `REPACK`-Token konsistent im Zielnamen).
+- Flat-Season-Ordner (Dateien direkt im Staffelordner) bekommen jetzt sauberes Episode-Inlining statt unspezifischer Season-Dateinamen.
+- Pfadlaengen-Schutz auf Windows gehaertet: erst normaler Zielname, dann deterministischer Paket-Fallback (z. B. `Show.S08E20`), danach sicherer Skip mit Warnlog statt fehlerhaftem Rename.
+
+### Abgedeckte reale Muster (Beispiele)
+
+- Arrow / Gotham / Britannia / Legion / Lethal.Weapon / Agent.X / Last.Impact
+- Nested Unterordner mit Episodentiteln und flache Staffelordner mit vielen Episoden-Dateien
+- Uneinheitliche Source-Namen wie `tvs-...-301`, `...-211`, `...teil1...`, `...rp...`
+
+### Intensive Bugtests
+
+- Unit-Tests fuer Renamer deutlich ausgebaut (`tests/auto-rename.test.ts`) mit zusaetzlichen realen Pattern- und Compact-Code-Faellen.
+- Zusätzliche intensive Szenario- und Stress-Checks mit temporaeren Testdateien ausgefuehrt (nested/flat, Repack, Teil/Part, Compact-Code, Pfadlaenge, Kollisionsschutz).
+- TypeScript Typecheck erfolgreich.
+- Voller Vitest Lauf erfolgreich (`279/279`).
+- End-to-End Self-Check erfolgreich.
+
+## 1.4.31 - 2026-03-01
+
+Diese Version schliesst die komplette Bug-Audit-Runde (156 Punkte) ab und fokussiert auf Stabilitaet, Datenintegritaet, sauberes Abbruchverhalten und reproduzierbares Release-Verhalten.
+
+### Audit-Abschluss
+
+- Vollstaendige Abarbeitung der Audit-Liste `Bug-Audit-Komplett-156-Bugs.txt` ueber Main-Process, Renderer, Storage, Update, Integrity und Logger.
+- Vereinheitlichte Fehlerbehandlung fuer Netzwerk-, Abort-, Retry- und Timeout-Pfade.
+- Harte Regression-Absicherung ueber Typecheck, Unit-Tests und Release-Build.
+
+### Download-Manager (Queue, Retry, Stop/Start, Post-Processing)
+
+- Retry-Status ist jetzt item-gebunden statt call-lokal (kein Retry-Reset bei Requeue, keine Endlos-Retry-Schleifen mehr).
+- Stop-zu-Start-Resume in derselben Session repariert (gestoppte Items werden wieder sauber gequeued).
+- HTTP-416-Pfade gehaertet (Body-Konsum, korrektes Fehlerbild im letzten Attempt, Contribution-Reset bei Datei-Neustart).
+- Target-Path-Reservierung gegen Race-Fenster verbessert (kein verfruehtes Release waehrend Retry-Delay).
+- Scheduler-Verhalten bei Reconnect/Abort bereinigt, inklusive Status- und Speed-Resets in Abbruchpfaden.
+- Post-Processing/Extraction-Abbruch und Paket-Lifecycle synchronisiert (inkl. Cleanup und Run-Finish-Konsistenz).
+- `prepareForShutdown()` raeumt Persist- und State-Emitter-Timer jetzt vollstaendig auf.
+- Read-only Queue-Checks entkoppelt von mutierenden Seiteneffekten.
+
+### Extractor
+
+- Cleanup-Modus `trash` ueberarbeitet (keine permanente Loeschung mehr im Trash-Pfad).
+- Konfliktmodus-Weitergabe in ZIP- und External-Fallback-Pfaden konsistent gemacht.
+- Fortschritts-Puls robust gegen callback-exceptions (kein unhandled crash durch `onProgress`).
+- ZIP/Volume-Erkennung und Cleanup-Targets fuer Multi-Part-Archive erweitert.
+- Schutz gegen gefaehrliche ZIP-Eintraege und Problemarchive weiter gehaertet.
+
+### Debrid / RealDebrid
+
+- Abort-signale werden in Filename-Resolution und Provider-Fallback konsequent respektiert.
+- Provider-Fallback bricht bei Abort sofort ab statt weitere Provider zu probieren.
+- Rapidgator-Filename-Resolution auf Content-Type, Retry-Klassen und Body-Handling gehaertet.
+- AllDebrid/BestDebrid URL-Validierung verbessert (nur gueltige HTTP(S)-direct URLs).
+- User-Agent-Versionsdrift beseitigt (nun zentral ueber `APP_VERSION`).
+- RealDebrid-Retry-Backoff ist abort-freundlich (kein unnoetiges Warten nach Stop/Abort).
+
+### Storage / Session / Settings
+
+- Temp-Dateipfade fuer Session-Save gegen Race/Kollision gehaertet.
+- Session-Normalisierung und PackageOrder-Deduplizierung stabilisiert.
+- Settings-Normalisierung tightened (kein unkontrolliertes Property-Leaking).
+- Import- und Update-Pfade robust gegen invalides Input-Shape.
+
+### Main / App-Controller / IPC
+
+- IPC-Validierung erweitert (Payload-Typen, String-Laengen, Import-Size-Limits).
+- Auto-Resume Start-Reihenfolge korrigiert, damit der Renderer initiale States sicher erhaelt.
+- Fenster-Lifecycle-Handler fuer neu erstellte Fenster vereinheitlicht (macOS activate-recreate eingeschlossen).
+- Clipboard-Normalisierung unicode-sicher (kein Surrogate-Split bei Truncation).
+- Container-Path-Filter so korrigiert, dass legitime Dateinamen mit `..` nicht falsch verworfen werden.
+
+### Update-System
+
+- Dateinamenhygiene fuer Setup-Assets gehaertet (`basename` + sanitize gegen Traversal/RCE-Pfade).
+- Zielpfad-Kollisionen beseitigt (Timestamp + PID + UUID).
+- `spawn`-Error-Handling hinzugefuegt (kein unhandled EventEmitter crash beim Installer-Start).
+- Download-Pipeline auf Shutdown-abort vorbereitet; aktive Update-Downloads koennen sauber abgebrochen werden.
+- Stream/Timeout/Retry-Handling bei Download und Release-Fetch konsolidiert.
+
+### Integrity
+
+- CRC32-Berechnung optimiert (Lookup-Table + Event-Loop-Yield), deutlich weniger UI-/Loop-Blockade bei grossen Dateien.
+- Hash-Manifest-Lesen gecacht (reduzierte Disk-I/O bei Multi-File-Validierung).
+- Manifest-Key-Matching fuer relative Pfade und Basenamen vereinheitlicht.
+
+### Logger
+
+- Rotation im async- und fallback-Pfad vervollstaendigt.
+- Rotate-Checks pro Datei getrennt statt global geteilt.
+- Async-Flush robust gegen Log-Loss bei Write-Fehlern (pending Lines werden erst nach erfolgreichem Write entfernt).
+
+### Renderer (App.tsx)
+
+- Theme-Toggle, Sortier-Optimismus und Picker-Busy-Lifecycle gegen Race Conditions gehaertet.
+- Mounted-Guards fuer fruehe Unmount-Pfade ergaenzt.
+- Drag-and-Drop nutzt aktive Tab-Referenz robust ueber async Grenzen.
+- Confirm-Dialog-Text rendert Zeilenumbrueche korrekt.
+- PackageCard-Memovergleich erweitert (inkl. Dateiname) fuer korrekte Re-Renders.
+- Human-size Anzeige gegen negative/NaN Inputs gehaertet.
+
+### QA / Build / Release
+
+- TypeScript Typecheck erfolgreich.
+- Voller Vitest Lauf erfolgreich (`262/262`).
+- Windows Release-Build erfolgreich (NSIS + Portable).

CLAUDE.md

@@ -1,23 +0,0 @@
-## Release + Update Source (Wichtig)
-
-- Primäre Plattform ist `https://git.24-music.de`
-- Standard-Repo: `Administrator/real-debrid-downloader`
-- Nicht mehr primär über Codeberg/GitHub releasen
-
-## Releasen
-
-1. Token setzen:
-   - PowerShell: `$env:GITEA_TOKEN="<token>"`
-2. Release ausführen:
-   - `npm run release:gitea -- <version> [notes]`
-
-Das Script:
-- bumped `package.json`
-- baut Windows-Artefakte
-- pusht `main` + Tag
-- erstellt Release auf `git.24-music.de`
-- lädt Assets hoch
-
-## Auto-Update
-
-- Updater nutzt aktuell `git.24-music.de` als Standardquelle

README.md

@@ -1,6 +1,6 @@
 # Multi Debrid Downloader
 
-Desktop downloader with fast queue management, automatic extraction, and robust error handling.
+Desktop downloader for **Real-Debrid, Mega-Debrid, BestDebrid, and AllDebrid** with fast queue management, automatic extraction, and robust error handling.
 
 ![Platform](https://img.shields.io/badge/platform-Windows%2010%2F11-0078D6)
 ![Electron](https://img.shields.io/badge/Electron-31.x-47848F)
@@ -20,10 +20,8 @@ Desktop downloader with fast queue management, automatic extraction, and robust
 
 - Package-based queue with file status, progress, ETA, speed, and retry counters.
 - Start, pause, stop, and cancel for both single items and full packages.
-- Multi-select via Ctrl+Click for batch operations on packages and items.
 - Duplicate handling when adding links: keep, skip, or overwrite.
 - Session recovery after restart, including optional auto-resume.
-- Circuit breaker with escalating backoff cooldowns to handle provider outages gracefully.
 
 ### Debrid and link handling
 
@@ -34,30 +32,10 @@ Desktop downloader with fast queue management, automatic extraction, and robust
 
 ### Extraction, cleanup, and quality
 
-- JVM-based extraction backend using SevenZipJBinding + Zip4j (supports RAR, 7z, ZIP, and more).
-- Automatic fallback to legacy UnRAR/7z CLI tools when JVM is unavailable.
 - Auto-extract with separate target directory and conflict strategies.
-- Hybrid extraction: simultaneous downloading and extracting with smart I/O priority throttling.
+- Hybrid extraction, optional removal of link artifacts and sample files.
-- Nested extraction: archives within archives are automatically extracted (one level deep).
-- Pre-extraction disk space validation to prevent incomplete extracts.
-- Right-click "Extract now" on any package with at least one completed item.
 - Post-download integrity checks (`CRC32`, `MD5`, `SHA1`) with auto-retry on failures.
 - Completed-item cleanup policy: `never`, `immediate`, `on_start`, `package_done`.
-- Optional removal of link artifacts and sample files after extraction.
-
-### Auto-rename
-
-- Automatic renaming of extracted files based on series/episode patterns.
-- Multi-episode token parsing for batch renames.
-
-### UI and progress
-
-- Visual progress bars with percentage overlay for packages and individual items.
-- Real-time bandwidth chart showing current download speeds.
-- Persistent download counters: all-time totals and per-session statistics.
-- Download history for completed packages.
-- Vertical sidebar with organized settings tabs.
-- Hoster display showing both the original source and the debrid provider used.
 
 ### Convenience and automation
 
@@ -65,18 +43,17 @@ Desktop downloader with fast queue management, automatic extraction, and robust
 - Minimize-to-tray with tray menu controls.
 - Speed limits globally or per download.
 - Bandwidth schedules for time-based speed profiles.
-- Built-in auto-updater via `git.24-music.de` Releases.
+- Built-in update checks via Codeberg Releases.
-- Long path support (>260 characters) on Windows.
 
 ## Installation
 
 ### Option A: prebuilt releases (recommended)
 
-1. Download a release from the `git.24-music.de` Releases page.
+1. Download a release from the Codeberg Releases page.
 2. Run the installer or portable build.
 3. Add your debrid tokens in Settings.
 
-Releases: `https://git.24-music.de/Administrator/real-debrid-downloader/releases`
+Releases: `https://codeberg.org/Sucukdeluxe/real-debrid-downloader/releases`
 
 ### Option B: build from source
 
@@ -103,34 +80,21 @@ npm run dev
 | `npm test` | Runs Vitest unit tests |
 | `npm run self-check` | Runs integrated end-to-end self-checks |
 | `npm run release:win` | Creates Windows installer and portable build |
-| `npm run release:gitea -- <version> [notes]` | One-command version bump + build + tag + release upload to `git.24-music.de` |
+| `npm run release:codeberg -- <version> [notes]` | One-command version bump + build + tag + Codeberg release upload |
-| `npm run release:codeberg -- <version> [notes]` | Legacy path for old Codeberg workflow |
 
-### One-command git.24-music release
+### One-command Codeberg release
 
 ```bash
-npm run release:gitea -- 1.6.31 "- Maintenance update"
+npm run release:codeberg -- 1.4.42 "- Maintenance update"
 ```
 
 This command will:
 
 1. Bump `package.json` version.
 2. Build setup/portable artifacts (`npm run release:win`).
-3. Commit and push `main` to your `git.24-music.de` remote.
+3. Commit and push `main` to your Codeberg remote.
 4. Create and push tag `v<version>`.
-5. Create/update the Gitea release and upload required assets.
+5. Create/update the Codeberg release and upload required assets.
-
-Required once before release:
-
-```bash
-git remote add gitea https://git.24-music.de/<user>/<repo>.git
-```
-
-PowerShell token setup:
-
-```powershell
-$env:GITEA_TOKEN="<dein-token>"
-```
 
 ## Typical workflow
 
@@ -147,7 +111,6 @@ $env:GITEA_TOKEN="<dein-token>"
 - `src/renderer` - React UI
 - `src/shared` - shared types and IPC contracts
 - `tests` - unit tests and self-check tests
-- `resources/extractor-jvm` - SevenZipJBinding + Zip4j sidecar JAR and native libraries
 
 ## Data and logs
 
@@ -160,43 +123,13 @@ The app stores runtime files in Electron's `userData` directory, including:
 ## Troubleshooting
 
 - Download does not start: verify token and selected provider in Settings.
-- Extraction fails: check archive passwords and native extractor installation (7-Zip/WinRAR). Optional JVM extractor can be forced with `RD_EXTRACT_BACKEND=jvm`.
+- Extraction fails: check archive passwords, JVM runtime (`resources/extractor-jvm`), or force legacy mode with `RD_EXTRACT_BACKEND=legacy`.
 - Very slow downloads: check active speed limit and bandwidth schedules.
 - Unexpected interruptions: enable reconnect and fallback providers.
-- Stalled downloads: the app auto-detects stalls within 10 seconds and retries automatically.
 
 ## Changelog
 
-Release history is available on [git.24-music.de Releases](https://git.24-music.de/Administrator/real-debrid-downloader/releases).
+Release history is available in `CHANGELOG.md` and on Codeberg Releases.
-
-### v1.6.61 (2026-03-05)
-
-- Fixed leftover empty package folders in `Downloader Unfertig` after successful extraction.
-- Resume marker files (`.rd_extract_progress*.json`) are now treated as ignorable for empty-folder cleanup.
-- Deferred post-processing now clears resume markers before running empty-directory removal.
-
-### v1.6.60 (2026-03-05)
-
-- Added package-scoped password cache for extraction: once the first archive in a package is solved, following archives in the same package reuse that password first.
-- Kept fallback behavior intact (`""` and other candidates are still tested), but moved empty-password probing behind the learned password to reduce per-archive delays.
-- Added cache invalidation on real `wrong_password` failures so stale passwords are automatically discarded.
-
-### v1.6.59 (2026-03-05)
-
-- Switched default extraction backend to native tools (`legacy`) for more stable archive-to-archive flow.
-- Prioritized 7-Zip as primary native extractor, with WinRAR/UnRAR as fallback.
-- JVM extractor remains available as opt-in via `RD_EXTRACT_BACKEND=jvm`.
-
-### v1.6.58 (2026-03-05)
-
-- Fixed extraction progress oscillation (`1% -> 100% -> 1%` loops) during password retries.
-- Kept strict archive completion logic, but normalized in-progress archive percent to avoid false visual done states before real completion.
-
-### v1.6.57 (2026-03-05)
-
-- Fixed extraction flow so archives are marked done only on real completion, not on temporary `100%` progress spikes.
-- Improved password handling: after the first successful archive, the discovered password is prioritized for subsequent archives.
-- Fixed progress parsing for password retries (reset/restart handling), reducing visible and real gaps between archive extractions.
 
 ## License
 

_upload_release.mjs

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const credResult = spawnSync("git", ["credential", "fill"], {
+  input: "protocol=https\nhost=codeberg.org\n\n",
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "pipe"]
+});
+const creds = new Map();
+for (const line of credResult.stdout.split(/\r?\n/)) {
+  if (line.includes("=")) {
+    const [k, v] = line.split("=", 2);
+    creds.set(k, v);
+  }
+}
+const auth = "Basic " + Buffer.from(creds.get("username") + ":" + creds.get("password")).toString("base64");
+const owner = "Sucukdeluxe";
+const repo = "real-debrid-downloader";
+const tag = "v1.5.35";
+const baseApi = `https://codeberg.org/api/v1/repos/${owner}/${repo}`;
+
+async function main() {
+  await fetch(baseApi, {
+    method: "PATCH",
+    headers: { Authorization: auth, "Content-Type": "application/json" },
+    body: JSON.stringify({ has_releases: true })
+  });
+
+  const createRes = await fetch(`${baseApi}/releases`, {
+    method: "POST",
+    headers: { Authorization: auth, "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify({
+      tag_name: tag,
+      target_commitish: "main",
+      name: tag,
+      body: "- Fix: Fortschritt zeigt jetzt kombinierten Wert (Download + Entpacken)\n- Fix: Pausieren zeigt nicht mehr 'Warte auf Daten'\n- Pixel-perfekte Dual-Layer Progress-Bar Texte (clip-path)",
+      draft: false,
+      prerelease: false
+    })
+  });
+  const release = await createRes.json();
+  if (!createRes.ok) {
+    console.error("Create failed:", JSON.stringify(release));
+    process.exit(1);
+  }
+  console.log("Release created:", release.id);
+
+  const files = [
+    "Real-Debrid-Downloader Setup 1.5.35.exe",
+    "Real-Debrid-Downloader 1.5.35.exe",
+    "latest.yml",
+    "Real-Debrid-Downloader Setup 1.5.35.exe.blockmap"
+  ];
+  for (const f of files) {
+    const filePath = path.join("release", f);
+    const data = fs.readFileSync(filePath);
+    const uploadUrl = `${baseApi}/releases/${release.id}/assets?name=${encodeURIComponent(f)}`;
+    const res = await fetch(uploadUrl, {
+      method: "POST",
+      headers: { Authorization: auth, "Content-Type": "application/octet-stream" },
+      body: data
+    });
+    if (res.ok) {
+      console.log("Uploaded:", f);
+    } else if (res.status === 409 || res.status === 422) {
+      console.log("Skipped existing:", f);
+    } else {
+      console.error("Upload failed for", f, ":", res.status);
+    }
+  }
+  console.log(`Done! https://codeberg.org/${owner}/${repo}/releases/tag/${tag}`);
+}
+
+main().catch(e => { console.error(e.message); process.exit(1); });

docs/plans/2026-03-03-disk-space-nested-extraction-design.md

@@ -0,0 +1,48 @@
+# Disk Space Pre-Check + Nested Extraction
+
+## Context
+Two feature gaps identified from JDownloader 2 comparison:
+1. JD2 checks disk space before extraction (DiskSpaceReservation)
+2. JD2 supports archives within archives (nested/deep extraction)
+
+## Feature 1: Disk Space Pre-Check
+
+### Approach
+Before extracting, calculate total archive size (sum of all archive parts) and check free disk space on the target drive. Use 1.1x archive size as minimum requirement (scene releases are mostly video with minimal compression).
+
+### Behavior
+- Check runs once in `extractPackageArchives()` before the extraction loop
+- On insufficient space: abort extraction, set status to failed with message "Nicht genug Speicherplatz: X GB benötigt, Y GB frei"
+- User can retry after freeing space (existing retry mechanism)
+- Uses `fs.statfs()` (Node 18+) or platform-specific fallback for free space
+
+### Implementation Location
+- `extractor.ts`: New `checkDiskSpace()` function
+- Called at the top of `extractPackageArchives()` after finding candidates
+- Calculates total size from `collectArchiveCleanupTargets()` for each candidate
+
+## Feature 2: Nested Extraction (1 Level Deep)
+
+### Approach
+After successfully extracting all archives, scan the output directory for new archive files. If found, extract them once (no further nesting check).
+
+### Blacklist
+Skip: `.iso`, `.img`, `.bin`, `.dmg` (disk images should not be auto-extracted)
+
+### Behavior
+- Runs after successful extraction of all top-level archives
+- Calls `findArchiveCandidates()` on `targetDir`
+- Filters out blacklisted extensions
+- Extracts found archives with same options (passwords, conflict mode, etc.)
+- No recursive nesting — exactly one additional pass
+- Progress reported as second phase
+- Cleanup of nested archives follows same cleanup mode
+
+### Implementation Location
+- `extractor.ts`: New nested extraction pass at end of `extractPackageArchives()`
+- After the main extraction loop succeeds, before cleanup
+- Reuses existing `runExternalExtract()` / `extractZipArchive()`
+
+## Files
+- `src/main/extractor.ts` — both features
+- `tests/extractor.test.ts` — disk space check tests (mock fs.statfs)

docs/plans/2026-03-03-disk-space-nested-extraction.md

@@ -0,0 +1,398 @@
+# Disk Space Pre-Check + Nested Extraction Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Add JDownloader-style disk space checking before extraction and single-level nested archive extraction.
+
+**Architecture:** Two independent features in `extractor.ts`. Disk space check uses `fs.statfs()` to verify free space before starting. Nested extraction calls `findArchiveCandidates()` on the output directory after the main pass completes, then extracts any found archives once.
+
+**Tech Stack:** Node.js `fs.statfs`, existing UnRAR/WinRAR extraction pipeline, vitest for tests.
+
+---
+
+### Task 1: Disk Space Check — Utility Function
+
+**Files:**
+- Modify: `src/main/extractor.ts` (after line 96, before `zipEntryMemoryLimitBytes`)
+
+**Step 1: Add the `checkDiskSpaceForExtraction` function**
+
+Add after the constants block (line 96) in `extractor.ts`:
+
+```typescript
+const DISK_SPACE_SAFETY_FACTOR = 1.1;
+
+async function estimateArchivesTotalBytes(candidates: string[]): Promise<number> {
+  let total = 0;
+  for (const archivePath of candidates) {
+    const parts = collectArchiveCleanupTargets(archivePath);
+    for (const part of parts) {
+      try {
+        total += (await fs.promises.stat(part)).size;
+      } catch { /* missing part, ignore */ }
+    }
+  }
+  return total;
+}
+
+function humanSizeGB(bytes: number): string {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(0)} MB`;
+}
+
+async function checkDiskSpaceForExtraction(targetDir: string, candidates: string[]): Promise<void> {
+  if (candidates.length === 0) return;
+  const archiveBytes = await estimateArchivesTotalBytes(candidates);
+  if (archiveBytes <= 0) return;
+  const requiredBytes = Math.ceil(archiveBytes * DISK_SPACE_SAFETY_FACTOR);
+
+  let freeBytes: number;
+  try {
+    const stats = await fs.promises.statfs(targetDir);
+    freeBytes = stats.bfree * stats.bsize;
+  } catch {
+    // statfs not supported or target doesn't exist yet — skip check
+    return;
+  }
+
+  if (freeBytes < requiredBytes) {
+    const msg = `Nicht genug Speicherplatz: ${humanSizeGB(requiredBytes)} benötigt, ${humanSizeGB(freeBytes)} frei`;
+    logger.error(`Disk-Space-Check: ${msg} (target=${targetDir})`);
+    throw new Error(msg);
+  }
+  logger.info(`Disk-Space-Check OK: ${humanSizeGB(freeBytes)} frei, ${humanSizeGB(requiredBytes)} benötigt (target=${targetDir})`);
+}
+```
+
+**Step 2: Wire into `extractPackageArchives`**
+
+In `extractPackageArchives()`, after the candidates are filtered (line ~1230, after the log line), add:
+
+```typescript
+  // Disk space pre-check
+  try {
+    await fs.promises.mkdir(options.targetDir, { recursive: true });
+  } catch { /* ignore */ }
+  await checkDiskSpaceForExtraction(options.targetDir, candidates);
+```
+
+This goes right after line 1230 (`logger.info(...)`) and before line 1231 (`if (candidates.length === 0)`).
+
+**Step 3: Build and verify**
+
+Run: `npm run build`
+Expected: Compiles without errors.
+
+**Step 4: Commit**
+
+```
+feat: add disk space pre-check before extraction
+```
+
+---
+
+### Task 2: Disk Space Check — Tests
+
+**Files:**
+- Modify: `tests/extractor.test.ts`
+
+**Step 1: Add disk space test**
+
+Add a new `describe("disk space check")` block in the extractor test file. Since `checkDiskSpaceForExtraction` is a private function, test it indirectly via `extractPackageArchives` — create a temp dir with a tiny zip, mock `fs.promises.statfs` to return very low free space, and verify extraction fails with the right message.
+
+```typescript
+describe("disk space check", () => {
+  it("aborts extraction when disk space is insufficient", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-diskspace-"));
+    tempDirs.push(root);
+    const packageDir = path.join(root, "pkg");
+    const targetDir = path.join(root, "out");
+    fs.mkdirSync(packageDir, { recursive: true });
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    // Create a small zip
+    const zip = new AdmZip();
+    zip.addFile("test.txt", Buffer.alloc(1024, 0x41));
+    zip.writeZip(path.join(packageDir, "test.zip"));
+
+    // Mock statfs to report almost no free space
+    const originalStatfs = fs.promises.statfs;
+    (fs.promises as any).statfs = async () => ({ bfree: 1, bsize: 1 });
+
+    try {
+      await expect(
+        extractPackageArchives({
+          packageDir,
+          targetDir,
+          cleanupMode: "none" as any,
+          conflictMode: "overwrite" as any,
+          removeLinks: false,
+          removeSamples: false,
+        })
+      ).rejects.toThrow(/Nicht genug Speicherplatz/);
+    } finally {
+      (fs.promises as any).statfs = originalStatfs;
+    }
+  });
+
+  it("proceeds when disk space is sufficient", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-diskspace-ok-"));
+    tempDirs.push(root);
+    const packageDir = path.join(root, "pkg");
+    const targetDir = path.join(root, "out");
+    fs.mkdirSync(packageDir, { recursive: true });
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    const zip = new AdmZip();
+    zip.addFile("test.txt", Buffer.alloc(1024, 0x41));
+    zip.writeZip(path.join(packageDir, "test.zip"));
+
+    // Don't mock statfs — real disk should have enough space
+    const result = await extractPackageArchives({
+      packageDir,
+      targetDir,
+      cleanupMode: "none" as any,
+      conflictMode: "overwrite" as any,
+      removeLinks: false,
+      removeSamples: false,
+    });
+    expect(result.extracted).toBe(1);
+    expect(result.failed).toBe(0);
+  });
+});
+```
+
+**Step 2: Run tests**
+
+Run: `npx vitest run tests/extractor.test.ts`
+Expected: All tests pass including new disk space tests.
+
+**Step 3: Commit**
+
+```
+test: add disk space pre-check tests
+```
+
+---
+
+### Task 3: Nested Extraction — Implementation
+
+**Files:**
+- Modify: `src/main/extractor.ts` (in `extractPackageArchives`, after line ~1404 main loop ends)
+
+**Step 1: Add the nested extraction blacklist constant**
+
+Add near the top of the file (after ARCHIVE_SORT_COLLATOR, line 96):
+
+```typescript
+const NESTED_EXTRACT_BLACKLIST_RE = /\.(iso|img|bin|dmg)$/i;
+```
+
+**Step 2: Add nested extraction pass in `extractPackageArchives`**
+
+After the main extraction for-loop ends (line ~1404, after the last `clearInterval(pulseTimer)`) and before the `if (extracted > 0)` block (line 1406), add:
+
+```typescript
+  // ── Nested extraction: check output dir for archives produced by extraction ──
+  if (extracted > 0 && failed === 0 && !options.skipPostCleanup && !options.onlyArchives) {
+    try {
+      const nestedCandidates = (await findArchiveCandidates(options.targetDir))
+        .filter((p) => !NESTED_EXTRACT_BLACKLIST_RE.test(p));
+      if (nestedCandidates.length > 0) {
+        logger.info(`Nested-Extraction: ${nestedCandidates.length} Archive im Output gefunden`);
+
+        // Disk space check for nested archives too
+        try {
+          await checkDiskSpaceForExtraction(options.targetDir, nestedCandidates);
+        } catch (spaceError) {
+          logger.warn(`Nested-Extraction Disk-Space-Check fehlgeschlagen: ${String(spaceError)}`);
+          // Don't fail the whole extraction, just skip nesting
+          nestedCandidates.length = 0;
+        }
+
+        for (const nestedArchive of nestedCandidates) {
+          if (options.signal?.aborted) {
+            throw new Error("aborted:extract");
+          }
+          const nestedName = path.basename(nestedArchive);
+          const nestedKey = archiveNameKey(nestedName);
+          if (resumeCompleted.has(nestedKey)) {
+            logger.info(`Nested-Extraction übersprungen (bereits entpackt): ${nestedName}`);
+            continue;
+          }
+          const nestedStartedAt = Date.now();
+          let nestedPercent = 0;
+          emitProgress(extracted + failed, `nested: ${nestedName}`, "extracting", nestedPercent, 0);
+          const nestedPulse = setInterval(() => {
+            emitProgress(extracted + failed, `nested: ${nestedName}`, "extracting", nestedPercent, Date.now() - nestedStartedAt);
+          }, 1100);
+          const hybrid = Boolean(options.hybridMode);
+          logger.info(`Nested-Entpacke: ${nestedName} -> ${options.targetDir}${hybrid ? " (hybrid)" : ""}`);
+          try {
+            const ext = path.extname(nestedArchive).toLowerCase();
+            if (ext === ".zip") {
+              try {
+                await extractZipArchive(nestedArchive, options.targetDir, options.conflictMode, options.signal);
+                nestedPercent = 100;
+              } catch (zipErr) {
+                if (!shouldFallbackToExternalZip(zipErr)) throw zipErr;
+                const usedPw = await runExternalExtract(nestedArchive, options.targetDir, options.conflictMode, passwordCandidates, (v) => { nestedPercent = Math.max(nestedPercent, v); }, options.signal, hybrid);
+                passwordCandidates = prioritizePassword(passwordCandidates, usedPw);
+              }
+            } else {
+              const usedPw = await runExternalExtract(nestedArchive, options.targetDir, options.conflictMode, passwordCandidates, (v) => { nestedPercent = Math.max(nestedPercent, v); }, options.signal, hybrid);
+              passwordCandidates = prioritizePassword(passwordCandidates, usedPw);
+            }
+            extracted += 1;
+            resumeCompleted.add(nestedKey);
+            await writeExtractResumeState(options.packageDir, resumeCompleted, options.packageId);
+            logger.info(`Nested-Entpacken erfolgreich: ${nestedName}`);
+            // Cleanup nested archive after successful extraction
+            if (options.cleanupMode === "delete") {
+              const nestedParts = collectArchiveCleanupTargets(nestedArchive);
+              for (const part of nestedParts) {
+                try { await fs.promises.unlink(part); } catch { /* ignore */ }
+              }
+            }
+          } catch (nestedErr) {
+            const errText = String(nestedErr);
+            if (isExtractAbortError(errText)) throw new Error("aborted:extract");
+            if (isNoExtractorError(errText)) {
+              logger.warn(`Nested-Extraction: Kein Extractor, überspringe restliche`);
+              break;
+            }
+            failed += 1;
+            lastError = errText;
+            logger.error(`Nested-Entpack-Fehler ${nestedName}: ${errText}`);
+          } finally {
+            clearInterval(nestedPulse);
+          }
+        }
+      }
+    } catch (nestedError) {
+      const errText = String(nestedError);
+      if (isExtractAbortError(errText)) throw new Error("aborted:extract");
+      logger.warn(`Nested-Extraction Fehler: ${cleanErrorText(errText)}`);
+    }
+  }
+```
+
+**Step 3: Build and verify**
+
+Run: `npm run build`
+Expected: Compiles without errors.
+
+**Step 4: Commit**
+
+```
+feat: add single-level nested archive extraction
+```
+
+---
+
+### Task 4: Nested Extraction — Tests
+
+**Files:**
+- Modify: `tests/extractor.test.ts`
+
+**Step 1: Add nested extraction test**
+
+```typescript
+describe("nested extraction", () => {
+  it("extracts archives found inside extracted output", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-nested-"));
+    tempDirs.push(root);
+    const packageDir = path.join(root, "pkg");
+    const targetDir = path.join(root, "out");
+    fs.mkdirSync(packageDir, { recursive: true });
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    // Create inner zip with a text file
+    const innerZip = new AdmZip();
+    innerZip.addFile("deep.txt", Buffer.from("deep content"));
+
+    // Create outer zip containing the inner zip
+    const outerZip = new AdmZip();
+    outerZip.addFile("inner.zip", innerZip.toBuffer());
+    outerZip.writeZip(path.join(packageDir, "outer.zip"));
+
+    const result = await extractPackageArchives({
+      packageDir,
+      targetDir,
+      cleanupMode: "none" as any,
+      conflictMode: "overwrite" as any,
+      removeLinks: false,
+      removeSamples: false,
+    });
+
+    // outer.zip extracted (1) + inner.zip extracted (1) = 2
+    expect(result.extracted).toBe(2);
+    expect(result.failed).toBe(0);
+
+    // deep.txt should exist in the target
+    expect(fs.existsSync(path.join(targetDir, "deep.txt"))).toBe(true);
+  });
+
+  it("does not extract blacklisted extensions like .iso", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-nested-bl-"));
+    tempDirs.push(root);
+    const packageDir = path.join(root, "pkg");
+    const targetDir = path.join(root, "out");
+    fs.mkdirSync(packageDir, { recursive: true });
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    // Create a zip that contains a file named "disc.iso"
+    // (not a real archive, but tests the blacklist filter path)
+    const zip = new AdmZip();
+    zip.addFile("disc.iso", Buffer.alloc(64, 0));
+    zip.addFile("readme.txt", Buffer.from("hello"));
+    zip.writeZip(path.join(packageDir, "package.zip"));
+
+    const result = await extractPackageArchives({
+      packageDir,
+      targetDir,
+      cleanupMode: "none" as any,
+      conflictMode: "overwrite" as any,
+      removeLinks: false,
+      removeSamples: false,
+    });
+
+    expect(result.extracted).toBe(1); // Only outer zip, no nested
+    expect(fs.existsSync(path.join(targetDir, "disc.iso"))).toBe(true);
+    expect(fs.existsSync(path.join(targetDir, "readme.txt"))).toBe(true);
+  });
+});
+```
+
+**Step 2: Run all extractor tests**
+
+Run: `npx vitest run tests/extractor.test.ts`
+Expected: All tests pass.
+
+**Step 3: Commit**
+
+```
+test: add nested extraction tests
+```
+
+---
+
+### Task 5: Full Build + Test Verification
+
+**Step 1: Build**
+
+Run: `npm run build`
+Expected: Clean compile.
+
+**Step 2: Run all fast tests**
+
+Run: `npx vitest run tests/extractor.test.ts tests/utils.test.ts tests/storage.test.ts tests/integrity.test.ts tests/cleanup.test.ts tests/debrid.test.ts tests/auto-rename.test.ts`
+Expected: All pass (except pre-existing cleanup.test.ts failures).
+
+**Step 3: Final commit with version bump if releasing**
+
+```
+feat: disk space pre-check + nested extraction (JD2 parity)
+```

installer/RealDebridDownloader.iss

@@ -25,11 +25,11 @@ AppPublisher=Sucukdeluxe
 DefaultDirName={autopf}\{#MyAppName}
 DefaultGroupName={#MyAppName}
 OutputDir={#MyOutputDir}
-OutputBaseFilename=Real-Debrid-Downloader Setup {#MyAppVersion}
+OutputBaseFilename=Real-Debrid-Downloader-Setup-{#MyAppVersion}
 Compression=lzma
 SolidCompression=yes
 WizardStyle=modern
-PrivilegesRequired=lowest
+PrivilegesRequired=admin
 ArchitecturesInstallIn64BitMode=x64compatible
 UninstallDisplayIcon={app}\{#MyAppExeName}
 SetupIconFile={#MyIconFile}
@@ -39,8 +39,8 @@ Name: "german"; MessagesFile: "compiler:Languages\German.isl"
 Name: "english"; MessagesFile: "compiler:Default.isl"
 
 [Files]
-Source: "{#MySourceDir}\\*"; DestDir: "{app}"; Flags: recursesubdirs createallsubdirs
+Source: "{#MySourceDir}\\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
-Source: "{#MyIconFile}"; DestDir: "{app}"; DestName: "app_icon.ico"
+Source: "{#MyIconFile}"; DestDir: "{app}"; DestName: "app_icon.ico"; Flags: ignoreversion
 
 [Icons]
 Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app_icon.ico"

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "real-debrid-downloader",
-  "version": "1.5.66",
+  "version": "1.4.68",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "real-debrid-downloader",
-      "version": "1.5.66",
+      "version": "1.4.68",
       "license": "MIT",
       "dependencies": {
         "adm-zip": "^0.5.16",
@@ -25,7 +25,6 @@
         "cross-env": "^7.0.3",
         "electron": "^31.7.7",
         "electron-builder": "^25.1.8",
-        "rcedit": "^5.0.2",
         "tsup": "^8.3.6",
         "tsx": "^4.19.2",
         "typescript": "^5.7.3",
@@ -65,6 +64,7 @@
       "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@babel/generator": "^7.29.0",
@@ -2043,6 +2043,7 @@
       "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.2.2"
@@ -2304,6 +2305,7 @@
       "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -2477,7 +2479,6 @@
       "integrity": "sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "archiver-utils": "^2.1.0",
         "async": "^3.2.4",
@@ -2497,7 +2498,6 @@
       "integrity": "sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "glob": "^7.1.4",
         "graceful-fs": "^4.2.0",
@@ -2520,7 +2520,6 @@
       "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "core-util-is": "~1.0.0",
         "inherits": "~2.0.3",
@@ -2536,8 +2535,7 @@
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/archiver-utils/node_modules/string_decoder": {
       "version": "1.1.1",
@@ -2545,7 +2543,6 @@
       "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "safe-buffer": "~5.1.0"
       }
@@ -2765,6 +2762,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -3346,7 +3344,6 @@
       "integrity": "sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "buffer-crc32": "^0.2.13",
         "crc32-stream": "^4.0.2",
@@ -3520,7 +3517,6 @@
       "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "crc32": "bin/crc32.njs"
       },
@@ -3534,7 +3530,6 @@
       "integrity": "sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "crc-32": "^1.2.0",
         "readable-stream": "^3.4.0"
@@ -3577,54 +3572,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/cross-spawn-windows-exe": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/cross-spawn-windows-exe/-/cross-spawn-windows-exe-1.2.0.tgz",
-      "integrity": "sha512-mkLtJJcYbDCxEG7Js6eUnUNndWjyUZwJ3H7bErmmtOYU/Zb99DyUkpamuIZE0b3bhmJyZ7D90uS6f+CGxRRjOw==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/malept"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/subscription/pkg/npm-cross-spawn-windows-exe?utm_medium=referral&utm_source=npm_fund"
-        }
-      ],
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@malept/cross-spawn-promise": "^1.1.0",
-        "is-wsl": "^2.2.0",
-        "which": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/cross-spawn-windows-exe/node_modules/@malept/cross-spawn-promise": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
-      "integrity": "sha512-RTBGWL5FWQcg9orDOCcp4LvItNzUPcyEU9bwaeJX0rJ1IQxzucC48Y0/sQLp/g6t99IQgAlGIaesJS+gTn7tVQ==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/malept"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund"
-        }
-      ],
-      "license": "Apache-2.0",
-      "dependencies": {
-        "cross-spawn": "^7.0.1"
-      },
-      "engines": {
-        "node": ">= 10"
-      }
-    },
     "node_modules/csstype": {
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
@@ -3833,6 +3780,7 @@
       "integrity": "sha512-NoXo6Liy2heSklTI5OIZbCgXC1RzrDQsZkeEwXhdOro3FT1VBOvbubvscdPnjVuQ4AMwwv61oaH96AbiYg9EnQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "app-builder-lib": "25.1.8",
         "builder-util": "25.1.7",
@@ -4028,7 +3976,6 @@
       "integrity": "sha512-2ntkJ+9+0GFP6nAISiMabKt6eqBB0kX1QqHNWFWAXgi0VULKGisM46luRFpIBiU3u/TDmhZMM8tzvo2Abn3ayg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "app-builder-lib": "25.1.8",
         "archiver": "^5.3.1",
@@ -4042,7 +3989,6 @@
       "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "graceful-fs": "^4.2.0",
         "jsonfile": "^6.0.1",
@@ -4058,7 +4004,6 @@
       "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "universalify": "^2.0.0"
       },
@@ -4072,7 +4017,6 @@
       "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">= 10.0.0"
       }
@@ -4309,6 +4253,7 @@
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "esbuild": "bin/esbuild"
       },
@@ -4594,8 +4539,7 @@
       "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
       "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/fs-extra": {
       "version": "8.1.0",
@@ -5202,22 +5146,6 @@
         "is-ci": "bin.js"
       }
     },
-    "node_modules/is-docker": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
-      "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "is-docker": "cli.js"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/is-fullwidth-code-point": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
@@ -5258,26 +5186,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/is-wsl": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
-      "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-docker": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/isarray": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
       "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/isbinaryfile": {
       "version": "5.0.7",
@@ -5462,7 +5376,6 @@
       "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "readable-stream": "^2.0.5"
       },
@@ -5476,7 +5389,6 @@
       "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "core-util-is": "~1.0.0",
         "inherits": "~2.0.3",
@@ -5492,8 +5404,7 @@
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/lazystream/node_modules/string_decoder": {
       "version": "1.1.1",
@@ -5501,7 +5412,6 @@
       "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "safe-buffer": "~5.1.0"
       }
@@ -5548,40 +5458,35 @@
       "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz",
       "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/lodash.difference": {
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz",
       "integrity": "sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/lodash.flatten": {
       "version": "4.4.0",
       "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz",
       "integrity": "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/lodash.isplainobject": {
       "version": "4.0.6",
       "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
       "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/lodash.union": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz",
       "integrity": "sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/log-symbols": {
       "version": "4.1.0",
@@ -6145,7 +6050,6 @@
       "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -6406,6 +6310,7 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -6470,6 +6375,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -6527,8 +6433,7 @@
       "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
       "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/progress": {
       "version": "2.0.3",
@@ -6602,24 +6507,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/rcedit": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/rcedit/-/rcedit-5.0.2.tgz",
-      "integrity": "sha512-dgysxaeXZ4snLpPjn8aVtHvZDCx+aRcvZbaWBgl1poU6OPustMvOkj9a9ZqASQ6i5Y5szJ13LSvglEOwrmgUxA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cross-spawn-windows-exe": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 22.12.0"
-      }
-    },
     "node_modules/react": {
       "version": "18.3.1",
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -6684,7 +6577,6 @@
       "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "minimatch": "^5.1.0"
       }
@@ -6694,8 +6586,7 @@
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
-      "peer": true
     },
     "node_modules/readdir-glob/node_modules/brace-expansion": {
       "version": "2.0.2",
@@ -6703,7 +6594,6 @@
       "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "balanced-match": "^1.0.0"
       }
@@ -6714,7 +6604,6 @@
       "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
       "dev": true,
       "license": "ISC",
-      "peer": true,
       "dependencies": {
         "brace-expansion": "^2.0.1"
       },
@@ -7395,7 +7284,6 @@
       "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "bl": "^4.0.3",
         "end-of-stream": "^1.4.1",
@@ -7680,6 +7568,7 @@
       "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "~0.27.0",
         "get-tsconfig": "^4.7.5"
@@ -7862,6 +7751,7 @@
       "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.4.4",
@@ -9471,6 +9361,7 @@
       "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.21.3",
         "postcss": "^8.4.43",
@@ -9728,7 +9619,6 @@
       "integrity": "sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "archiver-utils": "^3.0.4",
         "compress-commons": "^4.1.2",
@@ -9744,7 +9634,6 @@
       "integrity": "sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "glob": "^7.2.3",
         "graceful-fs": "^4.2.0",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "real-debrid-downloader",
-  "version": "1.6.66",
+  "version": "1.5.43",
-  "description": "Desktop downloader",
+  "description": "Real-Debrid Downloader Desktop (Electron + React + TypeScript)",
   "main": "build/main/main/main.js",
   "author": "Sucukdeluxe",
   "license": "MIT",
@@ -17,8 +17,7 @@
     "test": "vitest run",
     "self-check": "tsx tests/self-check.ts",
     "release:win": "npm run build && electron-builder --publish never --win nsis portable",
-    "release:gitea": "node scripts/release_gitea.mjs",
+    "release:codeberg": "node scripts/release_codeberg.mjs"
-    "release:forgejo": "node scripts/release_gitea.mjs"
   },
   "dependencies": {
     "adm-zip": "^0.5.16",
@@ -37,7 +36,6 @@
     "cross-env": "^7.0.3",
     "electron": "^31.7.7",
     "electron-builder": "^25.1.8",
-    "rcedit": "^5.0.2",
     "tsup": "^8.3.6",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3",
@@ -58,9 +56,6 @@
       "resources/extractor-jvm/**/*",
       "package.json"
     ],
-    "asarUnpack": [
-      "resources/extractor-jvm/**/*"
-    ],
     "win": {
       "target": [
         "nsis",
@@ -74,7 +69,6 @@
       "perMachine": false,
       "allowToChangeInstallationDirectory": true,
       "createDesktopShortcut": true
-    },
+    }
-    "afterPack": "scripts/afterPack.cjs"
   }
 }

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

@@ -3,9 +3,7 @@ package com.sucukdeluxe.extractor;
 import net.lingala.zip4j.ZipFile;
 import net.lingala.zip4j.exception.ZipException;
 import net.lingala.zip4j.model.FileHeader;
-import net.sf.sevenzipjbinding.ExtractAskMode;
 import net.sf.sevenzipjbinding.ExtractOperationResult;
-import net.sf.sevenzipjbinding.IArchiveExtractCallback;
 import net.sf.sevenzipjbinding.IArchiveOpenCallback;
 import net.sf.sevenzipjbinding.IArchiveOpenVolumeCallback;
 import net.sf.sevenzipjbinding.IInArchive;
@@ -28,7 +26,6 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.RandomAccessFile;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.Base64;
 import java.util.HashMap;
@@ -45,18 +42,11 @@ public final class JBindExtractorMain {
     private static final Pattern NUMBERED_ZIP_SPLIT_RE = Pattern.compile("(?i).*\\.zip\\.\\d{3}$");
     private static final Pattern OLD_ZIP_SPLIT_RE = Pattern.compile("(?i).*\\.z\\d{2,3}$");
     private static final Pattern SEVEN_ZIP_SPLIT_RE = Pattern.compile("(?i).*\\.7z\\.001$");
-    private static final Pattern DIGIT_SUFFIX_RE = Pattern.compile("\\d{2,3}");
-    private static final Pattern WINDOWS_SPECIAL_CHARS_RE = Pattern.compile("[:<>*?\"\\|]");
-    private static volatile boolean sevenZipInitialized = false;
 
     private JBindExtractorMain() {
     }
 
     public static void main(String[] args) {
-        if (args.length == 1 && "--daemon".equals(args[0])) {
-            runDaemon();
-            return;
-        }
         int exit = 1;
         try {
             ExtractionRequest request = parseArgs(args);
@@ -71,127 +61,6 @@ public final class JBindExtractorMain {
         System.exit(exit);
     }
 
-    private static void runDaemon() {
-        System.out.println("RD_DAEMON_READY");
-        System.out.flush();
-        java.io.BufferedReader reader = new java.io.BufferedReader(
-                new java.io.InputStreamReader(System.in, StandardCharsets.UTF_8));
-        try {
-            String line;
-            while ((line = reader.readLine()) != null) {
-                line = line.trim();
-                if (line.isEmpty()) {
-                    continue;
-                }
-                int exitCode = 1;
-                try {
-                    ExtractionRequest request = parseDaemonRequest(line);
-                    exitCode = runExtraction(request);
-                } catch (IllegalArgumentException error) {
-                    emitError("Argumentfehler: " + safeMessage(error));
-                    exitCode = 2;
-                } catch (Throwable error) {
-                    emitError(safeMessage(error));
-                    exitCode = 1;
-                }
-                System.out.println("RD_REQUEST_DONE " + exitCode);
-                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"));
-        String conflict = extractJsonString(jsonLine, "conflict");
-        if (conflict.length() > 0) {
-            request.conflictMode = ConflictMode.fromValue(conflict);
-        }
-        String backend = extractJsonString(jsonLine, "backend");
-        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);
-            int arrEnd = jsonLine.indexOf(']', arrStart);
-            if (arrStart >= 0 && arrEnd > arrStart) {
-                String arrContent = jsonLine.substring(arrStart + 1, arrEnd);
-                int idx = 0;
-                while (idx < arrContent.length()) {
-                    int qStart = arrContent.indexOf('"', idx);
-                    if (qStart < 0) break;
-                    int qEnd = findClosingQuote(arrContent, qStart + 1);
-                    if (qEnd < 0) break;
-                    request.passwords.add(unescapeJsonString(arrContent.substring(qStart + 1, qEnd)));
-                    idx = qEnd + 1;
-                }
-            }
-        }
-        if (request.archiveFile == null || !request.archiveFile.exists() || !request.archiveFile.isFile()) {
-            throw new IllegalArgumentException("Archiv nicht gefunden: " +
-                    (request.archiveFile == null ? "null" : request.archiveFile.getAbsolutePath()));
-        }
-        if (request.targetDir == null) {
-            throw new IllegalArgumentException("--target fehlt");
-        }
-        return request;
-    }
-
-    private static String extractJsonString(String json, String key) {
-        String search = "\"" + key + "\"";
-        int keyIdx = json.indexOf(search);
-        if (keyIdx < 0) return "";
-        int colonIdx = json.indexOf(':', keyIdx + search.length());
-        if (colonIdx < 0) return "";
-        int qStart = json.indexOf('"', colonIdx + 1);
-        if (qStart < 0) return "";
-        int qEnd = findClosingQuote(json, qStart + 1);
-        if (qEnd < 0) return "";
-        return unescapeJsonString(json.substring(qStart + 1, qEnd));
-    }
-
-    private static int findClosingQuote(String s, int from) {
-        for (int i = from; i < s.length(); i++) {
-            char c = s.charAt(i);
-            if (c == '\\') {
-                i++; // skip escaped character
-                continue;
-            }
-            if (c == '"') return i;
-        }
-        return -1;
-    }
-
-    private static String unescapeJsonString(String s) {
-        if (s.indexOf('\\') < 0) return s;
-        StringBuilder sb = new StringBuilder(s.length());
-        for (int i = 0; i < s.length(); i++) {
-            char c = s.charAt(i);
-            if (c == '\\' && i + 1 < s.length()) {
-                char next = s.charAt(i + 1);
-                switch (next) {
-                    case '"': sb.append('"'); i++; break;
-                    case '\\': sb.append('\\'); i++; break;
-                    case '/': sb.append('/'); i++; break;
-                    case 'n': sb.append('\n'); i++; break;
-                    case 'r': sb.append('\r'); i++; break;
-                    case 't': sb.append('\t'); i++; break;
-                    default: sb.append(c); break;
-                }
-            } else {
-                sb.append(c);
-            }
-        }
-        return sb.toString();
-    }
-
     private static int runExtraction(ExtractionRequest request) throws Exception {
         List<String> passwords = normalizePasswords(request.passwords);
         Exception lastError = null;
@@ -282,35 +151,30 @@ public final class JBindExtractorMain {
                 }
 
                 ensureDirectory(output.getParentFile());
-                rejectSymlink(output);
                 long[] remaining = new long[] { itemUnits };
-                boolean extractionSuccess = false;
                 try {
                     InputStream in = zipFile.getInputStream(header);
+                    OutputStream out = new FileOutputStream(output);
                     try {
-                        OutputStream out = new FileOutputStream(output);
+                        byte[] buffer = new byte[BUFFER_SIZE];
-                        try {
+                        while (true) {
-                            byte[] buffer = new byte[BUFFER_SIZE];
+                            int read = in.read(buffer);
-                            while (true) {
+                            if (read < 0) {
-                                int read = in.read(buffer);
+                                break;
-                                if (read < 0) {
-                                    break;
-                                }
-                                if (read == 0) {
-                                    continue;
-                                }
-                                out.write(buffer, 0, read);
-                                long accounted = Math.min(remaining[0], (long) read);
-                                remaining[0] -= accounted;
-                                progress.advance(accounted);
                             }
-                        } finally {
+                            if (read == 0) {
-                            try {
+                                continue;
-                                out.close();
-                            } catch (Throwable ignored) {
                             }
+                            out.write(buffer, 0, read);
+                            long accounted = Math.min(remaining[0], (long) read);
+                            remaining[0] -= accounted;
+                            progress.advance(accounted);
                         }
                     } finally {
+                        try {
+                            out.close();
+                        } catch (Throwable ignored) {
+                        }
                         try {
                             in.close();
                         } catch (Throwable ignored) {
@@ -323,19 +187,11 @@ public final class JBindExtractorMain {
                     if (modified > 0) {
                         output.setLastModified(modified);
                     }
-                    extractionSuccess = true;
                 } catch (ZipException error) {
                     if (isWrongPassword(error, encrypted)) {
                         throw new WrongPasswordException(error);
                     }
                     throw error;
-                } finally {
-                    if (!extractionSuccess && output.exists()) {
-                        try {
-                            output.delete();
-                        } catch (Throwable ignored) {
-                        }
-                    }
                 }
             }
 
@@ -348,113 +204,103 @@ public final class JBindExtractorMain {
         }
     }
 
-    private static synchronized void ensureSevenZipInitialized() throws Exception {
-        if (sevenZipInitialized) {
-            return;
-        }
-        SevenZip.initSevenZipFromPlatformJAR();
-        sevenZipInitialized = true;
-    }
-
     private static void extractWithSevenZip(ExtractionRequest request, String password) throws Exception {
-        ensureSevenZipInitialized();
         SevenZipArchiveContext context = null;
         try {
             context = openSevenZipArchive(request.archiveFile, password);
             IInArchive archive = context.archive;
-            int itemCount = archive.getNumberOfItems();
+            ISimpleInArchive simple = archive.getSimpleInterface();
-            if (itemCount <= 0) {
+            ISimpleInArchiveItem[] items = simple.getArchiveItems();
-                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>();
+            for (ISimpleInArchiveItem item : items) {
-            List<File> outputFiles = new ArrayList<File>();
+                if (item == null || item.isFolder()) {
-            List<Long> fileSizes = new ArrayList<Long>();
+                    continue;
+                }
+                try {
+                    encrypted = encrypted || item.isEncrypted();
+                } catch (Throwable ignored) {
+                    // ignore encrypted flag read issues
+                }
+                totalUnits += safeSize(item.getSize());
+            }
+            ProgressTracker progress = new ProgressTracker(totalUnits);
+            progress.emitStart();
+
             Set<String> reserved = new HashSet<String>();
+            for (ISimpleInArchiveItem item : items) {
+                if (item == null) {
+                    continue;
+                }
 
-            for (int i = 0; i < itemCount; i++) {
+                String entryName = normalizeEntryName(item.getPath(), "item-" + item.getItemIndex());
-                Boolean isFolder = (Boolean) archive.getProperty(i, PropID.IS_FOLDER);
+                if (item.isFolder()) {
-                String entryPath = (String) archive.getProperty(i, PropID.PATH);
-                String entryName = normalizeEntryName(entryPath, "item-" + i);
-
-                if (Boolean.TRUE.equals(isFolder)) {
                     File dir = resolveDirectory(request.targetDir, entryName);
                     ensureDirectory(dir);
                     reserved.add(pathKey(dir));
                     continue;
                 }
 
-                try {
+                long itemUnits = safeSize(item.getSize());
-                    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);
-                long itemSize = safeSize(rawSize);
-                totalUnits += itemSize;
-
                 File output = resolveOutputFile(request.targetDir, entryName, request.conflictMode, reserved);
-                fileIndices.add(i);
+                if (output == null) {
-                outputFiles.add(output); // null if skipped
+                    progress.advance(itemUnits);
-                fileSizes.add(itemSize);
+                    continue;
-            }
-
-            if (fileIndices.isEmpty()) {
-                // All items are folders or skipped
-                ProgressTracker progress = new ProgressTracker(1);
-                progress.emitStart();
-                progress.emitDone();
-                return;
-            }
-
-            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];
-            final FileOutputStream[] currentStream = new FileOutputStream[1];
-            final boolean[] currentSuccess = new boolean[1];
-            final long[] currentRemaining = new long[1];
-            final Throwable[] firstError = new Throwable[1];
-            final int[] currentPos = new int[] { -1 };
-
-            try {
-                archive.extract(indices, false, new BulkExtractCallback(
-                    archive, indexToPos, fileIndices, outputFiles, fileSizes,
-                    progress, encryptedFinal, effectivePassword, currentOutput,
-                    currentStream, currentSuccess, currentRemaining, currentPos, firstError
-                ));
-            } catch (SevenZipException error) {
-                if (looksLikeWrongPassword(error, encryptedFinal)) {
-                    throw new WrongPasswordException(error);
                 }
-                throw error;
-            }
 
-            if (firstError[0] != null) {
+                ensureDirectory(output.getParentFile());
-                if (firstError[0] instanceof WrongPasswordException) {
+                final FileOutputStream out = new FileOutputStream(output);
-                    throw (WrongPasswordException) firstError[0];
+                final long[] remaining = new long[] { itemUnits };
+                try {
+                    ExtractOperationResult result = item.extractSlow(new ISequentialOutStream() {
+                        @Override
+                        public int write(byte[] data) throws SevenZipException {
+                            if (data == null || data.length == 0) {
+                                return 0;
+                            }
+                            try {
+                                out.write(data);
+                            } catch (IOException error) {
+                                throw new SevenZipException("Fehler beim Schreiben: " + error.getMessage(), error);
+                            }
+                            long accounted = Math.min(remaining[0], (long) data.length);
+                            remaining[0] -= accounted;
+                            progress.advance(accounted);
+                            return data.length;
+                        }
+                    });
+
+                    if (remaining[0] > 0) {
+                        progress.advance(remaining[0]);
+                    }
+
+                    if (result != ExtractOperationResult.OK) {
+                        if (isPasswordFailure(result, encrypted)) {
+                            throw new WrongPasswordException(new IOException("Falsches Passwort"));
+                        }
+                        throw new IOException("7z-Fehler: " + result.name());
+                    }
+                } catch (SevenZipException error) {
+                    if (looksLikeWrongPassword(error, encrypted)) {
+                        throw new WrongPasswordException(error);
+                    }
+                    throw error;
+                } finally {
+                    try {
+                        out.close();
+                    } catch (Throwable ignored) {
+                    }
+                }
+
+                try {
+                    java.util.Date modified = item.getLastWriteTime();
+                    if (modified != null) {
+                        output.setLastModified(modified.getTime());
+                    }
+                } catch (Throwable ignored) {
+                    // best effort
                 }
-                throw (Exception) firstError[0];
             }
 
             progress.emitDone();
@@ -472,31 +318,14 @@ public final class JBindExtractorMain {
 
         if (SEVEN_ZIP_SPLIT_RE.matcher(nameLower).matches()) {
             VolumedArchiveInStream volumed = new VolumedArchiveInStream(archiveFile.getName(), callback);
-            try {
+            IInArchive archive = SevenZip.openInArchive(null, volumed, callback);
-                IInArchive archive = SevenZip.openInArchive(null, volumed, callback);
+            return new SevenZipArchiveContext(archive, null, volumed, callback);
-                return new SevenZipArchiveContext(archive, null, volumed, callback);
-            } catch (Exception error) {
-                callback.close();
-                throw error;
-            }
         }
 
         RandomAccessFile raf = new RandomAccessFile(archiveFile, "r");
         RandomAccessFileInStream stream = new RandomAccessFileInStream(raf);
-        try {
+        IInArchive archive = SevenZip.openInArchive(null, stream, callback);
-            IInArchive archive = SevenZip.openInArchive(null, stream, callback);
+        return new SevenZipArchiveContext(archive, stream, null, callback);
-            return new SevenZipArchiveContext(archive, stream, null, callback);
-        } catch (Exception error) {
-            try {
-                stream.close();
-            } catch (Throwable ignored) {
-            }
-            try {
-                raf.close();
-            } catch (Throwable ignored) {
-            }
-            throw error;
-        }
     }
 
     private static boolean isWrongPassword(ZipException error, boolean encrypted) {
@@ -557,7 +386,7 @@ public final class JBindExtractorMain {
                 }
                 if (siblingName.startsWith(prefix) && siblingName.length() >= prefix.length() + 2) {
                     String suffix = siblingName.substring(prefix.length());
-                    if (DIGIT_SUFFIX_RE.matcher(suffix).matches()) {
+                    if (suffix.matches("\\d{2,3}")) {
                         return true;
                     }
                 }
@@ -641,12 +470,6 @@ public final class JBindExtractorMain {
         }
         if (normalized.matches("^[a-zA-Z]:.*")) {
             normalized = normalized.substring(2);
-            while (normalized.startsWith("/")) {
-                normalized = normalized.substring(1);
-            }
-            while (normalized.startsWith("\\")) {
-                normalized = normalized.substring(1);
-            }
         }
         File targetCanonical = targetDir.getCanonicalFile();
         File output = new File(targetCanonical, normalized);
@@ -655,8 +478,7 @@ public final class JBindExtractorMain {
         String outputPath = outputCanonical.getPath();
         String targetPathNorm = isWindows() ? targetPath.toLowerCase(Locale.ROOT) : targetPath;
         String outputPathNorm = isWindows() ? outputPath.toLowerCase(Locale.ROOT) : outputPath;
-        String targetPrefix = targetPathNorm.endsWith(File.separator) ? targetPathNorm : targetPathNorm + File.separator;
+        if (!outputPathNorm.equals(targetPathNorm) && !outputPathNorm.startsWith(targetPathNorm + File.separator)) {
-        if (!outputPathNorm.equals(targetPathNorm) && !outputPathNorm.startsWith(targetPrefix)) {
             throw new IOException("Path Traversal blockiert: " + entryName);
         }
         return outputCanonical;
@@ -674,50 +496,20 @@ 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++) {
-            if (i > 0) {
-                sanitized.append('/');
-            }
-            sanitized.append(WINDOWS_SPECIAL_CHARS_RE.matcher(segments[i]).replaceAll("_"));
-        }
-        entry = sanitized.toString();
-        if (entry.length() == 0) {
-            return fallback;
-        }
         return entry;
     }
 
     private static long safeSize(Long value) {
         if (value == null) {
-            return 0;
+            return 1;
         }
         long size = value.longValue();
         if (size <= 0) {
-            return 0;
+            return 1;
         }
         return size;
     }
 
-    private static void rejectSymlink(File file) throws IOException {
-        if (file == null) {
-            return;
-        }
-        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())) {
-                throw new IOException("Elternverzeichnis ist ein Symlink, Schreiben verweigert: " + parent.getAbsolutePath());
-            }
-            parent = parent.getParentFile();
-        }
-    }
-
     private static void ensureDirectory(File dir) throws IOException {
         if (dir == null) {
             return;
@@ -879,176 +671,6 @@ 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;
-        private final List<Integer> fileIndices;
-        private final List<File> outputFiles;
-        private final List<Long> fileSizes;
-        private final ProgressTracker progress;
-        private final boolean encrypted;
-        private final String password;
-        private final File[] currentOutput;
-        private final FileOutputStream[] currentStream;
-        private final boolean[] currentSuccess;
-        private final long[] currentRemaining;
-        private final int[] currentPos;
-        private final Throwable[] firstError;
-
-        BulkExtractCallback(IInArchive archive, Map<Integer, Integer> indexToPos,
-                List<Integer> fileIndices, List<File> outputFiles, List<Long> fileSizes,
-                ProgressTracker progress, boolean encrypted, String password,
-                File[] currentOutput, FileOutputStream[] currentStream,
-                boolean[] currentSuccess, long[] currentRemaining, int[] currentPos,
-                Throwable[] firstError) {
-            this.archive = archive;
-            this.indexToPos = indexToPos;
-            this.fileIndices = fileIndices;
-            this.outputFiles = outputFiles;
-            this.fileSizes = fileSizes;
-            this.progress = progress;
-            this.encrypted = encrypted;
-            this.password = password;
-            this.currentOutput = currentOutput;
-            this.currentStream = currentStream;
-            this.currentSuccess = currentSuccess;
-            this.currentRemaining = currentRemaining;
-            this.currentPos = currentPos;
-            this.firstError = firstError;
-        }
-
-        @Override
-        public String cryptoGetTextPassword() {
-            return password;
-        }
-
-        @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
-        public ISequentialOutStream getStream(int index, ExtractAskMode extractAskMode) throws SevenZipException {
-            closeCurrentStream();
-
-            Integer pos = indexToPos.get(index);
-            if (pos == null) {
-                return null;
-            }
-            currentPos[0] = pos;
-            currentOutput[0] = outputFiles.get(pos);
-            currentSuccess[0] = false;
-            currentRemaining[0] = fileSizes.get(pos);
-
-            if (extractAskMode != ExtractAskMode.EXTRACT) {
-                currentOutput[0] = null;
-                return null;
-            }
-
-            if (currentOutput[0] == null) {
-                progress.advance(currentRemaining[0]);
-                return null;
-            }
-
-            try {
-                ensureDirectory(currentOutput[0].getParentFile());
-                rejectSymlink(currentOutput[0]);
-                currentStream[0] = new FileOutputStream(currentOutput[0]);
-            } catch (IOException error) {
-                throw new SevenZipException("Fehler beim Erstellen: " + error.getMessage(), error);
-            }
-
-            return new ISequentialOutStream() {
-                @Override
-                public int write(byte[] data) throws SevenZipException {
-                    if (data == null || data.length == 0) {
-                        return 0;
-                    }
-                    try {
-                        currentStream[0].write(data);
-                    } catch (IOException error) {
-                        throw new SevenZipException("Fehler beim Schreiben: " + error.getMessage(), error);
-                    }
-                    long accounted = Math.min(currentRemaining[0], (long) data.length);
-                    currentRemaining[0] -= accounted;
-                    progress.advance(accounted);
-                    return data.length;
-                }
-            };
-        }
-
-        @Override
-        public void prepareOperation(ExtractAskMode extractAskMode) {
-            // no-op
-        }
-
-        @Override
-        public void setOperationResult(ExtractOperationResult result) throws SevenZipException {
-            if (currentRemaining[0] > 0) {
-                progress.advance(currentRemaining[0]);
-                currentRemaining[0] = 0;
-            }
-
-            if (result == ExtractOperationResult.OK) {
-                currentSuccess[0] = true;
-                closeCurrentStream();
-                if (currentPos[0] >= 0 && currentOutput[0] != null) {
-                    try {
-                        int archiveIndex = fileIndices.get(currentPos[0]);
-                        java.util.Date modified = (java.util.Date) archive.getProperty(archiveIndex, PropID.LAST_MODIFICATION_TIME);
-                        if (modified != null) {
-                            currentOutput[0].setLastModified(modified.getTime());
-                        }
-                    } catch (Throwable ignored) {
-                        // best effort
-                    }
-                }
-            } else {
-                closeCurrentStream();
-                if (currentOutput[0] != null && currentOutput[0].exists()) {
-                    try {
-                        currentOutput[0].delete();
-                    } catch (Throwable ignored) {
-                    }
-                }
-                if (firstError[0] == null) {
-                    if (isPasswordFailure(result, encrypted)) {
-                        firstError[0] = new WrongPasswordException(new IOException("Falsches Passwort"));
-                    } else {
-                        firstError[0] = new IOException("7z-Fehler: " + result.name());
-                    }
-                }
-            }
-        }
-
-        private void closeCurrentStream() {
-            if (currentStream[0] != null) {
-                try {
-                    currentStream[0].close();
-                } catch (Throwable ignored) {
-                }
-                currentStream[0] = null;
-            }
-            if (!currentSuccess[0] && currentOutput[0] != null && currentOutput[0].exists()) {
-                try {
-                    currentOutput[0].delete();
-                } catch (Throwable ignored) {
-                }
-            }
-        }
-    }
-
     private static final class WrongPasswordException extends Exception {
         private static final long serialVersionUID = 1L;
 
@@ -1196,11 +818,12 @@ public final class JBindExtractorMain {
             if (filename == null || filename.trim().length() == 0) {
                 return null;
             }
-            // Always resolve relative to the archive's parent directory.
+            File direct = new File(filename);
-            // Never accept absolute paths to prevent path traversal.
+            if (direct.isAbsolute() && direct.exists()) {
-            String baseName = new File(filename).getName();
+                return direct;
+            }
             if (archiveDir != null) {
-                File relative = new File(archiveDir, baseName);
+                File relative = new File(archiveDir, filename);
                 if (relative.exists()) {
                     return relative;
                 }
@@ -1210,13 +833,13 @@ public final class JBindExtractorMain {
                         if (!sibling.isFile()) {
                             continue;
                         }
-                        if (sibling.getName().equalsIgnoreCase(baseName)) {
+                        if (sibling.getName().equalsIgnoreCase(filename)) {
                             return sibling;
                         }
                     }
                 }
             }
-            return null;
+            return direct.exists() ? direct : null;
         }
 
         @Override

scripts/afterPack.cjs

@@ -1,18 +0,0 @@
-const path = require("path");
-const { rcedit } = require("rcedit");
-
-module.exports = async function afterPack(context) {
-  const productFilename = context.packager?.appInfo?.productFilename;
-  if (!productFilename) {
-    console.warn("  • rcedit: skipped — productFilename not available");
-    return;
-  }
-  const exePath = path.join(context.appOutDir, `${productFilename}.exe`);
-  const iconPath = path.resolve(__dirname, "..", "assets", "app_icon.ico");
-  console.log(`  • rcedit: patching icon → ${exePath}`);
-  try {
-    await rcedit(exePath, { icon: iconPath });
-  } catch (error) {
-    console.warn(`  • rcedit: failed — ${String(error)}`);
-  }
-};

scripts/debrid_service_smoke.ts

@@ -31,21 +31,18 @@ async function main(): Promise<void> {
     login: settings.megaLogin,
     password: settings.megaPassword
   }));
-  try {
+  const service = new DebridService(settings, {
-    const service = new DebridService(settings, {
+    megaWebUnrestrict: (link) => megaWeb.unrestrict(link)
-      megaWebUnrestrict: (link) => megaWeb.unrestrict(link)
+  });
-    });
+  for (const link of links) {
-    for (const link of links) {
+    try {
-      try {
+      const result = await service.unrestrictLink(link);
-        const result = await service.unrestrictLink(link);
+      console.log(`[OK] ${result.providerLabel} -> ${result.fileName}`);
-        console.log(`[OK] ${result.providerLabel} -> ${result.fileName}`);
+    } catch (error) {
-      } catch (error) {
+      console.log(`[FAIL] ${String(error)}`);
-        console.log(`[FAIL] ${String(error)}`);
-      }
     }
-  } finally {
-    megaWeb.dispose();
   }
+  megaWeb.dispose();
 }
 
-main().catch(e => { console.error(e); process.exit(1); });
+void main();

scripts/mega_web_generate_download_test.mjs

@@ -16,8 +16,8 @@ function sleep(ms) {
 }
 
 function cookieFrom(headers) {
-  const cookies = headers.getSetCookie();
+  const raw = headers.get("set-cookie") || "";
-  return cookies.map((x) => x.split(";")[0].trim()).filter(Boolean).join("; ");
+  return raw.split(",").map((x) => x.split(";")[0].trim()).filter(Boolean).join("; ");
 }
 
 function parseDebridCodes(html) {
@@ -47,9 +47,6 @@ async function resolveCode(cookie, code) {
     });
     const text = (await res.text()).trim();
     if (text === "reload") {
-      if (attempt % 5 === 0) {
-        console.log(`  [retry] code=${code} attempt=${attempt}/50 (waiting for server)`);
-      }
       await sleep(800);
       continue;
     }
@@ -101,13 +98,7 @@ async function main() {
     redirect: "manual"
   });
 
-  if (loginRes.status >= 400) {
-    throw new Error(`Login failed with HTTP ${loginRes.status}`);
-  }
   const cookie = cookieFrom(loginRes.headers);
-  if (!cookie) {
-    throw new Error("Login returned no session cookie");
-  }
   console.log("login", loginRes.status, loginRes.headers.get("location") || "");
 
   const debridRes = await fetch("https://www.mega-debrid.eu/index.php?form=debrid", {
@@ -145,4 +136,4 @@ async function main() {
   }
 }
 
-await main().catch((e) => { console.error(e); process.exit(1); });
+await main();

scripts/provider_smoke_check.mjs

@@ -66,8 +66,6 @@ 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", {
@@ -79,15 +77,13 @@ async function callMegaDebrid(link) {
       body: new URLSearchParams({ login: megaLogin, password: megaPassword, remember: "on" }),
       redirect: "manual"
     });
-    if (loginRes.status >= 400) {
+    megaCookie = (loginRes.headers.get("set-cookie") || "")
-      return { ok: false, error: `Mega-Web login failed with HTTP ${loginRes.status}` };
+      .split(",")
-    }
-    megaCookie = loginRes.headers.getSetCookie()
       .map((chunk) => chunk.split(";")[0].trim())
       .filter(Boolean)
       .join("; ");
     if (!megaCookie) {
-      return { ok: false, error: "Mega-Web login returned no session cookie" };
+      return { ok: false, error: "Mega-Web login failed" };
     }
   }
 
@@ -294,4 +290,4 @@ async function main() {
   }
 }
 
-await main().catch((e) => { console.error(e); process.exit(1); });
+await main();

scripts/release_codeberg.mjs

@@ -2,15 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 
-const NPM_RELEASE_WIN = process.platform === "win32"
+const NPM_EXECUTABLE = process.platform === "win32" ? "npm.cmd" : "npm";
-  ? {
-      command: process.env.ComSpec || "cmd.exe",
-      args: ["/d", "/s", "/c", "npm run release:win"]
-    }
-  : {
-      command: "npm",
-      args: ["run", "release:win"]
-    };
 
 function run(command, args, options = {}) {
   const result = spawnSync(command, args, {
@@ -45,8 +37,7 @@ function runWithInput(command, args, input) {
     cwd: process.cwd(),
     encoding: "utf8",
     input,
-    stdio: ["pipe", "pipe", "pipe"],
+    stdio: ["pipe", "pipe", "pipe"]
-    timeout: 10000
   });
   if (result.status !== 0) {
     const stderr = String(result.stderr || "").trim();
@@ -68,74 +59,37 @@ function parseArgs(argv) {
   return { help: false, dryRun, version, notes };
 }
 
-function parseRemoteUrl(url) {
+function parseCodebergRemote(url) {
   const raw = String(url || "").trim();
-  const httpsMatch = raw.match(/^https?:\/\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  const httpsMatch = raw.match(/^https?:\/\/(?:www\.)?codeberg\.org\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
   if (httpsMatch) {
-    return { host: httpsMatch[1], owner: httpsMatch[2], repo: httpsMatch[3] };
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
   }
-  const sshMatch = raw.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  const sshMatch = raw.match(/^git@codeberg\.org:([^/]+)\/([^/]+?)(?:\.git)?$/i);
   if (sshMatch) {
-    return { host: sshMatch[1], owner: sshMatch[2], repo: sshMatch[3] };
+    return { owner: sshMatch[1], repo: sshMatch[2] };
   }
-  const sshAltMatch = raw.match(/^ssh:\/\/git@([^/:]+)(?::\d+)?\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  throw new Error(`Cannot parse Codeberg remote URL: ${raw}`);
-  if (sshAltMatch) {
-    return { host: sshAltMatch[1], owner: sshAltMatch[2], repo: sshAltMatch[3] };
-  }
-  throw new Error(`Cannot parse remote URL: ${raw}`);
 }
 
-function normalizeBaseUrl(url) {
+function getCodebergRepo() {
-  const raw = String(url || "").trim().replace(/\/+$/, "");
+  const remotes = ["codeberg", "origin"];
-  if (!raw) {
-    return "";
-  }
-  if (!/^https?:\/\//i.test(raw)) {
-    throw new Error("GITEA_BASE_URL must start with http:// or https://");
-  }
-  return raw;
-}
-
-function getGiteaRepo() {
-  const forcedRemote = String(process.env.GITEA_REMOTE || process.env.FORGEJO_REMOTE || "").trim();
-  const remotes = forcedRemote
-    ? [forcedRemote]
-    : ["gitea", "forgejo", "origin", "github-new", "codeberg"];
-
-  const preferredBase = normalizeBaseUrl(process.env.GITEA_BASE_URL || process.env.FORGEJO_BASE_URL || "https://git.24-music.de");
-
-  const preferredProtocol = preferredBase ? new URL(preferredBase).protocol : "https:";
-
   for (const remote of remotes) {
     try {
       const remoteUrl = runCapture("git", ["remote", "get-url", remote]);
-      const parsed = parseRemoteUrl(remoteUrl);
+      if (/codeberg\.org/i.test(remoteUrl)) {
-      const remoteBase = `https://${parsed.host}`.toLowerCase();
+        const parsed = parseCodebergRemote(remoteUrl);
-      if (preferredBase && remoteBase !== preferredBase.toLowerCase().replace(/^http:/, "https:")) {
+        return { remote, ...parsed };
-        continue;
       }
-      return { remote, ...parsed, baseUrl: `${preferredProtocol}//${parsed.host}` };
     } catch {
       // try next remote
     }
   }
-
+  throw new Error("No Codeberg remote found. Add one with: git remote add codeberg https://codeberg.org/<owner>/<repo>.git");
-  if (preferredBase) {
-    throw new Error(
-      `No remote found for ${preferredBase}. Add one with: git remote add gitea ${preferredBase}/<owner>/<repo>.git`
-    );
-  }
-
-  throw new Error("No suitable remote found. Set GITEA_REMOTE or GITEA_BASE_URL.");
 }
 
-function getAuthHeader(host) {
+function getCodebergAuthHeader() {
-  const explicitToken = String(process.env.GITEA_TOKEN || process.env.FORGEJO_TOKEN || "").trim();
+  const credentialText = runWithInput("git", ["credential", "fill"], "protocol=https\nhost=codeberg.org\n\n");
-  if (explicitToken) {
-    return `token ${explicitToken}`;
-  }
-
-  const credentialText = runWithInput("git", ["credential", "fill"], `protocol=https\nhost=${host}\n\n`);
   const map = new Map();
   for (const line of credentialText.split(/\r?\n/)) {
     if (!line.includes("=")) {
@@ -147,9 +101,7 @@ function getAuthHeader(host) {
   const username = map.get("username") || "";
   const password = map.get("password") || "";
   if (!username || !password) {
-    throw new Error(
+    throw new Error("Missing Codeberg credentials in git credential helper");
-      `Missing credentials for ${host}. Set GITEA_TOKEN or store credentials for this host in git credential helper.`
-    );
   }
   const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
   return `Basic ${token}`;
@@ -190,8 +142,7 @@ function updatePackageVersion(rootDir, version) {
   const packagePath = path.join(rootDir, "package.json");
   const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
   if (String(packageJson.version || "") === version) {
-    process.stdout.write(`package.json is already at version ${version}, skipping update.\n`);
+    throw new Error(`package.json is already at version ${version}`);
-    return;
   }
   packageJson.version = version;
   fs.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
@@ -246,7 +197,8 @@ function ensureTagMissing(tag) {
   }
 }
 
-async function createOrGetRelease(baseApi, tag, authHeader, notes) {
+async function createOrGetRelease(owner, repo, tag, authHeader, notes) {
+  const baseApi = `https://codeberg.org/api/v1/repos/${owner}/${repo}`;
   const byTag = await apiRequest("GET", `${baseApi}/releases/tags/${encodeURIComponent(tag)}`, authHeader);
   if (byTag.ok) {
     return byTag.body;
@@ -266,34 +218,13 @@ async function createOrGetRelease(baseApi, tag, authHeader, notes) {
   return created.body;
 }
 
-async function uploadReleaseAssets(baseApi, releaseId, authHeader, releaseDir, files) {
+async function uploadReleaseAssets(owner, repo, releaseId, authHeader, releaseDir, files) {
+  const baseApi = `https://codeberg.org/api/v1/repos/${owner}/${repo}`;
   for (const fileName of files) {
     const filePath = path.join(releaseDir, fileName);
-    const fileSize = fs.statSync(filePath).size;
+    const fileData = fs.readFileSync(filePath);
     const uploadUrl = `${baseApi}/releases/${releaseId}/assets?name=${encodeURIComponent(fileName)}`;
-
+    const response = await apiRequest("POST", uploadUrl, authHeader, fileData, "application/octet-stream");
-    // Stream large files instead of loading them entirely into memory
-    const fileStream = fs.createReadStream(filePath);
-    const response = await fetch(uploadUrl, {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        Authorization: authHeader,
-        "Content-Type": "application/octet-stream",
-        "Content-Length": String(fileSize)
-      },
-      body: fileStream,
-      duplex: "half"
-    });
-
-    const text = await response.text();
-    let parsed;
-    try {
-      parsed = text ? JSON.parse(text) : null;
-    } catch {
-      parsed = text;
-    }
-
     if (response.ok) {
       process.stdout.write(`Uploaded: ${fileName}\n`);
       continue;
@@ -302,7 +233,7 @@ async function uploadReleaseAssets(baseApi, releaseId, authHeader, releaseDir, f
       process.stdout.write(`Skipped existing asset: ${fileName}\n`);
       continue;
     }
-    throw new Error(`Asset upload failed for ${fileName} (${response.status}): ${JSON.stringify(parsed)}`);
+    throw new Error(`Asset upload failed for ${fileName} (${response.status}): ${JSON.stringify(response.body)}`);
   }
 }
 
@@ -310,44 +241,46 @@ async function main() {
   const rootDir = process.cwd();
   const args = parseArgs(process.argv);
   if (args.help) {
-    process.stdout.write("Usage: npm run release:gitea -- <version> [release notes] [--dry-run]\n");
+    process.stdout.write("Usage: npm run release:codeberg -- <version> [release notes] [--dry-run]\n");
-    process.stdout.write("Env: GITEA_BASE_URL, GITEA_REMOTE, GITEA_TOKEN\n");
+    process.stdout.write("Example: npm run release:codeberg -- 1.4.42 \"- Small fixes\"\n");
-    process.stdout.write("Compatibility envs still supported: FORGEJO_BASE_URL, FORGEJO_REMOTE, FORGEJO_TOKEN\n");
-    process.stdout.write("Example: npm run release:gitea -- 1.6.31 \"- Bugfixes\"\n");
     return;
   }
 
   const version = ensureVersionString(args.version);
   const tag = `v${version}`;
   const releaseNotes = args.notes || `- Release ${tag}`;
-  const repo = getGiteaRepo();
+  const { remote, owner, repo } = getCodebergRepo();
 
   ensureNoTrackedChanges();
   ensureTagMissing(tag);
-
-  if (args.dryRun) {
-    process.stdout.write(`Dry run: would release ${tag}. No changes made.\n`);
-    return;
-  }
-
   updatePackageVersion(rootDir, version);
 
   process.stdout.write(`Building release artifacts for ${tag}...\n`);
-  run(NPM_RELEASE_WIN.command, NPM_RELEASE_WIN.args);
+  run(NPM_EXECUTABLE, ["run", "release:win"]);
   const assets = ensureAssetsExist(rootDir, version);
 
+  if (args.dryRun) {
+    process.stdout.write(`Dry run complete. Assets exist for ${tag}.\n`);
+    return;
+  }
+
   run("git", ["add", "package.json"]);
   run("git", ["commit", "-m", `Release ${tag}`]);
-  run("git", ["push", repo.remote, "main"]);
+  run("git", ["push", remote, "main"]);
   run("git", ["tag", tag]);
-  run("git", ["push", repo.remote, tag]);
+  run("git", ["push", remote, tag]);
 
-  const authHeader = getAuthHeader(repo.host);
+  const authHeader = getCodebergAuthHeader();
-  const baseApi = `${repo.baseUrl}/api/v1/repos/${repo.owner}/${repo.repo}`;
+  const baseRepoApi = `https://codeberg.org/api/v1/repos/${owner}/${repo}`;
-  const release = await createOrGetRelease(baseApi, tag, authHeader, releaseNotes);
+  const patchReleaseEnabled = await apiRequest("PATCH", baseRepoApi, authHeader, JSON.stringify({ has_releases: true }));
-  await uploadReleaseAssets(baseApi, release.id, authHeader, assets.releaseDir, assets.files);
+  if (!patchReleaseEnabled.ok) {
+    throw new Error(`Failed to enable releases (${patchReleaseEnabled.status}): ${JSON.stringify(patchReleaseEnabled.body)}`);
+  }
 
-  process.stdout.write(`Release published: ${release.html_url || `${repo.baseUrl}/${repo.owner}/${repo.repo}/releases/tag/${tag}`}\n`);
+  const release = await createOrGetRelease(owner, repo, tag, authHeader, releaseNotes);
+  await uploadReleaseAssets(owner, repo, release.id, authHeader, assets.releaseDir, assets.files);
+
+  process.stdout.write(`Release published: ${release.html_url}\n`);
 }
 
 main().catch((error) => {

scripts/set_version_node.mjs

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const version = process.argv[2];
+if (!version) {
+  console.error("Usage: node scripts/set_version_node.mjs <version>");
+  process.exit(1);
+}
+
+const root = process.cwd();
+
+const packageJsonPath = path.join(root, "package.json");
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+packageJson.version = version;
+fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+
+const constantsPath = path.join(root, "src", "main", "constants.ts");
+const constants = fs.readFileSync(constantsPath, "utf8").replace(
+  /APP_VERSION = "[^"]+"/,
+  `APP_VERSION = "${version}"`
+);
+fs.writeFileSync(constantsPath, constants, "utf8");
+
+console.log(`Set version to ${version}`);

src/main/app-controller.ts

@@ -5,7 +5,6 @@ import {
   AppSettings,
   DuplicatePolicy,
   HistoryEntry,
-  PackagePriority,
   ParsedPackageInput,
   SessionStats,
   StartConflictEntry,
@@ -20,9 +19,8 @@ import { APP_VERSION } from "./constants";
 import { DownloadManager } from "./download-manager";
 import { parseCollectorInput } from "./link-parser";
 import { configureLogger, getLogFilePath, logger } from "./logger";
-import { initSessionLog, getSessionLogPath, shutdownSessionLog } from "./session-log";
 import { MegaWebFallback } from "./mega-web-fallback";
-import { addHistoryEntry, cancelPendingAsyncSaves, clearHistory, createStoragePaths, loadHistory, loadSession, loadSettings, normalizeLoadedSession, normalizeLoadedSessionTransientFields, normalizeSettings, removeHistoryEntry, saveSession, saveSettings } from "./storage";
+import { addHistoryEntry, clearHistory, createStoragePaths, loadHistory, loadSession, loadSettings, normalizeSettings, removeHistoryEntry, saveSession, saveSettings } from "./storage";
 import { abortActiveUpdateDownload, checkGitHubUpdate, installLatestUpdate } from "./update";
 import { startDebugServer, stopDebugServer } from "./debug-server";
 
@@ -54,7 +52,6 @@ export class AppController {
 
   public constructor() {
     configureLogger(this.storagePaths.baseDir);
-    initSessionLog(this.storagePaths.baseDir);
     this.settings = loadSettings(this.storagePaths);
     const session = loadSession(this.storagePaths);
     this.megaWebFallback = new MegaWebFallback(() => ({
@@ -82,15 +79,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.
+            this.autoResumePending = true;
-            // Otherwise mark as pending so the onState setter triggers the start.
+            logger.info("Auto-Resume beim Start vorgemerkt");
-            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)}`));
-            } else {
-              this.autoResumePending = true;
-              logger.info("Auto-Resume beim Start vorgemerkt");
-            }
           } else if (hasConflicts) {
             logger.info("Auto-Resume übersprungen: Start-Konflikte erkannt");
           }
@@ -105,8 +95,6 @@ export class AppController {
       || (settings.megaLogin.trim() && settings.megaPassword.trim())
       || settings.bestToken.trim()
       || settings.allDebridToken.trim()
-      || (settings.ddownloadLogin.trim() && settings.ddownloadPassword.trim())
-      || settings.oneFichierApiKey.trim()
     );
   }
 
@@ -122,9 +110,6 @@ export class AppController {
         this.autoResumePending = false;
         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();
       }
     }
   }
@@ -171,12 +156,6 @@ export class AppController {
   }
 
   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();
-    }
-
     const cacheAgeMs = Date.now() - this.lastUpdateCheckAt;
     const cached = this.lastUpdateCheck && !this.lastUpdateCheck.error && cacheAgeMs <= 10 * 60 * 1000
       ? this.lastUpdateCheck
@@ -225,14 +204,6 @@ export class AppController {
     await this.manager.start();
   }
 
-  public async startPackages(packageIds: string[]): Promise<void> {
-    await this.manager.startPackages(packageIds);
-  }
-
-  public async startItems(itemIds: string[]): Promise<void> {
-    await this.manager.startItems(itemIds);
-  }
-
   public stop(): void {
     this.manager.stop();
   }
@@ -249,10 +220,6 @@ export class AppController {
     this.manager.extractNow(packageId);
   }
 
-  public resetPackage(packageId: string): void {
-    this.manager.resetPackage(packageId);
-  }
-
   public cancelPackage(packageId: string): void {
     this.manager.cancelPackage(packageId);
   }
@@ -286,14 +253,7 @@ export class AppController {
   }
 
   public exportBackup(): string {
-    const settings = { ...this.settings };
+    const settings = this.settings;
-    const SENSITIVE_KEYS: (keyof AppSettings)[] = ["token", "megaLogin", "megaPassword", "bestToken", "allDebridToken", "ddownloadLogin", "ddownloadPassword", "oneFichierApiKey"];
-    for (const key of SENSITIVE_KEYS) {
-      const val = settings[key];
-      if (typeof val === "string" && val.length > 0) {
-        (settings as Record<string, unknown>)[key] = `***${val.slice(-4)}`;
-      }
-    }
     const session = this.manager.getSession();
     return JSON.stringify({ version: 1, settings, session }, null, 2);
   }
@@ -308,49 +268,20 @@ export class AppController {
     if (!parsed || typeof parsed !== "object" || !parsed.settings || !parsed.session) {
       return { restored: false, message: "Kein gültiges Backup (settings/session fehlen)" };
     }
-    const importedSettings = parsed.settings as AppSettings;
+    const restoredSettings = normalizeSettings(parsed.settings as AppSettings);
-    const SENSITIVE_KEYS: (keyof AppSettings)[] = ["token", "megaLogin", "megaPassword", "bestToken", "allDebridToken", "ddownloadLogin", "ddownloadPassword", "oneFichierApiKey"];
-    for (const key of SENSITIVE_KEYS) {
-      const val = (importedSettings as Record<string, unknown>)[key];
-      if (typeof val === "string" && val.startsWith("***")) {
-        (importedSettings as Record<string, unknown>)[key] = (this.settings as Record<string, unknown>)[key];
-      }
-    }
-    const restoredSettings = normalizeSettings(importedSettings);
     this.settings = restoredSettings;
     saveSettings(this.storagePaths, this.settings);
     this.manager.setSettings(this.settings);
-    // Full stop including extraction abort — the old session is being replaced,
+    const restoredSession = parsed.session as ReturnType<typeof loadSession>;
-    // so no extraction tasks from it should keep running.
-    this.manager.stop();
-    this.manager.abortAllPostProcessing();
-    // Cancel any deferred persist timer and queued async writes so the old
-    // in-memory session does not overwrite the restored session file on disk.
-    this.manager.clearPersistTimer();
-    cancelPendingAsyncSaves();
-    const restoredSession = normalizeLoadedSessionTransientFields(
-      normalizeLoadedSession(parsed.session)
-    );
     saveSession(this.storagePaths, restoredSession);
-    // Prevent prepareForShutdown from overwriting the restored session file
-    // with the old in-memory session when the app quits after backup restore.
-    this.manager.skipShutdownPersist = true;
-    // Block all persistence (including persistSoon from any IPC operations
-    // the user might trigger before restarting) to protect the restored backup.
-    this.manager.blockAllPersistence = true;
     return { restored: true, message: "Backup wiederhergestellt. Bitte App neustarten." };
   }
 
-  public getSessionLogPath(): string | null {
-    return getSessionLogPath();
-  }
-
   public shutdown(): void {
     stopDebugServer();
     abortActiveUpdateDownload();
     this.manager.prepareForShutdown();
     this.megaWebFallback.dispose();
-    shutdownSessionLog();
     logger.info("App beendet");
   }
 
@@ -362,18 +293,6 @@ export class AppController {
     clearHistory(this.storagePaths);
   }
 
-  public setPackagePriority(packageId: string, priority: PackagePriority): void {
-    this.manager.setPackagePriority(packageId, priority);
-  }
-
-  public skipItems(itemIds: string[]): void {
-    this.manager.skipItems(itemIds);
-  }
-
-  public resetItems(itemIds: string[]): void {
-    this.manager.resetItems(itemIds);
-  }
-
   public removeHistoryEntry(entryId: string): void {
     removeHistoryEntry(this.storagePaths, entryId);
   }

src/main/backup-crypto.ts

@@ -1,66 +0,0 @@
-import crypto from "node:crypto";
-
-export const SENSITIVE_KEYS = [
-  "token",
-  "megaLogin",
-  "megaPassword",
-  "bestToken",
-  "allDebridToken",
-  "archivePasswordList"
-] as const;
-
-export type SensitiveKey = (typeof SENSITIVE_KEYS)[number];
-
-export interface EncryptedCredentials {
-  salt: string;
-  iv: string;
-  tag: string;
-  data: string;
-}
-
-const PBKDF2_ITERATIONS = 100_000;
-const KEY_LENGTH = 32; // 256 bit
-const IV_LENGTH = 12; // 96 bit for GCM
-const SALT_LENGTH = 16;
-
-function deriveKey(username: string, salt: Buffer): Buffer {
-  return crypto.pbkdf2Sync(username, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
-}
-
-export function encryptCredentials(
-  fields: Record<string, string>,
-  username: string
-): EncryptedCredentials {
-  const salt = crypto.randomBytes(SALT_LENGTH);
-  const iv = crypto.randomBytes(IV_LENGTH);
-  const key = deriveKey(username, salt);
-
-  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
-  const plaintext = JSON.stringify(fields);
-  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-  const tag = cipher.getAuthTag();
-
-  return {
-    salt: salt.toString("hex"),
-    iv: iv.toString("hex"),
-    tag: tag.toString("hex"),
-    data: encrypted.toString("hex")
-  };
-}
-
-export function decryptCredentials(
-  encrypted: EncryptedCredentials,
-  username: string
-): Record<string, string> {
-  const salt = Buffer.from(encrypted.salt, "hex");
-  const iv = Buffer.from(encrypted.iv, "hex");
-  const tag = Buffer.from(encrypted.tag, "hex");
-  const data = Buffer.from(encrypted.data, "hex");
-  const key = deriveKey(username, salt);
-
-  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
-  decipher.setAuthTag(tag);
-  const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
-
-  return JSON.parse(decrypted.toString("utf8")) as Record<string, string>;
-}

src/main/constants.ts

@@ -16,26 +16,20 @@ 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;       // 512 KB write buffer (JDownloader: 500 KB)
-export const WRITE_FLUSH_TIMEOUT_MS = 2000;         // 2s flush timeout
-export const ALLOCATION_UNIT_SIZE = 4096;           // 4 KB NTFS alignment
-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;               // Show "Warte auf Festplatte" if writableLength > 0 for this long
-
 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"]);
 export const LINK_ARTIFACT_EXTENSIONS = new Set([".url", ".webloc", ".dlc", ".rsdf", ".ccf"]);
 export const SAMPLE_TOKEN_RE = /(^|[._\-\s])sample([._\-\s]|$)/i;
 
-export const ARCHIVE_TEMP_EXTENSIONS = new Set([".rar", ".zip", ".7z", ".tmp", ".part", ".tar", ".gz", ".bz2", ".xz", ".rev"]);
+export const ARCHIVE_TEMP_EXTENSIONS = new Set([".rar", ".zip", ".7z", ".tmp", ".part", ".tar", ".gz", ".bz2", ".xz"]);
 export const RAR_SPLIT_RE = /\.r\d{2,3}$/i;
 
 export const MAX_MANIFEST_FILE_BYTES = 5 * 1024 * 1024;
 export const MAX_LINK_ARTIFACT_BYTES = 256 * 1024;
-export const SPEED_WINDOW_SECONDS = 1;
+export const SPEED_WINDOW_SECONDS = 3;
 export const CLIPBOARD_POLL_INTERVAL_MS = 2000;
 
-export const DEFAULT_UPDATE_REPO = "Administrator/real-debrid-downloader";
+export const DEFAULT_UPDATE_REPO = "Sucukdeluxe/real-debrid-downloader";
 
 export function defaultSettings(): AppSettings {
   const baseDir = path.join(os.homedir(), "Downloads", "RealDebrid");
@@ -45,9 +39,6 @@ export function defaultSettings(): AppSettings {
     megaPassword: "",
     bestToken: "",
     allDebridToken: "",
-    ddownloadLogin: "",
-    ddownloadPassword: "",
-    oneFichierApiKey: "",
     archivePasswordList: "",
     rememberToken: true,
     providerPrimary: "realdebrid",
@@ -73,7 +64,6 @@ export function defaultSettings(): AppSettings {
     reconnectWaitSeconds: 45,
     completedCleanupPolicy: "never",
     maxParallel: 4,
-    maxParallelExtract: 2,
     retryLimit: 0,
     speedLimitEnabled: false,
     speedLimitKbps: 0,
@@ -87,9 +77,6 @@ export function defaultSettings(): AppSettings {
     autoSkipExtracted: false,
     confirmDeleteSelection: true,
     totalDownloadedAllTime: 0,
-    bandwidthSchedules: [],
+    bandwidthSchedules: []
-    columnOrder: ["name", "size", "progress", "hoster", "account", "prio", "status", "speed"],
-    extractCpuPriority: "high",
-    autoExtractWhenStopped: true
   };
 }

src/main/container.ts

@@ -164,7 +164,7 @@ async function decryptDlcLocal(filePath: string): Promise<ParsedPackageInput[]>
   const dlcData = content.slice(0, -88);
 
   const rcUrl = DLC_SERVICE_URL.replace("{KEY}", encodeURIComponent(dlcKey));
-  const rcResponse = await fetch(rcUrl, { method: "GET", signal: AbortSignal.timeout(30000) });
+  const rcResponse = await fetch(rcUrl, { method: "GET" });
   if (!rcResponse.ok) {
     return [];
   }
@@ -217,8 +217,7 @@ async function tryDcryptUpload(fileContent: Buffer, fileName: string): Promise<s
 
   const response = await fetch(DCRYPT_UPLOAD_URL, {
     method: "POST",
-    body: form,
+    body: form
-    signal: AbortSignal.timeout(30000)
   });
   if (response.status === 413) {
     return null;
@@ -236,8 +235,7 @@ async function tryDcryptPaste(fileContent: Buffer): Promise<string[] | null> {
 
   const response = await fetch(DCRYPT_PASTE_URL, {
     method: "POST",
-    body: form,
+    body: form
-    signal: AbortSignal.timeout(30000)
   });
   if (response.status === 413) {
     return null;

src/main/debrid.ts

@@ -11,16 +11,11 @@ const RAPIDGATOR_SCAN_MAX_BYTES = 512 * 1024;
 const BEST_DEBRID_API_BASE = "https://bestdebrid.com/api/v1";
 const ALL_DEBRID_API_BASE = "https://api.alldebrid.com/v4";
 
-const ONEFICHIER_API_BASE = "https://api.1fichier.com/v1";
-const ONEFICHIER_URL_RE = /^https?:\/\/(?:www\.)?(?:1fichier\.com|alterupload\.com|cjoint\.net|desfichiers\.com|dfichiers\.com|megadl\.fr|mesfichiers\.org|piecejointe\.net|pjointe\.com|tenvoi\.com|dl4free\.com)\/\?([a-z0-9]{5,20})$/i;
-
 const PROVIDER_LABELS: Record<DebridProvider, string> = {
   realdebrid: "Real-Debrid",
   megadebrid: "Mega-Debrid",
   bestdebrid: "BestDebrid",
-  alldebrid: "AllDebrid",
+  alldebrid: "AllDebrid"
-  ddownload: "DDownload",
-  onefichier: "1Fichier"
 };
 
 interface ProviderUnrestrictedLink extends UnrestrictedLink {
@@ -231,9 +226,7 @@ function isRapidgatorLink(link: string): boolean {
     return hostname === "rapidgator.net"
       || hostname.endsWith(".rapidgator.net")
       || hostname === "rg.to"
-      || hostname.endsWith(".rg.to")
+      || hostname.endsWith(".rg.to");
-      || hostname === "rapidgator.asia"
-      || hostname.endsWith(".rapidgator.asia");
   } catch {
     return false;
   }
@@ -322,7 +315,7 @@ async function runWithConcurrency<T>(items: T[], concurrency: number, worker: (i
   let index = 0;
   let firstError: unknown = null;
   const next = (): T | undefined => {
-    if (firstError || index >= items.length) {
+    if (index >= items.length) {
       return undefined;
     }
     const item = items[index];
@@ -422,7 +415,6 @@ async function resolveRapidgatorFilename(link: string, signal?: AbortSignal): Pr
         signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
       });
       if (!response.ok) {
-        try { await response.body?.cancel(); } catch { /* drain socket */ }
         if (shouldRetryStatus(response.status) && attempt < REQUEST_RETRIES + 2) {
           await sleepWithSignal(retryDelayForResponse(response, attempt), signal);
           continue;
@@ -438,11 +430,9 @@ async function resolveRapidgatorFilename(link: string, signal?: AbortSignal): Pr
         && !contentType.includes("text/plain")
         && !contentType.includes("text/xml")
         && !contentType.includes("application/xml")) {
-        try { await response.body?.cancel(); } catch { /* drain socket */ }
         return "";
       }
       if (!contentType && Number.isFinite(contentLength) && contentLength > RAPIDGATOR_SCAN_MAX_BYTES) {
-        try { await response.body?.cancel(); } catch { /* drain socket */ }
         return "";
       }
 
@@ -454,7 +444,7 @@ async function resolveRapidgatorFilename(link: string, signal?: AbortSignal): Pr
       return "";
     } catch (error) {
       const errorText = compactErrorText(error);
-      if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
+      if (/aborted/i.test(errorText)) {
         throw error;
       }
       if (attempt >= REQUEST_RETRIES + 2 || !isRetryableErrorText(errorText)) {
@@ -470,138 +460,6 @@ async function resolveRapidgatorFilename(link: string, signal?: AbortSignal): Pr
   return "";
 }
 
-export interface RapidgatorCheckResult {
-  online: boolean;
-  fileName: string;
-  fileSize: string | null;
-}
-
-const RG_FILE_ID_RE = /\/file\/([a-z0-9]{32}|\d+)/i;
-const RG_FILE_NOT_FOUND_RE = />\s*404\s*File not found/i;
-const RG_FILESIZE_RE = /File\s*size:\s*<strong>([^<>"]+)<\/strong>/i;
-
-export async function checkRapidgatorOnline(
-  link: string,
-  signal?: AbortSignal
-): Promise<RapidgatorCheckResult | null> {
-  if (!isRapidgatorLink(link)) {
-    return null;
-  }
-
-  const fileIdMatch = link.match(RG_FILE_ID_RE);
-  if (!fileIdMatch) {
-    return null;
-  }
-  const fileId = fileIdMatch[1];
-  const headers = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
-    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-    "Accept-Language": "en-US,en;q=0.9,de;q=0.8"
-  };
-
-  // Fast path: HEAD request (no body download, much faster)
-  for (let attempt = 1; attempt <= REQUEST_RETRIES + 1; attempt += 1) {
-    try {
-      if (signal?.aborted) throw new Error("aborted:debrid");
-
-      const response = await fetch(link, {
-        method: "HEAD",
-        redirect: "follow",
-        headers,
-        signal: withTimeoutSignal(signal, 15000)
-      });
-
-      if (response.status === 404) {
-        return { online: false, fileName: "", fileSize: null };
-      }
-
-      if (response.ok) {
-        const finalUrl = response.url || link;
-        if (!finalUrl.includes(fileId)) {
-          return { online: false, fileName: "", fileSize: null };
-        }
-        // HEAD 200 + URL still contains file ID → online
-        const fileName = filenameFromRapidgatorUrlPath(link);
-        return { online: true, fileName, fileSize: null };
-      }
-
-      // Non-OK, non-404: retry or give up
-      if (shouldRetryStatus(response.status) && attempt <= REQUEST_RETRIES) {
-        await sleepWithSignal(retryDelayForResponse(response, attempt), signal);
-        continue;
-      }
-
-      // HEAD inconclusive — fall through to GET
-      break;
-    } catch (error) {
-      const errorText = compactErrorText(error);
-      if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) throw error;
-      if (attempt > REQUEST_RETRIES || !isRetryableErrorText(errorText)) {
-        break; // fall through to GET
-      }
-      await sleepWithSignal(retryDelay(attempt), signal);
-    }
-  }
-
-  // Slow path: GET request (downloads HTML, more thorough)
-  for (let attempt = 1; attempt <= REQUEST_RETRIES + 1; attempt += 1) {
-    try {
-      if (signal?.aborted) throw new Error("aborted:debrid");
-
-      const response = await fetch(link, {
-        method: "GET",
-        redirect: "follow",
-        headers,
-        signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
-      });
-
-      if (response.status === 404) {
-        try { await response.body?.cancel(); } catch { /* drain socket */ }
-        return { online: false, fileName: "", fileSize: null };
-      }
-
-      if (!response.ok) {
-        try { await response.body?.cancel(); } catch { /* drain socket */ }
-        if (shouldRetryStatus(response.status) && attempt <= REQUEST_RETRIES) {
-          await sleepWithSignal(retryDelayForResponse(response, attempt), signal);
-          continue;
-        }
-        return null;
-      }
-
-      const finalUrl = response.url || link;
-      if (!finalUrl.includes(fileId)) {
-        try { await response.body?.cancel(); } catch { /* drain socket */ }
-        return { online: false, fileName: "", fileSize: null };
-      }
-
-      const html = await readResponseTextLimited(response, RAPIDGATOR_SCAN_MAX_BYTES, signal);
-
-      if (RG_FILE_NOT_FOUND_RE.test(html)) {
-        return { online: false, fileName: "", fileSize: null };
-      }
-
-      const fileName = extractRapidgatorFilenameFromHtml(html) || filenameFromRapidgatorUrlPath(link);
-      const sizeMatch = html.match(RG_FILESIZE_RE);
-      const fileSize = sizeMatch ? sizeMatch[1].trim() : null;
-
-      return { online: true, fileName, fileSize };
-    } catch (error) {
-      const errorText = compactErrorText(error);
-      if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) throw error;
-      if (attempt > REQUEST_RETRIES || !isRetryableErrorText(errorText)) {
-        return null;
-      }
-    }
-
-    if (attempt <= REQUEST_RETRIES) {
-      await sleepWithSignal(retryDelay(attempt), signal);
-    }
-  }
-
-  return null;
-}
-
 function buildBestDebridRequests(link: string, token: string): BestDebridRequest[] {
   const linkParam = encodeURIComponent(link);
   const safeToken = String(token || "").trim();
@@ -645,7 +503,7 @@ class MegaDebridClient {
         throw new Error("Mega-Web Antwort ohne Download-Link");
       }
       if (!lastError) {
-        lastError = "Mega-Web Antwort leer";
+        lastError = web ? "Mega-Web Antwort ohne Download-Link" : "Mega-Web Antwort leer";
       }
       // Don't retry permanent hoster errors (dead link, file removed, etc.)
       if (/permanent ungültig|hosternotavailable|file.?not.?found|file.?unavailable|link.?is.?dead/i.test(lastError)) {
@@ -655,7 +513,7 @@ class MegaDebridClient {
         await sleepWithSignal(retryDelay(attempt), signal);
       }
     }
-    throw new Error(String(lastError || "Mega-Web Unrestrict fehlgeschlagen").replace(/^Error:\s*/i, ""));
+    throw new Error(lastError || "Mega-Web Unrestrict fehlgeschlagen");
   }
 }
 
@@ -674,11 +532,7 @@ class BestDebridClient {
       try {
         return await this.tryRequest(request, link, signal);
       } catch (error) {
-        const errorText = compactErrorText(error);
+        lastError = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
-          throw error;
-        }
-        lastError = errorText;
       }
     }
 
@@ -743,7 +597,7 @@ class BestDebridClient {
         throw new Error("BestDebrid Antwort ohne Download-Link");
       } catch (error) {
         lastError = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(lastError) && !/timeout/i.test(lastError))) {
+        if (signal?.aborted || /aborted/i.test(lastError)) {
           break;
         }
         if (attempt >= REQUEST_RETRIES || !isRetryableErrorText(lastError)) {
@@ -837,7 +691,7 @@ class AllDebridClient {
           break;
         } catch (error) {
           const errorText = compactErrorText(error);
-          if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
+          if (signal?.aborted || /aborted/i.test(errorText)) {
             throw error;
           }
           if (attempt >= REQUEST_RETRIES || !isRetryableErrorText(errorText)) {
@@ -949,7 +803,7 @@ class AllDebridClient {
         };
       } catch (error) {
         lastError = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(lastError) && !/timeout/i.test(lastError))) {
+        if (signal?.aborted || /aborted/i.test(lastError)) {
           break;
         }
         if (attempt >= REQUEST_RETRIES || !isRetryableErrorText(lastError)) {
@@ -959,257 +813,7 @@ class AllDebridClient {
       }
     }
 
-    throw new Error(String(lastError || "AllDebrid Unrestrict fehlgeschlagen").replace(/^Error:\s*/i, ""));
+    throw new Error(lastError || "AllDebrid Unrestrict fehlgeschlagen");
-  }
-}
-
-// ── 1Fichier Client ──
-
-class OneFichierClient {
-  private apiKey: string;
-
-  public constructor(apiKey: string) {
-    this.apiKey = apiKey;
-  }
-
-  public async unrestrictLink(link: string, signal?: AbortSignal): Promise<UnrestrictedLink> {
-    if (!ONEFICHIER_URL_RE.test(link)) {
-      throw new Error("Kein 1Fichier-Link");
-    }
-
-    let lastError = "";
-    for (let attempt = 1; attempt <= REQUEST_RETRIES; attempt += 1) {
-      if (signal?.aborted) throw new Error("aborted:debrid");
-      try {
-        const res = await fetch(`${ONEFICHIER_API_BASE}/download/get_token.cgi`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.apiKey}`
-          },
-          body: JSON.stringify({ url: link, pretty: 1 }),
-          signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
-        });
-
-        const json = await res.json() as Record<string, unknown>;
-
-        if (json.status === "KO" || json.error) {
-          const msg = String(json.message || json.error || "Unbekannter 1Fichier-Fehler");
-          throw new Error(msg);
-        }
-
-        const directUrl = String(json.url || "");
-        if (!directUrl) {
-          throw new Error("1Fichier: Keine Download-URL in Antwort");
-        }
-
-        return {
-          fileName: filenameFromUrl(directUrl) || filenameFromUrl(link),
-          directUrl,
-          fileSize: null,
-          retriesUsed: attempt - 1
-        };
-      } catch (error) {
-        lastError = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(lastError) && !/timeout/i.test(lastError))) {
-          throw error;
-        }
-        if (attempt < REQUEST_RETRIES) {
-          await sleep(retryDelay(attempt), signal);
-        }
-      }
-    }
-    throw new Error(`1Fichier-Unrestrict fehlgeschlagen: ${lastError}`);
-  }
-}
-
-const DDOWNLOAD_URL_RE = /^https?:\/\/(?:www\.)?(?:ddownload\.com|ddl\.to)\/([a-z0-9]+)/i;
-const DDOWNLOAD_WEB_BASE = "https://ddownload.com";
-const DDOWNLOAD_WEB_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36";
-
-class DdownloadClient {
-  private login: string;
-  private password: string;
-  private cookies: string = "";
-
-  public constructor(login: string, password: string) {
-    this.login = login;
-    this.password = password;
-  }
-
-  private async webLogin(signal?: AbortSignal): Promise<void> {
-    // Step 1: GET login page to extract form token
-    const loginPageRes = await fetch(`${DDOWNLOAD_WEB_BASE}/login.html`, {
-      headers: { "User-Agent": DDOWNLOAD_WEB_UA },
-      redirect: "manual",
-      signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
-    });
-    const loginPageHtml = await loginPageRes.text();
-    const tokenMatch = loginPageHtml.match(/name="token" value="([^"]+)"/);
-    const pageCookies = (loginPageRes.headers.getSetCookie?.() || []).map((c: string) => c.split(";")[0]).join("; ");
-
-    // Step 2: POST login
-    const body = new URLSearchParams({
-      op: "login",
-      token: tokenMatch?.[1] || "",
-      rand: "",
-      redirect: "",
-      login: this.login,
-      password: this.password
-    });
-    const loginRes = await fetch(`${DDOWNLOAD_WEB_BASE}/`, {
-      method: "POST",
-      headers: {
-        "User-Agent": DDOWNLOAD_WEB_UA,
-        "Content-Type": "application/x-www-form-urlencoded",
-        ...(pageCookies ? { Cookie: pageCookies } : {})
-      },
-      body: body.toString(),
-      redirect: "manual",
-      signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
-    });
-
-    // Drain body
-    try { await loginRes.text(); } catch { /* ignore */ }
-
-    const setCookies = loginRes.headers.getSetCookie?.() || [];
-    const xfss = setCookies.find((c: string) => c.startsWith("xfss="));
-    const loginCookie = setCookies.find((c: string) => c.startsWith("login="));
-    if (!xfss) {
-      throw new Error("DDownload Login fehlgeschlagen (kein Session-Cookie)");
-    }
-    this.cookies = [loginCookie, xfss].filter(Boolean).map((c: string) => c.split(";")[0]).join("; ");
-  }
-
-  public async unrestrictLink(link: string, signal?: AbortSignal): Promise<UnrestrictedLink> {
-    const match = link.match(DDOWNLOAD_URL_RE);
-    if (!match) {
-      throw new Error("Kein DDownload-Link");
-    }
-    const fileCode = match[1];
-    let lastError = "";
-
-    for (let attempt = 1; attempt <= REQUEST_RETRIES; attempt += 1) {
-      try {
-        if (signal?.aborted) throw new Error("aborted:debrid");
-
-        // Login if no session yet
-        if (!this.cookies) {
-          await this.webLogin(signal);
-        }
-
-        // Step 1: GET file page to extract form fields
-        const filePageRes = await fetch(`${DDOWNLOAD_WEB_BASE}/${fileCode}`, {
-          headers: {
-            "User-Agent": DDOWNLOAD_WEB_UA,
-            Cookie: this.cookies
-          },
-          redirect: "manual",
-          signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
-        });
-
-        // Premium with direct downloads enabled → redirect immediately
-        if (filePageRes.status >= 300 && filePageRes.status < 400) {
-          const directUrl = filePageRes.headers.get("location") || "";
-          try { await filePageRes.text(); } catch { /* drain */ }
-          if (directUrl) {
-            return {
-              fileName: filenameFromUrl(directUrl) || filenameFromUrl(link),
-              directUrl,
-              fileSize: null,
-              retriesUsed: attempt - 1,
-              skipTlsVerify: true
-            };
-          }
-        }
-
-        const html = await filePageRes.text();
-
-        // Check for file not found
-        if (/File Not Found|file was removed|file was banned/i.test(html)) {
-          throw new Error("DDownload: Datei nicht gefunden");
-        }
-
-        // Extract form fields
-        const idVal = html.match(/name="id" value="([^"]+)"/)?.[1] || fileCode;
-        const randVal = html.match(/name="rand" value="([^"]+)"/)?.[1] || "";
-        const fileNameMatch = html.match(/class="file-info-name"[^>]*>([^<]+)</);
-        const fileName = fileNameMatch?.[1]?.trim() || filenameFromUrl(link);
-
-        // Step 2: POST download2 for premium download
-        const dlBody = new URLSearchParams({
-          op: "download2",
-          id: idVal,
-          rand: randVal,
-          referer: "",
-          method_premium: "1",
-          adblock_detected: "0"
-        });
-
-        const dlRes = await fetch(`${DDOWNLOAD_WEB_BASE}/${fileCode}`, {
-          method: "POST",
-          headers: {
-            "User-Agent": DDOWNLOAD_WEB_UA,
-            "Content-Type": "application/x-www-form-urlencoded",
-            Cookie: this.cookies,
-            Referer: `${DDOWNLOAD_WEB_BASE}/${fileCode}`
-          },
-          body: dlBody.toString(),
-          redirect: "manual",
-          signal: withTimeoutSignal(signal, API_TIMEOUT_MS)
-        });
-
-        if (dlRes.status >= 300 && dlRes.status < 400) {
-          const directUrl = dlRes.headers.get("location") || "";
-          try { await dlRes.text(); } catch { /* drain */ }
-          if (directUrl) {
-            return {
-              fileName: fileName || filenameFromUrl(directUrl),
-              directUrl,
-              fileSize: null,
-              retriesUsed: attempt - 1,
-              skipTlsVerify: true
-            };
-          }
-        }
-
-        const dlHtml = await dlRes.text();
-        // Try to find direct URL in response HTML
-        const directMatch = dlHtml.match(/https?:\/\/[a-z0-9]+\.(?:dstorage\.org|ddownload\.com|ddl\.to|ucdn\.to)[^\s"'<>]+/i);
-        if (directMatch) {
-          return {
-            fileName,
-            directUrl: directMatch[0],
-            fileSize: null,
-            retriesUsed: attempt - 1,
-            skipTlsVerify: true
-          };
-        }
-
-        // Check for error messages
-        const errMatch = dlHtml.match(/class="err"[^>]*>([^<]+)</i);
-        if (errMatch) {
-          throw new Error(`DDownload: ${errMatch[1].trim()}`);
-        }
-
-        throw new Error("DDownload: Kein Download-Link erhalten");
-      } catch (error) {
-        lastError = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(lastError) && !/timeout/i.test(lastError))) {
-          break;
-        }
-        // Re-login on auth errors
-        if (/login|session|cookie/i.test(lastError)) {
-          this.cookies = "";
-        }
-        if (attempt >= REQUEST_RETRIES || !isRetryableErrorText(lastError)) {
-          break;
-        }
-        await sleepWithSignal(retryDelay(attempt), signal);
-      }
-    }
-
-    throw new Error(String(lastError || "DDownload Unrestrict fehlgeschlagen").replace(/^Error:\s*/i, ""));
   }
 }
 
@@ -1218,9 +822,6 @@ export class DebridService {
 
   private options: DebridServiceOptions;
 
-  private cachedDdownloadClient: DdownloadClient | null = null;
-  private cachedDdownloadKey = "";
-
   public constructor(settings: AppSettings, options: DebridServiceOptions = {}) {
     this.settings = cloneSettings(settings);
     this.options = options;
@@ -1230,16 +831,6 @@ export class DebridService {
     this.settings = cloneSettings(next);
   }
 
-  private getDdownloadClient(login: string, password: string): DdownloadClient {
-    const key = `${login}\0${password}`;
-    if (this.cachedDdownloadClient && this.cachedDdownloadKey === key) {
-      return this.cachedDdownloadClient;
-    }
-    this.cachedDdownloadClient = new DdownloadClient(login, password);
-    this.cachedDdownloadKey = key;
-    return this.cachedDdownloadClient;
-  }
-
   public async resolveFilenames(
     links: string[],
     onResolved?: (link: string, fileName: string) => void,
@@ -1274,7 +865,7 @@ export class DebridService {
         }
       } catch (error) {
         const errorText = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
+        if (signal?.aborted || /aborted/i.test(errorText)) {
           throw error;
         }
         // ignore and continue with host page fallback
@@ -1292,46 +883,6 @@ export class DebridService {
 
   public async unrestrictLink(link: string, signal?: AbortSignal, settingsSnapshot?: AppSettings): Promise<ProviderUnrestrictedLink> {
     const settings = settingsSnapshot ? cloneSettings(settingsSnapshot) : cloneSettings(this.settings);
-
-    // 1Fichier is a direct file hoster. If the link is a 1fichier.com URL
-    // and the API key is configured, use 1Fichier directly before debrid providers.
-    if (ONEFICHIER_URL_RE.test(link) && this.isProviderConfiguredFor(settings, "onefichier")) {
-      try {
-        const result = await this.unrestrictViaProvider(settings, "onefichier", link, signal);
-        return {
-          ...result,
-          provider: "onefichier",
-          providerLabel: PROVIDER_LABELS["onefichier"]
-        };
-      } catch (error) {
-        const errorText = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
-          throw error;
-        }
-        // Fall through to normal provider chain
-      }
-    }
-
-    // DDownload is a direct file hoster, not a debrid service.
-    // If the link is a ddownload.com/ddl.to URL and the account is configured,
-    // use DDownload directly before trying any debrid providers.
-    if (DDOWNLOAD_URL_RE.test(link) && this.isProviderConfiguredFor(settings, "ddownload")) {
-      try {
-        const result = await this.unrestrictViaProvider(settings, "ddownload", link, signal);
-        return {
-          ...result,
-          provider: "ddownload",
-          providerLabel: PROVIDER_LABELS["ddownload"]
-        };
-      } catch (error) {
-        const errorText = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
-          throw error;
-        }
-        // Fall through to normal provider chain (debrid services may also support ddownload links)
-      }
-    }
-
     const order = toProviderOrder(
       settings.providerPrimary,
       settings.providerSecondary,
@@ -1359,11 +910,7 @@ export class DebridService {
           providerLabel: PROVIDER_LABELS[primary]
         };
       } catch (error) {
-        const errorText = compactErrorText(error);
+        throw new Error(`Unrestrict fehlgeschlagen: ${PROVIDER_LABELS[primary]}: ${compactErrorText(error)}`);
-        if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
-          throw error;
-        }
-        throw new Error(`Unrestrict fehlgeschlagen: ${PROVIDER_LABELS[primary]}: ${errorText}`);
       }
     }
 
@@ -1393,7 +940,7 @@ export class DebridService {
         };
       } catch (error) {
         const errorText = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(errorText) && !/timeout/i.test(errorText))) {
+        if (signal?.aborted || /aborted/i.test(errorText)) {
           throw error;
         }
         attempts.push(`${PROVIDER_LABELS[provider]}: ${compactErrorText(error)}`);
@@ -1417,12 +964,6 @@ export class DebridService {
     if (provider === "alldebrid") {
       return Boolean(settings.allDebridToken.trim());
     }
-    if (provider === "ddownload") {
-      return Boolean(settings.ddownloadLogin.trim() && settings.ddownloadPassword.trim());
-    }
-    if (provider === "onefichier") {
-      return Boolean(settings.oneFichierApiKey.trim());
-    }
     return Boolean(settings.bestToken.trim());
   }
 
@@ -1436,12 +977,6 @@ export class DebridService {
     if (provider === "alldebrid") {
       return new AllDebridClient(settings.allDebridToken).unrestrictLink(link, signal);
     }
-    if (provider === "ddownload") {
-      return this.getDdownloadClient(settings.ddownloadLogin, settings.ddownloadPassword).unrestrictLink(link, signal);
-    }
-    if (provider === "onefichier") {
-      return new OneFichierClient(settings.oneFichierApiKey).unrestrictLink(link, signal);
-    }
     return new BestDebridClient(settings.bestToken).unrestrictLink(link, signal);
   }
 }

src/main/debug-server.ts

@@ -261,7 +261,7 @@ export function startDebugServer(mgr: DownloadManager, baseDir: string): void {
   const port = getPort(baseDir);
 
   server = http.createServer(handleRequest);
-  server.listen(port, "127.0.0.1", () => {
+  server.listen(port, "0.0.0.0", () => {
     logger.info(`Debug-Server gestartet auf Port ${port}`);
   });
   server.on("error", (err) => {

src/main/logger.ts

@@ -8,19 +8,12 @@ const LOG_BUFFER_LIMIT_CHARS = 1_000_000;
 const LOG_MAX_FILE_BYTES = 10 * 1024 * 1024;
 const rotateCheckAtByFile = new Map<string, number>();
 
-type LogListener = (line: string) => void;
-let logListener: LogListener | null = null;
-
 let pendingLines: string[] = [];
 let pendingChars = 0;
 let flushTimer: NodeJS.Timeout | null = null;
 let flushInFlight = false;
 let exitHookAttached = false;
 
-export function setLogListener(listener: LogListener | null): void {
-  logListener = listener;
-}
-
 export function configureLogger(baseDir: string): void {
   logFilePath = path.join(baseDir, "rd_downloader.log");
   const cwdLogPath = path.resolve(process.cwd(), "rd_downloader.log");
@@ -195,10 +188,6 @@ function write(level: "INFO" | "WARN" | "ERROR", message: string): void {
   pendingLines.push(line);
   pendingChars += line.length;
 
-  if (logListener) {
-    try { logListener(line); } catch { /* ignore */ }
-  }
-
   while (pendingChars > LOG_BUFFER_LIMIT_CHARS && pendingLines.length > 1) {
     const removed = pendingLines.shift();
     if (!removed) {

src/main/main.ts

@@ -7,7 +7,6 @@ import { IPC_CHANNELS } from "../shared/ipc";
 import { getLogFilePath, logger } from "./logger";
 import { APP_NAME } from "./constants";
 import { extractHttpLinksFromText } from "./utils";
-import { cleanupStaleSubstDrives, shutdownDaemon } from "./extractor";
 
 /* ── IPC validation helpers ────────────────────────────────────── */
 function validateString(value: unknown, name: string): string {
@@ -51,7 +50,6 @@ process.on("unhandledRejection", (reason) => {
 let mainWindow: BrowserWindow | null = null;
 let tray: Tray | null = null;
 let clipboardTimer: ReturnType<typeof setInterval> | null = null;
-let updateQuitTimer: ReturnType<typeof setTimeout> | null = null;
 let lastClipboardText = "";
 const controller = new AppController();
 const CLIPBOARD_MAX_TEXT_CHARS = 50_000;
@@ -82,7 +80,7 @@ function createWindow(): BrowserWindow {
         responseHeaders: {
           ...details.responseHeaders,
           "Content-Security-Policy": [
-            "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https://api.real-debrid.com https://codeberg.org https://bestdebrid.com https://api.alldebrid.com https://www.mega-debrid.eu https://git.24-music.de https://ddownload.com https://ddl.to"
+            "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https://api.real-debrid.com https://codeberg.org https://bestdebrid.com https://api.alldebrid.com https://www.mega-debrid.eu"
           ]
         }
       });
@@ -131,7 +129,7 @@ function createTray(): void {
   const contextMenu = Menu.buildFromTemplate([
     { label: "Anzeigen", click: () => { mainWindow?.show(); mainWindow?.focus(); } },
     { type: "separator" },
-    { label: "Start", click: () => { void controller.start().catch((err) => logger.warn(`Tray Start Fehler: ${String(err)}`)); } },
+    { label: "Start", click: () => { controller.start(); } },
     { label: "Stop", click: () => { controller.stop(); } },
     { type: "separator" },
     { label: "Beenden", click: () => { app.quit(); } }
@@ -189,12 +187,7 @@ function startClipboardWatcher(): void {
   }
   lastClipboardText = normalizeClipboardText(clipboard.readText());
   clipboardTimer = setInterval(() => {
-    let text: string;
+    const text = normalizeClipboardText(clipboard.readText());
-    try {
-      text = normalizeClipboardText(clipboard.readText());
-    } catch {
-      return;
-    }
     if (text === lastClipboardText || !text.trim()) {
       return;
     }
@@ -243,9 +236,9 @@ function registerIpcHandlers(): void {
       mainWindow.webContents.send(IPC_CHANNELS.UPDATE_INSTALL_PROGRESS, progress);
     });
     if (result.started) {
-      updateQuitTimer = setTimeout(() => {
+      setTimeout(() => {
         app.quit();
-      }, 2500);
+      }, 800);
     }
     return result;
   });
@@ -295,14 +288,6 @@ function registerIpcHandlers(): void {
   });
   ipcMain.handle(IPC_CHANNELS.CLEAR_ALL, () => controller.clearAll());
   ipcMain.handle(IPC_CHANNELS.START, () => controller.start());
-  ipcMain.handle(IPC_CHANNELS.START_PACKAGES, (_event: IpcMainInvokeEvent, packageIds: string[]) => {
-    validateStringArray(packageIds ?? [], "packageIds");
-    return controller.startPackages(packageIds ?? []);
-  });
-  ipcMain.handle(IPC_CHANNELS.START_ITEMS, (_event: IpcMainInvokeEvent, itemIds: string[]) => {
-    validateStringArray(itemIds ?? [], "itemIds");
-    return controller.startItems(itemIds ?? []);
-  });
   ipcMain.handle(IPC_CHANNELS.STOP, () => controller.stop());
   ipcMain.handle(IPC_CHANNELS.TOGGLE_PAUSE, () => controller.togglePause());
   ipcMain.handle(IPC_CHANNELS.CANCEL_PACKAGE, (_event: IpcMainInvokeEvent, packageId: string) => {
@@ -337,45 +322,13 @@ function registerIpcHandlers(): void {
     validateString(packageId, "packageId");
     return controller.extractNow(packageId);
   });
-  ipcMain.handle(IPC_CHANNELS.RESET_PACKAGE, (_event: IpcMainInvokeEvent, packageId: string) => {
-    validateString(packageId, "packageId");
-    return controller.resetPackage(packageId);
-  });
-  ipcMain.handle(IPC_CHANNELS.SET_PACKAGE_PRIORITY, (_event: IpcMainInvokeEvent, packageId: string, priority: string) => {
-    validateString(packageId, "packageId");
-    validateString(priority, "priority");
-    if (priority !== "high" && priority !== "normal" && priority !== "low") {
-      throw new Error("priority muss 'high', 'normal' oder 'low' sein");
-    }
-    return controller.setPackagePriority(packageId, priority);
-  });
-  ipcMain.handle(IPC_CHANNELS.SKIP_ITEMS, (_event: IpcMainInvokeEvent, itemIds: string[]) => {
-    validateStringArray(itemIds ?? [], "itemIds");
-    return controller.skipItems(itemIds ?? []);
-  });
-  ipcMain.handle(IPC_CHANNELS.RESET_ITEMS, (_event: IpcMainInvokeEvent, itemIds: string[]) => {
-    validateStringArray(itemIds ?? [], "itemIds");
-    return controller.resetItems(itemIds ?? []);
-  });
   ipcMain.handle(IPC_CHANNELS.GET_HISTORY, () => controller.getHistory());
   ipcMain.handle(IPC_CHANNELS.CLEAR_HISTORY, () => controller.clearHistory());
   ipcMain.handle(IPC_CHANNELS.REMOVE_HISTORY_ENTRY, (_event: IpcMainInvokeEvent, entryId: string) => {
     validateString(entryId, "entryId");
     return controller.removeHistoryEntry(entryId);
   });
-  ipcMain.handle(IPC_CHANNELS.EXPORT_QUEUE, async () => {
+  ipcMain.handle(IPC_CHANNELS.EXPORT_QUEUE, () => controller.exportQueue());
-    const options = {
-      defaultPath: `rd-queue-export.json`,
-      filters: [{ name: "Queue Export", extensions: ["json"] }]
-    };
-    const result = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);
-    if (result.canceled || !result.filePath) {
-      return { saved: false };
-    }
-    const json = controller.exportQueue();
-    await fs.promises.writeFile(result.filePath, json, "utf8");
-    return { saved: true };
-  });
   ipcMain.handle(IPC_CHANNELS.IMPORT_QUEUE, (_event: IpcMainInvokeEvent, json: string) => {
     validateString(json, "json");
     const bytes = Buffer.byteLength(json, "utf8");
@@ -439,13 +392,6 @@ function registerIpcHandlers(): void {
     await shell.openPath(logPath);
   });
 
-  ipcMain.handle(IPC_CHANNELS.OPEN_SESSION_LOG, async () => {
-    const logPath = controller.getSessionLogPath();
-    if (logPath) {
-      await shell.openPath(logPath);
-    }
-  });
-
   ipcMain.handle(IPC_CHANNELS.IMPORT_BACKUP, async () => {
     const options = {
       properties: ["openFile"] as Array<"openFile">,
@@ -459,11 +405,6 @@ function registerIpcHandlers(): void {
       return { restored: false, message: "Abgebrochen" };
     }
     const filePath = result.filePaths[0];
-    const stat = await fs.promises.stat(filePath);
-    const BACKUP_MAX_BYTES = 50 * 1024 * 1024;
-    if (stat.size > BACKUP_MAX_BYTES) {
-      return { restored: false, message: `Backup-Datei zu groß (max 50 MB, Datei hat ${(stat.size / 1024 / 1024).toFixed(1)} MB)` };
-    }
     const json = await fs.promises.readFile(filePath, "utf8");
     return controller.importBackup(json);
   });
@@ -487,7 +428,6 @@ app.on("second-instance", () => {
 });
 
 app.whenReady().then(() => {
-  cleanupStaleSubstDrives();
   registerIpcHandlers();
   mainWindow = createWindow();
   bindMainWindowLifecycle(mainWindow);
@@ -500,9 +440,6 @@ app.whenReady().then(() => {
       bindMainWindowLifecycle(mainWindow);
     }
   });
-}).catch((error) => {
-  console.error("App startup failed:", error);
-  app.quit();
 });
 
 app.on("window-all-closed", () => {
@@ -512,10 +449,8 @@ app.on("window-all-closed", () => {
 });
 
 app.on("before-quit", () => {
-  if (updateQuitTimer) { clearTimeout(updateQuitTimer); updateQuitTimer = null; }
   stopClipboardWatcher();
   destroyTray();
-  shutdownDaemon();
   try {
     controller.shutdown();
   } catch (error) {

src/main/mega-web-fallback.ts

@@ -228,23 +228,22 @@ export class MegaWebFallback {
   }
 
   public async unrestrict(link: string, signal?: AbortSignal): Promise<UnrestrictedLink | null> {
-    const overallSignal = withTimeoutSignal(signal, 180000);
     return this.runExclusive(async () => {
-      throwIfAborted(overallSignal);
+      throwIfAborted(signal);
       const creds = this.getCredentials();
       if (!creds.login.trim() || !creds.password.trim()) {
         return null;
       }
 
       if (!this.cookie || Date.now() - this.cookieSetAt > 20 * 60 * 1000) {
-        await this.login(creds.login, creds.password, overallSignal);
+        await this.login(creds.login, creds.password, signal);
       }
 
-      const generated = await this.generate(link, overallSignal);
+      const generated = await this.generate(link, signal);
       if (!generated) {
         this.cookie = "";
-        await this.login(creds.login, creds.password, overallSignal);
+        await this.login(creds.login, creds.password, signal);
-        const retry = await this.generate(link, overallSignal);
+        const retry = await this.generate(link, signal);
         if (!retry) {
           return null;
         }
@@ -262,7 +261,7 @@ export class MegaWebFallback {
         fileSize: null,
         retriesUsed: 0
       };
-    }, overallSignal);
+    }, signal);
   }
 
   public invalidateSession(): void {

src/main/realdebrid.ts

@@ -8,7 +8,6 @@ export interface UnrestrictedLink {
   directUrl: string;
   fileSize: number | null;
   retriesUsed: number;
-  skipTlsVerify?: boolean;
 }
 
 function shouldRetryStatus(status: number): boolean {
@@ -63,8 +62,7 @@ function isRetryableErrorText(text: string): boolean {
     || lower.includes("aborted")
     || lower.includes("econnreset")
     || lower.includes("enotfound")
-    || lower.includes("etimedout")
+    || lower.includes("etimedout");
-    || lower.includes("html statt json");
 }
 
 function withTimeoutSignal(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal {
@@ -79,11 +77,6 @@ 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");
-  }
   await new Promise<void>((resolve, reject) => {
     let timer: NodeJS.Timeout | null = setTimeout(() => {
       timer = null;
@@ -100,6 +93,10 @@ async function sleepWithSignal(ms: number, signal?: AbortSignal): Promise<void>
       reject(new Error("aborted"));
     };
 
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
     signal.addEventListener("abort", onAbort, { once: true });
   });
 }
@@ -168,15 +165,6 @@ export class RealDebridClient {
         if (!directUrl) {
           throw new Error("Unrestrict ohne Download-URL");
         }
-        try {
-          const parsedUrl = new URL(directUrl);
-          if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
-            throw new Error(`Ungültiges Download-URL-Protokoll (${parsedUrl.protocol})`);
-          }
-        } catch (urlError) {
-          if (urlError instanceof Error && urlError.message.includes("Protokoll")) throw urlError;
-          throw new Error("Real-Debrid Antwort enthält keine gültige Download-URL");
-        }
 
         const fileName = String(payload.filename || "download.bin").trim() || "download.bin";
         const fileSizeRaw = Number(payload.filesize ?? NaN);
@@ -188,7 +176,7 @@ export class RealDebridClient {
         };
       } catch (error) {
         lastError = compactErrorText(error);
-        if (signal?.aborted || (/aborted/i.test(lastError) && !/timeout/i.test(lastError))) {
+        if (signal?.aborted || /aborted/i.test(lastError)) {
           break;
         }
         if (attempt >= REQUEST_RETRIES || !isRetryableErrorText(lastError)) {
@@ -198,6 +186,6 @@ export class RealDebridClient {
       }
     }
 
-    throw new Error(String(lastError || "Unrestrict fehlgeschlagen").replace(/^Error:\s*/i, ""));
+    throw new Error(lastError || "Unrestrict fehlgeschlagen");
   }
 }

src/main/session-log.ts

@@ -1,128 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { setLogListener } from "./logger";
-
-const SESSION_LOG_FLUSH_INTERVAL_MS = 200;
-
-let sessionLogPath: string | null = null;
-let sessionLogsDir: string | null = null;
-let pendingLines: string[] = [];
-let flushTimer: NodeJS.Timeout | null = null;
-
-function formatTimestamp(): string {
-  const now = new Date();
-  const y = now.getFullYear();
-  const mo = String(now.getMonth() + 1).padStart(2, "0");
-  const d = String(now.getDate()).padStart(2, "0");
-  const h = String(now.getHours()).padStart(2, "0");
-  const mi = String(now.getMinutes()).padStart(2, "0");
-  const s = String(now.getSeconds()).padStart(2, "0");
-  return `${y}-${mo}-${d}_${h}-${mi}-${s}`;
-}
-
-function flushPending(): void {
-  if (pendingLines.length === 0 || !sessionLogPath) {
-    return;
-  }
-  const chunk = pendingLines.join("");
-  pendingLines = [];
-  try {
-    fs.appendFileSync(sessionLogPath, chunk, "utf8");
-  } catch {
-    // ignore write errors
-  }
-}
-
-function scheduleFlush(): void {
-  if (flushTimer) {
-    return;
-  }
-  flushTimer = setTimeout(() => {
-    flushTimer = null;
-    flushPending();
-  }, SESSION_LOG_FLUSH_INTERVAL_MS);
-}
-
-function appendToSessionLog(line: string): void {
-  if (!sessionLogPath) {
-    return;
-  }
-  pendingLines.push(line);
-  scheduleFlush();
-}
-
-async function cleanupOldSessionLogs(dir: string, maxAgeDays: number): Promise<void> {
-  try {
-    const files = await fs.promises.readdir(dir);
-    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-    for (const file of files) {
-      if (!file.startsWith("session_") || !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 {
-        // ignore - file may be locked
-      }
-    }
-  } catch {
-    // ignore - dir may not exist
-  }
-}
-
-export function initSessionLog(baseDir: string): void {
-  sessionLogsDir = path.join(baseDir, "session-logs");
-  try {
-    fs.mkdirSync(sessionLogsDir, { recursive: true });
-  } catch {
-    sessionLogsDir = null;
-    return;
-  }
-
-  const timestamp = formatTimestamp();
-  sessionLogPath = path.join(sessionLogsDir, `session_${timestamp}.txt`);
-
-  const isoTimestamp = new Date().toISOString();
-  try {
-    fs.writeFileSync(sessionLogPath, `=== Session gestartet: ${isoTimestamp} ===\n`, "utf8");
-  } catch {
-    sessionLogPath = null;
-    return;
-  }
-
-  setLogListener((line) => appendToSessionLog(line));
-
-  void cleanupOldSessionLogs(sessionLogsDir, 7);
-}
-
-export function getSessionLogPath(): string | null {
-  return sessionLogPath;
-}
-
-export function shutdownSessionLog(): void {
-  if (!sessionLogPath) {
-    return;
-  }
-
-  // Flush any pending lines
-  if (flushTimer) {
-    clearTimeout(flushTimer);
-    flushTimer = null;
-  }
-  flushPending();
-
-  // Write closing line
-  const isoTimestamp = new Date().toISOString();
-  try {
-    fs.appendFileSync(sessionLogPath, `=== Session beendet: ${isoTimestamp} ===\n`, "utf8");
-  } catch {
-    // ignore
-  }
-
-  setLogListener(null);
-  sessionLogPath = null;
-}

src/main/storage.ts

@@ -1,24 +1,21 @@
 import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
-import { AppSettings, BandwidthScheduleEntry, DebridProvider, DownloadItem, DownloadStatus, HistoryEntry, PackageEntry, PackagePriority, SessionState } from "../shared/types";
+import { AppSettings, BandwidthScheduleEntry, DebridProvider, DownloadItem, DownloadStatus, HistoryEntry, PackageEntry, SessionState } from "../shared/types";
 import { defaultSettings } from "./constants";
 import { logger } from "./logger";
 
-const VALID_PRIMARY_PROVIDERS = new Set(["realdebrid", "megadebrid", "bestdebrid", "alldebrid", "ddownload", "onefichier"]);
+const VALID_PRIMARY_PROVIDERS = new Set(["realdebrid", "megadebrid", "bestdebrid", "alldebrid"]);
-const VALID_FALLBACK_PROVIDERS = new Set(["none", "realdebrid", "megadebrid", "bestdebrid", "alldebrid", "ddownload", "onefichier"]);
+const VALID_FALLBACK_PROVIDERS = new Set(["none", "realdebrid", "megadebrid", "bestdebrid", "alldebrid"]);
 const VALID_CLEANUP_MODES = new Set(["none", "trash", "delete"]);
 const VALID_CONFLICT_MODES = new Set(["overwrite", "skip", "rename", "ask"]);
 const VALID_FINISHED_POLICIES = new Set(["never", "immediate", "on_start", "package_done"]);
 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_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", "bestdebrid", "alldebrid", "ddownload", "onefichier"]);
+const VALID_ITEM_PROVIDERS = new Set<DebridProvider>(["realdebrid", "megadebrid", "bestdebrid", "alldebrid"]);
-const VALID_ONLINE_STATUSES = new Set(["online", "offline", "checking"]);
 
 function asText(value: unknown): string {
   return String(value ?? "").trim();
@@ -68,41 +65,6 @@ function normalizeAbsoluteDir(value: unknown, fallback: string): string {
   return path.resolve(text);
 }
 
-const DEFAULT_COLUMN_ORDER = ["name", "size", "progress", "hoster", "account", "prio", "status", "speed"];
-const ALL_VALID_COLUMNS = new Set([...DEFAULT_COLUMN_ORDER, "added"]);
-
-function normalizeColumnOrder(raw: unknown): string[] {
-  if (!Array.isArray(raw) || raw.length === 0) {
-    return [...DEFAULT_COLUMN_ORDER];
-  }
-  const valid = ALL_VALID_COLUMNS;
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const col of raw) {
-    if (typeof col === "string" && valid.has(col) && !seen.has(col)) {
-      seen.add(col);
-      result.push(col);
-    }
-  }
-  // "name" is mandatory — ensure it's always present
-  if (!seen.has("name")) {
-    result.unshift("name");
-  }
-  return result;
-}
-
-const DEPRECATED_UPDATE_REPOS = new Set([
-  "sucukdeluxe/real-debrid-downloader"
-]);
-
-function migrateUpdateRepo(raw: string, fallback: string): string {
-  const trimmed = raw.trim();
-  if (!trimmed || DEPRECATED_UPDATE_REPOS.has(trimmed.toLowerCase())) {
-    return fallback;
-  }
-  return trimmed;
-}
-
 export function normalizeSettings(settings: AppSettings): AppSettings {
   const defaults = defaultSettings();
   const normalized: AppSettings = {
@@ -111,10 +73,7 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     megaPassword: asText(settings.megaPassword),
     bestToken: asText(settings.bestToken),
     allDebridToken: asText(settings.allDebridToken),
-    ddownloadLogin: asText(settings.ddownloadLogin),
+    archivePasswordList: String(settings.archivePasswordList ?? "").replace(/\r\n/g, "\n"),
-    ddownloadPassword: asText(settings.ddownloadPassword),
-    oneFichierApiKey: asText(settings.oneFichierApiKey),
-    archivePasswordList: String(settings.archivePasswordList ?? "").replace(/\r\n|\r/g, "\n"),
     rememberToken: Boolean(settings.rememberToken),
     providerPrimary: settings.providerPrimary,
     providerSecondary: settings.providerSecondary,
@@ -137,7 +96,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     autoResumeOnStart: Boolean(settings.autoResumeOnStart),
     autoReconnect: Boolean(settings.autoReconnect),
     maxParallel: clampNumber(settings.maxParallel, defaults.maxParallel, 1, 50),
-    maxParallelExtract: clampNumber(settings.maxParallelExtract, defaults.maxParallelExtract, 1, 8),
     retryLimit: clampNumber(settings.retryLimit, defaults.retryLimit, 0, 99),
     reconnectWaitSeconds: clampNumber(settings.reconnectWaitSeconds, defaults.reconnectWaitSeconds, 10, 600),
     completedCleanupPolicy: settings.completedCleanupPolicy,
@@ -145,7 +103,7 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     speedLimitKbps: clampNumber(settings.speedLimitKbps, defaults.speedLimitKbps, 0, 500000),
     speedLimitMode: settings.speedLimitMode,
     autoUpdateCheck: Boolean(settings.autoUpdateCheck),
-    updateRepo: migrateUpdateRepo(asText(settings.updateRepo), defaults.updateRepo),
+    updateRepo: asText(settings.updateRepo) || defaults.updateRepo,
     clipboardWatch: Boolean(settings.clipboardWatch),
     minimizeToTray: Boolean(settings.minimizeToTray),
     collapseNewPackages: settings.collapseNewPackages !== undefined ? Boolean(settings.collapseNewPackages) : defaults.collapseNewPackages,
@@ -153,10 +111,7 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     confirmDeleteSelection: settings.confirmDeleteSelection !== undefined ? Boolean(settings.confirmDeleteSelection) : defaults.confirmDeleteSelection,
     totalDownloadedAllTime: typeof settings.totalDownloadedAllTime === "number" && settings.totalDownloadedAllTime >= 0 ? settings.totalDownloadedAllTime : defaults.totalDownloadedAllTime,
     theme: VALID_THEMES.has(settings.theme) ? settings.theme : defaults.theme,
-    bandwidthSchedules: normalizeBandwidthSchedules(settings.bandwidthSchedules),
+    bandwidthSchedules: normalizeBandwidthSchedules(settings.bandwidthSchedules)
-    columnOrder: normalizeColumnOrder(settings.columnOrder),
-    extractCpuPriority: settings.extractCpuPriority,
-    autoExtractWhenStopped: settings.autoExtractWhenStopped !== undefined ? Boolean(settings.autoExtractWhenStopped) : defaults.autoExtractWhenStopped
   };
 
   if (!VALID_PRIMARY_PROVIDERS.has(normalized.providerPrimary)) {
@@ -186,9 +141,6 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
   if (!VALID_SPEED_MODES.has(normalized.speedLimitMode)) {
     normalized.speedLimitMode = defaults.speedLimitMode;
   }
-  if (!VALID_EXTRACT_CPU_PRIORITIES.has(normalized.extractCpuPriority)) {
-    normalized.extractCpuPriority = defaults.extractCpuPriority;
-  }
 
   return normalized;
 }
@@ -204,9 +156,7 @@ function sanitizeCredentialPersistence(settings: AppSettings): AppSettings {
     megaPassword: "",
     bestToken: "",
     allDebridToken: "",
-    ddownloadLogin: "",
+    archivePasswordList: ""
-    ddownloadPassword: "",
-    oneFichierApiKey: ""
   };
 }
 
@@ -250,7 +200,7 @@ function readSettingsFile(filePath: string): AppSettings | null {
   }
 }
 
-export function normalizeLoadedSession(raw: unknown): SessionState {
+function normalizeLoadedSession(raw: unknown): SessionState {
   const fallback = emptySession();
   const parsed = asRecord(raw);
   if (!parsed) {
@@ -276,8 +226,6 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
     const status: DownloadStatus = VALID_DOWNLOAD_STATUSES.has(statusRaw) ? statusRaw : "queued";
     const providerRaw = asText(item.provider) as DebridProvider;
 
-    const onlineStatusRaw = asText(item.onlineStatus);
-
     itemsById[id] = {
       id,
       packageId,
@@ -295,7 +243,6 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
       attempts: clampNumber(item.attempts, 0, 0, 10_000),
       lastError: asText(item.lastError),
       fullStatus: asText(item.fullStatus),
-      onlineStatus: VALID_ONLINE_STATUSES.has(onlineStatusRaw) ? onlineStatusRaw as "online" | "offline" | "checking" : undefined,
       createdAt: clampNumber(item.createdAt, now, 0, Number.MAX_SAFE_INTEGER),
       updatedAt: clampNumber(item.updatedAt, now, 0, Number.MAX_SAFE_INTEGER)
     };
@@ -326,7 +273,6 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
         .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",
       createdAt: clampNumber(pkg.createdAt, now, 0, Number.MAX_SAFE_INTEGER),
       updatedAt: clampNumber(pkg.updatedAt, now, 0, Number.MAX_SAFE_INTEGER)
     };
@@ -357,8 +303,7 @@ export function normalizeLoadedSession(raw: unknown): SessionState {
       return true;
     });
   for (const packageId of Object.keys(packagesById)) {
-    if (!seenOrder.has(packageId)) {
+    if (!packageOrder.includes(packageId)) {
-      seenOrder.add(packageId);
       packageOrder.push(packageId);
     }
   }
@@ -430,7 +375,7 @@ function sessionBackupPath(sessionFile: string): string {
   return `${sessionFile}.bak`;
 }
 
-export function normalizeLoadedSessionTransientFields(session: SessionState): SessionState {
+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)) {
@@ -442,19 +387,6 @@ export function normalizeLoadedSessionTransientFields(session: SessionState): Se
     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)) {
-      pkg.status = "queued";
-    }
-    pkg.postProcessLabel = undefined;
-  }
-
-  // Clear stale session-level running/paused flags
-  session.running = false;
-  session.paused = false;
-
   return session;
 }
 
@@ -480,17 +412,12 @@ export function saveSettings(paths: StoragePaths, settings: AppSettings): void {
   const persisted = sanitizeCredentialPersistence(normalizeSettings(settings));
   const payload = JSON.stringify(persisted, null, 2);
   const tempPath = `${paths.configFile}.tmp`;
-  try {
+  fs.writeFileSync(tempPath, payload, "utf8");
-    fs.writeFileSync(tempPath, payload, "utf8");
+  syncRenameWithExdevFallback(tempPath, paths.configFile);
-    syncRenameWithExdevFallback(tempPath, paths.configFile);
-  } catch (error) {
-    try { fs.rmSync(tempPath, { force: true }); } catch { /* ignore */ }
-    throw error;
-  }
 }
 
 let asyncSettingsSaveRunning = false;
-let asyncSettingsSaveQueued: { paths: StoragePaths; settings: AppSettings } | null = null;
+let asyncSettingsSaveQueued: { paths: StoragePaths; payload: string } | null = null;
 
 async function writeSettingsPayload(paths: StoragePaths, payload: string): Promise<void> {
   await fs.promises.mkdir(paths.baseDir, { recursive: true });
@@ -504,7 +431,6 @@ async function writeSettingsPayload(paths: StoragePaths, payload: string): Promi
       await fsp.copyFile(tempPath, paths.configFile);
       await fsp.rm(tempPath, { force: true }).catch(() => {});
     } else {
-      await fsp.rm(tempPath, { force: true }).catch(() => {});
       throw renameError;
     }
   }
@@ -514,7 +440,7 @@ export async function saveSettingsAsync(paths: StoragePaths, settings: AppSettin
   const persisted = sanitizeCredentialPersistence(normalizeSettings(settings));
   const payload = JSON.stringify(persisted, null, 2);
   if (asyncSettingsSaveRunning) {
-    asyncSettingsSaveQueued = { paths, settings };
+    asyncSettingsSaveQueued = { paths, payload };
     return;
   }
   asyncSettingsSaveRunning = true;
@@ -527,7 +453,7 @@ export async function saveSettingsAsync(paths: StoragePaths, settings: AppSettin
     if (asyncSettingsSaveQueued) {
       const queued = asyncSettingsSaveQueued;
       asyncSettingsSaveQueued = null;
-      void saveSettingsAsync(queued.paths, queued.settings);
+      void writeSettingsPayload(queued.paths, queued.payload).catch((err) => logger.error(`Async Settings-Save (queued) fehlgeschlagen: ${String(err)}`));
     }
   }
 }
@@ -580,7 +506,6 @@ export function loadSession(paths: StoragePaths): SessionState {
 }
 
 export function saveSession(paths: StoragePaths, session: SessionState): void {
-  syncSaveGeneration += 1;
   ensureBaseDir(paths.baseDir);
   if (fs.existsSync(paths.sessionFile)) {
     try {
@@ -591,41 +516,25 @@ export function saveSession(paths: StoragePaths, session: SessionState): void {
   }
   const payload = JSON.stringify({ ...session, updatedAt: Date.now() });
   const tempPath = sessionTempPath(paths.sessionFile, "sync");
-  try {
+  fs.writeFileSync(tempPath, payload, "utf8");
-    fs.writeFileSync(tempPath, payload, "utf8");
+  syncRenameWithExdevFallback(tempPath, paths.sessionFile);
-    syncRenameWithExdevFallback(tempPath, paths.sessionFile);
-  } catch (error) {
-    try { fs.rmSync(tempPath, { force: true }); } catch { /* ignore */ }
-    throw error;
-  }
 }
 
 let asyncSaveRunning = false;
 let asyncSaveQueued: { paths: StoragePaths; payload: string } | null = null;
-let syncSaveGeneration = 0;
 
-async function writeSessionPayload(paths: StoragePaths, payload: string, generation: number): Promise<void> {
+async function writeSessionPayload(paths: StoragePaths, payload: string): Promise<void> {
   await fs.promises.mkdir(paths.baseDir, { recursive: true });
   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;
-  }
   try {
     await fsp.rename(tempPath, paths.sessionFile);
   } catch (renameError: unknown) {
     if (renameError && typeof renameError === "object" && "code" in renameError && (renameError as NodeJS.ErrnoException).code === "EXDEV") {
-      if (generation < syncSaveGeneration) {
-        await fsp.rm(tempPath, { force: true }).catch(() => {});
-        return;
-      }
       await fsp.copyFile(tempPath, paths.sessionFile);
       await fsp.rm(tempPath, { force: true }).catch(() => {});
     } else {
-      await fsp.rm(tempPath, { force: true }).catch(() => {});
       throw renameError;
     }
   }
@@ -637,9 +546,8 @@ async function saveSessionPayloadAsync(paths: StoragePaths, payload: string): Pr
     return;
   }
   asyncSaveRunning = true;
-  const gen = syncSaveGeneration;
   try {
-    await writeSessionPayload(paths, payload, gen);
+    await writeSessionPayload(paths, payload);
   } catch (error) {
     logger.error(`Async Session-Save fehlgeschlagen: ${String(error)}`);
   } finally {
@@ -652,12 +560,6 @@ async function saveSessionPayloadAsync(paths: StoragePaths, payload: string): Pr
   }
 }
 
-export function cancelPendingAsyncSaves(): void {
-  asyncSaveQueued = null;
-  asyncSettingsSaveQueued = null;
-  syncSaveGeneration += 1;
-}
-
 export async function saveSessionAsync(paths: StoragePaths, session: SessionState): Promise<void> {
   const payload = JSON.stringify({ ...session, updatedAt: Date.now() });
   await saveSessionPayloadAsync(paths, payload);
@@ -683,8 +585,7 @@ function normalizeHistoryEntry(raw: unknown, index: number): HistoryEntry | null
     completedAt: clampNumber(entry.completedAt, Date.now(), 0, Number.MAX_SAFE_INTEGER),
     durationSeconds: clampNumber(entry.durationSeconds, 0, 0, Number.MAX_SAFE_INTEGER),
     status: entry.status === "deleted" ? "deleted" : "completed",
-    outputDir: asText(entry.outputDir),
+    outputDir: asText(entry.outputDir)
-    urls: Array.isArray(entry.urls) ? (entry.urls as unknown[]).map(String).filter(Boolean) : undefined
   };
 }
 
@@ -714,13 +615,8 @@ export function saveHistory(paths: StoragePaths, entries: HistoryEntry[]): void
   const trimmed = entries.slice(0, MAX_HISTORY_ENTRIES);
   const payload = JSON.stringify(trimmed, null, 2);
   const tempPath = `${paths.historyFile}.tmp`;
-  try {
+  fs.writeFileSync(tempPath, payload, "utf8");
-    fs.writeFileSync(tempPath, payload, "utf8");
+  syncRenameWithExdevFallback(tempPath, paths.historyFile);
-    syncRenameWithExdevFallback(tempPath, paths.historyFile);
-  } catch (error) {
-    try { fs.rmSync(tempPath, { force: true }); } catch { /* ignore */ }
-    throw error;
-  }
 }
 
 export function addHistoryEntry(paths: StoragePaths, entry: HistoryEntry): HistoryEntry[] {

src/main/update.ts

@@ -14,32 +14,8 @@ const DOWNLOAD_BODY_IDLE_TIMEOUT_MS = 45000;
 const RETRIES_PER_CANDIDATE = 3;
 const RETRY_DELAY_MS = 1500;
 const UPDATE_USER_AGENT = `RD-Node-Downloader/${APP_VERSION}`;
-type UpdateSource = {
+const UPDATE_WEB_BASE = "https://codeberg.org";
-  name: string;
+const UPDATE_API_BASE = "https://codeberg.org/api/v1";
-  webBase: string;
-  apiBase: string;
-};
-
-const UPDATE_SOURCES: UpdateSource[] = [
-  {
-    name: "git24",
-    webBase: "https://git.24-music.de",
-    apiBase: "https://git.24-music.de/api/v1"
-  },
-  {
-    name: "codeberg",
-    webBase: "https://codeberg.org",
-    apiBase: "https://codeberg.org/api/v1"
-  },
-  {
-    name: "github",
-    webBase: "https://github.com",
-    apiBase: "https://api.github.com"
-  }
-];
-const PRIMARY_UPDATE_SOURCE = UPDATE_SOURCES[0];
-const UPDATE_WEB_BASE = PRIMARY_UPDATE_SOURCE.webBase;
-const UPDATE_API_BASE = PRIMARY_UPDATE_SOURCE.apiBase;
 
 let activeUpdateAbortController: AbortController | null = null;
 
@@ -81,9 +57,9 @@ export function normalizeUpdateRepo(repo: string): string {
 
   const normalizeParts = (input: string): string => {
     const cleaned = input
-      .replace(/^https?:\/\/(?:www\.)?(?:codeberg\.org|github\.com|git\.24-music\.de)\//i, "")
+      .replace(/^https?:\/\/(?:www\.)?(?:codeberg\.org|github\.com)\//i, "")
-      .replace(/^(?:www\.)?(?:codeberg\.org|github\.com|git\.24-music\.de)\//i, "")
+      .replace(/^(?:www\.)?(?:codeberg\.org|github\.com)\//i, "")
-      .replace(/^git@(?:codeberg\.org|github\.com|git\.24-music\.de):/i, "")
+      .replace(/^git@(?:codeberg\.org|github\.com):/i, "")
       .replace(/\.git$/i, "")
       .replace(/^\/+|\/+$/g, "");
     const parts = cleaned.split("/").filter(Boolean);
@@ -100,13 +76,7 @@ export function normalizeUpdateRepo(repo: string): string {
   try {
     const url = new URL(raw);
     const host = url.hostname.toLowerCase();
-    if (
+    if (host === "codeberg.org" || host === "www.codeberg.org" || host === "github.com" || host === "www.github.com") {
-      host === "codeberg.org"
-      || host === "www.codeberg.org"
-      || host === "github.com"
-      || host === "www.github.com"
-      || host === "git.24-music.de"
-    ) {
       const normalized = normalizeParts(url.pathname);
       if (normalized) {
         return normalized;
@@ -336,8 +306,6 @@ function parseReleasePayload(payload: Record<string, unknown>, fallback: UpdateC
   const releaseUrl = String(payload.html_url || fallback.releaseUrl);
   const setup = pickSetupAsset(readReleaseAssets(payload));
 
-  const body = typeof payload.body === "string" ? payload.body.trim() : "";
-
   return {
     updateAvailable: isRemoteNewer(APP_VERSION, latestVersion),
     currentVersion: APP_VERSION,
@@ -346,8 +314,7 @@ function parseReleasePayload(payload: Record<string, unknown>, fallback: UpdateC
     releaseUrl,
     setupAssetUrl: setup?.browser_download_url || "",
     setupAssetName: setup?.name || "",
-    setupAssetDigest: setup?.digest || "",
+    setupAssetDigest: setup?.digest || ""
-    releaseNotes: body || undefined
   };
 }
 
@@ -794,8 +761,7 @@ async function downloadFile(url: string, targetPath: string, onProgress?: Update
   };
 
   const reader = response.body.getReader();
-  const tempPath = targetPath + ".tmp";
+  const chunks: Buffer[] = [];
-  const writeStream = fs.createWriteStream(tempPath);
 
   try {
     resetIdleTimer();
@@ -809,39 +775,27 @@ async function downloadFile(url: string, targetPath: string, onProgress?: Update
         break;
       }
       const buf = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-      if (!writeStream.write(buf)) {
+      chunks.push(buf);
-        await new Promise<void>((resolve) => writeStream.once("drain", resolve));
-      }
       downloadedBytes += buf.byteLength;
       resetIdleTimer();
       emitDownloadProgress(false);
     }
-  } catch (error) {
-    writeStream.destroy();
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
-    throw error;
   } finally {
     clearIdleTimer();
   }
 
-  await new Promise<void>((resolve, reject) => {
-    writeStream.end(() => resolve());
-    writeStream.on("error", reject);
-  });
-
   if (idleTimedOut) {
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
     throw new Error(`Update Download Body Timeout nach ${Math.ceil(idleTimeoutMs / 1000)}s`);
   }
 
-  if (totalBytes && downloadedBytes !== totalBytes) {
+  const fileBuffer = Buffer.concat(chunks);
-    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
+  if (totalBytes && fileBuffer.byteLength !== totalBytes) {
-    throw new Error(`Update Download unvollständig (${downloadedBytes} / ${totalBytes} Bytes)`);
+    throw new Error(`Update Download unvollständig (${fileBuffer.byteLength} / ${totalBytes} Bytes)`);
   }
 
-  await fs.promises.rename(tempPath, targetPath);
+  await fs.promises.writeFile(targetPath, fileBuffer);
   emitDownloadProgress(true);
-  logger.info(`Update-Download abgeschlossen: ${targetPath} (${downloadedBytes} Bytes)`);
+  logger.info(`Update-Download abgeschlossen: ${targetPath} (${fileBuffer.byteLength} Bytes)`);
 
   return { expectedBytes: totalBytes };
 }

src/preload/preload.ts

@@ -4,7 +4,6 @@ import {
   AppSettings,
   DuplicatePolicy,
   HistoryEntry,
-  PackagePriority,
   SessionStats,
   StartConflictEntry,
   StartConflictResolutionResult,
@@ -31,7 +30,6 @@ const api: ElectronApi = {
     ipcRenderer.invoke(IPC_CHANNELS.RESOLVE_START_CONFLICT, packageId, policy),
   clearAll: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.CLEAR_ALL),
   start: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.START),
-  startPackages: (packageIds: string[]): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.START_PACKAGES, packageIds),
   stop: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.STOP),
   togglePause: (): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.TOGGLE_PAUSE),
   cancelPackage: (packageId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.CANCEL_PACKAGE, packageId),
@@ -39,7 +37,7 @@ 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),
-  exportQueue: (): Promise<{ saved: boolean }> => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_QUEUE),
+  exportQueue: (): Promise<string> => 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),
   pickFolder: (): Promise<string | null> => ipcRenderer.invoke(IPC_CHANNELS.PICK_FOLDER),
@@ -50,17 +48,11 @@ const api: ElectronApi = {
   exportBackup: (): Promise<{ saved: boolean }> => ipcRenderer.invoke(IPC_CHANNELS.EXPORT_BACKUP),
   importBackup: (): Promise<{ restored: boolean; message: string }> => ipcRenderer.invoke(IPC_CHANNELS.IMPORT_BACKUP),
   openLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_LOG),
-  openSessionLog: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.OPEN_SESSION_LOG),
   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),
   getHistory: (): Promise<HistoryEntry[]> => ipcRenderer.invoke(IPC_CHANNELS.GET_HISTORY),
   clearHistory: (): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.CLEAR_HISTORY),
   removeHistoryEntry: (entryId: string): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.REMOVE_HISTORY_ENTRY, entryId),
-  setPackagePriority: (packageId: string, priority: PackagePriority): Promise<void> => ipcRenderer.invoke(IPC_CHANNELS.SET_PACKAGE_PRIORITY, packageId, priority),
-  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),
   onStateUpdate: (callback: (snapshot: UiSnapshot) => void): (() => void) => {
     const listener = (_event: unknown, snapshot: UiSnapshot): void => callback(snapshot);
     ipcRenderer.on(IPC_CHANNELS.STATE_UPDATE, listener);

src/renderer/package-order.ts

@@ -1,25 +0,0 @@
-import type { PackageEntry } from "../shared/types";
-
-export function reorderPackageOrderByDrop(order: string[], draggedPackageId: string, targetPackageId: string): string[] {
-  const fromIndex = order.indexOf(draggedPackageId);
-  const toIndex = order.indexOf(targetPackageId);
-  if (fromIndex < 0 || toIndex < 0 || fromIndex === toIndex) {
-    return order;
-  }
-  const next = [...order];
-  const [dragged] = next.splice(fromIndex, 1);
-  const insertIndex = Math.max(0, Math.min(next.length, toIndex));
-  next.splice(insertIndex, 0, dragged);
-  return next;
-}
-
-export function sortPackageOrderByName(order: string[], packages: Record<string, PackageEntry>, descending: boolean): string[] {
-  const sorted = [...order];
-  sorted.sort((a, b) => {
-    const nameA = (packages[a]?.name ?? "").toLowerCase();
-    const nameB = (packages[b]?.name ?? "").toLowerCase();
-    const cmp = nameA.localeCompare(nameB, undefined, { numeric: true, sensitivity: "base" });
-    return descending ? -cmp : cmp;
-  });
-  return sorted;
-}

src/renderer/styles.css

@@ -344,15 +344,6 @@ body,
   background: rgba(244, 63, 94, 0.1);
 }
 
-.ctrl-icon-btn.ctrl-move:not(:disabled) {
-  color: var(--accent);
-}
-
-.ctrl-icon-btn.ctrl-move:hover:not(:disabled) {
-  border-color: var(--accent);
-  background: color-mix(in srgb, var(--accent) 10%, transparent);
-}
-
 .ctrl-icon-btn.ctrl-speed.active {
   color: #f59e0b;
   border-color: rgba(245, 158, 11, 0.5);
@@ -586,7 +577,7 @@ body,
 
 .pkg-column-header {
   display: grid;
-  /* grid-template-columns set via inline style from columnOrder */
+  grid-template-columns: 1fr 70px 160px 220px 180px 100px;
   gap: 8px;
   padding: 5px 12px;
   background: var(--card);
@@ -598,17 +589,6 @@ body,
   user-select: none;
 }
 
-.pkg-column-header .pkg-col-progress,
-.pkg-column-header .pkg-col-size,
-.pkg-column-header .pkg-col-hoster,
-.pkg-column-header .pkg-col-account,
-.pkg-column-header .pkg-col-prio,
-.pkg-column-header .pkg-col-status,
-.pkg-column-header .pkg-col-speed,
-.pkg-column-header .pkg-col-added {
-  text-align: center;
-}
-
 .pkg-column-header .sortable {
   cursor: pointer;
 }
@@ -623,7 +603,7 @@ body,
 
 .pkg-columns {
   display: grid;
-  /* grid-template-columns set via inline style from columnOrder */
+  grid-template-columns: 1fr 70px 160px 220px 180px 100px;
   gap: 8px;
   align-items: center;
   min-width: 0;
@@ -646,22 +626,17 @@ body,
 .pkg-columns .pkg-col-progress,
 .pkg-columns .pkg-col-size,
 .pkg-columns .pkg-col-hoster,
-.pkg-columns .pkg-col-account,
-.pkg-columns .pkg-col-prio,
 .pkg-columns .pkg-col-status,
-.pkg-columns .pkg-col-speed,
+.pkg-columns .pkg-col-speed {
-.pkg-columns .pkg-col-added {
   font-size: 13px;
   color: var(--muted);
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
-  text-align: center;
 }
 
 .pkg-col-progress {
   font-variant-numeric: tabular-nums;
-  padding-right: 12px;
 }
 
 .progress-size {
@@ -873,7 +848,7 @@ body,
 .status-bar {
   display: flex;
   flex-wrap: wrap;
-  gap: 8px 16px;
+  gap: 16px;
   align-items: center;
   color: var(--muted);
   font-size: 12px;
@@ -884,16 +859,6 @@ body,
   margin: 0 -14px -10px;
 }
 
-.footer-spacer {
-  flex: 1;
-}
-
-.footer-btn {
-  font-size: 11px;
-  padding: 2px 8px;
-  min-height: 0;
-}
-
 .settings-shell {
   display: grid;
   grid-template-rows: auto 1fr;
@@ -1307,7 +1272,7 @@ td {
 
 .item-row {
   display: grid;
-  /* grid-template-columns set via inline style from columnOrder */
+  grid-template-columns: 1fr 70px 160px 220px 180px 100px;
   gap: 8px;
   align-items: center;
   margin: 0 -12px;
@@ -1326,11 +1291,6 @@ td {
   white-space: nowrap;
   color: var(--muted);
   font-size: 13px;
-  text-align: center;
-}
-
-.item-row .pkg-col-name {
-  text-align: left;
 }
 
 .item-row .pkg-col-name {
@@ -1338,89 +1298,6 @@ td {
   padding-left: 32px;
 }
 
-.link-status-dot {
-  display: inline-block;
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  margin-right: 6px;
-  flex-shrink: 0;
-  vertical-align: middle;
-}
-.link-status-dot.online {
-  background: #22c55e;
-  box-shadow: 0 0 4px #22c55e80;
-}
-.link-status-dot.offline {
-  background: #ef4444;
-  box-shadow: 0 0 4px #ef444480;
-}
-.link-status-dot.checking {
-  background: #f59e0b;
-  box-shadow: 0 0 4px #f59e0b80;
-}
-
-.prio-high {
-  color: #f59e0b !important;
-  font-weight: 700;
-}
-
-.prio-low {
-  color: #64748b !important;
-}
-
-.pkg-col-dragging {
-  opacity: 0.4;
-}
-
-.pkg-col-drop-target {
-  box-shadow: -2px 0 0 0 var(--accent);
-}
-
-.pkg-column-header .pkg-col {
-  cursor: grab;
-}
-
-.pkg-column-header .pkg-col.sortable {
-  cursor: pointer;
-}
-
-.ctx-menu-sub {
-  position: relative;
-}
-
-.ctx-menu-sub > .ctx-menu-item::after {
-  content: "";
-}
-
-.ctx-menu-sub-items {
-  display: none;
-  position: absolute;
-  left: 100%;
-  top: 0;
-  min-width: 120px;
-  background: var(--card);
-  border: 1px solid var(--border);
-  border-radius: 6px;
-  padding: 4px 0;
-  box-shadow: 0 4px 12px rgba(0,0,0,.3);
-  z-index: 1001;
-}
-
-.ctx-menu-sub:hover .ctx-menu-sub-items {
-  display: block;
-}
-
-.ctx-menu-active {
-  color: var(--accent) !important;
-}
-
-.ctx-menu-disabled {
-  opacity: 0.4;
-  cursor: not-allowed !important;
-  pointer-events: none;
-}
-
 .item-remove {
   background: none;
   border: none;
@@ -1639,7 +1516,6 @@ td {
   border-radius: 12px;
   padding: 10px 14px;
   box-shadow: 0 16px 30px rgba(0, 0, 0, 0.35);
-  z-index: 50;
 }
 
 .ctx-menu {
@@ -1749,7 +1625,6 @@ td {
   font-weight: 600;
   pointer-events: none;
   backdrop-filter: blur(2px);
-  z-index: 200;
 }
 
 .modal-backdrop {
@@ -1764,8 +1639,6 @@ td {
 
 .modal-card {
   width: min(560px, 100%);
-  max-height: calc(100vh - 40px);
-  overflow-y: auto;
   border: 1px solid var(--border);
   border-radius: 14px;
   background: linear-gradient(180deg, color-mix(in srgb, var(--card) 98%, transparent), color-mix(in srgb, var(--surface) 98%, transparent));
@@ -1784,34 +1657,6 @@ td {
   color: var(--muted);
 }
 
-.modal-details {
-  border: 1px solid var(--border);
-  border-radius: 6px;
-  padding: 0;
-}
-.modal-details summary {
-  padding: 6px 10px;
-  cursor: pointer;
-  font-size: 13px;
-  color: var(--muted);
-  user-select: none;
-}
-.modal-details summary:hover {
-  color: var(--text);
-}
-.modal-details pre {
-  margin: 0;
-  padding: 8px 10px;
-  border-top: 1px solid var(--border);
-  font-size: 12px;
-  line-height: 1.5;
-  white-space: pre-wrap;
-  word-break: break-word;
-  max-height: 260px;
-  overflow-y: auto;
-  color: var(--muted);
-}
-
 .modal-path {
   font-size: 12px;
   word-break: break-all;
@@ -1882,30 +1727,23 @@ td {
   }
 
   .pkg-columns,
-  .pkg-column-header,
+  .pkg-column-header {
-  .item-row {
+    grid-template-columns: 1fr;
-    grid-template-columns: 1fr !important;
   }
 
   .pkg-column-header .pkg-col-progress,
   .pkg-column-header .pkg-col-size,
   .pkg-column-header .pkg-col-hoster,
-  .pkg-column-header .pkg-col-account,
-  .pkg-column-header .pkg-col-prio,
   .pkg-column-header .pkg-col-status,
-  .pkg-column-header .pkg-col-speed,
+  .pkg-column-header .pkg-col-speed {
-  .pkg-column-header .pkg-col-added {
     display: none;
   }
 
   .pkg-columns .pkg-col-progress,
   .pkg-columns .pkg-col-size,
   .pkg-columns .pkg-col-hoster,
-  .pkg-columns .pkg-col-account,
-  .pkg-columns .pkg-col-prio,
   .pkg-columns .pkg-col-status,
-  .pkg-columns .pkg-col-speed,
+  .pkg-columns .pkg-col-speed {
-  .pkg-columns .pkg-col-added {
     display: none;
   }
 

src/shared/ipc.ts

@@ -12,7 +12,6 @@ export const IPC_CHANNELS = {
   RESOLVE_START_CONFLICT: "queue:resolve-start-conflict",
   CLEAR_ALL: "queue:clear-all",
   START: "queue:start",
-  START_PACKAGES: "queue:start-packages",
   STOP: "queue:stop",
   TOGGLE_PAUSE: "queue:toggle-pause",
   CANCEL_PACKAGE: "queue:cancel-package",
@@ -33,15 +32,9 @@ export const IPC_CHANNELS = {
   EXPORT_BACKUP: "app:export-backup",
   IMPORT_BACKUP: "app:import-backup",
   OPEN_LOG: "app:open-log",
-  OPEN_SESSION_LOG: "app:open-session-log",
   RETRY_EXTRACTION: "queue:retry-extraction",
   EXTRACT_NOW: "queue:extract-now",
-  RESET_PACKAGE: "queue:reset-package",
   GET_HISTORY: "history:get",
   CLEAR_HISTORY: "history:clear",
-  REMOVE_HISTORY_ENTRY: "history:remove-entry",
+  REMOVE_HISTORY_ENTRY: "history:remove-entry"
-  SET_PACKAGE_PRIORITY: "queue:set-package-priority",
-  SKIP_ITEMS: "queue:skip-items",
-  RESET_ITEMS: "queue:reset-items",
-  START_ITEMS: "queue:start-items"
 } as const;

src/shared/preload-api.ts

@@ -3,7 +3,6 @@ import type {
   AppSettings,
   DuplicatePolicy,
   HistoryEntry,
-  PackagePriority,
   SessionStats,
   StartConflictEntry,
   StartConflictResolutionResult,
@@ -26,7 +25,6 @@ export interface ElectronApi {
   resolveStartConflict: (packageId: string, policy: DuplicatePolicy) => Promise<StartConflictResolutionResult>;
   clearAll: () => Promise<void>;
   start: () => Promise<void>;
-  startPackages: (packageIds: string[]) => Promise<void>;
   stop: () => Promise<void>;
   togglePause: () => Promise<boolean>;
   cancelPackage: (packageId: string) => Promise<void>;
@@ -34,7 +32,7 @@ export interface ElectronApi {
   reorderPackages: (packageIds: string[]) => Promise<void>;
   removeItem: (itemId: string) => Promise<void>;
   togglePackage: (packageId: string) => Promise<void>;
-  exportQueue: () => Promise<{ saved: boolean }>;
+  exportQueue: () => Promise<string>;
   importQueue: (json: string) => Promise<{ addedPackages: number; addedLinks: number }>;
   toggleClipboard: () => Promise<boolean>;
   pickFolder: () => Promise<string | null>;
@@ -45,17 +43,11 @@ export interface ElectronApi {
   exportBackup: () => Promise<{ saved: boolean }>;
   importBackup: () => Promise<{ restored: boolean; message: string }>;
   openLog: () => Promise<void>;
-  openSessionLog: () => Promise<void>;
   retryExtraction: (packageId: string) => Promise<void>;
   extractNow: (packageId: string) => Promise<void>;
-  resetPackage: (packageId: string) => Promise<void>;
   getHistory: () => Promise<HistoryEntry[]>;
   clearHistory: () => Promise<void>;
   removeHistoryEntry: (entryId: string) => Promise<void>;
-  setPackagePriority: (packageId: string, priority: PackagePriority) => Promise<void>;
-  skipItems: (itemIds: string[]) => Promise<void>;
-  resetItems: (itemIds: string[]) => Promise<void>;
-  startItems: (itemIds: string[]) => Promise<void>;
   onStateUpdate: (callback: (snapshot: UiSnapshot) => void) => () => void;
   onClipboardDetected: (callback: (links: string[]) => void) => () => void;
   onUpdateInstallProgress: (callback: (progress: UpdateInstallProgress) => void) => () => void;

src/shared/types.ts

@@ -14,11 +14,9 @@ export type CleanupMode = "none" | "trash" | "delete";
 export type ConflictMode = "overwrite" | "skip" | "rename" | "ask";
 export type SpeedMode = "global" | "per_download";
 export type FinishedCleanupPolicy = "never" | "immediate" | "on_start" | "package_done";
-export type DebridProvider = "realdebrid" | "megadebrid" | "bestdebrid" | "alldebrid" | "ddownload" | "onefichier";
+export type DebridProvider = "realdebrid" | "megadebrid" | "bestdebrid" | "alldebrid";
 export type DebridFallbackProvider = DebridProvider | "none";
 export type AppTheme = "dark" | "light";
-export type PackagePriority = "high" | "normal" | "low";
-export type ExtractCpuPriority = "high" | "middle" | "low";
 
 export interface BandwidthScheduleEntry {
   id: string;
@@ -42,9 +40,6 @@ export interface AppSettings {
   megaPassword: string;
   bestToken: string;
   allDebridToken: string;
-  ddownloadLogin: string;
-  ddownloadPassword: string;
-  oneFichierApiKey: string;
   archivePasswordList: string;
   rememberToken: boolean;
   providerPrimary: DebridProvider;
@@ -70,7 +65,6 @@ export interface AppSettings {
   reconnectWaitSeconds: number;
   completedCleanupPolicy: FinishedCleanupPolicy;
   maxParallel: number;
-  maxParallelExtract: number;
   retryLimit: number;
   speedLimitEnabled: boolean;
   speedLimitKbps: number;
@@ -85,9 +79,6 @@ export interface AppSettings {
   confirmDeleteSelection: boolean;
   totalDownloadedAllTime: number;
   bandwidthSchedules: BandwidthScheduleEntry[];
-  columnOrder: string[];
-  extractCpuPriority: ExtractCpuPriority;
-  autoExtractWhenStopped: boolean;
 }
 
 export interface DownloadItem {
@@ -109,7 +100,6 @@ export interface DownloadItem {
   fullStatus: string;
   createdAt: number;
   updatedAt: number;
-  onlineStatus?: "online" | "offline" | "checking";
 }
 
 export interface PackageEntry {
@@ -121,8 +111,6 @@ export interface PackageEntry {
   itemIds: string[];
   cancelled: boolean;
   enabled: boolean;
-  priority: PackagePriority;
-  postProcessLabel?: string;
   createdAt: number;
   updatedAt: number;
 }
@@ -223,7 +211,6 @@ export interface UpdateCheckResult {
   setupAssetUrl?: string;
   setupAssetName?: string;
   setupAssetDigest?: string;
-  releaseNotes?: string;
   error?: string;
 }
 
@@ -280,7 +267,6 @@ export interface HistoryEntry {
   durationSeconds: number;
   status: "completed" | "deleted";
   outputDir: string;
-  urls?: string[];
 }
 
 export interface HistoryState {

tests/app-order.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { reorderPackageOrderByDrop, sortPackageOrderByName } from "../src/renderer/package-order";
+import { reorderPackageOrderByDrop, sortPackageOrderByName } from "../src/renderer/App";
 
 describe("reorderPackageOrderByDrop", () => {
   it("moves adjacent package down by one on drop", () => {
@@ -25,9 +25,9 @@ describe("sortPackageOrderByName", () => {
     const sorted = sortPackageOrderByName(
       ["pkg3", "pkg1", "pkg2"],
       {
-        pkg1: { id: "pkg1", name: "Alpha", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, priority: "normal", createdAt: 0, updatedAt: 0 },
+        pkg1: { id: "pkg1", name: "Alpha", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, createdAt: 0, updatedAt: 0 },
-        pkg2: { id: "pkg2", name: "beta", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, priority: "normal", createdAt: 0, updatedAt: 0 },
+        pkg2: { id: "pkg2", name: "beta", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, createdAt: 0, updatedAt: 0 },
-        pkg3: { id: "pkg3", name: "Gamma", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, priority: "normal", createdAt: 0, updatedAt: 0 }
+        pkg3: { id: "pkg3", name: "Gamma", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, createdAt: 0, updatedAt: 0 }
       },
       false
     );
@@ -38,9 +38,9 @@ describe("sortPackageOrderByName", () => {
     const sorted = sortPackageOrderByName(
       ["pkg1", "pkg2", "pkg3"],
       {
-        pkg1: { id: "pkg1", name: "Alpha", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, priority: "normal", createdAt: 0, updatedAt: 0 },
+        pkg1: { id: "pkg1", name: "Alpha", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, createdAt: 0, updatedAt: 0 },
-        pkg2: { id: "pkg2", name: "beta", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, priority: "normal", createdAt: 0, updatedAt: 0 },
+        pkg2: { id: "pkg2", name: "beta", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, createdAt: 0, updatedAt: 0 },
-        pkg3: { id: "pkg3", name: "Gamma", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, priority: "normal", createdAt: 0, updatedAt: 0 }
+        pkg3: { id: "pkg3", name: "Gamma", outputDir: "", extractDir: "", status: "queued", itemIds: [], cancelled: false, enabled: true, createdAt: 0, updatedAt: 0 }
       },
       true
     );

tests/auto-rename.test.ts

@@ -269,7 +269,6 @@ describe("buildAutoRenameBaseName", () => {
     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
@@ -344,7 +343,6 @@ describe("buildAutoRenameBaseName", () => {
     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", () => {
@@ -375,7 +373,6 @@ describe("buildAutoRenameBaseName", () => {
     // 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"); // no duplication
   });
 
@@ -623,72 +620,4 @@ 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"],
-      "myst.road.de.dl.hdtv.7p-s02e05",
-      { forceEpisodeForSeasonFolder: true }
-    );
-    expect(result).toBe("Mystery Road S02E05");
-  });
-
-  it("renames with season-only folder and custom name without dots", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      ["Meine Serie S03"],
-      "meine-serie-s03e10-720p",
-      { forceEpisodeForSeasonFolder: true }
-    );
-    expect(result).toBe("Meine Serie S03E10");
-  });
-
-  it("prefers scene-group folder over season-only fallback", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      [
-        "Mystery Road S02",
-        "Mystery.Road.S02.GERMAN.DL.AC3.720p.HDTV.x264-hrs"
-      ],
-      "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");
-  });
-
-  it("does not use season-only fallback when forceEpisodeForSeasonFolder is false", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      ["Mystery Road S02"],
-      "myst.road.de.dl.hdtv.7p-s02e05",
-      { forceEpisodeForSeasonFolder: false }
-    );
-    expect(result).toBeNull();
-  });
-
-  it("renames Riviera S02 with single-digit episode s02e2", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      ["Riviera.S02.GERMAN.DUBBED.DL.720p.WebHD.x264-TVP"],
-      "tvp-riviera-s02e2-720p",
-      { forceEpisodeForSeasonFolder: true }
-    );
-    expect(result).toBe("Riviera.S02E02.GERMAN.DUBBED.DL.720p.WebHD.x264-TVP");
-  });
-
-  it("renames Room 104 abbreviated source r104.de.dl.web.7p-s04e02", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      ["Room.104.S04.GERMAN.DL.720p.WEBRiP.x264-LAW"],
-      "r104.de.dl.web.7p-s04e02",
-      { forceEpisodeForSeasonFolder: true }
-    );
-    expect(result).toBe("Room.104.S04E02.GERMAN.DL.720p.WEBRiP.x264-LAW");
-  });
-
-  it("renames Room 104 wayne source with episode", () => {
-    const result = buildAutoRenameBaseNameFromFoldersWithOptions(
-      ["Room.104.S04.GERMAN.DL.720p.WEBRiP.x264-LAW"],
-      "room.104.s04e01.german.dl.720p.web.h264-wayne",
-      { forceEpisodeForSeasonFolder: true }
-    );
-    expect(result).toBe("Room.104.S04E01.GERMAN.DL.720p.WEBRiP.x264-LAW");
-  });
 });

tests/cleanup.test.ts

@@ -25,15 +25,15 @@ describe("cleanup", () => {
     expect(fs.existsSync(path.join(dir, "movie.mkv"))).toBe(true);
   });
 
-  it("removes sample artifacts and link files", async () => {
+  it("removes sample artifacts and link files", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-clean-"));
     tempDirs.push(dir);
     fs.mkdirSync(path.join(dir, "Samples"), { recursive: true });
     fs.writeFileSync(path.join(dir, "Samples", "demo-sample.mkv"), "x");
     fs.writeFileSync(path.join(dir, "download_links.txt"), "https://example.com/a\n");
 
-    const links = await removeDownloadLinkArtifacts(dir);
+    const links = removeDownloadLinkArtifacts(dir);
-    const samples = await removeSampleArtifacts(dir);
+    const samples = removeSampleArtifacts(dir);
     expect(links).toBeGreaterThan(0);
     expect(samples.files + samples.dirs).toBeGreaterThan(0);
   });
@@ -66,7 +66,7 @@ describe("cleanup", () => {
     expect(fs.existsSync(path.join(sub2, "subtitle.srt"))).toBe(true);
   });
 
-  it("detects link artifacts by URL content in text files", async () => {
+  it("detects link artifacts by URL content in text files", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-clean-"));
     tempDirs.push(dir);
 
@@ -81,7 +81,7 @@ describe("cleanup", () => {
     // .dlc files should always be removed
     fs.writeFileSync(path.join(dir, "container.dlc"), "encrypted-data");
 
-    const removed = await removeDownloadLinkArtifacts(dir);
+    const removed = removeDownloadLinkArtifacts(dir);
     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);
@@ -90,7 +90,7 @@ describe("cleanup", () => {
     expect(fs.existsSync(path.join(dir, "readme.txt"))).toBe(true);
   });
 
-  it("does not recurse into sample symlink or junction targets", async () => {
+  it("does not recurse into sample symlink or junction targets", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-clean-"));
     const external = fs.mkdtempSync(path.join(os.tmpdir(), "rd-clean-ext-"));
     tempDirs.push(dir, external);
@@ -102,7 +102,7 @@ describe("cleanup", () => {
     const linkType: fs.symlink.Type = process.platform === "win32" ? "junction" : "dir";
     fs.symlinkSync(external, linkedSampleDir, linkType);
 
-    const result = await removeSampleArtifacts(dir);
+    const result = removeSampleArtifacts(dir);
     expect(result.files).toBe(0);
     expect(fs.existsSync(outsideFile)).toBe(true);
   });

tests/debrid.test.ts

@@ -317,7 +317,7 @@ describe("debrid service", () => {
     const controller = new AbortController();
     const abortTimer = setTimeout(() => {
       controller.abort("test");
-    }, 200);
+    }, 25);
 
     try {
       await expect(service.unrestrictLink("https://rapidgator.net/file/abort-mega-web", controller.signal)).rejects.toThrow(/aborted/i);

tests/download-manager.test.ts

@@ -177,7 +177,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "retry", links: ["https://dummy/retry"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -253,7 +253,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "same-name", links: ["https://dummy/first", "https://dummy/second"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const items = Object.values(manager.getSnapshot().session.items);
@@ -465,7 +465,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "stall", links: ["https://dummy/stall"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -563,7 +563,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "connect-stall", links: ["https://dummy/connect-stall"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 30000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -666,7 +666,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "stall-connect", links: ["https://dummy/stall-connect"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 30000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -765,7 +765,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "watchdog-stall", links: ["https://dummy/watchdog-stall"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 30000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -969,7 +969,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "content-name", links: ["https://rapidgator.net/file/6f09df2984fe01378537c7cd8d7fa7ce"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -1099,7 +1099,7 @@ describe("download manager", () => {
         createStoragePaths(path.join(root, "state"))
       );
 
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const item = manager.getSnapshot().session.items[itemId];
@@ -1232,7 +1232,7 @@ describe("download manager", () => {
         createStoragePaths(path.join(root, "state"))
       );
 
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const item = manager.getSnapshot().session.items[itemId];
@@ -1376,7 +1376,7 @@ describe("download manager", () => {
         createStoragePaths(path.join(root, "state"))
       );
 
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const item = manager.getSnapshot().session.items[itemId];
@@ -1491,7 +1491,7 @@ describe("download manager", () => {
         createStoragePaths(path.join(root, "state"))
       );
 
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 45000);
 
       const item = manager.getSnapshot().session.items[itemId];
@@ -1572,7 +1572,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "status-retry", links: ["https://dummy/status-retry"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 30000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -1792,7 +1792,7 @@ describe("download manager", () => {
     expect(fs.existsSync(targetPath)).toBe(false);
   });
 
-  it("detects start conflicts when extract output already exists", async () => {
+  it("detects start conflicts when extract output already exists", () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
     tempDirs.push(root);
 
@@ -1851,7 +1851,7 @@ describe("download manager", () => {
       createStoragePaths(path.join(root, "state"))
     );
 
-    const conflicts = await manager.getStartConflicts();
+    const conflicts = manager.getStartConflicts();
     expect(conflicts.length).toBe(1);
     expect(conflicts[0]?.packageId).toBe(packageId);
   });
@@ -2495,7 +2495,7 @@ describe("download manager", () => {
       createStoragePaths(path.join(root, "state"))
     );
 
-    await manager.start();
+    manager.start();
     await waitFor(() => !manager.getSnapshot().session.running, 5000);
 
     const snapshot = manager.getSnapshot();
@@ -2727,7 +2727,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "new", links: ["https://dummy/new"] }]);
-      await manager.start();
+      manager.start();
       await new Promise((resolve) => setTimeout(resolve, 120));
 
       const runningSnapshot = manager.getSnapshot();
@@ -2805,7 +2805,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "fresh-retry", links: ["https://dummy/fresh"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 30000);
 
       const item = Object.values(manager.getSnapshot().session.items)[0];
@@ -2890,7 +2890,7 @@ describe("download manager", () => {
       expect(extractDir).toBeTruthy();
       expect(fs.existsSync(extractDir)).toBe(false);
 
-      await manager.start();
+      manager.start();
       await new Promise((resolve) => setTimeout(resolve, 140));
       expect(fs.existsSync(extractDir)).toBe(false);
 
@@ -2899,14 +2899,14 @@ describe("download manager", () => {
       const snapshot = manager.getSnapshot();
       const item = Object.values(snapshot.session.items)[0];
       expect(item?.status).toBe("completed");
-      expect(item?.fullStatus).toBe("Entpackt - Done");
+      expect(item?.fullStatus).toBe("Entpackt");
       expect(fs.existsSync(extractDir)).toBe(true);
       expect(fs.existsSync(path.join(extractDir, "inside.txt"))).toBe(true);
     } finally {
       server.close();
       await once(server, "close");
     }
-  }, 35000);
+  });
 
   it("keeps accurate summary when completed items are cleaned immediately", async () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
@@ -2967,7 +2967,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "cleanup", links: ["https://dummy/cleanup"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const snapshot = manager.getSnapshot();
@@ -3048,7 +3048,7 @@ describe("download manager", () => {
       );
 
       manager.addPackages([{ name: "cleanup-package", links: ["https://dummy/cleanup-package"] }]);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 30000);
 
       const snapshot = manager.getSnapshot();
@@ -3061,7 +3061,7 @@ describe("download manager", () => {
       server.close();
       await once(server, "close");
     }
-  }, 35000);
+  });
 
   it("counts queued package cancellations in run summary", async () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
@@ -3213,7 +3213,7 @@ describe("download manager", () => {
       const disabledItemId = initial.session.packages[disabledPkgId]?.itemIds[0] || "";
 
       manager.togglePackage(disabledPkgId);
-      await manager.start();
+      manager.start();
       await waitFor(() => !manager.getSnapshot().session.running, 25000);
 
       const snapshot = manager.getSnapshot();
@@ -3705,7 +3705,7 @@ describe("download manager", () => {
     await waitFor(() => fs.existsSync(path.join(extractDir, "episode.txt")), 25000);
     const snapshot = manager.getSnapshot();
     expect(snapshot.session.packages[packageId]?.status).toBe("completed");
-    expect(snapshot.session.items[itemId]?.fullStatus).toBe("Entpackt - Done");
+    expect(snapshot.session.items[itemId]?.fullStatus).toBe("Entpackt");
   });
 
   it("does not fail startup post-processing when source package dir is missing but extract output exists", async () => {
@@ -3772,7 +3772,7 @@ describe("download manager", () => {
     await waitFor(() => manager.getSnapshot().session.items[itemId]?.fullStatus.startsWith("Entpackt"), 12000);
     const snapshot = manager.getSnapshot();
     expect(snapshot.session.packages[packageId]?.status).toBe("completed");
-    expect(snapshot.session.items[itemId]?.fullStatus).toBe("Entpackt - Done");
+    expect(snapshot.session.items[itemId]?.fullStatus).toBe("Entpackt");
   });
 
   it("marks missing source package dir as extracted instead of failed", async () => {
@@ -4012,7 +4012,7 @@ describe("download manager", () => {
     await waitFor(() => fs.existsSync(expectedPath), 12000);
     const snapshot = manager.getSnapshot();
     expect(snapshot.session.packages[packageId]?.status).toBe("completed");
-    expect(snapshot.session.items[itemId]?.fullStatus).toBe("Entpackt - Done");
+    expect(snapshot.session.items[itemId]?.fullStatus).toBe("Entpackt");
     expect(fs.existsSync(expectedPath)).toBe(true);
     expect(fs.existsSync(originalExtractedPath)).toBe(false);
   });
@@ -4135,7 +4135,7 @@ describe("download manager", () => {
     await waitFor(() => fs.existsSync(flattenedPath), 12000);
 
     expect(manager.getSnapshot().session.packages[packageId]?.status).toBe("completed");
-    expect(manager.getSnapshot().session.items[itemId]?.fullStatus).toBe("Entpackt - Done");
+    expect(manager.getSnapshot().session.items[itemId]?.fullStatus).toBe("Entpackt");
     expect(fs.existsSync(flattenedPath)).toBe(true);
     expect(fs.existsSync(originalExtractedPath)).toBe(false);
   });
@@ -4306,7 +4306,7 @@ describe("download manager", () => {
     expect(internal.globalSpeedLimitNextAt).toBeGreaterThan(start);
   });
 
-  it("resets speed window head when start finds no runnable items", async () => {
+  it("resets speed window head when start finds no runnable items", () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
     tempDirs.push(root);
 
@@ -4330,7 +4330,7 @@ describe("download manager", () => {
     internal.speedEventsHead = 5;
     internal.speedBytesLastWindow = 999;
 
-    await manager.start();
+    manager.start();
     expect(internal.speedEventsHead).toBe(0);
     expect(internal.speedEvents.length).toBe(0);
     expect(internal.speedBytesLastWindow).toBe(0);

tests/extractor-jvm.test.ts

@@ -36,8 +36,12 @@ afterEach(() => {
   }
 });
 
-describe.skipIf(!hasJavaRuntime() || !hasJvmExtractorRuntime())("extractor jvm backend", () => {
+describe("extractor jvm backend", () => {
   it("extracts zip archives through SevenZipJBinding backend", async () => {
+    if (!hasJavaRuntime() || !hasJvmExtractorRuntime()) {
+      return;
+    }
+
     process.env.RD_EXTRACT_BACKEND = "jvm";
 
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-jvm-extract-"));
@@ -65,112 +69,11 @@ describe.skipIf(!hasJavaRuntime() || !hasJvmExtractorRuntime())("extractor jvm b
     expect(fs.existsSync(path.join(targetDir, "episode.txt"))).toBe(true);
   });
 
-  it("emits progress callbacks with archiveName and percent", async () => {
-    process.env.RD_EXTRACT_BACKEND = "jvm";
-
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-jvm-progress-"));
-    tempDirs.push(root);
-    const packageDir = path.join(root, "pkg");
-    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)));
-    zip.addFile("file2.txt", Buffer.from("Another file ".repeat(100)));
-    zip.writeZip(zipPath);
-
-    const progressUpdates: Array<{
-      archiveName: string;
-      percent: number;
-      phase: string;
-      archivePercent?: number;
-    }> = [];
-
-    const result = await extractPackageArchives({
-      packageDir,
-      targetDir,
-      cleanupMode: "none",
-      conflictMode: "overwrite",
-      removeLinks: false,
-      removeSamples: false,
-      onProgress: (update) => {
-        progressUpdates.push({
-          archiveName: update.archiveName,
-          percent: update.percent,
-          phase: update.phase,
-          archivePercent: update.archivePercent,
-        });
-      },
-    });
-
-    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);
-  });
-
-  it("extracts multiple archives sequentially with progress for each", async () => {
-    process.env.RD_EXTRACT_BACKEND = "jvm";
-
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-jvm-multi-"));
-    tempDirs.push(root);
-    const packageDir = path.join(root, "pkg");
-    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"));
-
-    const zip2 = new AdmZip();
-    zip2.addFile("episode02.txt", Buffer.from("ep2 content"));
-    zip2.writeZip(path.join(packageDir, "archive2.zip"));
-
-    const archiveNames = new Set<string>();
-
-    const result = await extractPackageArchives({
-      packageDir,
-      targetDir,
-      cleanupMode: "none",
-      conflictMode: "overwrite",
-      removeLinks: false,
-      removeSamples: false,
-      onProgress: (update) => {
-        if (update.phase === "extracting" && update.archiveName) {
-          archiveNames.add(update.archiveName);
-        }
-      },
-    });
-
-    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);
-  });
-
   it("respects ask/skip conflict mode in jvm backend", async () => {
+    if (!hasJavaRuntime() || !hasJvmExtractorRuntime()) {
+      return;
+    }
+
     process.env.RD_EXTRACT_BACKEND = "jvm";
 
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-jvm-extract-"));

tests/extractor.test.ts

@@ -3,20 +3,10 @@ import os from "node:os";
 import path from "node:path";
 import AdmZip from "adm-zip";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
+import { buildExternalExtractArgs, collectArchiveCleanupTargets, extractPackageArchives } from "../src/main/extractor";
-  buildExternalExtractArgs,
-  collectArchiveCleanupTargets,
-  extractPackageArchives,
-  archiveFilenamePasswords,
-  detectArchiveSignature,
-  classifyExtractionError,
-  findArchiveCandidates,
-} from "../src/main/extractor";
 
 const tempDirs: string[] = [];
 const originalExtractBackend = process.env.RD_EXTRACT_BACKEND;
-const originalStatfs = fs.promises.statfs;
-const originalZipEntryMemoryLimit = process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB;
 
 beforeEach(() => {
   process.env.RD_EXTRACT_BACKEND = "legacy";
@@ -31,12 +21,6 @@ afterEach(() => {
   } else {
     process.env.RD_EXTRACT_BACKEND = originalExtractBackend;
   }
-  (fs.promises as any).statfs = originalStatfs;
-  if (originalZipEntryMemoryLimit === undefined) {
-    delete process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB;
-  } else {
-    process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB = originalZipEntryMemoryLimit;
-  }
 });
 
 describe("extractor", () => {
@@ -582,6 +566,7 @@ describe("extractor", () => {
   });
 
   it("keeps original ZIP size guard error when external fallback is unavailable", async () => {
+    const previousLimit = process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB;
     process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB = "8";
 
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-extract-"));
@@ -595,20 +580,32 @@ describe("extractor", () => {
     zip.addFile("large.bin", Buffer.alloc(9 * 1024 * 1024, 7));
     zip.writeZip(zipPath);
 
-    const result = await extractPackageArchives({
+    try {
-      packageDir,
+      const result = await extractPackageArchives({
-      targetDir,
+        packageDir,
-      cleanupMode: "none",
+        targetDir,
-      conflictMode: "overwrite",
+        cleanupMode: "none",
-      removeLinks: false,
+        conflictMode: "overwrite",
-      removeSamples: false
+        removeLinks: false,
-    });
+        removeSamples: false
-    expect(result.extracted).toBe(0);
+      });
-    expect(result.failed).toBe(1);
+      expect(result.extracted).toBe(0);
-    expect(String(result.lastError)).toMatch(/ZIP-Eintrag.*groß/i);
+      expect(result.failed).toBe(1);
+      expect(String(result.lastError)).toMatch(/ZIP-Eintrag.*groß/i);
+    } finally {
+      if (previousLimit === undefined) {
+        delete process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB;
+      } else {
+        process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB = previousLimit;
+      }
+    }
   });
 
-  it.skipIf(process.platform !== "win32")("matches resume-state archive names case-insensitively on Windows", async () => {
+  it("matches resume-state archive names case-insensitively on Windows", async () => {
+    if (process.platform !== "win32") {
+      return;
+    }
+
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-extract-"));
     tempDirs.push(root);
     const packageDir = path.join(root, "pkg");
@@ -645,18 +642,23 @@ describe("extractor", () => {
       zip.addFile("test.txt", Buffer.alloc(1024, 0x41));
       zip.writeZip(path.join(packageDir, "test.zip"));
 
+      const originalStatfs = fs.promises.statfs;
       (fs.promises as any).statfs = async () => ({ bfree: 1, bsize: 1 });
 
-      await expect(
+      try {
-        extractPackageArchives({
+        await expect(
-          packageDir,
+          extractPackageArchives({
-          targetDir,
+            packageDir,
-          cleanupMode: "none" as any,
+            targetDir,
-          conflictMode: "overwrite" as any,
+            cleanupMode: "none" as any,
-          removeLinks: false,
+            conflictMode: "overwrite" as any,
-          removeSamples: false,
+            removeLinks: false,
-        })
+            removeSamples: false,
-      ).rejects.toThrow(/Nicht genug Speicherplatz/);
+          })
+        ).rejects.toThrow(/Nicht genug Speicherplatz/);
+      } finally {
+        (fs.promises as any).statfs = originalStatfs;
+      }
     });
 
     it("proceeds when disk space is sufficient", async () => {
@@ -741,349 +743,4 @@ describe("extractor", () => {
       expect(fs.existsSync(path.join(targetDir, "readme.txt"))).toBe(true);
     });
   });
-
-  describe("archiveFilenamePasswords", () => {
-    it("extracts stem and spaced variant from archive name", () => {
-      const result = archiveFilenamePasswords("MyRelease.S01E01.rar");
-      expect(result).toContain("MyRelease.S01E01");
-      expect(result).toContain("MyRelease S01E01");
-    });
-
-    it("strips multipart rar suffix", () => {
-      const result = archiveFilenamePasswords("Show.S02E03.part01.rar");
-      expect(result).toContain("Show.S02E03");
-      expect(result).toContain("Show S02E03");
-    });
-
-    it("strips .zip.001 suffix", () => {
-      const result = archiveFilenamePasswords("Movie.2024.zip.001");
-      expect(result).toContain("Movie.2024");
-    });
-
-    it("strips .tar.gz suffix", () => {
-      const result = archiveFilenamePasswords("backup.tar.gz");
-      expect(result).toContain("backup");
-    });
-
-    it("returns empty array for empty input", () => {
-      expect(archiveFilenamePasswords("")).toEqual([]);
-    });
-
-    it("returns single entry when no dots/underscores", () => {
-      const result = archiveFilenamePasswords("simple.zip");
-      expect(result).toEqual(["simple"]);
-    });
-
-    it("replaces underscores with spaces", () => {
-      const result = archiveFilenamePasswords("my_archive_name.7z");
-      expect(result).toContain("my_archive_name");
-      expect(result).toContain("my archive name");
-    });
-  });
-
-  describe(".rev cleanup", () => {
-    it("collects .rev files for single RAR cleanup", () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-rev-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      const mainRar = path.join(packageDir, "show.rar");
-      const rev = path.join(packageDir, "show.rev");
-      const r00 = path.join(packageDir, "show.r00");
-
-      fs.writeFileSync(mainRar, "a", "utf8");
-      fs.writeFileSync(rev, "b", "utf8");
-      fs.writeFileSync(r00, "c", "utf8");
-
-      const targets = new Set(collectArchiveCleanupTargets(mainRar));
-      expect(targets.has(mainRar)).toBe(true);
-      expect(targets.has(rev)).toBe(true);
-      expect(targets.has(r00)).toBe(true);
-    });
-
-    it("collects .rev files for multipart RAR cleanup", () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-rev-mp-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      const part1 = path.join(packageDir, "show.part01.rar");
-      const part2 = path.join(packageDir, "show.part02.rar");
-      const rev = path.join(packageDir, "show.rev");
-
-      fs.writeFileSync(part1, "a", "utf8");
-      fs.writeFileSync(part2, "b", "utf8");
-      fs.writeFileSync(rev, "c", "utf8");
-
-      const targets = new Set(collectArchiveCleanupTargets(part1));
-      expect(targets.has(part1)).toBe(true);
-      expect(targets.has(part2)).toBe(true);
-      expect(targets.has(rev)).toBe(true);
-    });
-  });
-
-  describe("generic .001 split cleanup", () => {
-    it("collects all numbered parts for generic splits", () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-split-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      const p001 = path.join(packageDir, "movie.001");
-      const p002 = path.join(packageDir, "movie.002");
-      const p003 = path.join(packageDir, "movie.003");
-      const other = path.join(packageDir, "other.001");
-
-      fs.writeFileSync(p001, "a", "utf8");
-      fs.writeFileSync(p002, "b", "utf8");
-      fs.writeFileSync(p003, "c", "utf8");
-      fs.writeFileSync(other, "x", "utf8");
-
-      const targets = new Set(collectArchiveCleanupTargets(p001));
-      expect(targets.has(p001)).toBe(true);
-      expect(targets.has(p002)).toBe(true);
-      expect(targets.has(p003)).toBe(true);
-      expect(targets.has(other)).toBe(false);
-    });
-  });
-
-  describe("detectArchiveSignature", () => {
-    it("detects RAR signature", async () => {
-      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");
-    });
-
-    it("detects ZIP signature", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-sig-"));
-      tempDirs.push(root);
-      const filePath = path.join(root, "test.zip");
-      fs.writeFileSync(filePath, Buffer.from("504b030414000000", "hex"));
-      const sig = await detectArchiveSignature(filePath);
-      expect(sig).toBe("zip");
-    });
-
-    it("detects 7z signature", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-sig-"));
-      tempDirs.push(root);
-      const filePath = path.join(root, "test.7z");
-      fs.writeFileSync(filePath, Buffer.from("377abcaf271c0004", "hex"));
-      const sig = await detectArchiveSignature(filePath);
-      expect(sig).toBe("7z");
-    });
-
-    it("returns null for non-archive files", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-sig-"));
-      tempDirs.push(root);
-      const filePath = path.join(root, "test.txt");
-      fs.writeFileSync(filePath, "Hello World", "utf8");
-      const sig = await detectArchiveSignature(filePath);
-      expect(sig).toBeNull();
-    });
-
-    it("returns null for non-existent file", async () => {
-      const sig = await detectArchiveSignature("/nonexistent/file.rar");
-      expect(sig).toBeNull();
-    });
-  });
-
-  describe("findArchiveCandidates extended formats", () => {
-    it("finds .tar.gz files", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-tar-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      fs.writeFileSync(path.join(packageDir, "backup.tar.gz"), "data", "utf8");
-      fs.writeFileSync(path.join(packageDir, "readme.txt"), "info", "utf8");
-
-      const candidates = await findArchiveCandidates(packageDir);
-      expect(candidates.map((c) => path.basename(c))).toContain("backup.tar.gz");
-    });
-
-    it("finds .tar.bz2 files", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-tar-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      fs.writeFileSync(path.join(packageDir, "archive.tar.bz2"), "data", "utf8");
-
-      const candidates = await findArchiveCandidates(packageDir);
-      expect(candidates.map((c) => path.basename(c))).toContain("archive.tar.bz2");
-    });
-
-    it("finds generic .001 split files", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-split-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      fs.writeFileSync(path.join(packageDir, "movie.001"), "data", "utf8");
-      fs.writeFileSync(path.join(packageDir, "movie.002"), "data", "utf8");
-
-      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");
-    });
-
-    it("does not duplicate .zip.001 as generic split", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dedup-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      fs.writeFileSync(path.join(packageDir, "movie.zip.001"), "data", "utf8");
-      fs.writeFileSync(path.join(packageDir, "movie.zip.002"), "data", "utf8");
-
-      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);
-    });
-  });
-
-  describe("classifyExtractionError", () => {
-    it("classifies CRC errors", () => {
-      expect(classifyExtractionError("CRC failed for file.txt")).toBe("crc_error");
-      expect(classifyExtractionError("Checksum error in data")).toBe("crc_error");
-    });
-
-    it("classifies wrong password", () => {
-      expect(classifyExtractionError("Wrong password")).toBe("wrong_password");
-      expect(classifyExtractionError("Falsches Passwort")).toBe("wrong_password");
-    });
-
-    it("classifies missing parts", () => {
-      expect(classifyExtractionError("Missing volume: part2.rar")).toBe("missing_parts");
-      expect(classifyExtractionError("Unexpected end of archive")).toBe("missing_parts");
-    });
-
-    it("classifies unsupported format", () => {
-      expect(classifyExtractionError("kein RAR-Archiv")).toBe("unsupported_format");
-      expect(classifyExtractionError("UNSUPPORTEDMETHOD")).toBe("unsupported_format");
-    });
-
-    it("classifies disk full", () => {
-      expect(classifyExtractionError("Nicht genug Speicherplatz")).toBe("disk_full");
-      expect(classifyExtractionError("No space left on device")).toBe("disk_full");
-    });
-
-    it("classifies timeout", () => {
-      expect(classifyExtractionError("Entpacken Timeout nach 360s")).toBe("timeout");
-    });
-
-    it("classifies abort", () => {
-      expect(classifyExtractionError("aborted:extract")).toBe("aborted");
-    });
-
-    it("classifies no extractor", () => {
-      expect(classifyExtractionError("WinRAR/UnRAR nicht gefunden")).toBe("no_extractor");
-    });
-
-    it("returns unknown for unrecognized errors", () => {
-      expect(classifyExtractionError("something weird happened")).toBe("unknown");
-    });
-  });
-
-  describe("password discovery", () => {
-    it("extracts first archive serially before parallel pool when multiple passwords", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-pwdisc-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      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));
-        zip.writeZip(path.join(packageDir, name));
-      }
-
-      const seenOrder: string[] = [];
-      const result = await extractPackageArchives({
-        packageDir,
-        targetDir,
-        cleanupMode: "none",
-        conflictMode: "overwrite",
-        removeLinks: false,
-        removeSamples: false,
-        maxParallel: 2,
-        passwordList: "pw1|pw2|pw3",
-        onProgress: (update) => {
-          if (update.phase !== "extracting" || !update.archiveName) return;
-          if (seenOrder[seenOrder.length - 1] !== update.archiveName) {
-            seenOrder.push(update.archiveName);
-          }
-        }
-      });
-
-      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");
-    });
-
-    it("skips discovery when only one password candidate", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-pwdisc-skip-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      const targetDir = path.join(root, "out");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      for (const name of ["a.zip", "b.zip"]) {
-        const zip = new AdmZip();
-        zip.addFile(`${name}.txt`, Buffer.from(name));
-        zip.writeZip(path.join(packageDir, name));
-      }
-
-      // No passwordList → only empty string → length=1 → no discovery phase
-      const result = await extractPackageArchives({
-        packageDir,
-        targetDir,
-        cleanupMode: "none",
-        conflictMode: "overwrite",
-        removeLinks: false,
-        removeSamples: false,
-        maxParallel: 4
-      });
-
-      expect(result.extracted).toBe(2);
-      expect(result.failed).toBe(0);
-    });
-
-    it("skips discovery when only one archive", async () => {
-      const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-pwdisc-one-"));
-      tempDirs.push(root);
-      const packageDir = path.join(root, "pkg");
-      const targetDir = path.join(root, "out");
-      fs.mkdirSync(packageDir, { recursive: true });
-
-      const zip = new AdmZip();
-      zip.addFile("single.txt", Buffer.from("single"));
-      zip.writeZip(path.join(packageDir, "only.zip"));
-
-      const result = await extractPackageArchives({
-        packageDir,
-        targetDir,
-        cleanupMode: "none",
-        conflictMode: "overwrite",
-        removeLinks: false,
-        removeSamples: false,
-        maxParallel: 4,
-        passwordList: "pw1|pw2|pw3"
-      });
-
-      expect(result.extracted).toBe(1);
-      expect(result.failed).toBe(0);
-    });
-  });
 });

tests/mega-web-fallback.test.ts

@@ -166,7 +166,7 @@ describe("mega-web-fallback", () => {
       const controller = new AbortController();
       const timer = setTimeout(() => {
         controller.abort("test");
-      }, 200);
+      }, 30);
 
       try {
         await expect(fallback.unrestrict("https://mega.debrid/link2", controller.signal)).rejects.toThrow(/aborted/i);

tests/resolve-archive-items.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveArchiveItemsFromList } from "../src/main/download-manager";
-
-type MinimalItem = {
-  targetPath?: string;
-  fileName?: string;
-  [key: string]: unknown;
-};
-
-function makeItems(names: string[]): MinimalItem[] {
-  return names.map((name) => ({
-    targetPath: `C:\\Downloads\\Package\\${name}`,
-    fileName: name,
-    id: name,
-    status: "completed",
-  }));
-}
-
-describe("resolveArchiveItemsFromList", () => {
-  // ── Multipart RAR (.partN.rar) ──
-
-  it("matches multipart .part1.rar archives", () => {
-    const items = makeItems([
-      "Movie.part1.rar",
-      "Movie.part2.rar",
-      "Movie.part3.rar",
-      "Other.rar",
-    ]);
-    const result = resolveArchiveItemsFromList("Movie.part1.rar", items as any);
-    expect(result).toHaveLength(3);
-    expect(result.map((i: any) => i.fileName)).toEqual([
-      "Movie.part1.rar",
-      "Movie.part2.rar",
-      "Movie.part3.rar",
-    ]);
-  });
-
-  it("matches multipart .part01.rar archives (zero-padded)", () => {
-    const items = makeItems([
-      "Film.part01.rar",
-      "Film.part02.rar",
-      "Film.part10.rar",
-      "Unrelated.zip",
-    ]);
-    const result = resolveArchiveItemsFromList("Film.part01.rar", items as any);
-    expect(result).toHaveLength(3);
-  });
-
-  // ── Old-style RAR (.rar + .r00, .r01, etc.) ──
-
-  it("matches old-style .rar + .rNN volumes", () => {
-    const items = makeItems([
-      "Archive.rar",
-      "Archive.r00",
-      "Archive.r01",
-      "Archive.r02",
-      "Other.zip",
-    ]);
-    const result = resolveArchiveItemsFromList("Archive.rar", items as any);
-    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);
-    expect(result).toHaveLength(1);
-    expect((result[0] as any).fileName).toBe("SingleFile.rar");
-  });
-
-  // ── Split ZIP ──
-
-  it("matches split .zip.NNN files", () => {
-    const items = makeItems([
-      "Data.zip",
-      "Data.zip.001",
-      "Data.zip.002",
-      "Data.zip.003",
-    ]);
-    const result = resolveArchiveItemsFromList("Data.zip.001", items as any);
-    expect(result).toHaveLength(4);
-  });
-
-  // ── Split 7z ──
-
-  it("matches split .7z.NNN files", () => {
-    const items = makeItems([
-      "Backup.7z.001",
-      "Backup.7z.002",
-    ]);
-    const result = resolveArchiveItemsFromList("Backup.7z.001", items as any);
-    expect(result).toHaveLength(2);
-  });
-
-  // ── Generic .NNN splits ──
-
-  it("matches generic .NNN split files", () => {
-    const items = makeItems([
-      "video.001",
-      "video.002",
-      "video.003",
-    ]);
-    const result = resolveArchiveItemsFromList("video.001", items as any);
-    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);
-    expect(result).toHaveLength(1);
-    expect((result[0] as any).fileName).toBe("myarchive.zip");
-  });
-
-  // ── Case insensitivity ──
-
-  it("matches case-insensitively", () => {
-    const items = makeItems([
-      "MOVIE.PART1.RAR",
-      "MOVIE.PART2.RAR",
-    ]);
-    const result = resolveArchiveItemsFromList("movie.part1.rar", items as any);
-    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" },
-      { fileName: "Movie.part2.rar", id: "2", status: "completed" },
-    ];
-    const result = resolveArchiveItemsFromList("Movie.part1.rar", items as any);
-    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",
-      "Episode.S01E01.part2.rar",
-      "Episode.S01E02.part1.rar",
-      "Episode.S01E02.part2.rar",
-    ]);
-    const result1 = resolveArchiveItemsFromList("Episode.S01E01.part1.rar", items as any);
-    expect(result1).toHaveLength(2);
-    expect(result1.every((i: any) => i.fileName.includes("S01E01"))).toBe(true);
-
-    const result2 = resolveArchiveItemsFromList("Episode.S01E02.part1.rar", items as any);
-    expect(result2).toHaveLength(2);
-    expect(result2.every((i: any) => i.fileName.includes("S01E02"))).toBe(true);
-  });
-});

tests/self-check.ts

@@ -153,7 +153,7 @@ async function main(): Promise<void> {
       createStoragePaths(path.join(tempRoot, "state-pause"))
     );
     manager2.addPackages([{ name: "pause", links: ["https://dummy/slow"] }]);
-    await manager2.start();
+    manager2.start();
     await new Promise((resolve) => setTimeout(resolve, 120));
     const paused = manager2.togglePause();
     assert(paused, "Pause konnte nicht aktiviert werden");

tests/session-log.test.ts

@@ -1,163 +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 { initSessionLog, getSessionLogPath, shutdownSessionLog } from "../src/main/session-log";
-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 });
-  }
-});
-
-describe("session-log", () => {
-  it("initSessionLog creates directory and file", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    initSessionLog(baseDir);
-    const logPath = getSessionLogPath();
-    expect(logPath).not.toBeNull();
-    expect(fs.existsSync(logPath!)).toBe(true);
-    expect(fs.existsSync(path.join(baseDir, "session-logs"))).toBe(true);
-    expect(path.basename(logPath!)).toMatch(/^session_\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.txt$/);
-
-    const content = fs.readFileSync(logPath!, "utf8");
-    expect(content).toContain("=== Session gestartet:");
-
-    shutdownSessionLog();
-  });
-
-  it("logger listener writes to session log", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    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");
-    expect(content).toContain("Test-Nachricht für Session-Log");
-
-    shutdownSessionLog();
-  });
-
-  it("shutdownSessionLog writes closing line", () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    initSessionLog(baseDir);
-    const logPath = getSessionLogPath()!;
-
-    shutdownSessionLog();
-
-    const content = fs.readFileSync(logPath, "utf8");
-    expect(content).toContain("=== Session beendet:");
-  });
-
-  it("shutdownSessionLog removes listener", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    initSessionLog(baseDir);
-    const logPath = getSessionLogPath()!;
-
-    shutdownSessionLog();
-
-    // Log after shutdown - should NOT appear in session log
-    const { logger } = await import("../src/main/logger");
-    logger.info("Nach-Shutdown-Nachricht");
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const content = fs.readFileSync(logPath, "utf8");
-    expect(content).not.toContain("Nach-Shutdown-Nachricht");
-  });
-
-  it("cleanupOldSessionLogs deletes old files", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    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);
-    expect(fs.existsSync(newFile)).toBe(true);
-
-    shutdownSessionLog();
-  });
-
-  it("cleanupOldSessionLogs keeps recent files", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    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);
-    fs.utimesSync(recentFile, recentTime, recentTime);
-
-    initSessionLog(baseDir);
-
-    await new Promise((resolve) => setTimeout(resolve, 300));
-
-    expect(fs.existsSync(recentFile)).toBe(true);
-
-    shutdownSessionLog();
-  });
-
-  it("multiple sessions create different files", async () => {
-    const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-slog-"));
-    tempDirs.push(baseDir);
-
-    initSessionLog(baseDir);
-    const path1 = getSessionLogPath();
-    shutdownSessionLog();
-
-    // Small delay to ensure different timestamp
-    await new Promise((resolve) => setTimeout(resolve, 1100));
-
-    initSessionLog(baseDir);
-    const path2 = getSessionLogPath();
-    shutdownSessionLog();
-
-    expect(path1).not.toBeNull();
-    expect(path2).not.toBeNull();
-    expect(path1).not.toBe(path2);
-    expect(fs.existsSync(path1!)).toBe(true);
-    expect(fs.existsSync(path2!)).toBe(true);
-  });
-});

tests/update.test.ts

@@ -22,7 +22,7 @@ afterEach(() => {
 
 describe("update", () => {
   it("normalizes update repo input", () => {
-    expect(normalizeUpdateRepo("")).toBe("Administrator/real-debrid-downloader");
+    expect(normalizeUpdateRepo("")).toBe("Sucukdeluxe/real-debrid-downloader");
     expect(normalizeUpdateRepo("owner/repo")).toBe("owner/repo");
     expect(normalizeUpdateRepo("https://codeberg.org/owner/repo")).toBe("owner/repo");
     expect(normalizeUpdateRepo("https://www.codeberg.org/owner/repo")).toBe("owner/repo");
@@ -31,14 +31,14 @@ describe("update", () => {
     expect(normalizeUpdateRepo("git@codeberg.org:owner/repo.git")).toBe("owner/repo");
   });
 
-  it("uses normalized repo slug for API requests", async () => {
+  it("uses normalized repo slug for Codeberg API requests", async () => {
     let requestedUrl = "";
     globalThis.fetch = (async (input: RequestInfo | URL): Promise<Response> => {
       requestedUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
       return new Response(
         JSON.stringify({
           tag_name: `v${APP_VERSION}`,
-          html_url: "https://git.24-music.de/owner/repo/releases/tag/v1.0.0",
+          html_url: "https://codeberg.org/owner/repo/releases/tag/v1.0.0",
           assets: []
         }),
         {
@@ -48,8 +48,8 @@ describe("update", () => {
       );
     }) as typeof fetch;
 
-    const result = await checkGitHubUpdate("https://git.24-music.de/owner/repo/releases");
+    const result = await checkGitHubUpdate("https://codeberg.org/owner/repo/releases");
-    expect(requestedUrl).toBe("https://git.24-music.de/api/v1/repos/owner/repo/releases/latest");
+    expect(requestedUrl).toBe("https://codeberg.org/api/v1/repos/owner/repo/releases/latest");
     expect(result.currentVersion).toBe(APP_VERSION);
     expect(result.latestVersion).toBe(APP_VERSION);
     expect(result.updateAvailable).toBe(false);
@@ -484,14 +484,14 @@ describe("normalizeUpdateRepo extended", () => {
   });
 
   it("returns default for malformed inputs", () => {
-    expect(normalizeUpdateRepo("just-one-part")).toBe("Administrator/real-debrid-downloader");
+    expect(normalizeUpdateRepo("just-one-part")).toBe("Sucukdeluxe/real-debrid-downloader");
-    expect(normalizeUpdateRepo("   ")).toBe("Administrator/real-debrid-downloader");
+    expect(normalizeUpdateRepo("   ")).toBe("Sucukdeluxe/real-debrid-downloader");
   });
 
   it("rejects traversal-like owner or repo segments", () => {
-    expect(normalizeUpdateRepo("../owner/repo")).toBe("Administrator/real-debrid-downloader");
+    expect(normalizeUpdateRepo("../owner/repo")).toBe("Sucukdeluxe/real-debrid-downloader");
-    expect(normalizeUpdateRepo("owner/../repo")).toBe("Administrator/real-debrid-downloader");
+    expect(normalizeUpdateRepo("owner/../repo")).toBe("Sucukdeluxe/real-debrid-downloader");
-    expect(normalizeUpdateRepo("https://codeberg.org/owner/../../repo")).toBe("Administrator/real-debrid-downloader");
+    expect(normalizeUpdateRepo("https://codeberg.org/owner/../../repo")).toBe("Sucukdeluxe/real-debrid-downloader");
   });
 
   it("handles www prefix", () => {

tsconfig.json

@@ -12,5 +12,5 @@
     "isolatedModules": true,
     "types": ["node", "vite/client"]
   },
-  "include": ["src", "tests", "vite.config.mts"]
+  "include": ["src", "tests", "vite.config.ts"]
 }

verify_remote.mjs

@@ -0,0 +1,58 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+const localPath = "release/Real-Debrid-Downloader Setup 1.4.61.exe";
+const remoteUrl = "https://codeberg.org/Sucukdeluxe/real-debrid-downloader/releases/download/v1.4.61/Real-Debrid-Downloader%20Setup%201.4.61.exe";
+const tmpPath = path.join(os.tmpdir(), "rd-verify-1.4.61.exe");
+
+// Local file info
+const localSize = fs.statSync(localPath).size;
+const localHash = crypto.createHash("sha512");
+localHash.update(fs.readFileSync(localPath));
+const localSha = localHash.digest("hex");
+console.log("Local file size:", localSize);
+console.log("Local SHA512:", localSha.substring(0, 40) + "...");
+
+// Download from Codeberg
+console.log("\nDownloading from Codeberg...");
+const resp = await fetch(remoteUrl, { redirect: "follow" });
+console.log("Status:", resp.status);
+console.log("Content-Length:", resp.headers.get("content-length"));
+
+const source = Readable.fromWeb(resp.body);
+const target = fs.createWriteStream(tmpPath);
+await pipeline(source, target);
+
+const remoteSize = fs.statSync(tmpPath).size;
+const remoteHash = crypto.createHash("sha512");
+remoteHash.update(fs.readFileSync(tmpPath));
+const remoteSha = remoteHash.digest("hex");
+console.log("\nRemote file size:", remoteSize);
+console.log("Remote SHA512:", remoteSha.substring(0, 40) + "...");
+
+console.log("\nSize match:", localSize === remoteSize);
+console.log("SHA512 match:", localSha === remoteSha);
+
+if (localSha !== remoteSha) {
+  console.log("\n!!! FILE ON CODEBERG IS CORRUPTED !!!");
+  console.log("The upload to Codeberg damaged the file.");
+
+  // Find first difference
+  const localBuf = fs.readFileSync(localPath);
+  const remoteBuf = fs.readFileSync(tmpPath);
+  for (let i = 0; i < Math.min(localBuf.length, remoteBuf.length); i++) {
+    if (localBuf[i] !== remoteBuf[i]) {
+      console.log(`First byte difference at offset ${i}: local=0x${localBuf[i].toString(16)} remote=0x${remoteBuf[i].toString(16)}`);
+      break;
+    }
+  }
+} else {
+  console.log("\n>>> File on Codeberg is identical to local file <<<");
+  console.log("The problem is on the user's server (network/proxy issue).");
+}
+
+fs.unlinkSync(tmpPath);