Account-Rotation: Login/Premium-Badges + Live-Rotations-Panel + "Alle pruefen"

- Pro Mega-Debrid-Account UND Debrid-Link-Key im Bearbeiten-Dialog: Badge mit
  Login-Gueltigkeit + Premium-Restlaufzeit (connectUser vip_end / account/infos premiumLeft)
- "Alle pruefen"-Button oben rechts; prueft alle Accounts (Concurrency-Cap 4),
  Ergebnis persistiert (debridAccountStatuses), ueberlebt Neustart
- Rotations-Verlauf-Panel: zeigt live welcher Account/Key versucht wurde + warum
  gewechselt (Ring-Buffer -> Snapshot -> UI), statt nur "Link-Umwandlung erneut"
- Bug A: Mega-Debrid Per-Account-Verbrauch wurde nie erfasst (Heute/Insgesamt immer 0)
- Bug B: isProviderConfigured erkannte reine megaCredentials-Multi-Config nicht
- Neu: account-check.ts (standalone), CHECK_DEBRID_ACCOUNTS IPC, 13 Tests

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

src/main/account-check.ts

@@ -0,0 +1,220 @@
+import type { AppSettings, DebridAccountStatus } from "../shared/types";
+import { parseMegaDebridAccounts, type MegaDebridAccountEntry } from "../shared/mega-debrid-accounts";
+import { parseDebridLinkApiKeys, type DebridLinkApiKeyEntry } from "../shared/debrid-link-keys";
+import { logger } from "./logger";
+import { compactErrorText } from "./utils";
+
+/**
+ * Account-Validity + Premium-Check fuer Multi-Account-Provider.
+ *
+ * Standalone (eigene fetch-Calls, kein Import aus debrid.ts) damit es ohne
+ * Zirkular-Abhaengigkeit von der "Check all"-IPC und beim Programmstart genutzt
+ * werden kann.
+ *
+ * Verifizierte API-Felder (Live-Probe):
+ *  - Mega-Debrid connectUser -> { response_code:"ok", token, vip_end (Unix-ts), email }
+ *  - Debrid-Link /account/infos -> { success, value: { accountType, premiumLeft (s), username } }
+ */
+
+const MEGA_DEBRID_API = "https://www.mega-debrid.eu/api.php";
+const DEBRID_LINK_API = "https://debrid-link.com/api/v2";
+const CHECK_USER_AGENT =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+const CHECK_TIMEOUT_MS = 20000;
+
+function timeoutSignal(signal: AbortSignal | undefined, ms: number): AbortSignal {
+  const timeout = AbortSignal.timeout(ms);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+function parseJsonSafe(text: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(text) as unknown;
+    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+function formatRemaining(premiumUntilMs: number | null, now: number): string {
+  if (premiumUntilMs == null) {
+    return "Premium-Status unbekannt";
+  }
+  if (premiumUntilMs <= 0) {
+    return "Kein Premium";
+  }
+  const remainingMs = premiumUntilMs - now;
+  if (remainingMs <= 0) {
+    return "Premium abgelaufen";
+  }
+  const days = Math.floor(remainingMs / (24 * 60 * 60 * 1000));
+  if (days >= 1) {
+    return `Premium noch ${days} Tag${days === 1 ? "" : "e"}`;
+  }
+  const hours = Math.max(1, Math.floor(remainingMs / (60 * 60 * 1000)));
+  return `Premium noch ${hours} Std`;
+}
+
+/** Check a single Mega-Debrid account via connectUser. */
+export async function checkMegaDebridAccount(
+  account: MegaDebridAccountEntry,
+  signal?: AbortSignal,
+  now = Date.now()
+): Promise<DebridAccountStatus> {
+  const base: DebridAccountStatus = {
+    accountId: account.id,
+    provider: "megadebrid",
+    label: account.label,
+    maskedLogin: account.maskedLogin,
+    valid: false,
+    isPremium: false,
+    premiumUntilMs: null,
+    message: "",
+    checkedAt: now
+  };
+  try {
+    const url = `${MEGA_DEBRID_API}?action=connectUser&login=${encodeURIComponent(account.login)}&password=${encodeURIComponent(account.password)}`;
+    const response = await fetch(url, {
+      headers: { "User-Agent": CHECK_USER_AGENT },
+      signal: timeoutSignal(signal, CHECK_TIMEOUT_MS)
+    });
+    const text = await response.text();
+    const payload = parseJsonSafe(text);
+    if (!response.ok || !payload) {
+      return { ...base, message: `Login fehlgeschlagen (HTTP ${response.status})` };
+    }
+    if (payload.response_code !== "ok") {
+      const reason = String(payload.response_text || payload.response_code || "Login abgelehnt");
+      return { ...base, message: `Ungueltiger Login: ${reason}` };
+    }
+    // vip_end is a Unix timestamp (seconds). 0 / missing => no premium.
+    const vipEndRaw = Number(payload.vip_end || 0);
+    const premiumUntilMs = Number.isFinite(vipEndRaw) && vipEndRaw > 0 ? vipEndRaw * 1000 : 0;
+    const isPremium = premiumUntilMs > now;
+    const email = String(payload.email || "").trim() || undefined;
+    return {
+      ...base,
+      valid: true,
+      isPremium,
+      premiumUntilMs,
+      email,
+      message: formatRemaining(premiumUntilMs, now)
+    };
+  } catch (error) {
+    const errText = compactErrorText(error);
+    const aborted = signal?.aborted || /aborted/i.test(errText);
+    return {
+      ...base,
+      message: aborted ? "Pruefung abgebrochen" : `Pruefung fehlgeschlagen: ${errText}`
+    };
+  }
+}
+
+/** Check a single Debrid-Link API key via /account/infos. */
+export async function checkDebridLinkKey(
+  key: DebridLinkApiKeyEntry,
+  signal?: AbortSignal,
+  now = Date.now()
+): Promise<DebridAccountStatus> {
+  const base: DebridAccountStatus = {
+    accountId: key.id,
+    provider: "debridlink",
+    label: key.label,
+    maskedLogin: key.masked,
+    valid: false,
+    isPremium: false,
+    premiumUntilMs: null,
+    message: "",
+    checkedAt: now
+  };
+  try {
+    const response = await fetch(`${DEBRID_LINK_API}/account/infos`, {
+      headers: {
+        Authorization: `Bearer ${key.token}`,
+        "User-Agent": CHECK_USER_AGENT
+      },
+      signal: timeoutSignal(signal, CHECK_TIMEOUT_MS)
+    });
+    const text = await response.text();
+    const payload = parseJsonSafe(text);
+    if (!response.ok || !payload) {
+      // 401 = bad/expired token
+      if (response.status === 401 || response.status === 403) {
+        return { ...base, message: "Ungueltiger API-Key (nicht autorisiert)" };
+      }
+      return { ...base, message: `Pruefung fehlgeschlagen (HTTP ${response.status})` };
+    }
+    if (payload.success === false) {
+      const reason = String(payload.error || "Key abgelehnt");
+      return { ...base, message: `Ungueltiger API-Key: ${reason}` };
+    }
+    const value = (payload.value && typeof payload.value === "object" ? payload.value : payload) as Record<string, unknown>;
+    // premiumLeft = seconds of premium remaining. accountType>0 also indicates premium.
+    const premiumLeftSec = Number(value.premiumLeft || 0);
+    const accountType = Number(value.accountType || 0);
+    const premiumUntilMs = Number.isFinite(premiumLeftSec) && premiumLeftSec > 0 ? now + premiumLeftSec * 1000 : 0;
+    const isPremium = premiumUntilMs > now || accountType > 0;
+    const username = String(value.username || "").trim() || undefined;
+    return {
+      ...base,
+      valid: true,
+      isPremium,
+      premiumUntilMs: premiumUntilMs > 0 ? premiumUntilMs : (accountType > 0 ? null : 0),
+      email: username,
+      message: premiumUntilMs > 0
+        ? formatRemaining(premiumUntilMs, now)
+        : (accountType > 0 ? "Premium aktiv" : "Kein Premium (Free)")
+    };
+  } catch (error) {
+    const errText = compactErrorText(error);
+    const aborted = signal?.aborted || /aborted/i.test(errText);
+    return {
+      ...base,
+      message: aborted ? "Pruefung abgebrochen" : `Pruefung fehlgeschlagen: ${errText}`
+    };
+  }
+}
+
+/** Check ALL configured multi-account credentials (Mega-Debrid accounts +
+ *  Debrid-Link keys) concurrently. Returns one status per account id. */
+export async function checkAllDebridAccounts(
+  settings: AppSettings,
+  signal?: AbortSignal
+): Promise<DebridAccountStatus[]> {
+  const now = Date.now();
+  const megaAccounts = parseMegaDebridAccounts(settings.megaCredentials || "", settings.megaPassword || "");
+  const debridLinkKeys = parseDebridLinkApiKeys(settings.debridLinkApiKeys || "");
+
+  // Each task is a thunk so we can throttle concurrency. Firing all accounts at
+  // once (e.g. 9+ Debrid-Link keys) can trip provider rate-limits and produce
+  // false "invalid" badges, so cap at CHECK_CONCURRENCY parallel checks.
+  const taskFns: Array<() => Promise<DebridAccountStatus>> = [
+    ...megaAccounts.map((account) => () => checkMegaDebridAccount(account, signal, now)),
+    ...debridLinkKeys.map((key) => () => checkDebridLinkKey(key, signal, now))
+  ];
+
+  const results = await runWithConcurrency(taskFns, CHECK_CONCURRENCY);
+  logger.info(
+    `Account-Check abgeschlossen: ${results.length} Accounts geprueft ` +
+    `(${results.filter((r) => r.valid).length} gueltig, ${results.filter((r) => r.isPremium).length} premium)`
+  );
+  return results;
+}
+
+const CHECK_CONCURRENCY = 4;
+
+/** Run thunks with a bounded number in flight, preserving result order. */
+async function runWithConcurrency<T>(taskFns: Array<() => Promise<T>>, limit: number): Promise<T[]> {
+  const results: T[] = new Array(taskFns.length);
+  let nextIndex = 0;
+  const worker = async (): Promise<void> => {
+    while (nextIndex < taskFns.length) {
+      const current = nextIndex;
+      nextIndex += 1;
+      results[current] = await taskFns[current]();
+    }
+  };
+  const workers = Array.from({ length: Math.min(limit, taskFns.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}

src/main/account-rotation-log.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import type { RotationEvent } from "../shared/types";
 
 /** Dedicated log file for multi-account/key rotation events:
  *  Mega-Debrid account selection, Debrid-Link key selection, per-attempt
@@ -9,6 +10,70 @@ import path from "node:path";
 
 type RotationLevel = "INFO" | "WARN" | "ERROR";
 
+/** In-memory ring buffer of the most recent rotation events so the UI can show
+ *  a live "which account was tried and why it failed" panel — the same events
+ *  written to account-rotation.log, but surfaced to the renderer via snapshot. */
+const ROTATION_EVENT_RING_MAX = 60;
+const rotationEventRing: RotationEvent[] = [];
+let rotationEventSeq = 0;
+let rotationEventListener: ((event: RotationEvent) => void) | null = null;
+
+/** Register a callback fired whenever a new rotation event is recorded (used by
+ *  the download-manager to push a fresh snapshot to the UI immediately). */
+export function setRotationEventListener(listener: ((event: RotationEvent) => void) | null): void {
+  rotationEventListener = listener;
+}
+
+/** Returns the recent rotation events, newest first. */
+export function getRecentRotationEvents(limit = ROTATION_EVENT_RING_MAX): RotationEvent[] {
+  const slice = rotationEventRing.slice(-limit);
+  slice.reverse();
+  return slice;
+}
+
+/** Events that are noise for the UI panel (per-attempt TEST markers). The panel
+ *  focuses on outcomes: OK / FAILED / FATAL / skips. */
+function isUiRelevantRotationEvent(event: string): boolean {
+  return event !== "TEST";
+}
+
+function pushRotationEvent(
+  level: RotationLevel,
+  provider: string,
+  accountLabel: string,
+  event: string,
+  fields?: Record<string, unknown>,
+  at = Date.now()
+): void {
+  if (!isUiRelevantRotationEvent(event)) {
+    return;
+  }
+  rotationEventSeq += 1;
+  const entry: RotationEvent = {
+    id: `rot_${at}_${rotationEventSeq}`,
+    at,
+    level,
+    provider,
+    accountLabel,
+    event,
+    reason: fields && fields.reason != null ? String(fields.reason) : undefined,
+    category: fields && fields.category != null ? String(fields.category) : undefined,
+    cooldownSec: fields && fields.cooldownSec != null ? Number(fields.cooldownSec) || 0 : undefined,
+    next: fields && fields.next != null ? String(fields.next) : undefined
+  };
+  rotationEventRing.push(entry);
+  if (rotationEventRing.length > ROTATION_EVENT_RING_MAX) {
+    rotationEventRing.splice(0, rotationEventRing.length - ROTATION_EVENT_RING_MAX);
+  }
+  if (rotationEventListener) {
+    try {
+      rotationEventListener(entry);
+    } catch {
+      // never let a UI push break the rotation flow
+    }
+  }
+}
+
 const ROTATION_LOG_MAX_FILE_BYTES = Number(process.env.RD_ACCOUNT_ROTATION_LOG_MAX_BYTES || 5 * 1024 * 1024);
 const ROTATION_LOG_RETENTION_DAYS = Number(process.env.RD_ACCOUNT_ROTATION_LOG_RETENTION_DAYS || 14);
 
@@ -108,6 +173,8 @@ export function logAccountRotation(
   event: string,
   fields?: Record<string, unknown>
 ): void {
+  // Surface to the UI ring buffer regardless of whether the file log is ready.
+  pushRotationEvent(level, provider, accountLabel, event, fields);
   if (!rotationLogPath) {
     return;
   }

src/main/app-controller.ts

@@ -5,6 +5,7 @@ import {
   AddLinksPayload,
   AllDebridHostInfo,
   AppSettings,
+  DebridAccountStatus,
   DebridProvider,
   DuplicatePolicy,
   HistoryEntry,
@@ -23,6 +24,7 @@ import { importDlcContainers } from "./container";
 import { APP_VERSION } from "./constants";
 import { DownloadManager } from "./download-manager";
 import { fetchAllDebridHostInfo, fetchDebridLinkHostLimits } from "./debrid";
+import { checkAllDebridAccounts } from "./account-check";
 import { parseCollectorInput } from "./link-parser";
 import { configureLogger, getLogFilePath, logger } from "./logger";
 import { AllDebridWebFallback } from "./all-debrid-web";
@@ -374,6 +376,19 @@ export class AppController {
     return fetchDebridLinkHostLimits(this.settings.debridLinkApiKeys, host);
   }
 
+  /** Check login validity + premium expiry for ALL configured multi-account
+   *  credentials (Mega-Debrid accounts + Debrid-Link keys), persist the result
+   *  into settings (so badges survive restart), and return the statuses. */
+public async checkDebridAccounts(): Promise<DebridAccountStatus[]> {
+    const statuses = await checkAllDebridAccounts(this.settings);
+    this.manager.applyDebridAccountStatuses(statuses);
+    this.audit("INFO", "Debrid-Accounts geprueft", {
+      total: statuses.length,
+      valid: statuses.filter((s) => s.valid).length,
+      premium: statuses.filter((s) => s.isPremium).length
+    });
+    return statuses;
+  }
   public async checkUpdates(): Promise<UpdateCheckResult> {
     const result = await checkGitHubUpdate(this.settings.updateRepo);
     if (!result.error) {

src/main/constants.ts

@@ -123,6 +123,7 @@ export function defaultSettings(): AppSettings {
     megaDebridAccountDailyLimitBytes: {},
     megaDebridAccountDailyUsageBytes: {},
     megaDebridAccountTotalUsageBytes: {},
+    debridAccountStatuses: {},
     providerDailyUsageDay: getProviderUsageDayKey(),
     scheduledStartEpochMs: 0
   };

src/main/download-manager.ts

@@ -19,12 +19,13 @@ import {
   SessionState,
   StartConflictEntry,
   StartConflictResolutionResult,
-  UiSnapshot
-} from "../shared/types";
+  UiSnapshot, DebridAccountStatus } from "../shared/types";
 import { parseDebridLinkApiKeys } from "../shared/debrid-link-keys";
 import {
   addDebridLinkApiKeyDailyUsageBytes,
   addDebridLinkApiKeyTotalUsageBytes,
+  addMegaDebridAccountDailyUsageBytes,
+  addMegaDebridAccountTotalUsageBytes,
   addProviderDailyUsageBytes,
   addProviderTotalUsageBytes,
   getProviderUsageDayKey,
@@ -55,6 +56,7 @@ import { AllDebridWebUnrestrictor, BestDebridWebUnrestrictor, DebridService, Meg
 import { cleanupArchives, clearExtractResumeState, collectArchiveCleanupTargets, detectArchiveSignature, extractPackageArchives, findArchiveCandidates, hasAnyFilesRecursive, removeEmptyDirectoryTree, resetExtractorCachesForPasswordChange, type ExtractArchiveFailureInfo } from "./extractor";
 import { validateFileAgainstManifest } from "./integrity";
 import { logger } from "./logger";
+import { getRecentRotationEvents, setRotationEventListener } from "./account-rotation-log";
 import { ensureItemLog, getItemLogPath as getPersistedItemLogPath, logItemEvent as writeItemLogEvent } from "./item-log";
 import { ensurePackageLog, getPackageLogPath as getPersistedPackageLogPath, logPackageEvent as writePackageLogEvent } from "./package-log";
 import { logRenameEvent as writeRenameLogEvent } from "./rename-log";
@@ -1808,8 +1810,26 @@ export class DownloadManager extends EventEmitter {
     this.recoverPostProcessingOnStartup();
     this.checkExistingRapidgatorLinks();
     void this.cleanupExistingExtractedArchives().catch((err) => logger.warn(`cleanupExistingExtractedArchives Fehler (constructor): ${compactErrorText(err)}`));
+    // Push a fresh snapshot to the UI whenever a rotation event is recorded so
+    // the live rotation panel updates immediately. The listener is module-global,
+    // so guard against firing on a torn-down manager after shutdown.
+    setRotationEventListener(() => {
+      if (this.rotationListenerActive === false) {
+        return;
+      }
+      try {
+        // Forced emit: rotation happens during the idle link-resolve phase (no
+        // downloads running), where the normal emit cadence can be starved. The
+        // forced path has a 120ms floor — the right cadence for a live log panel.
+        this.emitState(true);
+      } catch {
+        // never let a UI push break the rotation flow
+      }
+    });
   }
 
+  private rotationListenerActive = true;
+
   public getPackageLogPath(packageId: string): string | null {
     const pkg = this.session.packages[packageId];
     if (pkg) {
@@ -2042,6 +2062,17 @@ export class DownloadManager extends EventEmitter {
     }
   }
 
+  public applyDebridAccountStatuses(statuses: DebridAccountStatus[]): void {
+    const map: Record<string, DebridAccountStatus> = { ...(this.settings.debridAccountStatuses || {}) };
+    for (const status of statuses) {
+      map[status.accountId] = status;
+    }
+    this.settings.debridAccountStatuses = map;
+    this.invalidateSettingsSnapshotCache();
+    void saveSettingsAsync(this.storagePaths, this.settings).catch((err) => logger.warn(`saveSettingsAsync Fehler (account-status): ${compactErrorText(err as Error)}`));
+    this.emitState();
+  }
+
   public setSettings(next: AppSettings): void {
     const previous = this.settings;
     next.totalDownloadedAllTime = Math.max(next.totalDownloadedAllTime || 0, this.settings.totalDownloadedAllTime || 0);
@@ -2324,6 +2355,7 @@ export class DownloadManager extends EventEmitter {
       : null;
 
     return {
+      rotationEvents: getRecentRotationEvents(40),
       settings: snapshotSettings,
       session: snapshotSession,
       summary: snapshotSummary,
@@ -5643,6 +5675,7 @@ export class DownloadManager extends EventEmitter {
 
   public prepareForShutdown(): void {
     logger.info(`Shutdown-Vorbereitung gestartet: active=${this.activeTasks.size}, running=${this.session.running}, paused=${this.session.paused}`);
+    this.rotationListenerActive = false;
     this.clearPersistTimer();
     if (this.stateEmitTimer) {
       clearTimeout(this.stateEmitTimer);
@@ -7781,6 +7814,15 @@ export class DownloadManager extends EventEmitter {
       this.settings.debridLinkApiKeyDailyUsageBytes = nextKeyUsage.debridLinkApiKeyDailyUsageBytes;
       this.settings.debridLinkApiKeyTotalUsageBytes = nextKeyTotalUsage.debridLinkApiKeyTotalUsageBytes;
     }
+    // Bug-Fix: Mega-Debrid Per-Account-Verbrauch wurde nie erfasst (nur Debrid-Link),
+    // sodass die "Heute"/"Insgesamt"-Statistik pro Mega-Account immer 0 anzeigte.
+    if ((effectiveProvider === "megadebrid-api" || effectiveProvider === "megadebrid-web") && providerAccountId) {
+      const nextAcctUsage = addMegaDebridAccountDailyUsageBytes(this.settings, providerAccountId, byteDelta);
+      const nextAcctTotalUsage = addMegaDebridAccountTotalUsageBytes(this.settings, providerAccountId, byteDelta);
+      this.settings.providerDailyUsageDay = nextAcctUsage.providerDailyUsageDay;
+      this.settings.megaDebridAccountDailyUsageBytes = nextAcctUsage.megaDebridAccountDailyUsageBytes;
+      this.settings.megaDebridAccountTotalUsageBytes = nextAcctTotalUsage.megaDebridAccountTotalUsageBytes;
+    }
   }
 
   private isProviderConfigured(provider: DebridProvider): boolean {
@@ -7796,12 +7838,12 @@ export class DownloadManager extends EventEmitter {
       return Boolean(this.settings.realDebridUseWebLogin || this.settings.token.trim());
     }
     if (effectiveProvider === "megadebrid-api") {
-      return Boolean(resolveMegaDebridProvider(this.settings, "megadebrid") === "megadebrid-api" && this.settings.megaLogin.trim() && this.settings.megaPassword.trim()
-        || this.settings.megaDebridApiEnabled && this.settings.megaLogin.trim() && this.settings.megaPassword.trim());
+      const hasMegaCreds = Boolean(this.settings.megaCredentials.trim() || (this.settings.megaLogin.trim() && this.settings.megaPassword.trim()));
+      return Boolean(hasMegaCreds && (resolveMegaDebridProvider(this.settings, "megadebrid") === "megadebrid-api" || this.settings.megaDebridApiEnabled));
     }
     if (effectiveProvider === "megadebrid-web") {
-      return Boolean(resolveMegaDebridProvider(this.settings, "megadebrid") === "megadebrid-web" && this.settings.megaLogin.trim() && this.settings.megaPassword.trim()
-        || this.settings.megaDebridWebEnabled && this.settings.megaLogin.trim() && this.settings.megaPassword.trim());
+      const hasMegaCreds = Boolean(this.settings.megaCredentials.trim() || (this.settings.megaLogin.trim() && this.settings.megaPassword.trim()));
+      return Boolean(hasMegaCreds && (resolveMegaDebridProvider(this.settings, "megadebrid") === "megadebrid-web" || this.settings.megaDebridWebEnabled));
     }
     if (effectiveProvider === "bestdebrid") {
       return Boolean(this.settings.bestDebridUseWebLogin || this.settings.bestToken.trim());

src/main/main.ts

@@ -644,6 +644,10 @@ function registerIpcHandlers(): void {
     return controller.getDebridLinkHostLimits();
   });
 
+  ipcMain.handle(IPC_CHANNELS.CHECK_DEBRID_ACCOUNTS, async () => {
+    return controller.checkDebridAccounts();
+  });
+
   ipcMain.handle(IPC_CHANNELS.IMPORT_BACKUP, async () => {
     const options = {
       properties: ["openFile"] as Array<"openFile">,

src/main/storage.ts

@@ -3,7 +3,7 @@ import fsp from "node:fs/promises";
 import path from "node:path";
 import { getDebridLinkApiKeyIds } from "../shared/debrid-link-keys";
 import { getMegaDebridAccountIds } from "../shared/mega-debrid-accounts";
-import { AppSettings, BandwidthScheduleEntry, DebridFallbackProvider, DebridProvider, DownloadItem, DownloadStatus, HistoryEntry, HistoryRetentionMode, PackageEntry, PackagePriority, SessionState } from "../shared/types";
+import { AppSettings, BandwidthScheduleEntry, DebridAccountStatus, DebridFallbackProvider, DebridProvider, DownloadItem, DownloadStatus, HistoryEntry, HistoryRetentionMode, PackageEntry, PackagePriority, SessionState } from "../shared/types";
 import { getProviderUsageDayKey } from "../shared/provider-daily-limits";
 import { defaultSettings } from "./constants";
 import { logger } from "./logger";
@@ -230,6 +230,39 @@ function normalizeNamedByteMap(raw: unknown, allowedKeys: readonly string[]): Re
   return result;
 }
 
+function normalizeDebridAccountStatuses(
+  value: unknown,
+  megaIds: string[],
+  debridLinkIds: string[]
+): Record<string, DebridAccountStatus> {
+  const allowed = new Set([...megaIds, ...debridLinkIds]);
+  const result: Record<string, DebridAccountStatus> = {};
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
+      if (!allowed.has(key) || !raw || typeof raw !== "object") {
+        continue;
+      }
+      const entry = raw as Partial<DebridAccountStatus>;
+      if (typeof entry.accountId !== "string" || typeof entry.checkedAt !== "number") {
+        continue;
+      }
+      result[key] = {
+        accountId: entry.accountId,
+        provider: entry.provider === "debridlink" ? "debridlink" : "megadebrid",
+        label: String(entry.label || ""),
+        maskedLogin: String(entry.maskedLogin || ""),
+        valid: Boolean(entry.valid),
+        isPremium: Boolean(entry.isPremium),
+        premiumUntilMs: typeof entry.premiumUntilMs === "number" ? entry.premiumUntilMs : null,
+        email: typeof entry.email === "string" ? entry.email : undefined,
+        message: String(entry.message || ""),
+        checkedAt: entry.checkedAt
+      };
+    }
+  }
+  return result;
+}
+
 function normalizeStringList(raw: unknown, allowedKeys: readonly string[]): string[] {
   if (!Array.isArray(raw)) {
     return [];
@@ -452,6 +485,7 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
       ? normalizeNamedByteMap(settings.megaDebridAccountDailyUsageBytes, megaDebridAccountIds)
       : {},
     megaDebridAccountTotalUsageBytes: normalizeNamedByteMap(settings.megaDebridAccountTotalUsageBytes, megaDebridAccountIds),
+    debridAccountStatuses: normalizeDebridAccountStatuses(settings.debridAccountStatuses, megaDebridAccountIds, debridLinkApiKeyIds),
     providerDailyUsageDay: providerDailyUsageDay === currentUsageDay ? providerDailyUsageDay : currentUsageDay,
     scheduledStartEpochMs: clampNumber(settings.scheduledStartEpochMs, defaults.scheduledStartEpochMs, 0, Number.MAX_SAFE_INTEGER)
   };