Merge pull request #105 from Masutayunikon/release-please--branches--main

chore(main): release 3.12.0

.claude/settings.local.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(find src:*)",
-      "Bash(find server:*)"
-    ]
-  }
-}

.gitignore

@@ -1,3 +1,6 @@
+# Claude Code
+.claude/
+
 # Logs
 logs
 *.log

CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [3.12.0](https://github.com/Masutayunikon/FanKarr/compare/v3.11.5...v3.12.0) (2026-04-29)
+
+
+### Features
+
+* désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission ([2446622](https://github.com/Masutayunikon/FanKarr/commit/24466228ef5305c36574f58fb2590aee8ee86e13))
+* désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission ([fcb1b88](https://github.com/Masutayunikon/FanKarr/commit/fcb1b88870bebb1bf0b4e484b2462e56ab3975fc))
+* désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission ([3fb4119](https://github.com/Masutayunikon/FanKarr/commit/3fb4119c79908c1023f3cbf9999b524eb1bc267e))
+
+
+### Bug Fixes
+
+* qbitorrent ([9834023](https://github.com/Masutayunikon/FanKarr/commit/98340235226394c4583159f36cce74e316eedf26))
+* qbitorrent header ([f5094c6](https://github.com/Masutayunikon/FanKarr/commit/f5094c68c6834f816b0b6d019e5d5637400e16ab))
+* spinner infinie apres supression ([39d2f99](https://github.com/Masutayunikon/FanKarr/commit/39d2f996aecb9f07dcd8c1ec7911090276908a2f))
+* spinner infinie apres supression ([97c573c](https://github.com/Masutayunikon/FanKarr/commit/97c573cc1d4fb76787ba5d1df4fda30faec5fbf2))
+* **UI/UX:** chevron pour ouvrir la description, bouton desimporter de la serie passer à supprimer et affichage de toute la description de la serie lors d'un clique ([f6ef818](https://github.com/Masutayunikon/FanKarr/commit/f6ef818e60875a1ac5d859480c1e0e53082c0858))
+* **UI/UX:** meilleur comprehension des parametres avancés des clients ([040a8d7](https://github.com/Masutayunikon/FanKarr/commit/040a8d7b339090d819c6e3dc049f1ab9d8b221f5))
+
+## [3.11.5](https://github.com/Masutayunikon/FanKarr/compare/v3.11.4...v3.11.5) (2026-04-26)
+
+
+### Bug Fixes
+
+* le folder picker affiche tous les disques depuis le bouton homes sous windows ([7149022](https://github.com/Masutayunikon/FanKarr/commit/7149022c8701f79d194c675da87c6cb2d5793a35))
+
+## [3.11.4](https://github.com/Masutayunikon/FanKarr/compare/v3.11.3...v3.11.4) (2026-04-26)
+
+
+### Bug Fixes
+
+* ajout de la mise a jour des noms toutes les 1h ([0fe5c8c](https://github.com/Masutayunikon/FanKarr/commit/0fe5c8ccb7ecdc1643b5e69de3957c39dfd8085e))
+
 ## [3.11.3](https://github.com/Masutayunikon/FanKarr/compare/v3.11.2...v3.11.3) (2026-04-26)
 
 

server/index.ts

@@ -11,7 +11,7 @@ import transmissionDriver from './torrent-clients/transmission.js'
 import synologyDsDriver   from './torrent-clients/synology-ds.js'
 import utorrentDriver     from './torrent-clients/utorrent.js'
 import rtorrentDriver     from './torrent-clients/rtorrent.js'
-import { autoOrganizeAll, scanMediaPath } from './organize.js'
+import { autoOrganizeAll, scanMediaPath, syncFilenameChanges } from './organize.js'
 import { logger } from './logger.js'
 import { DATA_DIR, BASE_DIR } from './config.js'
 import { readAvailable, readInfohashMap, loadEnrichedSeriesData } from './lib/github-cache.js'
@@ -139,4 +139,17 @@ server.listen(PORT, async () => {
             checkNfoUpdates().catch(err => logger.error('nfo-update', `Vérif horaire échouée : ${err instanceof Error ? err.message : err}`))
         }, 60 * 60_000)
     }, 30_000)
+
+    // Sync automatique des noms de fichiers toutes les heures.
+    // Le TTL du cache GitHub est de 1h — ce setInterval tire toujours sur des données fraîches.
+    setInterval(async () => {
+        try {
+            const seriesData = await loadEnrichedSeriesData()
+            const { renamed } = await syncFilenameChanges(seriesData, path.join(DATA_DIR, 'organized.json'))
+            if (renamed > 0)
+                logger.info('api', `Sync noms auto — ${renamed} fichier(s) renommé(s)`)
+        } catch (err) {
+            logger.error('api', `Sync noms auto échoué : ${err instanceof Error ? err.message : err}`)
+        }
+    }, 60 * 60_000)
 })

server/routes/downloads.ts

@@ -19,9 +19,10 @@ router.post('/download', requireAuth, async (req, res) => {
     const url = torrent_url ?? magnet
     if (!url) { res.status(400).json({ error: 'torrent_url ou magnet requis' }); return }
     const file_index: number | null = req.body.file_index != null ? Number(req.body.file_index) : null
-    const file_path : string | null = req.body.file_path ?? null
-    logger.info('api', `Téléchargement demandé via ${torrent_url ? '.torrent' : 'magnet'}${file_index != null ? ` (fichier #${file_index})` : ''}`)
-    const results = await dispatchDownload(url, { file_index, file_path, magnet })
+    const file_path : string | null = req.body.file_path  ?? null
+    const infohash  : string | null = req.body.infohash   ?? null
+    logger.info('api', `Téléchargement demandé via ${torrent_url ? '.torrent' : 'magnet'}${file_path ? ` (${file_path})` : ''}`)
+    const results = await dispatchDownload(url, { file_index, file_path, infohash, magnet })
     res.status(results.every((r: any) => r.ok) ? 200 : 207).json({ results })
 })
 

server/routes/import.ts

@@ -8,6 +8,7 @@ import { readSettings } from '../settings.js'
 import { getGitlabTitle } from '../gitlab-map.js'
 import { readSerieData, loadEnrichedSeriesData } from '../lib/github-cache.js'
 import { GITLAB_API_NFO, GITLAB_RAW_NFO } from '../lib/nfo.js'
+import { dispatchRemove } from '../torrent-clients/index.js'
 
 const router = Router()
 
@@ -222,6 +223,7 @@ router.delete('/organized/:serieId', requireAuth, async (req, res) => {
     }
     let removed = 0
     const errors: string[] = []
+    const emptyHashes: string[] = []
     for (const [hash, episodes] of Object.entries(organized)) {
         for (const epId of Object.keys(episodes)) {
             if (!episodeIds.has(epId)) continue
@@ -232,10 +234,53 @@ router.delete('/organized/:serieId', requireAuth, async (req, res) => {
             delete organized[hash][epId]
             removed++
         }
-        if (Object.keys(organized[hash]).length === 0) delete organized[hash]
+        if (Object.keys(organized[hash]).length === 0) { delete organized[hash]; emptyHashes.push(hash) }
     }
     saveOrganizedJson(organized)
-    logger.info('api', `Désimport série ${serieId} — ${removed} épisode(s) retirés`)
+    if (deleteFile) {
+        for (const hash of emptyHashes) {
+            if (hash === 'manual') continue
+            dispatchRemove(hash, false).catch(err => logger.warn('api', `Impossible de retirer le torrent ${hash.slice(0, 8)}… du client : ${err instanceof Error ? err.message : err}`))
+        }
+    }
+    logger.info('api', `Désimport série ${serieId} — ${removed} épisode(s) retirés${deleteFile && emptyHashes.length ? `, ${emptyHashes.length} torrent(s) retirés du client` : ''}`)
+    res.json({ ok: true, removed, errors })
+})
+
+// ── Désimport saison ───────────────────────────────────────────
+router.delete('/organized/:serieId/seasons/:seasonId', requireAuth, async (req, res) => {
+    const serieId    = String(req.params.serieId)
+    const seasonId   = Number(req.params.seasonId)
+    const deleteFile = req.query.deleteFile === 'true'
+    const organized  = loadOrganizedJson()
+    const sd = await readSerieData(Number(serieId))
+    if (!sd) { res.status(404).json({ error: 'Série introuvable' }); return }
+    const season = sd.seasons?.find((s: any) => s.id === seasonId)
+    if (!season) { res.status(404).json({ error: 'Saison introuvable' }); return }
+    const episodeIds = new Set<string>(season.episodes?.map((e: any) => String(e.id)) ?? [])
+    let removed = 0
+    const errors: string[] = []
+    const emptyHashes: string[] = []
+    for (const [hash, episodes] of Object.entries(organized)) {
+        for (const epId of Object.keys(episodes)) {
+            if (!episodeIds.has(epId)) continue
+            const entry = episodes[epId]
+            if (deleteFile && entry?.dest_path && fs.existsSync(entry.dest_path)) {
+                try { fs.unlinkSync(entry.dest_path) } catch { errors.push(entry.dest_path) }
+            }
+            delete organized[hash][epId]
+            removed++
+        }
+        if (Object.keys(organized[hash]).length === 0) { delete organized[hash]; emptyHashes.push(hash) }
+    }
+    saveOrganizedJson(organized)
+    if (deleteFile) {
+        for (const hash of emptyHashes) {
+            if (hash === 'manual') continue
+            dispatchRemove(hash, false).catch(err => logger.warn('api', `Impossible de retirer le torrent ${hash.slice(0, 8)}… du client : ${err instanceof Error ? err.message : err}`))
+        }
+    }
+    logger.info('api', `Désimport saison ${seasonId} (série ${serieId}) — ${removed} épisode(s) retirés${deleteFile && emptyHashes.length ? `, ${emptyHashes.length} torrent(s) retirés du client` : ''}`)
     res.json({ ok: true, removed, errors })
 })
 
@@ -256,9 +301,14 @@ router.delete('/organized/:serieId/:episodeId', requireAuth, async (req, res) =>
             logger.info('api', `Désimport + suppression fichier : "${foundEntry.dest_path}"`)
         }
         delete organized[foundHash][episodeId]
-        if (Object.keys(organized[foundHash]).length === 0) delete organized[foundHash]
+        const torrentEmpty = Object.keys(organized[foundHash]).length === 0
+        if (torrentEmpty) delete organized[foundHash]
         saveOrganizedJson(organized)
-        logger.info('api', `Désimport ep ${episodeId}`)
+        // Si plus aucun épisode de ce torrent n'est importé → retirer le torrent du client
+        if (deleteFile && torrentEmpty && foundHash !== 'manual') {
+            dispatchRemove(foundHash, false).catch(err => logger.warn('api', `Impossible de retirer le torrent ${foundHash.slice(0, 8)}… du client : ${err instanceof Error ? err.message : err}`))
+        }
+        logger.info('api', `Désimport ep ${episodeId}${deleteFile && torrentEmpty ? ` + torrent ${foundHash.slice(0, 8)}… retiré du client` : ''}`)
         res.json({ ok: true })
     } catch (err) {
         const msg = err instanceof Error ? err.message : 'Erreur inconnue'

server/routes/system.ts

@@ -47,11 +47,36 @@ router.get('/version', (_req, res) => {
 
 // ── Parcours fichiers ──────────────────────────────────────────
 router.get('/browse', requireAuth, (req, res) => {
-    const dirPath = (req.query.path as string) || '/'
+    const isWindows = process.platform === 'win32'
+    const dirPath   = (req.query.path as string) || '/'
+
+    // ── Racine virtuelle Windows : liste les lecteurs disponibles ──
+    if (isWindows && dirPath === '/') {
+        const drives: string[] = []
+        for (const letter of 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') {
+            const d = `${letter}:\\`
+            try { fs.readdirSync(d); drives.push(d) } catch {}
+        }
+        res.json({ path: '/', parent: null, dirs: drives, drivesRoot: true })
+        return
+    }
+
     try {
         const entries = fs.readdirSync(dirPath, { withFileTypes: true })
         const dirs    = entries.filter(e => e.isDirectory()).map(e => e.name).filter(n => !n.startsWith('.')).sort((a, b) => a.localeCompare(b))
-        res.json({ path: dirPath, parent: dirPath === '/' ? null : path.dirname(dirPath), dirs })
+
+        // Sur Windows, remonter à '/' quand on est à la racine d'un lecteur (ex: C:\)
+        let parent: string | null
+        if (dirPath === '/') {
+            parent = null
+        } else if (isWindows && /^[A-Za-z]:\\?$/.test(dirPath)) {
+            parent = '/'
+        } else {
+            const up = path.dirname(dirPath)
+            parent   = up === dirPath ? null : up   // dirname de C:\ retourne C:\ → null
+        }
+
+        res.json({ path: dirPath, parent, dirs })
     } catch (err) {
         logger.warn('api', `Lecture dossier "${dirPath}" impossible : ${err instanceof Error ? err.message : err}`)
         res.status(400).json({ error: err instanceof Error ? err.message : 'Erreur lecture dossier' })

server/torrent-clients/index.ts

@@ -59,7 +59,8 @@ export interface TorrentInfo {
 export interface DownloadOptions {
     file_index?: number | null
     file_path ?: string | null
-    magnet    ?: string | null   // conservé pour extraire le hash même quand on envoie le .torrent
+    infohash  ?: string | null   // hash direct depuis les données API (plus fiable que parser le magnet)
+    magnet    ?: string | null   // fallback pour extraire le hash si infohash absent
 }
 
 export interface TorrentClientDriver {

server/torrent-clients/qbittorrent.ts

@@ -48,9 +48,8 @@ async function qbTorrentExists(config: Record<string, string | number>, sid: str
 }
 
 /**
- * Attend que les métadonnées soient disponibles, applique les priorités, puis reprend le torrent.
- * Utilisé après un ajout avec stopCondition=MetadataReceived (qBit actif → auto-pause après metadata)
- * ou pour un torrent déjà présent (resume=false, juste mise à jour de priorité).
+ * Attend que les fichiers soient disponibles, résout l'index par chemin si possible,
+ * applique les priorités, puis reprend le torrent.
  */
 async function qbApplyFilePriority(
     config   : Record<string, string | number>,
@@ -70,55 +69,72 @@ async function qbApplyFilePriority(
             const files: any[] = await res.json()
             if (!Array.isArray(files) || files.length === 0) continue
 
+            if (fileIndex >= files.length) {
+                throw new Error(`Index fichier ${fileIndex} hors limites (torrent a ${files.length} fichiers)`)
+            }
+
             // Si tous les fichiers sont à priorité normale (état initial du torrent),
             // on applique le filtrage complet : on désactive tout sauf la cible.
             // Si certains sont déjà à 0 (filtrage déjà effectué pour un épisode précédent),
             // on se contente d'activer la nouvelle cible sans toucher aux autres.
             const isInitialState = files.every((f: any) => (f.priority ?? 1) > 0)
 
+            const headers = { Cookie: `SID=${sid}`, 'Content-Type': 'application/x-www-form-urlencoded' }
+
             if (isInitialState) {
                 const unwanted = files.map((_, i) => i).filter(i => i !== fileIndex)
                 if (unwanted.length > 0) {
-                    const form = new FormData()
-                    form.append('hash', hash)
-                    form.append('id', unwanted.join('|'))
-                    form.append('priority', '0')
-                    await fetch(`${config.url}/api/v2/torrents/filePrio`, { method: 'POST', body: form, headers: { Cookie: `SID=${sid}` } })
+                    const body = new URLSearchParams({ hash, id: unwanted.join('|'), priority: '0' })
+                    const r = await fetch(`${config.url}/api/v2/torrents/filePrio`, { method: 'POST', body, headers })
+                    if (!r.ok) { logger.warn('qbittorrent', `filePrio désactivation échouée (${r.status}) — retry`); continue }
                 }
             }
 
             // Activer le fichier cible (dans tous les cas)
-            const form2 = new FormData()
-            form2.append('hash', hash)
-            form2.append('id', String(fileIndex))
-            form2.append('priority', '1')
-            await fetch(`${config.url}/api/v2/torrents/filePrio`, { method: 'POST', body: form2, headers: { Cookie: `SID=${sid}` } })
+            const r2 = await fetch(`${config.url}/api/v2/torrents/filePrio`, {
+                method: 'POST',
+                body   : new URLSearchParams({ hash, id: String(fileIndex), priority: '1' }),
+                headers,
+            })
+            if (!r2.ok) { logger.warn('qbittorrent', `filePrio activation échouée (${r2.status}) — retry`); continue }
 
-            // Reprendre (torrent auto-mis en pause par stopCondition=MetadataReceived)
+            // Vérification : le fichier cible est bien à priorité > 0
+            const verif = await fetch(`${config.url}/api/v2/torrents/files?hash=${hash}`, { headers: { Cookie: `SID=${sid}` } })
+            if (verif.ok) {
+                const verifiedFiles: any[] = await verif.json()
+                const target = verifiedFiles[fileIndex]
+                if (!target || (target.priority ?? 0) === 0) {
+                    logger.warn('qbittorrent', `Fichier ${fileIndex} toujours à priorité 0 après application — retry`)
+                    continue
+                }
+            }
+
+            // Reprendre (torrent mis en pause via paused/stopped à l'ajout)
             // On appelle les deux endpoints : resume (qBit ≤ 4.x) et start (qBit ≥ 5.0)
             if (resume) {
-                const resumeForm = new FormData()
-                resumeForm.append('hashes', hash)
+                const resumeBody = new URLSearchParams({ hashes: hash })
                 await Promise.allSettled([
-                    fetch(`${config.url}/api/v2/torrents/resume`, { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
-                    fetch(`${config.url}/api/v2/torrents/start`,  { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
+                    fetch(`${config.url}/api/v2/torrents/resume`, { method: 'POST', body: resumeBody, headers }),
+                    fetch(`${config.url}/api/v2/torrents/start`,  { method: 'POST', body: resumeBody, headers }),
                 ])
             }
 
             logger.info('qbittorrent', `Fichier ${fileIndex} sélectionné${resume ? ' + reprise' : ''} pour ${hash.slice(0, 8)}…`)
             return
-        } catch {}
+        } catch (err) {
+            if (err instanceof Error && err.message.includes('hors limites')) throw err
+        }
     }
 
     // Timeout : reprendre quand même pour ne pas laisser le torrent bloqué
     if (resume) {
         try {
-            const sid = await qbLogin(config)
-            const resumeForm = new FormData()
-            resumeForm.append('hashes', hash)
+            const sid     = await qbLogin(config)
+            const headers = { Cookie: `SID=${sid}`, 'Content-Type': 'application/x-www-form-urlencoded' }
+            const body    = new URLSearchParams({ hashes: hash })
             await Promise.allSettled([
-                fetch(`${config.url}/api/v2/torrents/resume`, { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
-                fetch(`${config.url}/api/v2/torrents/start`,  { method: 'POST', body: resumeForm, headers: { Cookie: `SID=${sid}` } }),
+                fetch(`${config.url}/api/v2/torrents/resume`, { method: 'POST', body, headers }),
+                fetch(`${config.url}/api/v2/torrents/start`,  { method: 'POST', body, headers }),
             ])
         } catch {}
     }
@@ -216,32 +232,42 @@ const QB: TorrentClientDriver = {
     async add(config, url, options?: DownloadOptions) {
         const sid = await qbLogin(config)
 
-        // Extraire le hash depuis l'URL (si magnet) ou depuis options.magnet (si .torrent URL)
-        const hashMatch = url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
-                       ?? options?.magnet?.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
-        const hash      = hashMatch?.[1]?.toLowerCase() ?? null
+        // Priorité : infohash direct (depuis les données API) > parsing du magnet/URL
+        const hash = (options?.infohash?.toLowerCase() ?? null)
+                  || url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)?.[1]?.toLowerCase()
+                  || options?.magnet?.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)?.[1]?.toLowerCase()
+                  || null
 
-        if (options?.file_index != null && hash) {
-            const exists = await qbTorrentExists(config, sid, hash)
-
-            if (exists) {
-                // Torrent déjà présent → mettre à jour la priorité directement (async OK)
-                logger.info('qbittorrent', `Torrent ${hash.slice(0, 8)}… déjà présent, mise à jour priorité fichier ${options.file_index}`)
-                qbApplyFilePriority(config, hash, options.file_index, false).catch(err =>
-                    logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
-                )
-                return
+        if (options?.file_index != null) {
+            if (hash) {
+                const exists = await qbTorrentExists(config, sid, hash)
+                if (exists) {
+                    logger.info('qbittorrent', `Torrent ${hash.slice(0, 8)}… déjà présent, mise à jour priorité fichier ${options.file_index}`)
+                    qbApplyFilePriority(config, hash, options.file_index, false).catch(err =>
+                        logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
+                    )
+                    return
+                }
             }
 
-            // Nouveau torrent → ajout actif avec stopCondition=MetadataReceived
-            // qBit fetch les métadonnées normalement via DHT/peers,
-            // puis se met en pause automatiquement dès qu'elles sont disponibles.
-            // On set les priorités sur la pause, puis on reprend. Zéro data indésirable.
+            // Snapshot des hashes avant ajout (pour retrouver le nouveau si hash inconnu)
+            let knownHashes: Set<string> = new Set()
+            if (!hash) {
+                try {
+                    const lr = await fetch(`${config.url}/api/v2/torrents/info`, { headers: { Cookie: `SID=${sid}` } })
+                    if (lr.ok) knownHashes = new Set((await lr.json()).map((t: any) => String(t.hash).toLowerCase()))
+                } catch {}
+            }
+
+            // Ajout du torrent en pause immédiate (toutes versions qBit)
+            // paused=true  → qBit < 5.0
+            // stopped=true → qBit ≥ 5.0
             const form = new FormData()
             form.append('urls', url)
             if (config.category) form.append('category', String(config.category))
             if (config.savePath)  form.append('savepath', String(config.savePath))
-            form.append('stopCondition', 'MetadataReceived')  // qBit ≥ 4.6
+            form.append('paused',  'true')
+            form.append('stopped', 'true')
 
             const res  = await fetch(`${config.url}/api/v2/torrents/add`, {
                 method: 'POST', body: form, headers: { Cookie: `SID=${sid}` },
@@ -249,10 +275,33 @@ const QB: TorrentClientDriver = {
             const text = await res.text()
             if (text !== 'Ok.') throw new Error(`Ajout échoué : ${text}`)
 
-            logger.info('qbittorrent', `Torrent ajouté (stopCondition=MetadataReceived, sélection fichier ${options.file_index} en attente)`)
-            qbApplyFilePriority(config, hash, options.file_index, true).catch(err =>
-                logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
-            )
+            if (hash) {
+                logger.info('qbittorrent', `Torrent ajouté (en pause, sélection fichier ${options.file_index} en attente)`)
+                qbApplyFilePriority(config, hash, options.file_index, true).catch(err =>
+                    logger.warn('qbittorrent', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
+                )
+            } else {
+                // Hash inconnu (pas d'infohash, pas de magnet) → retrouve le nouveau torrent par diff de liste
+                logger.info('qbittorrent', `Torrent ajouté sans hash connu — recherche dans la liste (sélection fichier ${options.file_index})`)
+                const fileIndex = options.file_index
+                ;(async () => {
+                    for (let attempt = 0; attempt < 20; attempt++) {
+                        await new Promise(r => setTimeout(r, 500))
+                        try {
+                            const s  = await qbLogin(config)
+                            const lr = await fetch(`${config.url}/api/v2/torrents/info`, { headers: { Cookie: `SID=${s}` } })
+                            if (!lr.ok) continue
+                            const newT = (await lr.json()).find((t: any) => !knownHashes.has(String(t.hash).toLowerCase()))
+                            if (!newT) continue
+                            const resolvedHash = String(newT.hash).toLowerCase()
+                            logger.info('qbittorrent', `Hash résolu : ${resolvedHash.slice(0, 8)}… — application priorité fichier ${fileIndex}`)
+                            await qbApplyFilePriority(config, resolvedHash, fileIndex, true)
+                            return
+                        } catch {}
+                    }
+                    logger.warn('qbittorrent', `Impossible de résoudre le hash pour appliquer la priorité fichier ${fileIndex}`)
+                })().catch(() => {})
+            }
             return
         }
 

server/torrent-clients/transmission.ts

@@ -52,6 +52,44 @@ async function trRequest(
     return { ...data, sessionId }
 }
 
+async function trGetIdByHash(config: Record<string, string | number>, hash: string): Promise<number | null> {
+    const data     = await trRequest(config, 'torrent-get', { fields: ['hashString', 'id'] })
+    const torrents = data.arguments?.torrents ?? []
+    return torrents.find((t: any) => t.hashString?.toLowerCase() === hash.toLowerCase())?.id ?? null
+}
+
+/**
+ * Attend que les métadonnées soient disponibles (polling 500 ms),
+ * puis applique les priorités : fichier cible voulu, tous les autres ignorés.
+ */
+async function trApplyFilePriority(
+    config   : Record<string, string | number>,
+    hash     : string,
+    fileIndex: number,
+): Promise<void> {
+    for (let attempt = 0; attempt < 100; attempt++) {
+        await new Promise(r => setTimeout(r, 500))
+        try {
+            const id = await trGetIdByHash(config, hash)
+            if (id == null) continue
+
+            const data  = await trRequest(config, 'torrent-get', { ids: [id], fields: ['files'] })
+            const files = data.arguments?.torrents?.[0]?.files
+            if (!Array.isArray(files) || files.length === 0) continue
+
+            const unwanted = files.map((_: any, i: number) => i).filter((i: number) => i !== fileIndex)
+            await trRequest(config, 'torrent-set', {
+                ids              : [id],
+                'files-wanted'   : [fileIndex],
+                'files-unwanted' : unwanted,
+            })
+            logger.info('transmission', `Fichier ${fileIndex} sélectionné pour ${hash.slice(0, 8)}…`)
+            return
+        } catch {}
+    }
+    throw new Error(`Timeout : métadonnées non disponibles pour ${hash.slice(0, 8)}…`)
+}
+
 const TR: TorrentClientDriver = {
     definition: {
         id    : 'transmission',
@@ -96,7 +134,7 @@ const TR: TorrentClientDriver = {
             'hashString', 'name', 'status', 'percentDone', 'totalSize',
             'downloadedEver', 'uploadedEver', 'uploadRatio',
             'rateDownload', 'rateUpload', 'eta', 'downloadDir', 'labels',
-            'fileStats',   // progression par fichier (bytesCompleted + length)
+            'files',  // bytesCompleted + length par fichier (fileStats n'a pas 'length')
         ]
         const data = await trRequest(config, 'torrent-get', { fields })
         const torrents: any[] = data.arguments?.torrents ?? []
@@ -120,42 +158,36 @@ const TR: TorrentClientDriver = {
                 eta       : t.eta ?? -1,
                 save_path : t.downloadDir,
                 category  : t.labels?.[0] ?? '',
-                files     : Array.isArray(t.fileStats) && t.fileStats.length > 0
-                    ? t.fileStats.map((fs: any, i: number) => ({
+                files     : Array.isArray(t.files) && t.files.length > 0
+                    ? t.files.map((f: any, i: number) => ({
                         index   : i,
-                        progress: fs.length > 0 ? Math.round((fs.bytesCompleted / fs.length) * 100) : 0,
+                        progress: f.length > 0 ? Math.round((f.bytesCompleted / f.length) * 100) : 0,
                     }))
                     : undefined,
             } satisfies TorrentInfo))
     },
 
     async add(config, url, options?: DownloadOptions) {
-        const args: Record<string, unknown> = { filename: url }
+        const hashMatch = url.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
+                       ?? options?.magnet?.match(/xt=urn:btih:([a-fA-F0-9]{40,})/i)
+        const hash      = hashMatch?.[1]?.toLowerCase() ?? null
 
+        const args: Record<string, unknown> = { filename: url }
         if (config.savePath) args['download-dir'] = String(config.savePath)
         if (config.category) args['labels']        = [String(config.category)]
 
-        // Transmission applique files-wanted après récupération des métadonnées,
-        // sans démarrer les autres fichiers entre-temps — natif et fiable.
-        if (options?.file_index != null) {
-            args['files-wanted'] = [options.file_index]
-        }
-
         const res = await trRequest(config, 'torrent-add', args)
 
-        // Torrent déjà présent → Transmission renvoie torrent-duplicate
-        // On s'assure quand même que le fichier voulu est activé
-        if (options?.file_index != null && res.arguments?.['torrent-duplicate']) {
-            const dup = res.arguments['torrent-duplicate']
-            try {
-                await trRequest(config, 'torrent-set', {
-                    ids           : [dup.id],
-                    'files-wanted': [options.file_index],
-                })
-                logger.info('transmission', `Torrent ${dup.hashString?.slice(0, 8)}… déjà présent, fichier ${options.file_index} activé`)
-            } catch (err) {
-                logger.warn('transmission', `Activation fichier sur torrent existant échouée : ${err instanceof Error ? err.message : err}`)
+        if (options?.file_index != null && hash) {
+            const isDuplicate = !!res.arguments?.['torrent-duplicate']
+            if (isDuplicate) {
+                logger.info('transmission', `Torrent ${hash.slice(0, 8)}… déjà présent, mise à jour priorité fichier ${options.file_index}`)
+            } else {
+                logger.info('transmission', `Torrent ajouté (sélection fichier ${options.file_index} en attente de métadonnées)`)
             }
+            trApplyFilePriority(config, hash, options.file_index).catch(err =>
+                logger.warn('transmission', `Priorité fichier non appliquée : ${err instanceof Error ? err.message : err}`)
+            )
             return
         }
 

src/components/FolderPicker.vue

@@ -14,7 +14,7 @@
 
         <!-- Chemin éditable -->
         <div class="px-5 py-3 border-b border-border shrink-0 flex gap-2">
-          <button @click="navigateTo('/')" class="btn-secondary px-2 text-muted hover:text-primary" title="Retour à la racine">
+          <button @click="navigateTo('/')" class="btn-secondary px-2 text-muted hover:text-primary" :title="drivesRoot ? 'Lecteurs' : 'Retour à la racine'">
             <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
               <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>
               <polyline points="9 22 9 12 15 12 15 22"/>
@@ -85,12 +85,13 @@ import { ref, watch } from 'vue'
 const props = defineProps<{ initialPath?: string }>()
 const emit  = defineEmits<{ select: [path: string]; cancel: [] }>()
 
-const current   = ref(props.initialPath || '/')
-const inputPath = ref(current.value)
-const dirs      = ref<string[]>([])
-const parent    = ref<string | null>(null)
-const loading   = ref(false)
-const error     = ref('')
+const current    = ref(props.initialPath || '/')
+const inputPath  = ref(current.value)
+const dirs       = ref<string[]>([])
+const parent     = ref<string | null>(null)
+const loading    = ref(false)
+const error      = ref('')
+const drivesRoot = ref(false)   // true quand la liste affiche les lecteurs Windows
 
 // FIX : la regex /\/+$/ dans un @click inline fait planter le parser Vue
 function selectCurrent() {
@@ -98,8 +99,10 @@ function selectCurrent() {
 }
 
 function joinPath(base: string, name: string): string {
+  // Lecteur Windows complet (ex: "C:\") → chemin absolu, pas de jointure
+  if (/^[A-Za-z]:\\$/.test(name)) return name
   if (base === '/') return `/${name}`
-  const cleanBase = base.endsWith('/') ? base.slice(0, -1) : base
+  const cleanBase = base.replace(/[\\/]+$/, '')
   return `${cleanBase}/${name}`
 }
 
@@ -114,10 +117,11 @@ async function navigateTo(p: string) {
       return
     }
     const data  = await res.json()
-    current.value   = data.path
-    inputPath.value = data.path
-    parent.value    = data.parent
-    dirs.value      = data.dirs
+    current.value    = data.path
+    inputPath.value  = data.path
+    parent.value     = data.parent
+    dirs.value       = data.dirs
+    drivesRoot.value = data.drivesRoot ?? false
   } catch {
     error.value = 'Impossible de lire ce dossier'
   } finally {

src/components/serie/SerieHero.vue

@@ -39,7 +39,12 @@
           >{{ serie.status }}</span>
         </div>
 
-        <p v-if="serie.plot" class="text-sm text-secondary leading-relaxed max-w-2xl line-clamp-3">
+        <p
+            v-if="serie.plot"
+            @click="expanded = !expanded"
+            class="text-sm text-secondary leading-relaxed max-w-2xl cursor-pointer select-none transition-all"
+            :class="expanded ? '' : 'line-clamp-3'"
+        >
           {{ serie.plot }}
         </p>
       </div>
@@ -48,8 +53,10 @@
 </template>
 
 <script setup lang="ts">
+import { ref } from 'vue'
 import { RouterLink } from 'vue-router'
 import { ArrowLeft, Tv } from 'lucide-vue-next'
 
 defineProps<{ serie: any }>()
+const expanded = ref(false)
 </script>

src/components/serie/SerieSeasonCard.vue

@@ -31,6 +31,15 @@
 
       <!-- Boutons saison -->
       <div class="flex items-center gap-2">
+        <!-- Corbeille saison -->
+        <button
+            v-if="season.organized_count > 0"
+            @click.stop="openUnimportSeasonModal"
+            class="w-8 h-8 rounded-lg border flex items-center justify-center transition-colors border-red-500/30 text-red-400 bg-red-500/10 hover:bg-red-500/20"
+            title="Désimporter la saison"
+        >
+          <Trash2 :size="14" />
+        </button>
         <!-- Pas de pack saison : bouton "Saison" (dropdown si plusieurs packs via intégrales) -->
         <template v-if="season.torrents.length === 0 && hasDownloadable">
           <div v-if="uniquePackOptions.length > 1" class="relative" @click.stop>
@@ -169,8 +178,8 @@
             </div>
           </div>
 
-          <!-- Bouton état épisode (dropdown si plusieurs options) -->
-          <div class="relative shrink-0" @click.stop>
+          <!-- Bouton téléchargement épisode (uniquement si non organisé) -->
+          <div v-if="!ep.organized" class="relative shrink-0" @click.stop>
             <button
                 class="w-8 h-8 rounded-lg border flex items-center justify-center transition-colors"
                 :class="epBtnClass(ep)"
@@ -180,7 +189,7 @@
               <component :is="epStateIcon(ep)" />
             </button>
             <!-- Dropdown quand plusieurs options de torrent -->
-            <div v-if="epOptionsOpen === ep.id && !ep.organized && ep.torrents && ep.torrents.length > 1"
+            <div v-if="epOptionsOpen === ep.id && ep.torrents && ep.torrents.length > 1"
                  class="absolute right-0 bottom-full mb-1 bg-card border border-border rounded-xl p-1 z-20 w-52 shadow-xl flex flex-col gap-0.5">
               <button
                   v-for="(t, i) in ep.torrents"
@@ -188,7 +197,7 @@
                   class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-primary hover:bg-hover transition-colors"
                   :class="(isDownloaded(`ep-${ep.id}-${i}`) || isAlreadyQueued(t)) ? 'opacity-50 cursor-not-allowed' : ''"
                   :disabled="isDownloaded(`ep-${ep.id}-${i}`) || isAlreadyQueued(t)"
-                  @click="!isDownloaded(`ep-${ep.id}-${i}`) && !isAlreadyQueued(t) && (emit('download', `ep-${ep.id}-${i}`, t.torrent_url, t.magnet, t.file_index ?? null, t.file_path ?? null), epOptionsOpen = null)"
+                  @click="!isDownloaded(`ep-${ep.id}-${i}`) && !isAlreadyQueued(t) && (emit('download', `ep-${ep.id}-${i}`, t.torrent_url, t.magnet, t.file_index ?? null, t.file_path ?? null, t.infohash ?? null), epOptionsOpen = null)"
               >
                 <component :is="(isDownloaded(`ep-${ep.id}-${i}`) || isAlreadyQueued(t)) ? checkIcon : downloadIcon" />
                 {{ groupLabels(ep.torrents)[i] }}
@@ -198,35 +207,35 @@
 
           <!-- Actions épisode importé -->
           <template v-if="ep.organized && organizedByEpisode[String(ep.id)]">
-            <span
+            <!-- Badge rename cliquable -->
+            <button
                 v-if="epNeedsRename(ep)"
-                class="shrink-0 text-[10px] px-1.5 py-0.5 rounded border bg-yellow-500/10 text-yellow-400 border-yellow-500/20 cursor-default"
+                @click.stop="emit('renameEpisode', ep, season)"
+                :disabled="epActionLoading[ep.id]"
+                class="shrink-0 text-[10px] px-1.5 py-0.5 rounded border bg-yellow-500/10 text-yellow-400 border-yellow-500/20 hover:bg-yellow-500/20 transition-colors"
                 :title="`Actuel : ${organizedByEpisode[String(ep.id)]?.dest_filename}\nAttendu : ${epExpectedName(ep)}`"
-            >Rename</span>
-
-            <div class="relative" @click.stop>
-              <button
-                  @click="epMenuOpen = epMenuOpen === ep.id ? null : ep.id"
-                  class="w-6 h-6 flex items-center justify-center rounded text-muted hover:text-primary transition-colors"
-              >
-                <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor"><circle cx="12" cy="5" r="1.5"/><circle cx="12" cy="12" r="1.5"/><circle cx="12" cy="19" r="1.5"/></svg>
-              </button>
-              <div v-if="epMenuOpen === ep.id" class="absolute right-0 top-full mt-1 bg-card border border-border rounded-xl p-1 z-20 w-44 shadow-xl flex flex-col gap-0.5">
-                <button v-if="epNeedsRename(ep)" @click="emit('renameEpisode', ep, season); epMenuOpen = null" :disabled="epActionLoading[ep.id]" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-primary hover:bg-hover transition-colors">
-                  <svg width="11" height="11" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
-                  Renommer
-                </button>
-                <button @click="emit('unimportEpisode', ep, season, false); epMenuOpen = null" :disabled="epActionLoading[ep.id]" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-muted hover:bg-hover transition-colors">
-                  <svg width="11" height="11" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/></svg>
-                  Désimporter
-                </button>
-                <button @click="emit('unimportEpisode', ep, season, true); epMenuOpen = null" :disabled="epActionLoading[ep.id]" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-red-400 hover:bg-red-500/10 transition-colors">
-                  <svg width="11" height="11" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none"><path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/></svg>
-                  Supprimer le fichier
-                </button>
-              </div>
-            </div>
+            >Rename</button>
+            <!-- Corbeille épisode -->
+            <button
+                @click.stop="openUnimportModal(ep, season)"
+                :disabled="epActionLoading[ep.id]"
+                class="w-6 h-6 flex items-center justify-center rounded text-red-400 hover:bg-red-500/10 transition-colors"
+                title="Désimporter l'épisode"
+            >
+              <Trash2 :size="12" />
+            </button>
           </template>
+
+          <!-- Chevron synopsis (à droite, visible si l'épisode a un plot) -->
+          <button
+              v-if="ep.plot"
+              @click.stop="togglePlot(ep.id)"
+              class="w-6 h-6 flex items-center justify-center rounded transition-colors shrink-0"
+              :class="plotOpen === ep.id ? 'text-accent' : 'text-muted hover:text-primary'"
+              title="Voir le synopsis"
+          >
+            <ChevronUp :size="14" class="transition-transform duration-200" :class="plotOpen === ep.id ? '' : 'rotate-180'" />
+          </button>
         </div>
 
         <!-- Barre progression épisode -->
@@ -235,14 +244,59 @@
             <div class="h-full bg-accent rounded-full transition-all duration-500" :style="{ width: `${epProgress(ep)!.progress}%` }" />
           </div>
         </div>
+
+        <!-- Synopsis -->
+        <div v-if="plotOpen === ep.id && ep.plot" class="mt-2 sm:pl-[92px]">
+          <p class="text-xs text-muted leading-relaxed" style="white-space: pre-line">{{ ep.plot }}</p>
+        </div>
       </div>
     </div>
   </div>
+
+  <!-- Modal désimport épisode -->
+  <Teleport to="body">
+    <div v-if="unimportModal" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="unimportModal = false">
+      <div class="bg-card border border-border rounded-2xl p-6 w-full max-w-sm shadow-2xl mx-4">
+        <h3 class="text-sm font-semibold text-primary mb-1">Désimporter l'épisode</h3>
+        <p class="text-xs text-muted mb-4">L'épisode sera retiré de la bibliothèque.</p>
+        <label class="flex items-center gap-2 mb-5 cursor-pointer select-none">
+          <input type="checkbox" v-model="deleteFileOnUnimport" class="accent-red-500" />
+          <span class="text-xs text-muted">Supprimer le fichier du disque</span>
+        </label>
+        <div class="flex gap-2 justify-end">
+          <button @click="unimportModal = false" class="px-4 py-2 text-xs rounded-lg border border-border text-muted hover:bg-hover transition-colors">Annuler</button>
+          <button @click="confirmUnimport" class="px-4 py-2 text-xs rounded-lg bg-red-500/20 border border-red-500/30 text-red-400 hover:bg-red-500/30 transition-colors">
+            {{ deleteFileOnUnimport ? 'Supprimer' : 'Désimporter' }}
+          </button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
+
+  <!-- Modal désimport saison -->
+  <Teleport to="body">
+    <div v-if="unimportSeasonModal" class="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm" @click.self="unimportSeasonModal = false">
+      <div class="bg-card border border-border rounded-2xl p-6 w-full max-w-sm shadow-2xl mx-4">
+        <h3 class="text-sm font-semibold text-primary mb-1">Désimporter la saison</h3>
+        <p class="text-xs text-muted mb-4">Tous les épisodes importés de cette saison seront retirés de la bibliothèque.</p>
+        <label class="flex items-center gap-2 mb-5 cursor-pointer select-none">
+          <input type="checkbox" v-model="deleteSeasonFiles" class="accent-red-500" />
+          <span class="text-xs text-muted">Supprimer les fichiers du disque</span>
+        </label>
+        <div class="flex gap-2 justify-end">
+          <button @click="unimportSeasonModal = false" class="px-4 py-2 text-xs rounded-lg border border-border text-muted hover:bg-hover transition-colors">Annuler</button>
+          <button @click="confirmUnimportSeason" class="px-4 py-2 text-xs rounded-lg bg-red-500/20 border border-red-500/30 text-red-400 hover:bg-red-500/30 transition-colors">
+            {{ deleteSeasonFiles ? 'Supprimer' : 'Désimporter' }}
+          </button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
 </template>
 
 <script setup lang="ts">
 import { ref, computed, h, onMounted, onUnmounted } from 'vue'
-import { ChevronUp, Download, Loader, Check, X } from 'lucide-vue-next'
+import { ChevronUp, Download, Loader, Check, X, Trash2 } from 'lucide-vue-next'
 
 interface ActiveTorrent { hash: string; progress: number; state: string; files?: { index: number; progress: number }[] }
 
@@ -260,15 +314,21 @@ const props = defineProps<{
 
 const emit = defineEmits<{
   toggle         : [id: number]
-  download       : [key: string, url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null]
+  download       : [key: string, url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null, infohash?: string | null]
   downloadSeason : [season: any, packHash?: string]
   renameEpisode  : [ep: any, season: any]
   unimportEpisode: [ep: any, season: any, deleteFile: boolean]
+  unimportSeason : [season: any, deleteFiles: boolean]
 }>()
 
-const epMenuOpen    = ref<number | null>(null)
-const epOptionsOpen = ref<number | null>(null)
-const seasonMenuOpen = ref(false)
+const epOptionsOpen      = ref<number | null>(null)
+const plotOpen           = ref<number | null>(null)
+const seasonMenuOpen     = ref(false)
+const unimportModal      = ref(false)
+const deleteFileOnUnimport = ref(false)
+const unimportEpTarget   = ref<{ ep: any; season: any } | null>(null)
+const unimportSeasonModal = ref(false)
+const deleteSeasonFiles  = ref(false)
 const downloadIcon = h(Download, { size: 12 })
 const loaderIcon   = h(Loader, { size: 12, class: 'animate-spin' })
 const checkIcon    = h(Check, { size: 12 })
@@ -366,15 +426,16 @@ function epProgress(ep: any): ActiveTorrent | null {
       const sessionDl = isDownloaded(key0) || isDownloaded(keyI)
       if (active.files && active.files.length > 0) {
         const file = active.files.find(f => f.index === t.file_index)
-        // Avec données par fichier on se fie à la progression réelle du fichier précis,
-        // pas à l'état global du torrent — évite d'afficher les fichiers non sélectionnés (progress 0).
-        if (file != null && (sessionDl || file.progress > 0)) {
+        // Avec données par fichier on se fie à la progression réelle du fichier précis.
+        // Si le fichier est à 100% sans session active → déjà téléchargé hors session
+        // (ex : désimporté puis re-consulté) → ne pas afficher le spinner.
+        if (file != null && (sessionDl || (file.progress > 0 && file.progress < 100))) {
           return { ...active, progress: file.progress }
         }
         if (!sessionDl) continue
       } else {
-        // Pas de données par fichier : session ou torrent terminé
-        if (!sessionDl && active.state !== 'seeding') continue
+        // Pas de données par fichier : ignorer si pas de session active
+        if (!sessionDl) continue
         return { ...active, progress: active.state === 'seeding' ? 100 : active.progress }
       }
     }
@@ -393,7 +454,7 @@ function handleEpBtnClick(ep: any) {
   }
   // Option unique → téléchargement direct
   if (ep.torrent && !isAlreadyQueued(ep.torrent)) {
-    emit('download', `ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet, ep.torrent.file_index ?? null, ep.torrent.file_path ?? null)
+    emit('download', `ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet, ep.torrent.file_index ?? null, ep.torrent.file_path ?? null, ep.torrent.infohash ?? null)
   }
 }
 
@@ -505,9 +566,35 @@ function formatDuration(seconds: number): string {
   return `${m} min`
 }
 
+function togglePlot(epId: number) {
+  plotOpen.value = plotOpen.value === epId ? null : epId
+}
+
+function openUnimportModal(ep: any, season: any) {
+  unimportEpTarget.value   = { ep, season }
+  deleteFileOnUnimport.value = false
+  unimportModal.value      = true
+}
+
+function confirmUnimport() {
+  if (!unimportEpTarget.value) return
+  emit('unimportEpisode', unimportEpTarget.value.ep, unimportEpTarget.value.season, deleteFileOnUnimport.value)
+  unimportModal.value = false
+  unimportEpTarget.value = null
+}
+
+function openUnimportSeasonModal() {
+  deleteSeasonFiles.value   = false
+  unimportSeasonModal.value = true
+}
+
+function confirmUnimportSeason() {
+  emit('unimportSeason', props.season, deleteSeasonFiles.value)
+  unimportSeasonModal.value = false
+}
+
 function closeAllMenus() {
-  epMenuOpen.value    = null
-  epOptionsOpen.value = null
+  epOptionsOpen.value  = null
   seasonMenuOpen.value = false
 }
 

src/stores/series.ts

@@ -100,12 +100,12 @@ export const useSeriesStore = defineStore('series', () => {
         }
     }
 
-    async function download(torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null): Promise<{ success: boolean; error?: string }> {
+    async function download(torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null, infohash?: string | null): Promise<{ success: boolean; error?: string }> {
         try {
             const res = await fetch('/api/download', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ torrent_url, magnet, file_index: file_index ?? null, file_path: file_path ?? null })
+                body: JSON.stringify({ torrent_url, magnet, file_index: file_index ?? null, file_path: file_path ?? null, infohash: infohash ?? null })
             })
             const data = await res.json()
             if (res.ok) return { success: true }

src/views/SerieView.vue

@@ -35,26 +35,17 @@
             Import manuel
           </button>
 
-          <!-- Désimporter -->
-          <div v-if="Object.keys(organizedByEpisode).length > 0" class="relative" @click.stop>
-            <button
-                @click="unimportMenuOpen = !unimportMenuOpen"
-                class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg bg-red-500/10 text-red-400 border border-red-500/20 hover:bg-red-500/20 transition"
-            >
-              <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
-                <path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/>
-              </svg>
-              Désimporter
-            </button>
-            <div v-if="unimportMenuOpen" class="absolute top-full left-0 mt-1 bg-card border border-border rounded-xl p-1 z-20 w-48 shadow-xl flex flex-col gap-0.5">
-              <button @click="unimportSerie(false); unimportMenuOpen = false" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-muted hover:bg-hover transition-colors">
-                Retirer de la bibliothèque
-              </button>
-              <button @click="unimportSerie(true); unimportMenuOpen = false" class="flex items-center gap-2 px-3 py-2 rounded-lg text-xs text-red-400 hover:bg-red-500/10 transition-colors">
-                Supprimer les fichiers
-              </button>
-            </div>
-          </div>
+          <!-- Supprimer série -->
+          <button
+              v-if="Object.keys(organizedByEpisode).length > 0"
+              @click="openUnimportSerieModal"
+              class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg bg-red-500/10 text-red-400 border border-red-500/20 hover:bg-red-500/20 transition"
+          >
+            <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" fill="none">
+              <path d="M3 6h18M8 6V4h8v2M19 6l-1 14H6L5 6"/>
+            </svg>
+            Supprimer
+          </button>
         </div>
 
         <!-- Droite : téléchargements -->
@@ -109,14 +100,37 @@
             :downloading-season="!!downloadingSeason[season.id]"
             :nfo-support="nfoSupport"
             @toggle="toggleSeason"
-            @download="(key, url, magnet, fi, fp) => download(key, url, magnet, fi, fp)"
+            @download="(key, url, magnet, fi, fp, ih) => download(key, url, magnet, fi, fp, ih)"
             @download-season="(s, h) => downloadSeason(s, h)"
             @rename-episode="(ep, s) => renameEpisode(ep, s)"
             @unimport-episode="(ep, s, del) => unimportEpisode(ep, s, del)"
+            @unimport-season="(s, del) => unimportSeason(s, del)"
         />
       </div>
     </template>
 
+    <!-- Modal désimport série -->
+    <Teleport to="body">
+      <div v-if="unimportSerieModal" class="fixed inset-0 bg-black/60 flex items-center justify-center z-50 px-4" @click.self="unimportSerieModal = false">
+        <div class="bg-card border border-border rounded-xl w-full max-w-sm p-6 flex flex-col gap-5">
+          <div>
+            <p class="text-sm font-semibold text-primary">Supprimer la série</p>
+            <p class="text-xs text-muted mt-1 truncate">{{ data?.serie?.title }}</p>
+          </div>
+          <label class="flex items-center gap-3 cursor-pointer select-none">
+            <input type="checkbox" v-model="deleteSerieFiles" class="w-4 h-4 rounded border-border accent-accent" />
+            <span class="text-xs text-muted">Supprimer également les fichiers physiques du disque</span>
+          </label>
+          <div class="flex items-center justify-end gap-2">
+            <button @click="unimportSerieModal = false" class="btn-secondary text-xs">Annuler</button>
+            <button @click="confirmUnimportSerie" class="px-4 py-2 rounded-lg border border-red-500/30 text-red-400 bg-red-500/10 hover:bg-red-500/20 transition-colors text-xs font-medium">
+              {{ deleteSerieFiles ? 'Supprimer les fichiers' : 'Supprimer' }}
+            </button>
+          </div>
+        </div>
+      </div>
+    </Teleport>
+
     <!-- Modal import manuel -->
     <ManualImportModal
         v-if="manualImportOpen && data"
@@ -154,7 +168,8 @@ const organizedByEpisode = ref<Record<string, any>>({})
 const mediaPath          = ref('/')
 const nfoSupport         = ref(false)
 const epActionLoading    = ref<Record<number, boolean>>({})
-const unimportMenuOpen   = ref(false)
+const unimportSerieModal = ref(false)
+const deleteSerieFiles   = ref(false)
 const downloadMenuOpen   = ref(false)
 const downloadingAll     = ref(false)
 const downloadingSeason  = ref<Record<number, boolean>>({})
@@ -214,7 +229,13 @@ function isDownloading(key: string) { return downloading.value.includes(key) }
 function isDownloaded(key: string)  { return downloaded.value.includes(key) }
 function addDownloading(key: string) { if (!downloading.value.includes(key)) downloading.value.push(key) }
 function removeDownloading(key: string) { downloading.value = downloading.value.filter(k => k !== key) }
-function addDownloaded(key: string) { if (!downloaded.value.includes(key)) downloaded.value.push(key) }
+function addDownloaded(key: string)    { if (!downloaded.value.includes(key)) downloaded.value.push(key) }
+function removeDownloaded(key: string) { downloaded.value = downloaded.value.filter(k => k !== key) }
+function clearEpDownloaded(ep: any) {
+  removeDownloaded(`ep-${ep.id}`)
+  const count = ep.torrents?.length ?? 0
+  for (let i = 0; i < count; i++) removeDownloaded(`ep-${ep.id}-${i}`)
+}
 function extractHash(torrent: any): string | null {
   if (torrent?.infohash) return torrent.infohash.toLowerCase()
   if (!torrent?.magnet) return null
@@ -314,16 +335,16 @@ async function triggerOrganize(torrent: any) {
 function openManualImport() { fetchOrganized(); manualImportOpen.value = true }
 
 // ── Download ──────────────────────────────────────────────────
-async function download(key: string, torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null) {
+async function download(key: string, torrent_url: string | null, magnet: string | null, file_index?: number | null, file_path?: string | null, infohash?: string | null) {
   if (isDownloading(key) || isDownloaded(key)) return
   addDownloading(key)
-  const result = await store.download(torrent_url, magnet, file_index, file_path)
+  const result = await store.download(torrent_url, magnet, file_index, file_path, infohash)
   removeDownloading(key)
   if (result.success) { addDownloaded(key); toast('Téléchargement lancé ✓', 'success'); fetchActiveDownloads() }
   else toast(result.error ?? 'Erreur inconnue', 'error')
 }
 
-type DlItem = { key: string; torrent_url: string | null; magnet: string | null; file_index?: number | null; file_path?: string | null }
+type DlItem = { key: string; torrent_url: string | null; magnet: string | null; file_index?: number | null; file_path?: string | null; infohash?: string | null }
 
 // Construit la liste de tout ce qui doit être téléchargé.
 // integraleIndex : si défini, utilise uniquement cette intégrale (+ épisodes non couverts).
@@ -369,7 +390,7 @@ function collectDownloadables(integraleIndex?: number): DlItem[] {
   for (const season of data.value.seasons)
     for (const ep of season.episodes) {
       if (!ep.torrent || !ep.available || ep.organized || isAlreadyQueued(ep.torrent) || isDownloaded(`ep-${ep.id}`) || covered.has(ep.id)) continue
-      result.push({ key: `ep-${ep.id}`, torrent_url: ep.torrent.torrent_url, magnet: ep.torrent.magnet, file_index: ep.torrent.file_index ?? null, file_path: ep.torrent.file_path ?? null })
+      result.push({ key: `ep-${ep.id}`, torrent_url: ep.torrent.torrent_url, magnet: ep.torrent.magnet, file_index: ep.torrent.file_index ?? null, file_path: ep.torrent.file_path ?? null, infohash: ep.torrent.infohash ?? null })
     }
 
   return result
@@ -393,7 +414,7 @@ async function downloadAll(integraleIndex?: number) {
   const torrents = collectDownloadables(integraleIndex)
   let sent = 0
   for (const t of torrents) {
-    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
+    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path, t.infohash); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
   }
   downloadingAll.value = false
   if (sent > 0) { toast(`${sent} torrent(s) envoyé(s) ✓`, 'success'); fetchActiveDownloads() }
@@ -418,12 +439,12 @@ async function downloadSeason(season: Season, packHash?: string) {
         ? (ep.torrents?.find((t: any) => (t.infohash ?? extractHash(t)) === packHash) ?? ep.torrent)
         : ep.torrent
       if (!epTorrent || !ep.available || ep.organized || isAlreadyQueued(epTorrent) || isDownloaded(`ep-${ep.id}`)) continue
-      torrents.push({ key: `ep-${ep.id}`, torrent_url: epTorrent.torrent_url, magnet: epTorrent.magnet, file_index: epTorrent.file_index ?? null, file_path: epTorrent.file_path ?? null })
+      torrents.push({ key: `ep-${ep.id}`, torrent_url: epTorrent.torrent_url, magnet: epTorrent.magnet, file_index: epTorrent.file_index ?? null, file_path: epTorrent.file_path ?? null, infohash: epTorrent.infohash ?? null })
     }
   }
   let sent = 0
   for (const t of torrents) {
-    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
+    try { const r = await store.download(t.torrent_url, t.magnet, t.file_index, t.file_path, t.infohash); if (r.success) { addDownloaded(t.key); sent++ } } catch {}
   }
   downloadingSeason.value[season.id] = false
   if (sent > 0) { toast(`${sent} torrent(s) envoyé(s) ✓`, 'success'); fetchActiveDownloads() }
@@ -436,12 +457,28 @@ function toggleSeason(id: number) {
   else collapsedSeasons.value.add(id)
 }
 
+function openUnimportSerieModal() { deleteSerieFiles.value = false; unimportSerieModal.value = true }
+async function confirmUnimportSerie() { unimportSerieModal.value = false; await unimportSerie(deleteSerieFiles.value) }
+
+async function unimportSeason(season: any, deleteFile: boolean) {
+  try {
+    const res = await fetch(`/api/organized/${route.params.id}/seasons/${season.id}?deleteFile=${deleteFile}`, { method: 'DELETE', credentials: 'include' })
+    if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur désimport saison', 'error'); return }
+    const d = await res.json()
+    toast(`${d.removed} épisode(s) désimporté(s) ✓`, 'success')
+    for (const ep of season.episodes ?? []) clearEpDownloaded(ep)
+    removeDownloaded(`season-${season.id}`)
+    await fetchOrganized(); load()
+  } catch { toast('Impossible de contacter le serveur', 'error') }
+}
+
 async function unimportSerie(deleteFile: boolean) {
   try {
     const res = await fetch(`/api/organized/${route.params.id}?deleteFile=${deleteFile}`, { method: 'DELETE', credentials: 'include' })
     if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur désimport', 'error'); return }
     const d = await res.json()
     toast(`${d.removed} épisode(s) désimporté(s) ✓`, 'success')
+    downloaded.value = []
     await fetchOrganized(); load()
   } catch { toast('Impossible de contacter le serveur', 'error') }
 }
@@ -468,12 +505,13 @@ async function unimportEpisode(ep: any, _season: any, deleteFile: boolean) {
     const res = await fetch(`/api/organized/${route.params.id}/${ep.id}?deleteFile=${deleteFile}`, { method: 'DELETE', credentials: 'include' })
     if (!res.ok) { const d = await res.json(); toast(d.error ?? 'Erreur désimport', 'error'); return }
     toast(deleteFile ? 'Fichier supprimé ✓' : 'Désimporté ✓', 'success')
+    clearEpDownloaded(ep)
     await fetchOrganized(); load()
   } catch { toast('Impossible de contacter le serveur', 'error') }
   finally { epActionLoading.value[ep.id] = false }
 }
 
-const closeMenus = () => { unimportMenuOpen.value = false; downloadMenuOpen.value = false }
+const closeMenus = () => { downloadMenuOpen.value = false }
 
 onMounted(() => {
   load(); fetchSettings(); fetchOrganized(); fetchActiveDownloads()

src/views/settings/DownloadClientView.vue

@@ -110,18 +110,61 @@
                 <option v-for="def in availableClients" :key="def.id" :value="def.id">{{ def.label }}</option>
               </select>
             </div>
-            <div v-if="currentDefinition" v-for="field in currentDefinition.fields" :key="field.key">
-              <label class="settings-label">
-                {{ field.label }}
-                <span v-if="field.required" class="text-red-400 ml-0.5">*</span>
-              </label>
-              <input
-                  v-model="modal.config[field.key]"
-                  :type="field.type === 'password' ? 'password' : 'text'"
-                  :placeholder="field.placeholder ?? ''"
-                  class="settings-input"
-              />
-            </div>
+
+            <!-- Champs principaux -->
+            <template v-if="currentDefinition">
+              <div v-for="field in basicFields" :key="field.key">
+                <label class="settings-label">
+                  {{ field.label }}
+                  <span v-if="field.required" class="text-red-400 ml-0.5">*</span>
+                </label>
+                <input
+                    v-model="modal.config[field.key]"
+                    :type="field.type === 'password' ? 'password' : 'text'"
+                    :placeholder="field.placeholder ?? ''"
+                    class="settings-input"
+                />
+              </div>
+
+              <!-- Paramètres avancés -->
+              <div v-if="advancedFields.length > 0">
+                <button
+                    type="button"
+                    @click="advancedOpen = !advancedOpen"
+                    class="flex items-center gap-1.5 text-xs text-muted hover:text-primary transition-colors w-full py-1"
+                >
+                  <ChevronDown
+                      :size="13"
+                      class="transition-transform duration-200 shrink-0"
+                      :class="advancedOpen ? 'rotate-180' : ''"
+                  />
+                  Paramètres avancés
+                </button>
+
+                <div v-if="advancedOpen" class="flex flex-col gap-3 mt-2 pl-3 border-l border-border">
+                  <div v-for="field in advancedFields" :key="field.key">
+                    <label class="settings-label flex items-center gap-1.5">
+                      {{ field.label }}
+                      <span
+                          class="inline-flex items-center justify-center w-4 h-4 rounded-full border border-border text-[10px] text-muted cursor-default leading-none shrink-0 relative group"
+                          tabindex="-1"
+                      >
+                        i
+                        <span class="absolute bottom-full left-1/2 -translate-x-1/2 mb-1.5 w-56 text-[11px] text-secondary bg-card border border-border rounded-lg px-2.5 py-1.5 shadow-lg pointer-events-none opacity-0 group-hover:opacity-100 transition-opacity z-10 leading-relaxed">
+                          {{ fieldTooltip(field.key) }}
+                        </span>
+                      </span>
+                    </label>
+                    <input
+                        v-model="modal.config[field.key]"
+                        :type="field.type === 'password' ? 'password' : 'text'"
+                        placeholder=""
+                        class="settings-input"
+                    />
+                  </div>
+                </div>
+              </div>
+            </template>
           </div>
 
           <p v-if="!modal.tested && modal.type" class="text-xs text-muted">
@@ -154,6 +197,7 @@
 
 <script setup lang="ts">
 import { ref, computed, watch, onMounted } from 'vue'
+import { ChevronDown } from 'lucide-vue-next'
 import { useToast } from '@/composables/useToast'
 
 const { add: toast } = useToast()
@@ -181,10 +225,32 @@ const modal = ref({
   tested : false,
 })
 
+const ADVANCED_KEYS = ['savePath', 'remotePath', 'localPath']
+
+const FIELD_TOOLTIPS: Record<string, string> = {
+  savePath   : 'Optionnel. Permet de placer les téléchargements dans un sous-dossier spécifique à l\'intérieur du dossier déjà configuré dans la gestion des médias.',
+  remotePath : 'Si le client tourne sur une autre machine, indiquez ici le chemin qu\'il utilise (ex: /downloads). À associer avec le chemin local ci-dessous.',
+  localPath  : 'Chemin équivalent au chemin distant, mais vu par FanKarr sur sa machine (ex: /mnt/nas/downloads). Les deux champs fonctionnent en binôme pour faire la correspondance.',
+}
+
+function fieldTooltip(key: string): string {
+  return FIELD_TOOLTIPS[key] ?? ''
+}
+
+const advancedOpen = ref(false)
+
 const currentDefinition = computed(() =>
     availableClients.value.find(d => d.id === modal.value.type) ?? null
 )
 
+const basicFields = computed(() =>
+    currentDefinition.value?.fields.filter((f: any) => !ADVANCED_KEYS.includes(f.key)) ?? []
+)
+
+const advancedFields = computed(() =>
+    currentDefinition.value?.fields.filter((f: any) => ADVANCED_KEYS.includes(f.key)) ?? []
+)
+
 function clientLabel(type: string) {
   return availableClients.value.find(d => d.id === type)?.label ?? type
 }
@@ -229,6 +295,7 @@ async function deleteClient(uuid: string) {
 
 function openAddModal() {
   modal.value = { open: true, uuid: null, name: '', type: '', config: {}, testing: false, saving: false, tested: false }
+  advancedOpen.value = false
 }
 
 function editClient(client: any) {
@@ -249,6 +316,7 @@ function closeModal() { modal.value.open = false }
 function onTypeChange() {
   modal.value.config = {}
   modal.value.tested = false
+  advancedOpen.value = false
   const def = currentDefinition.value
   if (def) {
     for (const field of def.fields) {

version.txt

@@ -1 +1 @@
-3.11.3
+3.12.0