JDownloader 2-style UI overhaul, multi-select, hoster display, settings sidebar

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/main/app-controller.ts

@@ -19,7 +19,7 @@ import { DownloadManager } from "./download-manager";
 import { parseCollectorInput } from "./link-parser";
 import { configureLogger, getLogFilePath, logger } from "./logger";
 import { MegaWebFallback } from "./mega-web-fallback";
-import { createStoragePaths, loadSession, loadSettings, normalizeSettings, saveSettings } from "./storage";
+import { createStoragePaths, loadSession, loadSettings, normalizeSettings, saveSession, saveSettings } from "./storage";
 import { abortActiveUpdateDownload, checkGitHubUpdate, installLatestUpdate } from "./update";
 import { startDebugServer, stopDebugServer } from "./debug-server";
 
@@ -237,6 +237,31 @@ export class AppController {
     return this.manager.getSessionStats();
   }
 
+  public exportBackup(): string {
+    const settings = this.settings;
+    const session = this.manager.getSession();
+    return JSON.stringify({ version: 1, settings, session }, null, 2);
+  }
+
+  public importBackup(json: string): { restored: boolean; message: string } {
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(json) as Record<string, unknown>;
+    } catch {
+      return { restored: false, message: "Ungültiges JSON" };
+    }
+    if (!parsed || typeof parsed !== "object" || !parsed.settings || !parsed.session) {
+      return { restored: false, message: "Kein gültiges Backup (settings/session fehlen)" };
+    }
+    const restoredSettings = normalizeSettings(parsed.settings as AppSettings);
+    this.settings = restoredSettings;
+    saveSettings(this.storagePaths, this.settings);
+    this.manager.setSettings(this.settings);
+    const restoredSession = parsed.session as ReturnType<typeof loadSession>;
+    saveSession(this.storagePaths, restoredSession);
+    return { restored: true, message: "Backup wiederhergestellt. Bitte App neustarten." };
+  }
+
   public shutdown(): void {
     stopDebugServer();
     abortActiveUpdateDownload();

src/main/constants.ts

@@ -73,6 +73,8 @@ export function defaultSettings(): AppSettings {
     clipboardWatch: false,
     minimizeToTray: false,
     theme: "dark" as const,
+    collapseNewPackages: true,
+    autoSkipExtracted: false,
     bandwidthSchedules: []
   };
 }

src/main/download-manager.ts

@@ -867,7 +867,7 @@ export class DownloadManager extends EventEmitter {
       summary: snapshotSummary,
       stats: this.getStats(now),
       speedText: `Geschwindigkeit: ${humanSize(Math.max(0, Math.floor(speedBps)))}/s`,
-      etaText: paused ? "ETA: --" : `ETA: ${formatEta(eta)}`,
+      etaText: paused || !this.session.running ? "ETA: --" : `ETA: ${formatEta(eta)}`,
       canStart: !this.session.running,
       canStop: this.session.running,
       canPause: this.session.running,

src/main/main.ts

@@ -1,9 +1,10 @@
+import fs from "node:fs";
 import path from "node:path";
 import { app, BrowserWindow, clipboard, dialog, ipcMain, IpcMainInvokeEvent, Menu, shell, Tray } from "electron";
 import { AddLinksPayload, AppSettings, UpdateInstallProgress } from "../shared/types";
 import { AppController } from "./app-controller";
 import { IPC_CHANNELS } from "../shared/ipc";
-import { logger } from "./logger";
+import { getLogFilePath, logger } from "./logger";
 import { APP_NAME } from "./constants";
 import { extractHttpLinksFromText } from "./utils";
 
@@ -86,6 +87,9 @@ function createWindow(): BrowserWindow {
     });
   }
 
+  window.setMenuBarVisibility(false);
+  window.setAutoHideMenuBar(true);
+
   if (isDevMode()) {
     void window.loadURL("http://localhost:5173");
   } else {
@@ -346,6 +350,51 @@ function registerIpcHandlers(): void {
   });
   ipcMain.handle(IPC_CHANNELS.GET_SESSION_STATS, () => controller.getSessionStats());
 
+  ipcMain.handle(IPC_CHANNELS.RESTART, () => {
+    app.relaunch();
+    app.quit();
+  });
+
+  ipcMain.handle(IPC_CHANNELS.QUIT, () => {
+    app.quit();
+  });
+
+  ipcMain.handle(IPC_CHANNELS.EXPORT_BACKUP, async () => {
+    const options = {
+      defaultPath: `mdd-backup-${new Date().toISOString().slice(0, 10)}.json`,
+      filters: [{ name: "Backup", 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.exportBackup();
+    await fs.promises.writeFile(result.filePath, json, "utf8");
+    return { saved: true };
+  });
+
+  ipcMain.handle(IPC_CHANNELS.OPEN_LOG, async () => {
+    const logPath = getLogFilePath();
+    await shell.openPath(logPath);
+  });
+
+  ipcMain.handle(IPC_CHANNELS.IMPORT_BACKUP, async () => {
+    const options = {
+      properties: ["openFile"] as Array<"openFile">,
+      filters: [
+        { name: "Backup", extensions: ["json"] },
+        { name: "Alle Dateien", extensions: ["*"] }
+      ]
+    };
+    const result = mainWindow ? await dialog.showOpenDialog(mainWindow, options) : await dialog.showOpenDialog(options);
+    if (result.canceled || result.filePaths.length === 0) {
+      return { restored: false, message: "Abgebrochen" };
+    }
+    const filePath = result.filePaths[0];
+    const json = await fs.promises.readFile(filePath, "utf8");
+    return controller.importBackup(json);
+  });
+
   controller.onState = (snapshot) => {
     if (!mainWindow || mainWindow.isDestroyed()) {
       return;

src/main/storage.ts

@@ -106,6 +106,8 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     updateRepo: asText(settings.updateRepo) || defaults.updateRepo,
     clipboardWatch: Boolean(settings.clipboardWatch),
     minimizeToTray: Boolean(settings.minimizeToTray),
+    collapseNewPackages: settings.collapseNewPackages !== undefined ? Boolean(settings.collapseNewPackages) : defaults.collapseNewPackages,
+    autoSkipExtracted: settings.autoSkipExtracted !== undefined ? Boolean(settings.autoSkipExtracted) : defaults.autoSkipExtracted,
     theme: VALID_THEMES.has(settings.theme) ? settings.theme : defaults.theme,
     bandwidthSchedules: normalizeBandwidthSchedules(settings.bandwidthSchedules)
   };