Add start conflict prompts for existing extracted packages in v1.4.2

src/main/app-controller.ts

@@ -1,6 +1,16 @@
 import path from "node:path";
 import { app } from "electron";
-import { AddLinksPayload, AppSettings, ParsedPackageInput, UiSnapshot, UpdateCheckResult, UpdateInstallResult } from "../shared/types";
+import {
+  AddLinksPayload,
+  AppSettings,
+  DuplicatePolicy,
+  ParsedPackageInput,
+  StartConflictEntry,
+  StartConflictResolutionResult,
+  UiSnapshot,
+  UpdateCheckResult,
+  UpdateInstallResult
+} from "../shared/types";
 import { importDlcContainers } from "./container";
 import { APP_VERSION, defaultSettings } from "./constants";
 import { DownloadManager } from "./download-manager";
@@ -39,9 +49,12 @@ export class AppController {
     if (this.settings.autoResumeOnStart) {
       const snapshot = this.manager.getSnapshot();
       const hasPending = Object.values(snapshot.session.items).some((item) => item.status === "queued" || item.status === "reconnect_wait");
-      if (hasPending && this.hasAnyProviderToken(this.settings)) {
+      const hasConflicts = this.manager.getStartConflicts().length > 0;
+      if (hasPending && this.hasAnyProviderToken(this.settings) && !hasConflicts) {
         this.manager.start();
         logger.info("Auto-Resume beim Start aktiviert");
+      } else if (hasPending && hasConflicts) {
+        logger.info("Auto-Resume übersprungen: Start-Konflikte erkannt");
       }
     }
   }
@@ -113,6 +126,14 @@ export class AppController {
     return result;
   }
 
+  public getStartConflicts(): StartConflictEntry[] {
+    return this.manager.getStartConflicts();
+  }
+
+  public resolveStartConflict(packageId: string, policy: DuplicatePolicy): StartConflictResolutionResult {
+    return this.manager.resolveStartConflict(packageId, policy);
+  }
+
   public clearAll(): void {
     this.manager.clearAll();
   }

src/main/download-manager.ts

@@ -3,7 +3,20 @@ import path from "node:path";
 import os from "node:os";
 import { EventEmitter } from "node:events";
 import { v4 as uuidv4 } from "uuid";
-import { AppSettings, DownloadItem, DownloadStats, DownloadSummary, DownloadStatus, PackageEntry, ParsedPackageInput, SessionState, UiSnapshot } from "../shared/types";
+import {
+  AppSettings,
+  DownloadItem,
+  DownloadStats,
+  DownloadSummary,
+  DownloadStatus,
+  DuplicatePolicy,
+  PackageEntry,
+  ParsedPackageInput,
+  SessionState,
+  StartConflictEntry,
+  StartConflictResolutionResult,
+  UiSnapshot
+} from "../shared/types";
 import { REQUEST_RETRIES } from "./constants";
 import { cleanupCancelledPackageArtifactsAsync } from "./cleanup";
 import { DebridService, MegaWebUnrestrictor } from "./debrid";
@@ -514,6 +527,105 @@ export class DownloadManager extends EventEmitter {
     return { addedPackages, addedLinks };
   }
 
+  public getStartConflicts(): StartConflictEntry[] {
+    const conflicts: StartConflictEntry[] = [];
+    for (const packageId of this.session.packageOrder) {
+      const pkg = this.session.packages[packageId];
+      if (!pkg || pkg.cancelled || !pkg.enabled) {
+        continue;
+      }
+
+      const hasPendingItems = pkg.itemIds.some((itemId) => {
+        const item = this.session.items[itemId];
+        if (!item) {
+          return false;
+        }
+        return item.status === "queued" || item.status === "reconnect_wait";
+      });
+      if (!hasPendingItems) {
+        continue;
+      }
+
+      if (this.directoryHasAnyFiles(pkg.extractDir)) {
+        conflicts.push({
+          packageId: pkg.id,
+          packageName: pkg.name,
+          extractDir: pkg.extractDir
+        });
+      }
+    }
+    return conflicts;
+  }
+
+  public resolveStartConflict(packageId: string, policy: DuplicatePolicy): StartConflictResolutionResult {
+    const pkg = this.session.packages[packageId];
+    if (!pkg || pkg.cancelled) {
+      return { skipped: false, overwritten: false };
+    }
+
+    if (policy === "skip") {
+      for (const itemId of pkg.itemIds) {
+        const active = this.activeTasks.get(itemId);
+        if (active) {
+          active.abortReason = "cancel";
+          active.abortController.abort("cancel");
+        }
+        this.releaseTargetPath(itemId);
+        delete this.session.items[itemId];
+      }
+      delete this.session.packages[packageId];
+      this.session.packageOrder = this.session.packageOrder.filter((id) => id !== packageId);
+      this.persistSoon();
+      this.emitState(true);
+      return { skipped: true, overwritten: false };
+    }
+
+    if (policy === "overwrite") {
+      try {
+        fs.rmSync(pkg.extractDir, { recursive: true, force: true });
+      } catch {
+        // ignore
+      }
+      try {
+        fs.rmSync(pkg.outputDir, { recursive: true, force: true });
+      } catch {
+        // ignore
+      }
+
+      for (const itemId of pkg.itemIds) {
+        const item = this.session.items[itemId];
+        if (!item) {
+          continue;
+        }
+        const active = this.activeTasks.get(itemId);
+        if (active) {
+          active.abortReason = "cancel";
+          active.abortController.abort("cancel");
+        }
+        this.releaseTargetPath(itemId);
+        item.status = "queued";
+        item.retries = 0;
+        item.speedBps = 0;
+        item.downloadedBytes = 0;
+        item.totalBytes = null;
+        item.progressPercent = 0;
+        item.resumable = true;
+        item.attempts = 0;
+        item.lastError = "";
+        item.fullStatus = "Wartet";
+        item.updatedAt = nowMs();
+        item.targetPath = path.join(pkg.outputDir, sanitizeFilename(item.fileName || filenameFromUrl(item.url)));
+      }
+      pkg.status = "queued";
+      pkg.updatedAt = nowMs();
+      this.persistSoon();
+      this.emitState(true);
+      return { skipped: false, overwritten: true };
+    }
+
+    return { skipped: false, overwritten: false };
+  }
+
   private async resolveQueuedFilenames(unresolvedByLink: Map<string, string[]>): Promise<void> {
     try {
       let changed = false;

src/main/main.ts

@@ -154,6 +154,9 @@ function registerIpcHandlers(): void {
   });
   ipcMain.handle(IPC_CHANNELS.ADD_LINKS, (_event: IpcMainInvokeEvent, payload: AddLinksPayload) => controller.addLinks(payload));
   ipcMain.handle(IPC_CHANNELS.ADD_CONTAINERS, async (_event: IpcMainInvokeEvent, filePaths: string[]) => controller.addContainers(filePaths ?? []));
+  ipcMain.handle(IPC_CHANNELS.GET_START_CONFLICTS, () => controller.getStartConflicts());
+  ipcMain.handle(IPC_CHANNELS.RESOLVE_START_CONFLICT, (_event: IpcMainInvokeEvent, packageId: string, policy: "keep" | "skip" | "overwrite") =>
+    controller.resolveStartConflict(packageId, policy));
   ipcMain.handle(IPC_CHANNELS.CLEAR_ALL, () => controller.clearAll());
   ipcMain.handle(IPC_CHANNELS.START, () => controller.start());
   ipcMain.handle(IPC_CHANNELS.STOP, () => controller.stop());