Fix resume retry fallback for truncated direct links

src/main/download-manager.ts

@@ -64,6 +64,7 @@ type ActiveTask = {
   resumable: boolean;
   nonResumableCounted: boolean;
   freshRetryUsed?: boolean;
+  resumeHardResetUsed?: boolean;
   stallRetries?: number;
   genericErrorRetries?: number;
   unrestrictRetries?: number;
@@ -394,6 +395,11 @@ function isFetchFailure(errorText: string): boolean {
   return text.includes("fetch failed") || text.includes("socket hang up") || text.includes("econnreset") || text.includes("network error");
 }
 
+function isResumeHardResetReason(errorText: string): boolean {
+  const text = String(errorText || "");
+  return text.startsWith("resume_download_underflow:");
+}
+
 function isPermanentLinkError(errorText: string): boolean {
   const text = String(errorText || "").toLowerCase();
   return text.includes("permanent ungültig")
@@ -1170,6 +1176,7 @@ export class DownloadManager extends EventEmitter {
 
   private retryStateByItem = new Map<string, {
     freshRetryUsed: boolean;
+    resumeHardResetUsed: boolean;
     stallRetries: number;
     genericErrorRetries: number;
     unrestrictRetries: number;
@@ -5539,6 +5546,7 @@ export class DownloadManager extends EventEmitter {
         retryState.unrestrictRetries = 0;
         retryState.genericErrorRetries = 0;
         retryState.freshRetryUsed = false;
+        retryState.resumeHardResetUsed = false;
         logger.info(`Soft-Reset: Retry-Counter zurückgesetzt für ${item.fileName || itemId} (${Math.floor(staleMs / 60000)} min stale)`);
       }
     }
@@ -5897,6 +5905,7 @@ export class DownloadManager extends EventEmitter {
     active.abortReason = "none";
     this.retryStateByItem.set(item.id, {
       freshRetryUsed: Boolean(active.freshRetryUsed),
+      resumeHardResetUsed: Boolean(active.resumeHardResetUsed),
       stallRetries: Number(active.stallRetries || 0),
       genericErrorRetries: Number(active.genericErrorRetries || 0),
       unrestrictRetries: Number(active.unrestrictRetries || 0)
@@ -5907,7 +5916,8 @@ export class DownloadManager extends EventEmitter {
       stallRetries: Number(active.stallRetries || 0),
       unrestrictRetries: Number(active.unrestrictRetries || 0),
       genericRetries: Number(active.genericErrorRetries || 0),
-      freshRetryUsed: Boolean(active.freshRetryUsed)
+      freshRetryUsed: Boolean(active.freshRetryUsed),
+      resumeHardResetUsed: Boolean(active.resumeHardResetUsed)
     });
     // Caller returns immediately after this; startItem().finally releases the active slot,
     // so the retry backoff never blocks a worker.
@@ -5987,12 +5997,14 @@ export class DownloadManager extends EventEmitter {
 
     const retryState = this.retryStateByItem.get(item.id) || {
       freshRetryUsed: false,
+      resumeHardResetUsed: false,
       stallRetries: 0,
       genericErrorRetries: 0,
       unrestrictRetries: 0
     };
     this.retryStateByItem.set(item.id, retryState);
     active.freshRetryUsed = retryState.freshRetryUsed;
+    active.resumeHardResetUsed = retryState.resumeHardResetUsed;
     active.stallRetries = retryState.stallRetries;
     active.genericErrorRetries = retryState.genericErrorRetries;
     active.unrestrictRetries = retryState.unrestrictRetries;
@@ -6471,11 +6483,36 @@ export class DownloadManager extends EventEmitter {
             error: errorText,
             abortReason: reason || "none"
           });
-          const directLinkRetryMatch = errorText.match(/^direct_link_retry_exhausted:(.+)$/);
+          const directLinkRetryMatch = errorText.match(/^(?:Error:\s*)?direct_link_retry_exhausted:(.+)$/);
+          if (directLinkRetryMatch) {
+            const exhaustedReason = compactErrorText(directLinkRetryMatch[1] || errorText).replace(/^Error:\s*/i, "");
+            if (isResumeHardResetReason(exhaustedReason) && !active.resumeHardResetUsed) {
+              active.resumeHardResetUsed = true;
+              item.retries += 1;
+              logger.warn(`Resume-Neustart: item=${item.fileName || item.id}, error=${exhaustedReason}, provider=${item.provider || "?"}`);
+              if (claimedTargetPath) {
+                try {
+                  fs.rmSync(claimedTargetPath, { force: true });
+                } catch {
+                  // ignore
+                }
+              }
+              this.releaseTargetPath(item.id);
+              this.dropItemContribution(item.id);
+              item.lastError = exhaustedReason;
+              item.downloadedBytes = 0;
+              item.totalBytes = null;
+              item.progressPercent = 0;
+              this.queueRetry(item, active, 300, "Resume-Fehler erkannt, kompletter Neuversuch");
+              this.persistSoon();
+              this.emitState();
+              return;
+            }
+          }
           if (directLinkRetryMatch && active.genericErrorRetries < maxGenericErrorRetries) {
             active.genericErrorRetries += 1;
             item.retries += 1;
-            const exhaustedReason = compactErrorText(directLinkRetryMatch[1] || errorText);
+            const exhaustedReason = compactErrorText(directLinkRetryMatch[1] || errorText).replace(/^Error:\s*/i, "");
             const refreshDelayMs = retryDelayWithJitter(active.genericErrorRetries, 200);
             logger.warn(
               `Direktlink erschöpft: item=${item.fileName || item.id}, ` +
@@ -7486,13 +7523,14 @@ export class DownloadManager extends EventEmitter {
           throw error;
         }
         lastError = compactErrorText(error);
+        const normalizedLastError = lastError.replace(/^Error:\s*/i, "");
         logAttemptEvent("WARN", "HTTP-Download-Versuch fehlgeschlagen", {
           attempt,
           error: lastError,
           targetPath: effectiveTargetPath
         });
-        if (lastError.startsWith("range_ignored_on_resume:")) {
+        if (normalizedLastError.startsWith("range_ignored_on_resume:")) {
-          throw new Error(`direct_link_retry_exhausted:${lastError}`);
+          throw new Error(`direct_link_retry_exhausted:${normalizedLastError}`);
         }
         if (attempt < maxAttempts) {
           item.retries += 1;
@@ -7502,9 +7540,12 @@ export class DownloadManager extends EventEmitter {
           continue;
         }
         if (maxAttemptsBySetting > maxAttempts) {
-          throw new Error(`direct_link_retry_exhausted:${lastError || "Download fehlgeschlagen"}`);
+          const exhaustedError = existingBytes > 0 && normalizedLastError.startsWith("download_underflow:")
+            ? `resume_download_underflow:${normalizedLastError.slice("download_underflow:".length)}`
+            : (normalizedLastError || lastError || "Download fehlgeschlagen");
+          throw new Error(`direct_link_retry_exhausted:${exhaustedError}`);
         }
-        throw new Error(lastError || "Download fehlgeschlagen");
+        throw new Error(normalizedLastError || lastError || "Download fehlgeschlagen");
       }
     }
 

tests/download-manager.test.ts

@@ -473,6 +473,151 @@ describe("download manager", () => {
     }
   });
 
+  it("restarts from zero after repeated resume underflow on fresh direct links", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
+    tempDirs.push(root);
+    const binary = Buffer.alloc(256 * 1024, 23);
+    const pkgDir = path.join(root, "downloads", "resume-underflow");
+    fs.mkdirSync(pkgDir, { recursive: true });
+    const existingTargetPath = path.join(pkgDir, "resume-underflow.mkv");
+    const partialSize = 96 * 1024;
+    fs.writeFileSync(existingTargetPath, binary.subarray(0, partialSize));
+
+    let unrestrictCalls = 0;
+    const starts: number[] = [];
+
+    const server = http.createServer((req, res) => {
+      const range = String(req.headers.range || "");
+      const match = range.match(/bytes=(\d+)-/i);
+      const start = match ? Number(match[1]) : 0;
+      starts.push(start);
+
+      if (start > 0) {
+        const chunk = binary.subarray(start, Math.min(start + 8192, binary.length));
+        res.statusCode = 206;
+        res.setHeader("Accept-Ranges", "bytes");
+        res.setHeader("Content-Range", `bytes ${start}-${start + chunk.length - 1}/${binary.length}`);
+        res.setHeader("Content-Length", String(chunk.length));
+        res.end(chunk);
+        return;
+      }
+
+      res.statusCode = 200;
+      res.setHeader("Accept-Ranges", "bytes");
+      res.setHeader("Content-Length", String(binary.length));
+      res.end(binary);
+    });
+
+    server.listen(0, "127.0.0.1");
+    await once(server, "listening");
+
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("server address unavailable");
+    }
+    const directUrl = `http://127.0.0.1:${address.port}/resume-underflow`;
+
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      if (url.includes("/unrestrict/link")) {
+        unrestrictCalls += 1;
+        return new Response(
+          JSON.stringify({
+            download: directUrl,
+            filename: "resume-underflow.mkv",
+            filesize: binary.length
+          }),
+          {
+            status: 200,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      return originalFetch(input, init);
+    };
+
+    try {
+      const session = emptySession();
+      const packageId = "resume-underflow-pkg";
+      const itemId = "resume-underflow-item";
+      const createdAt = Date.now() - 10_000;
+
+      session.packageOrder = [packageId];
+      session.packages[packageId] = {
+        id: packageId,
+        name: "resume-underflow",
+        outputDir: pkgDir,
+        extractDir: path.join(root, "extract", "resume-underflow"),
+        status: "queued",
+        itemIds: [itemId],
+        cancelled: false,
+        enabled: true,
+        createdAt,
+        updatedAt: createdAt
+      };
+      session.items[itemId] = {
+        id: itemId,
+        packageId,
+        url: "https://dummy/resume-underflow",
+        provider: null,
+        status: "queued",
+        retries: 0,
+        speedBps: 0,
+        downloadedBytes: partialSize,
+        totalBytes: binary.length,
+        progressPercent: Math.floor((partialSize / binary.length) * 100),
+        fileName: "resume-underflow.mkv",
+        targetPath: existingTargetPath,
+        resumable: true,
+        attempts: 0,
+        lastError: "",
+        fullStatus: "Wartet",
+        createdAt,
+        updatedAt: createdAt
+      };
+
+      const manager = new DownloadManager(
+        {
+          ...defaultSettings(),
+          token: "rd-token",
+          outputDir: path.join(root, "downloads"),
+          extractDir: path.join(root, "extract"),
+          retryLimit: 4,
+          autoExtract: false,
+          autoReconnect: false
+        },
+        session,
+        createStoragePaths(path.join(root, "state"))
+      );
+
+      await manager.start();
+      await waitFor(() => !manager.getSnapshot().session.running, 25000);
+
+      const item = manager.getSnapshot().session.items[itemId];
+      if (item?.status !== "completed") {
+        throw new Error(JSON.stringify({
+          status: item?.status,
+          downloadedBytes: item?.downloadedBytes,
+          totalBytes: item?.totalBytes,
+          retries: item?.retries,
+          lastError: item?.lastError,
+          fullStatus: item?.fullStatus,
+          starts,
+          unrestrictCalls
+        }));
+      }
+      expect(item?.status).toBe("completed");
+      expect(item?.downloadedBytes).toBe(binary.length);
+      expect(unrestrictCalls).toBeGreaterThanOrEqual(2);
+      expect(starts).toContain(partialSize);
+      expect(starts).toContain(0);
+      expect(fs.readFileSync(existingTargetPath).equals(binary)).toBe(true);
+    } finally {
+      server.close();
+      await once(server, "close");
+    }
+  });
+
   it("assigns unique target paths for same filenames in parallel", async () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
     tempDirs.push(root);