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

chore(main): release 3.12.1
2026-04-30 01:18:03 +02:00 · 2026-04-30 00:48:31 +02:00 · 2026-04-30 00:47:56 +02:00 · 2026-04-29 19:00:35 +00:00 · 2026-04-29 21:00:05 +02:00 · 2026-04-29 20:59:26 +02:00
22 changed files with 726 additions and 213 deletions
@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(find src:*)",
-      "Bash(find server:*)"
-    ]
-  }
-}
@@ -1,3 +1,6 @@
+# Claude Code
+.claude/
+
 # Logs
 logs
 *.log
@@ -1,5 +1,66 @@
 # Changelog

+## [3.12.1](https://github.com/Masutayunikon/FanKarr/compare/v3.12.0...v3.12.1) (2026-04-29)
+
+
+### Bug Fixes
+
+* **UI/UX:** ajout d'un modal de confirmation lors de l'activation des nfo ([8b98b0e](https://github.com/Masutayunikon/FanKarr/commit/8b98b0edf926ba6b542501afdf524050d72f043b))
+
+## [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)
+
+
+### Bug Fixes
+
+* dockerfile node version to 22 ([5983494](https://github.com/Masutayunikon/FanKarr/commit/598349407750c729579bd639680ebc6a8ebcc12f))
+
+## [3.11.2](https://github.com/Masutayunikon/FanKarr/compare/v3.11.1...v3.11.2) (2026-04-26)
+
+
+### Bug Fixes
+
+* ajout de undici dans le package.json ([459e602](https://github.com/Masutayunikon/FanKarr/commit/459e602c1df1c610466be5015a660624b1189620))
+
+## [3.11.1](https://github.com/Masutayunikon/FanKarr/compare/v3.11.0...v3.11.1) (2026-04-26)
+
+
+### Bug Fixes
+
+* le setup plex peux maintenant etre utilisé sur un serveur local (probleme de certificat) ([6907584](https://github.com/Masutayunikon/FanKarr/commit/69075842be396b149949b158922a9dc84dbc7ccf))
+
 ## [3.11.0](https://github.com/Masutayunikon/FanKarr/compare/v3.10.0...v3.11.0) (2026-04-23)


@@ -1,4 +1,4 @@
-FROM node:20-slim AS base
+FROM node:22-slim AS base
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
 RUN corepack enable
@@ -15,7 +15,7 @@ RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
 RUN pnpm run build

 # ── Production ─────────────────────────────────────────────────
-FROM node:20-slim
+FROM node:22-slim
 RUN apt-get update && apt-get install -y gosu && rm -rf /var/lib/apt/lists/*

 WORKDIR /app
@@ -28,4 +28,4 @@ RUN mkdir -p /config

 EXPOSE 3001
 ENV NODE_ENV=production
-ENTRYPOINT ["/entrypoint.sh"]
+ENTRYPOINT ["/entrypoint.sh"]
@@ -26,6 +26,7 @@
    "node-fetch": "^3.3.2",
    "pinia": "^3.0.4",
    "tailwindcss": "^4.2.1",
+    "undici": "^8.1.0",
    "vue": "^3.5.25",
    "vue-router": "^5.0.3"
  },
@@ -38,6 +38,9 @@ importers:
      tailwindcss:
        specifier: ^4.2.1
        version: 4.2.1
+      undici:
+        specifier: ^8.1.0
+        version: 8.1.0
      vue:
        specifier: ^3.5.25
        version: 3.5.29(typescript@5.9.3)
@@ -1343,6 +1346,10 @@ packages:
  undici-types@7.16.0:
    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}

+  undici@8.1.0:
+    resolution: {integrity: sha512-E9MkTS4xXLnRPYqxH2e6Hr2/49e7WFDKczKcCaFH4VaZs2iNvHMqeIkyUAD9vM8kujy9TjVrRlQ5KkdEJxB2pw==}
+    engines: {node: '>=22.19.0'}
+
  unpipe@1.0.0:
    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
    engines: {node: '>= 0.8'}
@@ -2645,6 +2652,8 @@ snapshots:

  undici-types@7.16.0: {}

+  undici@8.1.0: {}
+
  unpipe@1.0.0: {}

  unplugin-utils@0.3.1:
@@ -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)
 })
@@ -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 })
 })

@@ -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'
@@ -1,4 +1,5 @@
 import { Router } from 'express'
+import { Agent, fetch as undiciFetch } from 'undici'
 import { requireAuth } from '../auth.js'
 import { logger } from '../logger.js'

@@ -6,6 +7,16 @@ const router = Router()

 const PLEX_TV_API = 'https://plex.tv/api/v2'

+// ── Fetch avec bypass SSL pour les serveurs locaux ────────────────────────────
+function getServerFetch(serverUrl: string) {
+    return (url: string, opts: any = {}) =>
+        undiciFetch(url, {
+            ...opts,
+            dispatcher: new Agent({ connect: { rejectUnauthorized: false } }),
+        })
+}
+
+// ── Fetch vers plex.tv (certificat valide, pas besoin de bypass) ──────────────
 async function plexFetch(url: string, options: RequestInit = {}): Promise<any> {
    const res = await fetch(url, {
        ...options,
@@ -105,6 +116,10 @@ router.post('/plex/setup', requireAuth, async (req, res) => {
    if (!token || !serverUrl || !libraryName || !libraryPath) {
        res.status(400).json({ error: 'token, serverUrl, libraryName, libraryPath requis' }); return
    }
+
+    // Fetch avec SSL bypass pour les appels vers le serveur Plex local
+    const serverFetch = getServerFetch(serverUrl)
+
    const headers: Record<string, string> = { 'X-Plex-Token': token, 'Accept': 'application/json' }
    const TARGET_AGENT_URI = 'https://metadata.fankai.fr/plex'
    const steps: { step: string; ok: boolean; message: string }[] = []
@@ -114,27 +129,30 @@ router.post('/plex/setup', requireAuth, async (req, res) => {

    // ── Étape 1 : Enregistrer le provider Fankai ─────────────
    try {
-        const providersRes = await fetch(`${serverUrl}/media/providers/metadata`, { headers })
+        const providersRes = await serverFetch(`${serverUrl}/media/providers/metadata`, { headers })
        if (providersRes.ok) {
-            const data = await providersRes.json()
+            const data = await providersRes.json() as any
            const providers: any[] = data?.MediaContainer?.MetadataAgentProvider ?? []
            let provider = providers.find((p: any) => p.uri === TARGET_AGENT_URI)
            if (!provider) {
-                const r = await fetch(`${serverUrl}/media/providers/metadata?uri=${encodeURIComponent(TARGET_AGENT_URI)}`, { method: 'POST', headers })
-                if (r.ok) provider = (await r.json())?.MediaContainer?.MetadataAgentProvider?.[0]
+                const r = await serverFetch(`${serverUrl}/media/providers/metadata?uri=${encodeURIComponent(TARGET_AGENT_URI)}`, { method: 'POST', headers })
+                if (r.ok) provider = ((await r.json()) as any)?.MediaContainer?.MetadataAgentProvider?.[0]
            }
            if (provider) {
                agentIdentifier = provider.identifier ?? agentIdentifier
                steps.push({ step: 'provider', ok: true, message: `Provider enregistré (${agentIdentifier})` })
            }
-            const groupsRes = await fetch(`${serverUrl}/media/providers/metadata/group`, { headers })
+            const groupsRes = await serverFetch(`${serverUrl}/media/providers/metadata/group`, { headers })
            if (groupsRes.ok) {
-                const gdata = await groupsRes.json()
+                const gdata = await groupsRes.json() as any
                const groups: any[] = gdata?.MediaContainer?.MetadataAgentProviderGroup ?? []
                let group = groups.find((g: any) => g.primaryIdentifier === agentIdentifier)
                if (!group) {
-                    const r = await fetch(`${serverUrl}/media/providers/metadata/group?title=Fankai&primaryIdentifier=${encodeURIComponent(agentIdentifier)}`, { method: 'POST', headers })
-                    if (r.ok) group = (await r.json())?.MediaContainer?.MetadataAgentProviderGroup?.[0]
+                    const r = await serverFetch(
+                        `${serverUrl}/media/providers/metadata/group?title=Fankai&primaryIdentifier=${encodeURIComponent(agentIdentifier)}`,
+                        { method: 'POST', headers },
+                    )
+                    if (r.ok) group = ((await r.json()) as any)?.MediaContainer?.MetadataAgentProviderGroup?.[0]
                }
                if (group) {
                    groupId = String(group.id ?? '')
@@ -142,18 +160,29 @@ router.post('/plex/setup', requireAuth, async (req, res) => {
                    agentSetupOk = true
                }
            }
+        } else {
+            const status = providersRes.status
+            steps.push({ step: 'agent', ok: false, message: `Agent non configuré (HTTP ${status} — Plex < 1.43 ?) — setup manuel requis` })
+            logger.warn('plex', `Setup agent Fankai — HTTP ${status} depuis ${serverUrl}`)
        }
    } catch (err) {
        const msg = err instanceof Error ? err.message : 'Erreur'
-        steps.push({ step: 'agent', ok: false, message: `Agent non configuré (Plex < 1.43 ?) — setup manuel requis` })
+        steps.push({ step: 'agent', ok: false, message: `Agent non configuré — setup manuel requis` })
        logger.warn('plex', `Setup agent Fankai échoué : ${msg}`)
    }

    // ── Étape 2 : Créer la bibliothèque ──────────────────────
    try {
-        const params = new URLSearchParams({ type: 'show', name: libraryName, agent: agentIdentifier, scanner: 'Plex TV Series', language: 'fr-FR', location: libraryPath })
+        const params = new URLSearchParams({
+            type    : 'show',
+            name    : libraryName,
+            agent   : agentIdentifier,
+            scanner : 'Plex TV Series',
+            language: 'fr-FR',
+            location: libraryPath,
+        })
        if (groupId) params.set('metadataAgentProviderGroupId', groupId)
-        const libRes = await fetch(`${serverUrl}/library/sections?${params}`, { method: 'POST', headers })
+        const libRes = await serverFetch(`${serverUrl}/library/sections?${params}`, { method: 'POST', headers })
        if (!libRes.ok) throw new Error(`HTTP ${libRes.status}: ${await libRes.text()}`)
        steps.push({ step: 'library', ok: true, message: `Bibliothèque "${libraryName}" créée` })
        logger.info('plex', `Bibliothèque "${libraryName}" créée sur ${serverUrl}`)
@@ -166,4 +195,4 @@ router.post('/plex/setup', requireAuth, async (req, res) => {
    }
 })

-export default router
+export default router
@@ -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' })
@@ -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 {
@@ -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
        }

@@ -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
        }

@@ -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 {
@@ -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>
@@ -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
 }

@@ -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 }
@@ -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()
@@ -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) {
@@ -87,7 +87,8 @@
            description="Importer automatiquement dès qu'un téléchargement est terminé. Vérifie toutes les 5 minutes."
        />
        <SettingsToggle
-            v-model="form.nfoSupport"
+            :model-value="form.nfoSupport"
+            @update:model-value="onNfoToggle"
            label="NFO / Métadonnées"
            description="Télécharge les NFO et images depuis GitLab lors de l'import (Kodi, Infuse, etc.)."
        />
@@ -146,6 +147,34 @@
      :media-path="form.mediaPath"
      @close="plexOpen = false"
  />
+
+  <!-- Confirmation NFO -->
+  <Teleport to="body">
+    <div
+        v-if="nfoConfirmOpen"
+        class="fixed inset-0 bg-black/60 flex items-center justify-center z-50 px-4"
+        @click.self="nfoConfirmOpen = false"
+    >
+      <div class="bg-card border border-border rounded-xl w-full max-w-sm p-6 flex flex-col gap-4">
+        <div class="flex flex-col gap-1.5">
+          <h3 class="text-sm font-semibold text-primary">Activer les NFO / Métadonnées ?</h3>
+          <p class="text-xs text-muted leading-relaxed">
+            Si vous utilisez l'agent Fankai sur <span class="text-primary">Jellyfin, Plex ou Emby</span>,
+            les métadonnées sont déjà gérées directement par l'agent — activer les NFO est inutile
+            et peut créer des conflits.
+          </p>
+          <p class="text-xs text-muted leading-relaxed">
+            Activez cette option uniquement si vous utilisez <span class="text-primary">Kodi, Infuse</span>
+            ou un lecteur qui lit les fichiers NFO locaux.
+          </p>
+        </div>
+        <div class="flex gap-2 pt-1">
+          <button @click="confirmNfo" class="btn-primary text-xs">Oui, activer quand même</button>
+          <button @click="nfoConfirmOpen = false" class="btn-secondary text-xs">Annuler</button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
 </template>

 <script setup lang="ts">
@@ -157,12 +186,26 @@ import PlexWizard from '@/components/settings/PlexWizard.vue'

 const { add: toast } = useToast()

-const saving     = ref(false)
-const scanning   = ref(false)
-const isDocker   = ref(false)
-const loaded     = ref(false)
-const plexOpen   = ref(false)
-const scanResult = ref<{ found: number; added: number } | null>(null)
+const saving         = ref(false)
+const scanning       = ref(false)
+const isDocker       = ref(false)
+const loaded         = ref(false)
+const plexOpen       = ref(false)
+const nfoConfirmOpen = ref(false)
+const scanResult     = ref<{ found: number; added: number } | null>(null)
+
+function onNfoToggle(val: boolean) {
+  if (val && !form.value.nfoSupport) {
+    nfoConfirmOpen.value = true
+  } else {
+    form.value.nfoSupport = val
+  }
+}
+
+function confirmNfo() {
+  form.value.nfoSupport = true
+  nfoConfirmOpen.value  = false
+}

 const form = ref({
  mediaPath           : '',
@@ -1 +1 @@
-3.11.0
+3.12.1
Author	SHA1	Message	Date
Quentin Robert	82a82b1e84	Merge pull request #106 from Masutayunikon/release-please--branches--main chore(main): release 3.12.1	2026-04-30 01:18:03 +02:00
Quentin Robert	85bce309e9	chore(main): release 3.12.1	2026-04-30 00:48:31 +02:00
MasutaYunikon	8b98b0edf9	fix(UI/UX): ajout d'un modal de confirmation lors de l'activation des nfo	2026-04-30 00:47:56 +02:00
github-actions[bot]	8c765bbf39	chore: update version.txt to v3.12.0	2026-04-29 19:00:35 +00:00
Quentin Robert	0fd10576fe	Merge pull request #105 from Masutayunikon/release-please--branches--main chore(main): release 3.12.0	2026-04-29 21:00:05 +02:00
Quentin Robert	744e0336c5	chore(main): release 3.12.0	2026-04-29 20:59:26 +02:00
MasutaYunikon	040a8d7b33	fix(UI/UX): meilleur comprehension des parametres avancés des clients	2026-04-29 20:58:26 +02:00
MasutaYunikon	39d2f996ae	fix: spinner infinie apres supression	2026-04-29 20:15:01 +02:00
MasutaYunikon	97c573cc1d	fix: spinner infinie apres supression	2026-04-29 19:12:23 +02:00
MasutaYunikon	f6ef818e60	fix(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	2026-04-29 18:59:01 +02:00
MasutaYunikon	f5094c68c6	fix: qbitorrent header	2026-04-29 18:34:51 +02:00
MasutaYunikon	9834023522	fix: qbitorrent	2026-04-29 18:29:18 +02:00
MasutaYunikon	c267562aec	chore: retrigger release-please after tag fix	2026-04-29 18:07:46 +02:00
MasutaYunikon	a68b9cff95	chore: remove .claude folder and add to .gitignore	2026-04-29 18:04:38 +02:00
MasutaYunikon	a604b0d0cc	chore: retrigger release-please	2026-04-29 18:03:02 +02:00
MasutaYunikon	24466228ef	feat: désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission - SerieSeasonCard: remplace le menu burger épisode par corbeille directe, badge Rename cliquable, bouton synopsis (ℹ) avec affichage inline, bouton téléchargement masqué si épisode importé - SerieSeasonCard: modal désimport épisode (avec checkbox suppression fichier) via Teleport - SerieSeasonCard: bouton corbeille saison + modal désimport saison (avec checkbox suppression fichier) - SerieView: bouton Désimporter série → modal (remplace dropdown), gère l'emit unimportSeason depuis card - import.ts: nouvel endpoint DELETE /organized/:serieId/seasons/:seasonId - qbittorrent: fallback hash pour .torrent sans magnet (snapshot → poll → diff → priorité fichier) - transmission: fix sélection fichier (trApplyFilePriority async, fileStats→files, files-wanted via torrent-set)	2026-04-28 22:51:03 +02:00
MasutaYunikon	fcb1b88870	feat: désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission - SerieSeasonCard: remplace le menu burger épisode par corbeille directe, badge Rename cliquable, bouton synopsis (ℹ) avec affichage inline, bouton téléchargement masqué si épisode importé - SerieSeasonCard: modal désimport épisode (avec checkbox suppression fichier) via Teleport - SerieSeasonCard: bouton corbeille saison + modal désimport saison (avec checkbox suppression fichier) - SerieView: bouton Désimporter série → modal (remplace dropdown), gère l'emit unimportSeason depuis card - import.ts: nouvel endpoint DELETE /organized/:serieId/seasons/:seasonId - qbittorrent: fallback hash pour .torrent sans magnet (snapshot → poll → diff → priorité fichier) - transmission: fix sélection fichier (trApplyFilePriority async, fileStats→files, files-wanted via torrent-set)	2026-04-28 22:46:13 +02:00
MasutaYunikon	3fb4119c79	feat: désimport saison/série avec modal, refonte UX épisodes, fix sélection fichier qBit/Transmission - SerieSeasonCard: remplace le menu burger épisode par corbeille directe, badge Rename cliquable, bouton synopsis (ℹ) avec affichage inline, bouton téléchargement masqué si épisode importé - SerieSeasonCard: modal désimport épisode (avec checkbox suppression fichier) via Teleport - SerieSeasonCard: bouton corbeille saison + modal désimport saison (avec checkbox suppression fichier) - SerieView: bouton Désimporter série → modal (remplace dropdown), gère l'emit unimportSeason depuis card - import.ts: nouvel endpoint DELETE /organized/:serieId/seasons/:seasonId - qbittorrent: fallback hash pour .torrent sans magnet (snapshot → poll → diff → priorité fichier) - transmission: fix sélection fichier (trApplyFilePriority async, fileStats→files, files-wanted via torrent-set)	2026-04-28 20:03:47 +02:00
github-actions[bot]	eb4cb30efd	chore: update version.txt to v3.11.5	2026-04-26 21:50:59 +00:00
MasutaYunikon	53c226eba8	Merge pull request #102 from Masutayunikon/release-please--branches--main chore(main): release 3.11.5	2026-04-26 23:50:39 +02:00
MasutaYunikon	3b74d93b74	chore(main): release 3.11.5	2026-04-26 23:50:03 +02:00
MasutaYunikon	ff54ab4ef6	Merge remote-tracking branch 'origin/main'	2026-04-26 23:49:38 +02:00
MasutaYunikon	a7c90b63df	fix: le folder picker affiche tous les disques depuis le bouton homes sous windows	2026-04-26 23:49:28 +02:00
github-actions[bot]	872962c435	chore: update version.txt to v3.11.4	2026-04-26 21:11:56 +00:00
MasutaYunikon	b9c4627a77	Merge pull request #101 from Masutayunikon/release-please--branches--main chore(main): release 3.11.4	2026-04-26 23:11:37 +02:00
MasutaYunikon	eff7a288cf	chore(main): release 3.11.4	2026-04-26 23:08:13 +02:00
MasutaYunikon	94d419cf01	Merge remote-tracking branch 'origin/main'	2026-04-26 23:07:49 +02:00
MasutaYunikon	4760d576f3	fix: ajout de la mise a jour des noms toutes les 1h	2026-04-26 23:07:39 +02:00
github-actions[bot]	800c9f3f02	chore: update version.txt to v3.11.3	2026-04-26 18:29:57 +00:00
MasutaYunikon	6c7def3184	Merge pull request #100 from Masutayunikon/release-please--branches--main chore(main): release 3.11.3	2026-04-26 20:29:34 +02:00
MasutaYunikon	962279db29	chore(main): release 3.11.3	2026-04-26 20:27:48 +02:00
MasutaYunikon	bffe286f40	fix: dockerfile node version to 22	2026-04-26 20:27:27 +02:00
github-actions[bot]	abc96dd648	chore: update version.txt to v3.11.2	2026-04-26 14:35:36 +00:00
MasutaYunikon	6142dbdb25	Merge pull request #99 from Masutayunikon/release-please--branches--main chore(main): release 3.11.2	2026-04-26 16:35:15 +02:00
MasutaYunikon	01040ada26	chore(main): release 3.11.2	2026-04-26 16:34:33 +02:00
MasutaYunikon	ee2d83993a	Merge remote-tracking branch 'origin/main'	2026-04-26 16:34:09 +02:00
MasutaYunikon	0103960645	fix: ajout de undici dans le package.json	2026-04-26 16:34:00 +02:00
github-actions[bot]	b8e30e13f2	chore: update version.txt to v3.11.1	2026-04-26 14:16:42 +00:00
MasutaYunikon	b8554af71b	Merge pull request #98 from Masutayunikon/release-please--branches--main chore(main): release 3.11.1	2026-04-26 16:16:22 +02:00
MasutaYunikon	e130e945d5	chore(main): release 3.11.1	2026-04-26 15:57:11 +02:00
MasutaYunikon	7c4496ae1d	Merge remote-tracking branch 'origin/main'	2026-04-26 15:56:44 +02:00
MasutaYunikon	cfd0914b9b	fix: le setup plex peux maintenant etre utilisé sur un serveur local (probleme de certificat)	2026-04-26 15:56:35 +02:00
github-actions[bot]	53a6f0abfc	chore: update version.txt to v3.11.0	2026-04-23 20:06:51 +00:00
@@ -1 +1 @@
 .11.0
 .12.1