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

chore(main): release 2.3.3

.dockerignore

@@ -2,7 +2,7 @@ node_modules
 .git
 .gitignore
 *.md
-data
+config
 .env
 .env.*
 !.env.example

.github/workflows/build-binaries.yml

@@ -0,0 +1,119 @@
+name: Build Binaries
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+
+jobs:
+  build-frontend:
+    name: Build Frontend
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v3
+        with:
+          version: latest
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build Vue frontend
+        run: pnpm build
+
+      - name: Upload frontend dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: frontend-dist
+          path: dist/client/
+          retention-days: 1
+
+  build-binaries:
+    name: Build ${{ matrix.target }}
+    needs: build-frontend
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        include:
+          - target: windows-x64
+            os: windows-latest
+            bun-target: bun-windows-x64
+            binary: binaries/fankarr.exe
+            archive: fankarr-windows-x64.zip
+          - target: linux-x64
+            os: ubuntu-latest
+            bun-target: bun-linux-x64
+            binary: binaries/fankarr
+            archive: fankarr-linux-x64.zip
+          - target: macos
+            os: macos-latest
+            bun-target: bun-darwin-arm64
+            binary: binaries/fankarr
+            archive: fankarr-macos.zip
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - uses: pnpm/action-setup@v3
+        with:
+          version: latest
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Download frontend dist
+        uses: actions/download-artifact@v4
+        with:
+          name: frontend-dist
+          path: public/
+
+      - name: Build binary (Unix)
+        if: matrix.target != 'windows-x64'
+        run: |
+          mkdir -p binaries
+          bun build server/index.ts --compile --target ${{ matrix.bun-target }} --outfile ${{ matrix.binary }}
+
+      - name: Build binary (Windows)
+        if: matrix.target == 'windows-x64'
+        run: |
+          New-Item -ItemType Directory -Force -Path binaries
+          bun build server/index.ts --compile --target ${{ matrix.bun-target }} --outfile ${{ matrix.binary }}
+        shell: pwsh
+
+      - name: Build worker
+        run: bun build server/organize-worker.ts --target node --outfile organize-worker.js
+
+      - name: Package archive (Windows)
+        if: matrix.target == 'windows-x64'
+        run: Compress-Archive -Path ${{ matrix.binary }}, organize-worker.js, public -DestinationPath ${{ matrix.archive }}
+        shell: pwsh
+
+      - name: Package archive (Unix)
+        if: matrix.target != 'windows-x64'
+        run: |
+          chmod +x ${{ matrix.binary }}
+          zip -r ${{ matrix.archive }} ${{ matrix.binary }} organize-worker.js public/
+
+      - name: Upload archive to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: ${{ matrix.archive }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -7,10 +7,12 @@ yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
 
+config
 node_modules
 dist
 dist-ssr
 *.local
+binaries
 
 # Editor directories and files
 .vscode/*

CHANGELOG.md

@@ -1,5 +1,490 @@
 # Changelog
 
+## [2.3.3](https://github.com/Masutayunikon/FanKarr/compare/v2.3.2...v2.3.3) (2026-03-24)
+
+
+### Bug Fixes
+
+* recuperation des episodes avec un delai ([dfc6c13](https://github.com/Masutayunikon/FanKarr/commit/dfc6c1300e3dd8323e422ce3e71465bac77f94cf))
+
+## [2.3.2](https://github.com/Masutayunikon/FanKarr/compare/v2.3.1...v2.3.2) (2026-03-24)
+
+
+### Bug Fixes
+
+* badge catalogue sur les series importé ([f070f17](https://github.com/Masutayunikon/FanKarr/commit/f070f1754ef616874cfb081eb2fefadad602c221))
+
+## [2.3.1](https://github.com/Masutayunikon/FanKarr/compare/v2.3.0...v2.3.1) (2026-03-24)
+
+
+### Bug Fixes
+
+* add readsettings import ([ceb8e64](https://github.com/Masutayunikon/FanKarr/commit/ceb8e64a55937e20e27c1fb64865aba59516d518))
+
+## [2.3.0](https://github.com/Masutayunikon/FanKarr/compare/v2.2.0...v2.3.0) (2026-03-24)
+
+
+### Features
+
+* **catalogue:** badge IMPORTÉ et refresh automatique post-import ([0cf3446](https://github.com/Masutayunikon/FanKarr/commit/0cf344667baccd44c946cee507c4343286783d3f))
+* **catalogue:** tri du catalogue avec 4 options ([0cf3446](https://github.com/Masutayunikon/FanKarr/commit/0cf344667baccd44c946cee507c4343286783d3f))
+* **downloads:** bouton Organiser tout renommé Importer tout ([0cf3446](https://github.com/Masutayunikon/FanKarr/commit/0cf344667baccd44c946cee507c4343286783d3f))
+* **organize:** nommage des fichiers selon original_filename ou formatted_name ([0cf3446](https://github.com/Masutayunikon/FanKarr/commit/0cf344667baccd44c946cee507c4343286783d3f))
+* **settings:** ajout du toggle import automatique (activé par défaut) ([0cf3446](https://github.com/Masutayunikon/FanKarr/commit/0cf344667baccd44c946cee507c4343286783d3f))
+* **settings:** textes génériques sans mention de logiciels spécifiques ([0cf3446](https://github.com/Masutayunikon/FanKarr/commit/0cf344667baccd44c946cee507c4343286783d3f))
+
+
+### Bug Fixes
+
+* add config directory to .gitignore ([2d8749a](https://github.com/Masutayunikon/FanKarr/commit/2d8749ae7bc2986871fb402c2a4242bcb87d3a77))
+
+## [2.2.0](https://github.com/Masutayunikon/FanKarr/compare/v2.1.3...v2.2.0) (2026-03-23)
+
+
+### Features
+
+* add organize all button ([bbaccfd](https://github.com/Masutayunikon/FanKarr/commit/bbaccfd97b51724932f2ebf22cad81be1cde61c0))
+
+
+### Bug Fixes
+
+* organizer reuse the wrong name for gitlab path ([bbaccfd](https://github.com/Masutayunikon/FanKarr/commit/bbaccfd97b51724932f2ebf22cad81be1cde61c0))
+
+## [2.1.3](https://github.com/Masutayunikon/FanKarr/compare/v2.1.2...v2.1.3) (2026-03-23)
+
+
+### Bug Fixes
+
+* use magnet before torrent ([ed4665a](https://github.com/Masutayunikon/FanKarr/commit/ed4665a378d15c0b45a2be32d612e41082a43df1))
+
+## [2.1.2](https://github.com/Masutayunikon/FanKarr/compare/v2.1.1...v2.1.2) (2026-03-23)
+
+
+### Bug Fixes
+
+* path now work on every device ([cfc3440](https://github.com/Masutayunikon/FanKarr/commit/cfc3440a95cb73802778e01d5f256f473e0cc952))
+
+## [2.1.1](https://github.com/Masutayunikon/FanKarr/compare/v2.1.0...v2.1.1) (2026-03-23)
+
+
+### Bug Fixes
+
+* torrent path to hash ([d9e453b](https://github.com/Masutayunikon/FanKarr/commit/d9e453b486b9fd85b69ee134bee2bd6a1a6d3702))
+
+## [2.1.0](https://github.com/Masutayunikon/FanKarr/compare/v2.0.0...v2.1.0) (2026-03-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* **organize:** le format paths[] dans series/{id}.json passe de string[] à { infohash: string, path: string }[] — nécessite une mise à jour du scraper.
+
+### Bug Fixes
+
+* **organize:** buildFileMap matche par infohash au lieu d'index ou titre ([43ac2ed](https://github.com/Masutayunikon/FanKarr/commit/43ac2ed2e85d9e769735547817f19100d3d7f980))
+* **organize:** migration vers paths { infohash, path } pour le matching fichiers ([43ac2ed](https://github.com/Masutayunikon/FanKarr/commit/43ac2ed2e85d9e769735547817f19100d3d7f980))
+* **organize:** scanMediaPath adapté au nouveau format paths[] ([43ac2ed](https://github.com/Masutayunikon/FanKarr/commit/43ac2ed2e85d9e769735547817f19100d3d7f980))
+* **organize:** source fichier via save_path qBittorrent + fullPath relatif ([43ac2ed](https://github.com/Masutayunikon/FanKarr/commit/43ac2ed2e85d9e769735547817f19100d3d7f980))
+* remove logo ([48416c4](https://github.com/Masutayunikon/FanKarr/commit/48416c4fef3a964b05aa135ffd9e80d5dec9a81a))
+
+## [2.0.0](https://github.com/Masutayunikon/FanKarr/compare/v1.14.0...v2.0.0) (2026-03-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* suppression de torrent_final.json au profit d'un système de fichiers par série (series/{id}.json) avec cache mémoire GitHub 6h. Version majeure — nécessite un nouveau scraper et une mise à jour complète.
+
+### Features
+
+* **api:** adaptation complète à la nouvelle structure API Fankai ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **api:** cache mémoire GitHub TTL 6h avec invalidation via /api/update ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **api:** matching torrents par hiérarchie série/saison/épisode ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* migration vers nouvelle architecture API et scraper par série ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **organize:** refonte complète sans torrent_final.json ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **scraper:** extraction nom bencode dans raw pour torrents locaux ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **series-view:** badge "Hors Fankai" sur épisodes de torrents manuels ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **series-view:** tooltip raw name sur boutons intégrale via :title ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+
+
+### Bug Fixes
+
+* **catalogue:** état download basé sur épisodes organisés vs torrents bruts ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+* **series:** boutons saison Yu-Gi-Oh via fallback season_number ([b3fd7dd](https://github.com/Masutayunikon/FanKarr/commit/b3fd7dded40bf067acc8552cbf5f34a57d27000c))
+
+## [1.14.0](https://github.com/Masutayunikon/FanKarr/compare/v1.13.0...v1.14.0) (2026-03-21)
+
+
+### Features
+
+* **scraper:** extraction du nom bencode pour les torrents locaux ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+* **series-view:** badge "Hors Fankai" sur les épisodes de torrents manuels ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+* **series-view:** tooltip avec le nom du torrent sur les boutons intégrale ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+
+
+### Bug Fixes
+
+* **catalogue:** état "partiel" incorrect quand l'intégrale est organisée ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+* **series:** résolution boutons de téléchargement saisons Yu-Gi-Oh et séries similaires ([67237e9](https://github.com/Masutayunikon/FanKarr/commit/67237e977e34edda4d92a9375de4c4e470725eb1))
+
+## [1.13.0](https://github.com/Masutayunikon/FanKarr/compare/v1.12.2...v1.13.0) (2026-03-21)
+
+
+### Features
+
+* add favicon ([dc4a2d4](https://github.com/Masutayunikon/FanKarr/commit/dc4a2d48f5c0cddd8e431ce33a69fc9146143fb6))
+* add README.md ([4eb487a](https://github.com/Masutayunikon/FanKarr/commit/4eb487a96beed8c82cb19d9a9b63c3b69d841386))
+* add windows / linux / macos binaries on build ([f17a73b](https://github.com/Masutayunikon/FanKarr/commit/f17a73b9591fb49a75bd5fcdadf1970585877dab))
+* **auth:** génération automatique du JWT secret au démarrage ([eaa52e9](https://github.com/Masutayunikon/FanKarr/commit/eaa52e90900ff0e198beae190d7ad0298a702482))
+* cache images ([da460de](https://github.com/Masutayunikon/FanKarr/commit/da460de60c4eec6851ea58ce0ae646a1208f6018))
+* fix worker for multiple series in integral (one piece fix ?) ([2c773f8](https://github.com/Masutayunikon/FanKarr/commit/2c773f83ffd76d82c77a50a9c5729f20ea22b450))
+* initial project ([eaf01cf](https://github.com/Masutayunikon/FanKarr/commit/eaf01cfc591dd72f9b093b533ced6c12a6c490a1))
+* make the organizer threaded to not consumme api main thread ([14c0e56](https://github.com/Masutayunikon/FanKarr/commit/14c0e567525e179da82c6b58d9886cc3d544a98d))
+* now rename episodes with original_filename from api ([9bdb21a](https://github.com/Masutayunikon/FanKarr/commit/9bdb21a673ebb9871548aea6691bafbd049554ce))
+* **organize:** scan initial mediaPath + logs fichier centralisés ([807f786](https://github.com/Masutayunikon/FanKarr/commit/807f786b038579ca9d7cd136998f759cecae2255))
+* **organize:** worker thread + badges statut + notifications ([b7242bc](https://github.com/Masutayunikon/FanKarr/commit/b7242bc95f59d259ab1a636aa304bf149f895041))
+* **serie:** badges état organisation sur épisodes et saisons ([4d3a6bd](https://github.com/Masutayunikon/FanKarr/commit/4d3a6bd276907f793452429d62693fafc1d804db))
+* **ui:** états catalogue + logs + badges erreurs downloads ([5326828](https://github.com/Masutayunikon/FanKarr/commit/5326828d89aa10a53bbe1ac4016a5eee4d5dbc97))
+* UX improvements, folder picker, download state & NFO support ([20771fc](https://github.com/Masutayunikon/FanKarr/commit/20771fc31c187fd1fea8aa9b07093b15621a5b85))
+
+
+### Bug Fixes
+
+* add config.ts with config variable (BASE_DIR...) ([a3eb67c](https://github.com/Masutayunikon/FanKarr/commit/a3eb67c9a0944500142a6636d57cae0acfd7543d))
+* add log for debug ([6876c5e](https://github.com/Masutayunikon/FanKarr/commit/6876c5ee6c7734e664a6da4e4bc721cc7c5abdf7))
+* add log for debug ([d8cdeae](https://github.com/Masutayunikon/FanKarr/commit/d8cdeae675bc73b5842d18d01eff9d5bb0e0a7e8))
+* add target node ([58b09f2](https://github.com/Masutayunikon/FanKarr/commit/58b09f2267345c60ed589c160f7e47698e9be9a4))
+* add target node ([6c629e0](https://github.com/Masutayunikon/FanKarr/commit/6c629e0f6b4d38453cfb22fd315e02d9e8750c45))
+* add user permissions when the scripts is launched ([501bbfc](https://github.com/Masutayunikon/FanKarr/commit/501bbfcf18c236f7ac382c50d90482b1f51244c1))
+* CatalogView.vue badge deleted ([d897192](https://github.com/Masutayunikon/FanKarr/commit/d8971920462efd8d1d99eb867016c96713dfef58))
+* config path /config/config to /config ([7518191](https://github.com/Masutayunikon/FanKarr/commit/75181910244621a8eca989067fd4777922914d8e))
+* docker errors ([2702764](https://github.com/Masutayunikon/FanKarr/commit/27027642eb55b75adb04446a88e5007e88f75948))
+* docker is able to change directory ([af08f7d](https://github.com/Masutayunikon/FanKarr/commit/af08f7d9d4fb2e23c5feac6d33b2ef495f9d91b2))
+* empty docker-compose.yml ([303dfd8](https://github.com/Masutayunikon/FanKarr/commit/303dfd85b5d033e2b247fd064ae1ae612fdb49e1))
+* entrypoint.sh config directory ([7e4b2fa](https://github.com/Masutayunikon/FanKarr/commit/7e4b2fa60a5946d3220618f13420a07fa57e8e1b))
+* export _isBunBinary ([3d43de3](https://github.com/Masutayunikon/FanKarr/commit/3d43de3eb223ec0338e0b9aebffff35e116e00a0))
+* improve torrent organization and cleanup logic ([1908cb3](https://github.com/Masutayunikon/FanKarr/commit/1908cb3e8c5b99e91e26735f7cfa3dcd23709df7))
+* logger third args ([5abac1e](https://github.com/Masutayunikon/FanKarr/commit/5abac1e11236ed1e8f7f0de7f0cff881d1b60f10))
+* nfo settings and add json file when not existing ([0b6bfa6](https://github.com/Masutayunikon/FanKarr/commit/0b6bfa6a81d99353be877ed6d99687ad3d55adbc))
+* organize file ([d6550e9](https://github.com/Masutayunikon/FanKarr/commit/d6550e9961789073be1583e03d599afb6d295004))
+* organize use torrent hash and not name ([61901f9](https://github.com/Masutayunikon/FanKarr/commit/61901f9014a759e2950311cd96266ea8201fa902))
+* path ([7ddd9ca](https://github.com/Masutayunikon/FanKarr/commit/7ddd9cad9271d79a258f45245bf405f13b9d764f))
+* path ([0329ee2](https://github.com/Masutayunikon/FanKarr/commit/0329ee27a34038456eb297f07b808de3157d88f4))
+* path ([314f817](https://github.com/Masutayunikon/FanKarr/commit/314f817280f39d10eb21c4784f2aea41b9a6d32c))
+* port 9898, /config volume, Kaï→Kai matching, NFO pagination GitLab, saison 0 specials, JoJo/Hokuto strict season resolve ([3a278ba](https://github.com/Masutayunikon/FanKarr/commit/3a278ba33388d6ff6f33413d7696d58d0172c953))
+* remove user creation in entrypoint.sh ([92d9fa6](https://github.com/Masutayunikon/FanKarr/commit/92d9fa6b01f1e2de1ceb13528afd309b21f9d4cb))
+* rename if the torrent name is not the same as the api ([b8fcf71](https://github.com/Masutayunikon/FanKarr/commit/b8fcf71f54ab14e5572a7553d8554b617b4981b7))
+* season 0 not clonficting anymore ([635082d](https://github.com/Masutayunikon/FanKarr/commit/635082de00bb42bdeaf20b1654f742ad1c4addbe))
+* season 0 resolved is no longer skipped in the worker ([c48ec76](https://github.com/Masutayunikon/FanKarr/commit/c48ec769ba7725327e657366e882498846d0c63f))
+* season fallback ([e9b5091](https://github.com/Masutayunikon/FanKarr/commit/e9b5091242d73be77bf6fb525ce2865554e336cc))
+* skip excluded folders ([edf806d](https://github.com/Masutayunikon/FanKarr/commit/edf806d9bc48d4de1c3609a4b0405442305d546e))
+* title readme align ([8ba3b37](https://github.com/Masutayunikon/FanKarr/commit/8ba3b370d1e2cd1565f9c2453be8706e3c198243))
+* use bcryptjs for compilation ([6a6981e](https://github.com/Masutayunikon/FanKarr/commit/6a6981e10a3a9019f49982d7680e562872ee95a5))
+* use season number from resolved episodes in priority ([dc48634](https://github.com/Masutayunikon/FanKarr/commit/dc486347193a8066a32d8f0106518abc2b04b7e2))
+* worker now work on multiple github files pages ([71784cd](https://github.com/Masutayunikon/FanKarr/commit/71784cd8bd8f3ea5dc7423687b080c1588d70854))
+* worker outside the exe ([c2ab58e](https://github.com/Masutayunikon/FanKarr/commit/c2ab58e7b2c34aae09b50dbdfde3277da4c276ff))
+* worker outside the exe ([a47c3a4](https://github.com/Masutayunikon/FanKarr/commit/a47c3a43fb5dbbedd87c9ac2d584c3290fcc6097))
+* worker path ([3df8def](https://github.com/Masutayunikon/FanKarr/commit/3df8defa5e46b09722a345c7c3a94e91aa16e4d8))
+* worker path ([360572b](https://github.com/Masutayunikon/FanKarr/commit/360572b8be64dafbb452dfcb849a40305bf1b8cf))
+* workflow directory ([baebd8f](https://github.com/Masutayunikon/FanKarr/commit/baebd8fae146db70ee1cce0c876d2d3bc0f9bf4e))
+* workflow directory ([d8405c1](https://github.com/Masutayunikon/FanKarr/commit/d8405c1589f277cd8fdd3e1fd15cc02d98834aa6))
+* workflow permmisions ([3620bfb](https://github.com/Masutayunikon/FanKarr/commit/3620bfb71d8c2774b23c097e5e01326099c2f180))
+
+## [1.12.2](https://github.com/Masutayunikon/FanKarr/compare/v1.12.1...v1.12.2) (2026-03-21)
+
+
+### Bug Fixes
+
+* use season number from resolved episodes in priority ([dc48634](https://github.com/Masutayunikon/FanKarr/commit/dc486347193a8066a32d8f0106518abc2b04b7e2))
+
+## [1.12.1](https://github.com/Masutayunikon/FanKarr/compare/v1.12.0...v1.12.1) (2026-03-21)
+
+
+### Bug Fixes
+
+* path ([7ddd9ca](https://github.com/Masutayunikon/FanKarr/commit/7ddd9cad9271d79a258f45245bf405f13b9d764f))
+
+## [1.12.0](https://github.com/Masutayunikon/FanKarr/compare/v1.11.10...v1.12.0) (2026-03-21)
+
+
+### Features
+
+* now rename episodes with original_filename from api ([9bdb21a](https://github.com/Masutayunikon/FanKarr/commit/9bdb21a673ebb9871548aea6691bafbd049554ce))
+
+## [1.11.10](https://github.com/Masutayunikon/FanKarr/compare/v1.11.9...v1.11.10) (2026-03-21)
+
+
+### Bug Fixes
+
+* improve torrent organization and cleanup logic ([1908cb3](https://github.com/Masutayunikon/FanKarr/commit/1908cb3e8c5b99e91e26735f7cfa3dcd23709df7))
+* season 0 not clonficting anymore ([635082d](https://github.com/Masutayunikon/FanKarr/commit/635082de00bb42bdeaf20b1654f742ad1c4addbe))
+
+## [1.11.9](https://github.com/Masutayunikon/FanKarr/compare/v1.11.8...v1.11.9) (2026-03-20)
+
+
+### Bug Fixes
+
+* season 0 resolved is no longer skipped in the worker ([c48ec76](https://github.com/Masutayunikon/FanKarr/commit/c48ec769ba7725327e657366e882498846d0c63f))
+
+## [1.11.8](https://github.com/Masutayunikon/FanKarr/compare/v1.11.7...v1.11.8) (2026-03-20)
+
+
+### Bug Fixes
+
+* config path /config/config to /config ([7518191](https://github.com/Masutayunikon/FanKarr/commit/75181910244621a8eca989067fd4777922914d8e))
+
+## [1.11.7](https://github.com/Masutayunikon/FanKarr/compare/v1.11.6...v1.11.7) (2026-03-20)
+
+
+### Bug Fixes
+
+* worker path ([3df8def](https://github.com/Masutayunikon/FanKarr/commit/3df8defa5e46b09722a345c7c3a94e91aa16e4d8))
+
+## [1.11.6](https://github.com/Masutayunikon/FanKarr/compare/v1.11.5...v1.11.6) (2026-03-20)
+
+
+### Bug Fixes
+
+* path ([0329ee2](https://github.com/Masutayunikon/FanKarr/commit/0329ee27a34038456eb297f07b808de3157d88f4))
+
+## [1.11.5](https://github.com/Masutayunikon/FanKarr/compare/v1.11.4...v1.11.5) (2026-03-20)
+
+
+### Bug Fixes
+
+* export _isBunBinary ([3d43de3](https://github.com/Masutayunikon/FanKarr/commit/3d43de3eb223ec0338e0b9aebffff35e116e00a0))
+
+## [1.11.4](https://github.com/Masutayunikon/FanKarr/compare/v1.11.3...v1.11.4) (2026-03-20)
+
+
+### Bug Fixes
+
+* add config.ts with config variable (BASE_DIR...) ([a3eb67c](https://github.com/Masutayunikon/FanKarr/commit/a3eb67c9a0944500142a6636d57cae0acfd7543d))
+
+## [1.11.3](https://github.com/Masutayunikon/FanKarr/compare/v1.11.2...v1.11.3) (2026-03-20)
+
+
+### Bug Fixes
+
+* entrypoint.sh config directory ([7e4b2fa](https://github.com/Masutayunikon/FanKarr/commit/7e4b2fa60a5946d3220618f13420a07fa57e8e1b))
+
+## [1.11.2](https://github.com/Masutayunikon/FanKarr/compare/v1.11.1...v1.11.2) (2026-03-20)
+
+
+### Bug Fixes
+
+* port 9898, /config volume, Kaï→Kai matching, NFO pagination GitLab, saison 0 specials, JoJo/Hokuto strict season resolve ([3a278ba](https://github.com/Masutayunikon/FanKarr/commit/3a278ba33388d6ff6f33413d7696d58d0172c953))
+
+## [1.11.1](https://github.com/Masutayunikon/FanKarr/compare/v1.11.0...v1.11.1) (2026-03-13)
+
+
+### Bug Fixes
+
+* worker now work on multiple github files pages ([71784cd](https://github.com/Masutayunikon/FanKarr/commit/71784cd8bd8f3ea5dc7423687b080c1588d70854))
+
+## [1.11.0](https://github.com/Masutayunikon/FanKarr/compare/v1.10.3...v1.11.0) (2026-03-13)
+
+
+### Features
+
+* fix worker for multiple series in integral (one piece fix ?) ([2c773f8](https://github.com/Masutayunikon/FanKarr/commit/2c773f83ffd76d82c77a50a9c5729f20ea22b450))
+
+## [1.10.3](https://github.com/Masutayunikon/FanKarr/compare/v1.10.2...v1.10.3) (2026-03-13)
+
+
+### Bug Fixes
+
+* worker path ([360572b](https://github.com/Masutayunikon/FanKarr/commit/360572b8be64dafbb452dfcb849a40305bf1b8cf))
+
+## [1.10.2](https://github.com/Masutayunikon/FanKarr/compare/v1.10.1...v1.10.2) (2026-03-13)
+
+
+### Bug Fixes
+
+* add target node ([58b09f2](https://github.com/Masutayunikon/FanKarr/commit/58b09f2267345c60ed589c160f7e47698e9be9a4))
+
+## [1.10.1](https://github.com/Masutayunikon/FanKarr/compare/v1.10.0...v1.10.1) (2026-03-13)
+
+
+### Bug Fixes
+
+* add target node ([6c629e0](https://github.com/Masutayunikon/FanKarr/commit/6c629e0f6b4d38453cfb22fd315e02d9e8750c45))
+
+## [1.10.0](https://github.com/Masutayunikon/FanKarr/compare/v1.9.5...v1.10.0) (2026-03-13)
+
+
+### Features
+
+* add favicon ([dc4a2d4](https://github.com/Masutayunikon/FanKarr/commit/dc4a2d48f5c0cddd8e431ce33a69fc9146143fb6))
+* add README.md ([4eb487a](https://github.com/Masutayunikon/FanKarr/commit/4eb487a96beed8c82cb19d9a9b63c3b69d841386))
+* add windows / linux / macos binaries on build ([f17a73b](https://github.com/Masutayunikon/FanKarr/commit/f17a73b9591fb49a75bd5fcdadf1970585877dab))
+* **auth:** génération automatique du JWT secret au démarrage ([eaa52e9](https://github.com/Masutayunikon/FanKarr/commit/eaa52e90900ff0e198beae190d7ad0298a702482))
+* cache images ([da460de](https://github.com/Masutayunikon/FanKarr/commit/da460de60c4eec6851ea58ce0ae646a1208f6018))
+* initial project ([eaf01cf](https://github.com/Masutayunikon/FanKarr/commit/eaf01cfc591dd72f9b093b533ced6c12a6c490a1))
+* make the organizer threaded to not consumme api main thread ([14c0e56](https://github.com/Masutayunikon/FanKarr/commit/14c0e567525e179da82c6b58d9886cc3d544a98d))
+* **organize:** scan initial mediaPath + logs fichier centralisés ([807f786](https://github.com/Masutayunikon/FanKarr/commit/807f786b038579ca9d7cd136998f759cecae2255))
+* **organize:** worker thread + badges statut + notifications ([b7242bc](https://github.com/Masutayunikon/FanKarr/commit/b7242bc95f59d259ab1a636aa304bf149f895041))
+* **serie:** badges état organisation sur épisodes et saisons ([4d3a6bd](https://github.com/Masutayunikon/FanKarr/commit/4d3a6bd276907f793452429d62693fafc1d804db))
+* **ui:** états catalogue + logs + badges erreurs downloads ([5326828](https://github.com/Masutayunikon/FanKarr/commit/5326828d89aa10a53bbe1ac4016a5eee4d5dbc97))
+* UX improvements, folder picker, download state & NFO support ([20771fc](https://github.com/Masutayunikon/FanKarr/commit/20771fc31c187fd1fea8aa9b07093b15621a5b85))
+
+
+### Bug Fixes
+
+* add log for debug ([6876c5e](https://github.com/Masutayunikon/FanKarr/commit/6876c5ee6c7734e664a6da4e4bc721cc7c5abdf7))
+* add log for debug ([d8cdeae](https://github.com/Masutayunikon/FanKarr/commit/d8cdeae675bc73b5842d18d01eff9d5bb0e0a7e8))
+* add user permissions when the scripts is launched ([501bbfc](https://github.com/Masutayunikon/FanKarr/commit/501bbfcf18c236f7ac382c50d90482b1f51244c1))
+* CatalogView.vue badge deleted ([d897192](https://github.com/Masutayunikon/FanKarr/commit/d8971920462efd8d1d99eb867016c96713dfef58))
+* docker errors ([2702764](https://github.com/Masutayunikon/FanKarr/commit/27027642eb55b75adb04446a88e5007e88f75948))
+* docker is able to change directory ([af08f7d](https://github.com/Masutayunikon/FanKarr/commit/af08f7d9d4fb2e23c5feac6d33b2ef495f9d91b2))
+* empty docker-compose.yml ([303dfd8](https://github.com/Masutayunikon/FanKarr/commit/303dfd85b5d033e2b247fd064ae1ae612fdb49e1))
+* logger third args ([5abac1e](https://github.com/Masutayunikon/FanKarr/commit/5abac1e11236ed1e8f7f0de7f0cff881d1b60f10))
+* nfo settings and add json file when not existing ([0b6bfa6](https://github.com/Masutayunikon/FanKarr/commit/0b6bfa6a81d99353be877ed6d99687ad3d55adbc))
+* organize file ([d6550e9](https://github.com/Masutayunikon/FanKarr/commit/d6550e9961789073be1583e03d599afb6d295004))
+* organize use torrent hash and not name ([61901f9](https://github.com/Masutayunikon/FanKarr/commit/61901f9014a759e2950311cd96266ea8201fa902))
+* path ([314f817](https://github.com/Masutayunikon/FanKarr/commit/314f817280f39d10eb21c4784f2aea41b9a6d32c))
+* remove user creation in entrypoint.sh ([92d9fa6](https://github.com/Masutayunikon/FanKarr/commit/92d9fa6b01f1e2de1ceb13528afd309b21f9d4cb))
+* rename if the torrent name is not the same as the api ([b8fcf71](https://github.com/Masutayunikon/FanKarr/commit/b8fcf71f54ab14e5572a7553d8554b617b4981b7))
+* season fallback ([e9b5091](https://github.com/Masutayunikon/FanKarr/commit/e9b5091242d73be77bf6fb525ce2865554e336cc))
+* skip excluded folders ([edf806d](https://github.com/Masutayunikon/FanKarr/commit/edf806d9bc48d4de1c3609a4b0405442305d546e))
+* title readme align ([8ba3b37](https://github.com/Masutayunikon/FanKarr/commit/8ba3b370d1e2cd1565f9c2453be8706e3c198243))
+* use bcryptjs for compilation ([6a6981e](https://github.com/Masutayunikon/FanKarr/commit/6a6981e10a3a9019f49982d7680e562872ee95a5))
+* worker outside the exe ([c2ab58e](https://github.com/Masutayunikon/FanKarr/commit/c2ab58e7b2c34aae09b50dbdfde3277da4c276ff))
+* worker outside the exe ([a47c3a4](https://github.com/Masutayunikon/FanKarr/commit/a47c3a43fb5dbbedd87c9ac2d584c3290fcc6097))
+* workflow directory ([baebd8f](https://github.com/Masutayunikon/FanKarr/commit/baebd8fae146db70ee1cce0c876d2d3bc0f9bf4e))
+* workflow directory ([d8405c1](https://github.com/Masutayunikon/FanKarr/commit/d8405c1589f277cd8fdd3e1fd15cc02d98834aa6))
+* workflow permmisions ([3620bfb](https://github.com/Masutayunikon/FanKarr/commit/3620bfb71d8c2774b23c097e5e01326099c2f180))
+
+## [1.9.5](https://github.com/Masutayunikon/FanKarr/compare/v1.9.4...v1.9.5) (2026-03-13)
+
+
+### Bug Fixes
+
+* worker outside the exe ([c2ab58e](https://github.com/Masutayunikon/FanKarr/commit/c2ab58e7b2c34aae09b50dbdfde3277da4c276ff))
+
+## [1.9.4](https://github.com/Masutayunikon/FanKarr/compare/v1.9.3...v1.9.4) (2026-03-13)
+
+
+### Bug Fixes
+
+* worker outside the exe ([a47c3a4](https://github.com/Masutayunikon/FanKarr/commit/a47c3a43fb5dbbedd87c9ac2d584c3290fcc6097))
+
+## [1.9.3](https://github.com/Masutayunikon/FanKarr/compare/v1.9.2...v1.9.3) (2026-03-13)
+
+
+### Bug Fixes
+
+* use bcryptjs for compilation ([6a6981e](https://github.com/Masutayunikon/FanKarr/commit/6a6981e10a3a9019f49982d7680e562872ee95a5))
+
+## [1.9.2](https://github.com/Masutayunikon/FanKarr/compare/v1.9.1...v1.9.2) (2026-03-13)
+
+
+### Bug Fixes
+
+* workflow directory ([baebd8f](https://github.com/Masutayunikon/FanKarr/commit/baebd8fae146db70ee1cce0c876d2d3bc0f9bf4e))
+
+## [1.9.1](https://github.com/Masutayunikon/FanKarr/compare/v1.9.0...v1.9.1) (2026-03-13)
+
+
+### Bug Fixes
+
+* workflow directory ([d8405c1](https://github.com/Masutayunikon/FanKarr/commit/d8405c1589f277cd8fdd3e1fd15cc02d98834aa6))
+* workflow permmisions ([3620bfb](https://github.com/Masutayunikon/FanKarr/commit/3620bfb71d8c2774b23c097e5e01326099c2f180))
+
+## [1.9.0](https://github.com/Masutayunikon/FanKarr/compare/v1.8.2...v1.9.0) (2026-03-13)
+
+
+### Features
+
+* add windows / linux / macos binaries on build ([f17a73b](https://github.com/Masutayunikon/FanKarr/commit/f17a73b9591fb49a75bd5fcdadf1970585877dab))
+
+## [1.8.2](https://github.com/Masutayunikon/FanKarr/compare/v1.8.1...v1.8.2) (2026-03-13)
+
+
+### Bug Fixes
+
+* season fallback ([e9b5091](https://github.com/Masutayunikon/FanKarr/commit/e9b5091242d73be77bf6fb525ce2865554e336cc))
+
+## [1.8.1](https://github.com/Masutayunikon/FanKarr/compare/v1.8.0...v1.8.1) (2026-03-13)
+
+
+### Bug Fixes
+
+* nfo settings and add json file when not existing ([0b6bfa6](https://github.com/Masutayunikon/FanKarr/commit/0b6bfa6a81d99353be877ed6d99687ad3d55adbc))
+
+## [1.8.0](https://github.com/Masutayunikon/FanKarr/compare/v1.7.3...v1.8.0) (2026-03-12)
+
+
+### Features
+
+* cache images ([da460de](https://github.com/Masutayunikon/FanKarr/commit/da460de60c4eec6851ea58ce0ae646a1208f6018))
+
+## [1.7.3](https://github.com/Masutayunikon/FanKarr/compare/v1.7.2...v1.7.3) (2026-03-12)
+
+
+### Bug Fixes
+
+* CatalogView.vue badge deleted ([d897192](https://github.com/Masutayunikon/FanKarr/commit/d8971920462efd8d1d99eb867016c96713dfef58))
+* empty docker-compose.yml ([303dfd8](https://github.com/Masutayunikon/FanKarr/commit/303dfd85b5d033e2b247fd064ae1ae612fdb49e1))
+
+## [1.7.2](https://github.com/Masutayunikon/FanKarr/compare/v1.7.1...v1.7.2) (2026-03-12)
+
+
+### Bug Fixes
+
+* docker is able to change directory ([af08f7d](https://github.com/Masutayunikon/FanKarr/commit/af08f7d9d4fb2e23c5feac6d33b2ef495f9d91b2))
+
+## [1.7.1](https://github.com/Masutayunikon/FanKarr/compare/v1.7.0...v1.7.1) (2026-03-12)
+
+
+### Bug Fixes
+
+* path ([314f817](https://github.com/Masutayunikon/FanKarr/commit/314f817280f39d10eb21c4784f2aea41b9a6d32c))
+
+## [1.7.0](https://github.com/Masutayunikon/FanKarr/compare/v1.6.0...v1.7.0) (2026-03-12)
+
+
+### Features
+
+* UX improvements, folder picker, download state & NFO support ([20771fc](https://github.com/Masutayunikon/FanKarr/commit/20771fc31c187fd1fea8aa9b07093b15621a5b85))
+
+
+### Bug Fixes
+
+* rename if the torrent name is not the same as the api ([b8fcf71](https://github.com/Masutayunikon/FanKarr/commit/b8fcf71f54ab14e5572a7553d8554b617b4981b7))
+
+## [1.6.0](https://github.com/Masutayunikon/FanKarr/compare/v1.5.0...v1.6.0) (2026-03-11)
+
+
+### Features
+
+* add favicon ([dc4a2d4](https://github.com/Masutayunikon/FanKarr/commit/dc4a2d48f5c0cddd8e431ce33a69fc9146143fb6))
+
+## [1.5.0](https://github.com/Masutayunikon/FanKarr/compare/v1.4.1...v1.5.0) (2026-03-11)
+
+
+### Features
+
+* **auth:** génération automatique du JWT secret au démarrage ([eaa52e9](https://github.com/Masutayunikon/FanKarr/commit/eaa52e90900ff0e198beae190d7ad0298a702482))
+
+## [1.4.1](https://github.com/Masutayunikon/FanKarr/compare/v1.4.0...v1.4.1) (2026-03-11)
+
+
+### Bug Fixes
+
+* logger third args ([5abac1e](https://github.com/Masutayunikon/FanKarr/commit/5abac1e11236ed1e8f7f0de7f0cff881d1b60f10))
+
+## [1.4.0](https://github.com/Masutayunikon/FanKarr/compare/v1.3.0...v1.4.0) (2026-03-11)
+
+
+### Features
+
+* add README.md ([4eb487a](https://github.com/Masutayunikon/FanKarr/commit/4eb487a96beed8c82cb19d9a9b63c3b69d841386))
+* **organize:** scan initial mediaPath + logs fichier centralisés ([807f786](https://github.com/Masutayunikon/FanKarr/commit/807f786b038579ca9d7cd136998f759cecae2255))
+
+
+### Bug Fixes
+
+* title readme align ([8ba3b37](https://github.com/Masutayunikon/FanKarr/commit/8ba3b370d1e2cd1565f9c2453be8706e3c198243))
+
 ## [1.3.0](https://github.com/Masutayunikon/FanKarr/compare/v1.2.0...v1.3.0) (2026-03-11)
 
 

Dockerfile

@@ -24,7 +24,7 @@ COPY --from=build /app/dist/server /app/dist/server
 COPY --from=build /app/dist/client /app/public
 COPY entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh
-RUN mkdir -p /app/data
+RUN mkdir -p /config
 
 EXPOSE 3001
 ENV NODE_ENV=production

README.md

@@ -1,5 +1,193 @@
-# Vue 3 + TypeScript + Vite
+<div align="center">
 
-This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+# Fankarr
 
-Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).
+![Version](https://img.shields.io/github/v/release/masutayunikon/fankarr?style=flat-square&color=e8513a&label=version)
+![Docker Image Size](https://img.shields.io/docker/image-size/masutayunikon/fankarr/latest?style=flat-square&color=1e2d3d&label=image)
+![Docker Pulls](https://img.shields.io/docker/pulls/masutayunikon/fankarr?style=flat-square&color=1e2d3d)
+![GitHub Actions](https://img.shields.io/github/actions/workflow/status/masutayunikon/fankarr/containerize.yml?style=flat-square&label=build)
+![License](https://img.shields.io/github/license/masutayunikon/fankarr?style=flat-square&color=5a7a94)
+![Node](https://img.shields.io/badge/node-20-5a7a94?style=flat-square)
+![Vue](https://img.shields.io/badge/vue-3-42b883?style=flat-square)
+
+**Gestionnaire de téléchargements pour le catalogue [Fankai](https://fankai.fr)**
+Inspiré de Radarr/Sonarr — interface dédiée aux éditions Kai & Yabai
+
+</div>
+
+---
+
+![Catalogue](.github/images/catalog.png)
+
+> Vue catalogue : toutes les séries Fankai avec leur état d'organisation. Les badges indiquent si les fichiers sont déjà présents dans votre médiathèque Jellyfin.
+
+---
+
+## Fonctionnalités
+
+- **Catalogue complet** des séries Fankai avec affiches, statut et badges d'état
+- **Téléchargement en un clic** vers qBittorrent — par épisode, par saison ou intégrale
+- **Organisation automatique** des fichiers téléchargés vers votre médiathèque (hardlink ou déplacement)
+- **Suivi par épisode** — badge ✓ organisé sur chaque épisode et compteur par saison
+- **Notifications** toast automatiques quand une organisation se termine
+- **Page téléchargements** avec statut d'organisation et badge erreurs avec détail au hover
+- **Logs centralisés** avec filtre par niveau/source, rotation automatique et clear depuis l'UI
+- **Multi-client torrent** — architecture extensible (qBittorrent supporté)
+- **Authentification** par mot de passe avec session JWT
+- **Compatible Runtipi / Docker**
+
+---
+
+![Serie](.github/images/serie.png)
+
+> Vue série : détail des épisodes avec leur état de disponibilité torrent et d'organisation dans Jellyfin.
+
+---
+
+![Download](.github/images/download.png)
+
+> Vue téléchargements : suivi en temps réel de l'organisation avec détail des erreurs au survol.
+
+---
+
+![Logs](.github/images/log.png)
+
+> Page logs : historique complet des événements avec filtres et gestion de la taille.
+
+---
+
+## Données torrent — Scraper
+
+Les données du catalogue sont récupérées depuis le repo [`fankarr-scraper`](https://github.com/masutayunikon/fankarr-scraper).
+
+Ce repo contient un pipeline de scripts Python qui collecte, parse et résout les torrents Fankai depuis les trackers publics, puis les croise avec l'API metadata de Fankai pour identifier chaque épisode. Les scripts tournent automatiquement **toutes les 6 heures** via GitHub Actions et publient le fichier `torrent_final.json` dans le repo.
+
+Fankarr récupère ce fichier au démarrage et via le bouton **Mettre à jour** dans les paramètres. Aucun scraping ne se fait en local.
+
+---
+
+## Installation
+
+### Docker Compose (recommandé)
+
+**Prérequis** : Docker + Docker Compose, qBittorrent accessible en réseau.
+
+```yaml
+services:
+  fankarr:
+    image: masutayunikon/fankarr:latest
+    container_name: fankarr
+    environment:
+      - PUID=1000        # UID de votre utilisateur (id -u)
+      - PGID=1000        # GID de votre utilisateur (id -g)
+      - TZ=Europe/Paris  # Votre timezone
+    volumes:
+      - ./config:/config  # Config, logs, base de données
+      - /votre/chemin:/media  # Racine de votre médiathèque (voir note hardlinks)
+    ports:
+      - 9898:9898
+    restart: unless-stopped
+```
+
+```bash
+docker compose up -d
+```
+
+> **⚠️ Note sur les hardlinks** : Pour que le mode `hardlink` fonctionne, vos dossiers de téléchargement complets et votre médiathèque doivent être sur le **même filesystem**. La solution recommandée est de monter un seul volume racine (ex: `/votre/chemin:/media`) et de configurer vos chemins à l'intérieur — comme le font Radarr et Sonarr.
+>
+> Vous pouvez tout à fait monter plusieurs volumes si vous le souhaitez, mais dans ce cas les hardlinks ne seront pas possibles entre deux volumes différents et Fankarr basculera automatiquement en copie.
+
+### Binaire autonome (Windows / Linux / macOS)
+
+Téléchargez l'archive correspondant à votre système depuis les [Releases GitHub](https://github.com/masutayunikon/fankarr/releases/latest) :
+
+| Système               | Archive                   |
+| --------------------- | ------------------------- |
+| Windows x64           | `fankarr-windows-x64.zip` |
+| Linux x64             | `fankarr-linux-x64.zip`   |
+| macOS (Apple Silicon) | `fankarr-macos.zip`       |
+
+Extrayez l'archive — elle contient le binaire **et** le dossier `public/` qui doivent rester ensemble :
+
+```
+fankarr-windows-x64/
+├── fankarr.exe   ← lancer ce fichier
+└── public/       ← ne pas déplacer séparément
+```
+
+**Linux / macOS** : rendre le binaire exécutable avant le premier lancement :
+
+```bash
+chmod +x fankarr
+./fankarr
+```
+
+Fankarr sera accessible sur `http://localhost:9898`. Les données (config, logs, base de données) sont sauvegardées dans un dossier `data/` créé automatiquement à côté du binaire.
+
+### Variables d'environnement
+
+| Variable         | Défaut       | Description                                                             |
+| ---------------- | ------------ | ----------------------------------------------------------------------- |
+| `PUID`           | `1000`       | UID utilisateur pour les permissions fichiers (Docker)                  |
+| `PGID`           | `1000`       | GID utilisateur pour les permissions fichiers (Docker)                  |
+| `TZ`             | —            | Timezone (ex: `Europe/Paris`)                                           |
+| `PORT`           | `9898`       | Port d'écoute du serveur                                                |
+| `JWT_SECRET`     | auto-généré  | Secret JWT — généré automatiquement dans `/config/secret.key` si absent |
+| `GITHUB_RAW_URL` | repo scraper | URL du `torrent_final.json` à utiliser                                  |
+
+### Premier démarrage
+
+1. Ouvrir `http://localhost:9898`
+2. Créer un mot de passe à la première connexion
+3. Aller dans **Paramètres** → ajouter votre client qBittorrent
+4. Vérifier les chemins `completePath` et `mediaPath`
+5. Choisir le mode d'organisation : `hardlink` (recommandé) ou `move`
+6. Retourner au catalogue et télécharger
+
+---
+
+## Organisation des fichiers
+
+Fankarr organise automatiquement les fichiers terminés toutes les **30 secondes** vers la structure attendue par Jellyfin :
+
+```
+/media/Kai/
+└── Black Lagoon Henshū/
+    └── Saison 1/
+        ├── Black Lagoon Henshū S01E01.mkv
+        ├── Black Lagoon Henshū S01E02.mkv
+        └── ...
+```
+
+Le mode **hardlink** est recommandé si vos dossiers `complete` et `media` sont sur le même filesystem — les fichiers ne sont pas déplacés, qBittorrent continue de seeder.
+
+---
+
+## Runtipi
+
+Fankarr est disponible dans l'appstore personnalisé. Pour l'installer :
+
+1. Dans Runtipi, aller dans **Paramètres → App Stores**
+2. Ajouter l'URL : `https://github.com/Masutayunikon/runtipi-appstore`
+3. Fankarr apparaît dans le catalogue → **Installer**
+
+---
+
+## Stack technique
+
+| Couche            | Technologie                              |
+| ----------------- | ---------------------------------------- |
+| Frontend          | Vue 3 + Vite + Tailwind CSS              |
+| Backend           | Express 5 + TypeScript                   |
+| Auth              | JWT + bcrypt                             |
+| Packaging Docker  | `node:20-slim` + pnpm + gosu (PUID/PGID) |
+| Packaging binaire | Bun (self-contained, pas de Node requis) |
+
+---
+
+## Liens
+
+- [fankai.fr](https://fankai.fr) — Le projet Fankai
+- [Plugin Jellyfin Fankai](https://github.com/Nackophilz/fankai_jellyfin) — Reconnaissance des métadonnées dans Jellyfin
+- [fankarr-scraper](https://github.com/masutayunikon/fankarr-scraper) — Pipeline de collecte des torrents
+- [runtipi-appstore](https://github.com/Masutayunikon/runtipi-appstore) — Appstore Runtipi personnel

docker-compose.yml

@@ -0,0 +1,14 @@
+fankarr:
+  image: masutayunikon/fankarr:latest
+  container_name: fankarr
+  environment:
+    - PUID=1000        # UID de votre utilisateur (id -u)
+    - PGID=1000        # GID de votre utilisateur (id -g)
+    - TZ=Europe/Paris  # Votre timezone
+  volumes:
+    - ./config:/config  # Config, logs, base de données
+    - /votre/chemin:/media  # Racine de votre mediatheque (hardlinks compatibles)
+  ports:
+    - 9898:9898
+  restart: unless-stopped
+ 

entrypoint.sh

@@ -7,6 +7,6 @@ PGID=${PGID:-1000}
 echo "[fankarr] Running as UID=${PUID} GID=${PGID}"
 
 # Corriger les permissions du dossier data
-chown -R "$PUID:$PGID" /app/data
+chown -R "$PUID:$PGID" /config
 
 exec gosu "$PUID:$PGID" node dist/server/index.js

package.json

@@ -7,12 +7,16 @@
     "dev": "concurrently \"vite\" \"tsx watch server/index.ts\"",
     "dev:server": "tsx watch server/index.ts",
     "dev:client": "vite",
-    "build": "vite build --outDir dist/client && tsc -p tsconfig.server.json",
+    "build": "vite build && tsc -p tsconfig.server.json",
+    "build:bun:linux": "bun build server/index.ts --compile --target bun-linux-x64    --outfile binaries/fankarr-linux-x64 && bun build server/organize-worker.ts --target node --outfile binaries/organize-worker.js",
+    "build:bun:windows": "bun build server/index.ts --compile --target bun-windows-x64  --outfile binaries/fankarr-windows-x64.exe && bun build server/organize-worker.ts --target node --outfile binaries/organize-worker.js",
+    "build:bun:macos": "bun build server/index.ts --compile --target bun-darwin-arm64 --outfile binaries/fankarr-macos && bun build server/organize-worker.ts --target node --outfile binaries/organize-worker.js",
+    "build:bun:all": "pnpm build:bun:linux && pnpm build:bun:windows && pnpm build:bun:macos",
+    "start": "node dist/server/index.js",
     "preview": "vite preview"
   },
   "dependencies": {
     "@tailwindcss/vite": "^4.2.1",
-    "bcrypt": "^6.0.0",
     "cookie-parser": "^1.4.7",
     "express": "^5.2.1",
     "jsonwebtoken": "^9.0.3",
@@ -20,10 +24,10 @@
     "pinia": "^3.0.4",
     "tailwindcss": "^4.2.1",
     "vue": "^3.5.25",
-    "vue-router": "^5.0.3"
+    "vue-router": "^5.0.3",
+    "bcryptjs": "^3.0.3"
   },
   "devDependencies": {
-    "@types/bcrypt": "^5.0.2",
     "@types/cookie-parser": "^1.4.8",
     "@types/express": "^5.0.6",
     "@types/jsonwebtoken": "^9.0.9",
@@ -34,6 +38,7 @@
     "tsx": "^4.21.0",
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
-    "vue-tsc": "^3.1.5"
+    "vue-tsc": "^3.1.5",
+    "@types/bcrypt": "^5.0.2"
   }
 }

pnpm-lock.yaml

@@ -11,9 +11,9 @@ importers:
       '@tailwindcss/vite':
         specifier: ^4.2.1
         version: 4.2.1(vite@7.3.1(@types/node@24.12.0)(jiti@2.6.1)(lightningcss@1.31.1)(tsx@4.21.0)(yaml@2.8.2))
-      bcrypt:
-        specifier: ^6.0.0
-        version: 6.0.0
+      bcryptjs:
+        specifier: ^3.0.3
+        version: 3.0.3
       cookie-parser:
         specifier: ^1.4.7
         version: 1.4.7
@@ -650,9 +650,9 @@ packages:
     resolution: {integrity: sha512-cbdCP0PGOBq0ASG+sjnKIoYkWMKhhz+F/h9pRexUdX2Hd38+WOlBkRKlqkGOSm0YQpcFMQBJeK4WspUAkwsEdg==}
     engines: {node: '>=20.19.0'}
 
-  bcrypt@6.0.0:
-    resolution: {integrity: sha512-cU8v/EGSrnH+HnxV2z0J7/blxH8gq7Xh2JFT6Aroax7UohdmiJJlxApMxtKfuI7z68NvvVcmR78k2LbT6efhRg==}
-    engines: {node: '>= 18'}
+  bcryptjs@3.0.3:
+    resolution: {integrity: sha512-GlF5wPWnSa/X5LKM1o0wz0suXIINz1iHRLvTS+sLyi7XPbe5ycmYI3DlZqVGZZtDgl4DmasFg7gOB3JYbphV5g==}
+    hasBin: true
 
   birpc@2.9.0:
     resolution: {integrity: sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==}
@@ -1087,10 +1087,6 @@ packages:
     resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
     engines: {node: '>= 0.6'}
 
-  node-addon-api@8.6.0:
-    resolution: {integrity: sha512-gBVjCaqDlRUk0EwoPNKzIr9KkS9041G/q31IBShPs1Xz6UTA+EXdZADbzqAJQrpDRq71CIMnOP5VMut3SL0z5Q==}
-    engines: {node: ^18 || ^20 || >= 21}
-
   node-domexception@1.0.0:
     resolution: {integrity: sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==}
     engines: {node: '>=10.5.0'}
@@ -1100,10 +1096,6 @@ packages:
     resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
-  node-gyp-build@4.8.4:
-    resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}
-    hasBin: true
-
   object-inspect@1.13.4:
     resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
     engines: {node: '>= 0.4'}
@@ -1919,10 +1911,7 @@ snapshots:
       '@babel/parser': 7.29.0
       ast-kit: 2.2.0
 
-  bcrypt@6.0.0:
-    dependencies:
-      node-addon-api: 8.6.0
-      node-gyp-build: 4.8.4
+  bcryptjs@3.0.3: {}
 
   birpc@2.9.0: {}
 
@@ -2351,8 +2340,6 @@ snapshots:
 
   negotiator@1.0.0: {}
 
-  node-addon-api@8.6.0: {}
-
   node-domexception@1.0.0: {}
 
   node-fetch@3.3.2:
@@ -2361,8 +2348,6 @@ snapshots:
       fetch-blob: 3.2.0
       formdata-polyfill: 4.0.10
 
-  node-gyp-build@4.8.4: {}
-
   object-inspect@1.13.4: {}
 
   on-finished@2.4.1:

server/auth.ts

@@ -1,11 +1,12 @@
 import fs from 'fs'
 import path from 'path'
-import bcrypt from 'bcrypt'
+import bcrypt from 'bcryptjs'
 import jwt from 'jsonwebtoken'
 import type { Request, Response, NextFunction } from 'express'
+import { JWT_SECRET } from './secret.js'
+import { DATA_DIR } from './config.js'
 
-const DATA_PATH = path.join(process.cwd(), 'data', 'auth.json')
-const JWT_SECRET = process.env.JWT_SECRET || 'fankarr-secret-change-me'
+const DATA_PATH = path.join(DATA_DIR, 'auth.json')
 const SALT_ROUNDS = 10
 
 interface AuthData {
@@ -63,7 +64,7 @@ export function authSetup(req: Request, res: Response): void {
     const passwordHash = bcrypt.hashSync(password, SALT_ROUNDS)
     writeAuth({ username, passwordHash })
 
-    const token = jwt.sign({ username }, JWT_SECRET, { expiresIn: '30d' })
+    const token = jwt.sign({ username }, JWT_SECRET, { expiresIn: '1d' })
     res.cookie('fankarr_token', token, { httpOnly: true, sameSite: 'lax' })
     res.json({ success: true })
 }
@@ -87,7 +88,7 @@ export function authLogin(req: Request, res: Response): void {
         return
     }
 
-    const token = jwt.sign({ username }, JWT_SECRET, { expiresIn: '30d' })
+    const token = jwt.sign({ username }, JWT_SECRET, { expiresIn: '1d' })
     res.cookie('fankarr_token', token, { httpOnly: true, sameSite: 'lax' })
     res.json({ success: true })
 }

server/config.ts

@@ -0,0 +1,13 @@
+import fs from 'fs'
+import path from 'path'
+
+export const _isBunBinary = typeof (globalThis as any).Bun !== 'undefined'
+    && path.dirname((process as any).execPath) !== process.cwd()
+
+export const BASE_DIR = _isBunBinary
+    ? path.dirname((process as any).execPath)
+    : process.cwd()
+
+export const DATA_DIR = fs.existsSync('/.dockerenv')
+    ? '/config'
+    : path.join(BASE_DIR, 'config')

server/index.ts

@@ -10,23 +10,23 @@ import {
     sanitizeClient, dispatchDownload, dispatchList
 } from './torrent-clients/index.js'
 import qbittorrentDriver from './torrent-clients/qbittorrent.js'
-import { organizeTorrent, autoOrganizeAll } from './organize.js'
+import { organizeTorrent, autoOrganizeAll, scanMediaPath } from './organize.js'
 import { logger, readLogs, clearLogs, logsFileSize } from './logger.js'
+import { DATA_DIR, BASE_DIR }  from './config.js'
 
 registerDriver(qbittorrentDriver)
 
 const app = express()
-const PORT = 3001
-const FANKAI_API    = 'https://metadata.fankai.fr'
-const TORRENTS_PATH = path.join(process.cwd(), 'data', 'torrent_final.json')
-const GITHUB_RAW_URL = process.env.GITHUB_RAW_URL
-    ?? 'https://raw.githubusercontent.com/masutayunikon/fankarr-scraper/main/data/torrent_final.json'
+const PORT = Number(process.env.PORT) || 9898
+const FANKAI_API  = 'https://metadata.fankai.fr'
+const GITHUB_BASE = process.env.GITHUB_BASE
+    ?? 'https://raw.githubusercontent.com/masutayunikon/fankarr-scraper/main'
 
 app.use(express.json())
 app.use(cookieParser())
 
 // ── Static frontend (prod) ─────────────────────────────────────
-const PUBLIC_PATH = path.join(process.cwd(), 'public')
+const PUBLIC_PATH = path.join(BASE_DIR, 'public')
 if (fs.existsSync(PUBLIC_PATH)) {
     app.use(express.static(PUBLIC_PATH))
 }
@@ -42,8 +42,8 @@ app.get('/api/settings', requireAuth, (_req, res) => {
     res.json(readSettings())
 })
 app.post('/api/settings', requireAuth, (req, res) => {
-    const { mediaPath, completePath, organizeMode, category } = req.body
-    res.json(writeSettings({ mediaPath, completePath, organizeMode, category }))
+    const { mediaPath, completePath, organizeMode, category, nfoSupport, autoImport } = req.body
+    res.json(writeSettings({ mediaPath, completePath, organizeMode, category, nfoSupport, autoImport }))
 })
 
 // ── Torrent clients ────────────────────────────────────────────
@@ -86,71 +86,315 @@ app.get('/api/torrent-clients/:uuid/healthcheck', requireAuth, async (req, res)
     res.json(await driver.healthcheck(client.config))
 })
 
-// ── Helpers ────────────────────────────────────────────────────
-function readTorrents(): any[] {
+// ── Cache GitHub ───────────────────────────────────────────────
+
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000  // 6 heures
+
+interface CacheEntry<T> { data: T; expiresAt: number }
+const _cache = new Map<string, CacheEntry<any>>()
+
+function cacheGet<T>(key: string): T | null {
+    const entry = _cache.get(key)
+    if (!entry) return null
+    if (Date.now() > entry.expiresAt) { _cache.delete(key); return null }
+    return entry.data as T
+}
+
+function cacheSet<T>(key: string, data: T): void {
+    _cache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS })
+}
+
+function cacheClear(): void { _cache.clear() }
+
+async function githubGet(urlPath: string): Promise<any> {
+    const key = urlPath
+    const cached = cacheGet(key)
+    if (cached) return cached
+    const res = await fetch(`${GITHUB_BASE}/${urlPath}`)
+    if (!res.ok) throw new Error(`GitHub ${res.status}: ${urlPath}`)
+    const data = await res.json()
+    cacheSet(key, data)
+    return data
+}
+
+async function readAvailable(): Promise<number[]> {
     try {
-        if (!fs.existsSync(TORRENTS_PATH)) return []
-        return JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8'))
+        return await githubGet('available.json') as number[]
     } catch { return [] }
 }
+
+async function readSerieData(serieId: number): Promise<any | null> {
+    try {
+        return await githubGet(`series/${serieId}.json`)
+    } catch { return null }
+}
+
+// Extrait tous les torrents d'un series/{id}.json avec leur type et niveau hiérarchique
+// Retourne une liste plate compatible avec l'ancienne interface { infohash, torrent_url, magnet, raw, type, ... }
+function extractTorrentsFromSerieData(sd: any): any[] {
+    const result: any[] = []
+    if (!sd) return result
+
+    // Torrents au niveau série → pack_integrale (ou pack_saison si une seule saison)
+    for (const t of sd.torrents ?? []) {
+        result.push({
+            ...t,
+            raw       : t.title,
+            type      : 'pack_integrale',
+            serie_id  : sd.id,
+            serie_title: sd.title,
+            // episodes couverts : tous les épisodes de toutes les saisons qui ont paths[i]
+            _serieLevel: true,
+            _serieData : sd,
+            _torrentIdx: (sd.torrents ?? []).indexOf(t),
+        })
+    }
+
+    // Torrents au niveau saison → pack_saison
+    for (const season of sd.seasons ?? []) {
+        for (const t of season.torrents ?? []) {
+            result.push({
+                ...t,
+                raw          : t.title,
+                type         : 'pack_saison',
+                serie_id     : sd.id,
+                serie_title  : sd.title,
+                season_id    : season.id,
+                season_number: season.season_number,
+                _seasonLevel : true,
+                _season      : season,
+                _torrentIdx  : (season.torrents ?? []).indexOf(t),
+            })
+        }
+
+        // Torrents au niveau épisode → episode
+        for (const ep of season.episodes ?? []) {
+            for (const t of ep.torrents ?? []) {
+                result.push({
+                    ...t,
+                    raw          : t.title,
+                    type         : 'episode',
+                    serie_id     : sd.id,
+                    serie_title  : sd.title,
+                    season_id    : season.id,
+                    season_number: season.season_number,
+                    episode_id   : ep.id,
+                    episode_number: ep.episode_number,
+                    _episodeLevel: true,
+                    _episode     : ep,
+                    _torrentIdx  : (ep.torrents ?? []).indexOf(t),
+                })
+            }
+        }
+    }
+
+    return result
+}
+
+// Construit resolved_episodes pour un torrent à partir des paths[torrentIdx]
+// Construit les épisodes résolus pour un torrent donné par son infohash
+function buildResolvedEpisodes(sd: any, hash: string, seasonFilter?: number): any[] {
+    const resolved: any[] = []
+    const h = hash.toLowerCase()
+
+    for (const season of sd.seasons ?? []) {
+        if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
+        for (const ep of season.episodes ?? []) {
+            const paths: any[] = ep.paths ?? []
+
+            // Nouveau format { infohash, path } ou legacy string
+            let filePath: string | null = null
+            for (const p of paths) {
+                if (typeof p === 'string') {
+                    if (!filePath) filePath = p.replace(/\\/g, '/')  // legacy fallback
+                } else if (p?.infohash?.toLowerCase() === h) {
+                    filePath = p.path.replace(/\\/g, '/')
+                    break
+                }
+            }
+            if (!filePath) continue
+
+            const filename = filePath.split('/').pop() ?? filePath
+            resolved.push({
+                episode_id       : ep.id,
+                episode_number   : ep.episode_number,
+                season_number    : season.season_number,
+                season_id        : season.id,
+                filename,
+                original_filename: filename,
+            })
+        }
+    }
+    return resolved
+}
+
 async function fankaiGet(endpoint: string): Promise<any> {
     const res = await fetch(`${FANKAI_API}${endpoint}`)
     if (!res.ok) throw new Error(`Fankai API ${res.status}: ${endpoint}`)
     return res.json()
 }
-function indexBySerie(torrents: any[]): Map<number, any[]> {
-    const map = new Map<number, any[]>()
-    for (const t of torrents) {
-        if (!t.serie_id) continue
-        if (!map.has(t.serie_id)) map.set(t.serie_id, [])
-        map.get(t.serie_id)!.push(t)
-    }
-    return map
+
+function normalizeTitle(s: string): string {
+    return s.toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
 }
 
-// ── Series ─────────────────────────────────────────────────────
+function imgProxy(url: string | null | undefined, w: number, q = 70): string | null {
+    if (!url) return null
+    const stripped = url.replace(/^https?:\/\//, '')
+    return `https://wsrv.nl/?url=${stripped}&w=${w}&q=${q}`
+}
+
+function normalizeSerie(serie: any): any {
+    const poster = serie.poster_image ?? serie.images?.poster ?? null
+    const fanart = serie.fanart_image ?? serie.images?.fanart  ?? null
+    return {
+        ...serie,
+        poster_image: imgProxy(poster, 300),
+        fanart_image: imgProxy(fanart, 1280, 60),
+    }
+}
+
+function normalizeSeason(season: any): any {
+    const poster = season.poster_image ?? season.images?.poster ?? null
+    return {
+        ...season,
+        poster_image: imgProxy(poster, 300),
+    }
+}
+
+function normalizeEpisode(ep: any): any {
+    const thumb = ep.thumb_image ?? ep.thumbnail ?? null
+    return {
+        ...ep,
+        thumb_image: imgProxy(thumb, 400),
+    }
+}
+
+// ── Enrichissement seriesData avec original_filename depuis l'API ──────────────
+// Fetche /seasons/{id}/episodes pour chaque saison et injecte original_filename
+// dans chaque épisode du serieData, indexé par episode_id
+async function enrichSeriesDataWithOriginalFilenames(seriesData: any[]): Promise<any[]> {
+    const results: any[] = []
+
+    for (const sd of seriesData) {
+        if (!sd) { results.push(sd); continue }
+
+        const enrichedSeasons: any[] = []
+        for (const season of sd.seasons ?? []) {
+            let epsData: any[] = []
+            try {
+                // 2 tentatives en cas d'erreur réseau ponctuelle
+                let lastErr: any
+                for (let attempt = 0; attempt < 2; attempt++) {
+                    try {
+                        const res = await fankaiGet(`/seasons/${season.id}/episodes`)
+                        epsData = Array.isArray(res) ? res : (res.episodes ?? [])
+                        break
+                    } catch (e) {
+                        lastErr = e
+                        if (attempt === 0) await new Promise(r => setTimeout(r, 500))
+                    }
+                }
+                if (epsData.length === 0 && lastErr) throw lastErr
+            } catch {
+                enrichedSeasons.push(season)
+                continue
+            }
+
+            // Petit délai pour ne pas saturer l'API
+            await new Promise(r => setTimeout(r, 50))
+
+            const origMap = new Map<number, { original_filename: string; formatted_name: string }>()
+            for (const ep of epsData) {
+                if (ep.id) origMap.set(ep.id, {
+                    original_filename: ep.original_filename ?? '',
+                    formatted_name   : ep.formatted_name ?? '',
+                })
+            }
+
+            const enrichedEpisodes = (season.episodes ?? []).map((ep: any) => ({
+                ...ep,
+                original_filename: origMap.get(ep.id)?.original_filename ?? null,
+                formatted_name   : origMap.get(ep.id)?.formatted_name    ?? null,
+            }))
+
+            enrichedSeasons.push({ ...season, episodes: enrichedEpisodes })
+        }
+
+        results.push({ ...sd, seasons: enrichedSeasons })
+    }
+
+    return results
+}
+
+// Helper réutilisable : charge + enrichit toutes les seriesData du cache
+async function loadEnrichedSeriesData(): Promise<any[]> {
+    const ids   = await readAvailable()
+    const allSd = await Promise.all(ids.map(id => readSerieData(id)))
+    const valid = allSd.filter(Boolean)
+    return enrichSeriesDataWithOriginalFilenames(valid)
+}
 
 function computeSerieDownloadState(
-    serieTorrents : any[],
+    serieData     : any | null,
     organized     : Record<string, Record<string, string>>,
-    activeTorrents: Set<string>  // hashes actuellement dans qB en downloading
+    activeTorrents: Set<string>
 ): 'none' | 'downloading' | 'partial' | 'complete' {
-    if (serieTorrents.length === 0) return 'none'
+    if (!serieData) return 'none'
 
-    // Un torrent de la série est en cours de téléchargement ?
-    const hasActive = serieTorrents.some(t => activeTorrents.has(t.infohash?.toLowerCase()))
+    const allTorrents = extractTorrentsFromSerieData(serieData)
+    if (allTorrents.length === 0) return 'none'
+
+    const hasActive = allTorrents.some(t => t.infohash && activeTorrents.has(t.infohash.toLowerCase()))
     if (hasActive) return 'downloading'
 
-    // Compter les fichiers attendus vs organisés
-    let totalFiles = 0
-    let doneFiles  = 0
-    for (const t of serieTorrents) {
-        const files: any[] = t.torrent_files ?? []
-        if (files.length === 0) {
-            // Fichier unique
-            totalFiles++
-            if (organized[t.infohash?.toLowerCase()]?.[t.raw]) doneFiles++
-        } else {
-            totalFiles += files.length
-            doneFiles  += files.filter((f: any) => organized[t.infohash?.toLowerCase()]?.[f.filename]).length
+    // Collecter tous les episode_id de la série et ceux organisés
+    const allEpisodeIds = new Set<number>()
+    const organizedEpisodeIds = new Set<number>()
+
+    for (const season of serieData.seasons ?? []) {
+        for (const ep of season.episodes ?? []) {
+            if ((ep.torrents ?? []).length > 0 || (ep.paths ?? []).length > 0) {
+                allEpisodeIds.add(ep.id)
+            }
         }
     }
 
-    if (totalFiles === 0) return 'none'
-    if (doneFiles === 0)  return 'none'
-    if (doneFiles >= totalFiles) return 'complete'
+    // Vérifier via organized.json : si le filename du path est organisé
+    for (const t of allTorrents) {
+        const hash = t.infohash?.toLowerCase()
+        if (!hash) continue
+        const orgFiles = organized[hash] ?? {}
+        if (Object.keys(orgFiles).length === 0) continue
+        const resolved = buildResolvedEpisodes(serieData, hash, t.season_number)
+        for (const ep of resolved) {
+            if (orgFiles[ep.filename]) organizedEpisodeIds.add(ep.episode_id)
+        }
+    }
+
+    if (allEpisodeIds.size === 0) return 'none'
+    if (organizedEpisodeIds.size === 0) return 'none'
+    if (organizedEpisodeIds.size >= allEpisodeIds.size) return 'complete'
     return 'partial'
 }
 
 app.get('/api/series', requireAuth, async (_req, res) => {
     try {
-        const [apiData, torrents] = await Promise.all([fankaiGet('/series'), Promise.resolve(readTorrents())])
-        const byId = indexBySerie(torrents)
+        const [apiData, availableIds] = await Promise.all([
+            fankaiGet('/series'),
+            readAvailable(),
+        ])
+        const availableSet = new Set<number>(availableIds)
 
         // Charger organized.json
         let organized: Record<string, Record<string, string>> = {}
         try {
-            const orgPath = path.join(process.cwd(), 'data', 'organized.json')
+            const orgPath = path.join(DATA_DIR, 'organized.json')
             if (fs.existsSync(orgPath))
                 organized = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
         } catch {}
@@ -161,19 +405,31 @@ app.get('/api/series', requireAuth, async (_req, res) => {
             const { category } = readSettings()
             const active = await dispatchList(category ?? 'fankai')
             for (const t of active) {
-                if (t.state === 'downloading' && t.hash)
-                    activeTorrents.add(t.hash.toLowerCase())
+                if (t.hash && t.state === 'downloading') activeTorrents.add(t.hash.toLowerCase())
             }
         } catch {}
 
-        const seriesList = Array.isArray(apiData) ? apiData : (apiData.series ?? [])
-        res.json({ series: seriesList.map((serie: any) => {
-                const serieTorrents = byId.get(serie.id) ?? []
+        const seriesRaw = (Array.isArray(apiData) ? apiData : (apiData.series ?? [])).map(normalizeSerie)
+
+        // Charger les series data en parallèle uniquement pour celles qui ont des torrents
+        const serieDataMap = new Map<number, any>()
+        await Promise.all(
+            seriesRaw
+                .filter((s: any) => availableSet.has(s.id))
+                .map(async (s: any) => {
+                    const sd = await readSerieData(s.id)
+                    if (sd) serieDataMap.set(s.id, sd)
+                })
+        )
+
+        res.json({ series: seriesRaw.map((serie: any) => {
+                const hasTorrents = availableSet.has(serie.id)
+                const serieData   = serieDataMap.get(serie.id) ?? null
                 return {
                     ...serie,
-                    torrent_count : serieTorrents.length,
-                    has_torrents  : serieTorrents.length > 0,
-                    download_state: computeSerieDownloadState(serieTorrents, organized, activeTorrents),
+                    torrent_count : serieData ? extractTorrentsFromSerieData(serieData).length : 0,
+                    has_torrents  : hasTorrents,
+                    download_state: computeSerieDownloadState(serieData, organized, activeTorrents),
                 }
             })})
     } catch (err) {
@@ -184,129 +440,127 @@ app.get('/api/series', requireAuth, async (_req, res) => {
 app.get('/api/series/:id', requireAuth, async (req, res) => {
     const id = Number(req.params.id)
     try {
-        const [serie, seasonsData] = await Promise.all([fankaiGet(`/series/${id}`), fankaiGet(`/series/${id}/seasons`)])
+        const [serieRaw, seasonsData, serieData] = await Promise.all([
+            fankaiGet(`/series/${id}`),
+            fankaiGet(`/series/${id}/seasons`),
+            readSerieData(id),
+        ])
+        const serie   = normalizeSerie(serieRaw)
         const seasons = Array.isArray(seasonsData) ? seasonsData : (seasonsData.seasons ?? [])
+
+        // Fetch épisodes depuis l'API Fankai (avec original_filename, thumb_image, etc.)
         const seasonsWithEpisodes = await Promise.all(seasons.map(async (season: any) => {
-            const epsData = await fankaiGet(`/seasons/${season.id}/episodes`)
-            return { ...season, episodes: Array.isArray(epsData) ? epsData : (epsData.episodes ?? []) }
+            const epsData  = await fankaiGet(`/seasons/${season.id}/episodes`)
+            const episodes = (Array.isArray(epsData) ? epsData : (epsData.episodes ?? [])).map(normalizeEpisode)
+            return { ...normalizeSeason(season), episodes }
         }))
 
-        const torrents = readTorrents().filter(t => t.serie_id === id)
-        const allSeasonIds = new Set<number>(seasonsWithEpisodes.filter((s: any) => s.season_number !== 0).map((s: any) => s.id))
-        const availableEpisodeIds  = new Set<number>()
-        const episodeTorrentMap: Record<number, any> = {}
-        const seasonTorrentMap : Record<number, any> = {}
-        const integraleTorrents: any[] = []
-        const packEpisodesTorrents: any[] = []
-
-        for (const t of torrents) {
-            const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: t.type, raw: t.raw }
-            for (const ep of t.resolved_episodes ?? []) {
-                availableEpisodeIds.add(ep.episode_id)
-                if (t.type === 'episode') episodeTorrentMap[ep.episode_id] = ref
-            }
-            if (t.type === 'pack_saison') {
-                const rs: any[] = t.resolved_seasons ?? []
-                if (rs.length > 1) {
-                    packEpisodesTorrents.push(t)
-                } else {
-                    const sids = rs.length > 0 ? rs.map((r: any) => r.season_id) : [t.season_id]
-                    for (const sid of sids) { if (sid) seasonTorrentMap[sid] = ref }
-                }
-            } else if (t.type === 'pack_integrale') {
-                integraleTorrents.push(t)
-            } else if (t.type === 'pack_episodes') {
-                packEpisodesTorrents.push(t)
-            }
-        }
-
-        let promotedIntegrale: any = null
-        if (integraleTorrents.length === 0 && allSeasonIds.size > 0) {
-            for (const t of torrents.filter(t => t.type === 'pack_saison')) {
-                const rs: any[] = t.resolved_seasons ?? []
-                const tIds = new Set<number>(rs.length > 0 ? rs.map((r: any) => r.season_id) : t.season_id ? [t.season_id] : [])
-                if ([...allSeasonIds].every(sid => tIds.has(sid))) { promotedIntegrale = t; break }
-            }
-        }
-
-        if (integraleTorrents.length > 0 || promotedIntegrale) {
-            for (const key of Object.keys(seasonTorrentMap)) delete seasonTorrentMap[Number(key)]
-            if (promotedIntegrale) {
-                const idx = packEpisodesTorrents.indexOf(promotedIntegrale)
-                if (idx !== -1) packEpisodesTorrents.splice(idx, 1)
-            }
-        }
-
-        function packEpisodesLabel(t: any): string {
-            const eps: any[] = t.resolved_episodes ?? []
-            if (!eps.length) return t.raw
-            const bySeason = new Map<number, number[]>()
-            for (const ep of eps) {
-                const sn = ep.season_number ?? 0
-                if (!bySeason.has(sn)) bySeason.set(sn, [])
-                bySeason.get(sn)!.push(ep.episode_number)
-            }
-            return [...bySeason.entries()].sort(([a], [b]) => a - b).map(([sn, nums]) => {
-                const s = nums.sort((a, b) => a - b)
-                const label = sn === 0 ? 'S0' : `S${sn}`
-                return s[0] === s[s.length-1] ? `${label} Ep ${s[0]}` : `${label} Eps ${s[0]}-${s[s.length-1]}`
-            }).join(' · ')
-        }
-
-        // Charger organized.json pour les badges d'état
+        // Charger organized.json
         let organized: Record<string, Record<string, string>> = {}
         try {
-            const orgPath = path.join(process.cwd(), 'data', 'organized.json')
+            const orgPath = path.join(DATA_DIR, 'organized.json')
             if (fs.existsSync(orgPath))
                 organized = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
         } catch {}
 
-        // Construire un set des episode_id organisés
-        // On croise resolved_episodes de chaque torrent avec organized.json
-        const organizedEpisodeIds = new Set<number>()
-        for (const t of torrents) {
-            const hash  = t.infohash?.toLowerCase()
-            const files = t.torrent_files ?? []
-            const orgFiles = organized[hash] ?? {}
-            if (Object.keys(orgFiles).length === 0) continue
-            // Au moins un fichier organisé pour ce torrent → on marque les épisodes résolus
-            for (const ep of t.resolved_episodes ?? []) {
-                // Vérifier si le fichier de cet épisode est organisé
-                const epFile = files.find((f: any) =>
-                    f.episode_ids?.includes(ep.episode_id) || f.episode_number === ep.episode_number
-                )
-                if (epFile ? orgFiles[epFile.filename] : Object.keys(orgFiles).length > 0) {
-                    organizedEpisodeIds.add(ep.episode_id)
+        // ── Construire les maps torrent depuis series/{id}.json ───────────
+        const availableEpisodeIds   = new Set<number>()
+        const episodeTorrentMap     : Record<number, any> = {}  // episode_id → ref
+        const seasonTorrentMapBySn  : Record<number, any> = {}  // season_number → ref
+        const integraleTorrents     : any[] = []
+        const packEpisodesTorrents  : any[] = []
+        const organizedEpisodeIds   = new Set<number>()
+
+        if (serieData) {
+            // ── Torrents niveau série (pack_integrale) ──────────────────
+            for (const t of (serieData.torrents ?? [])) {
+                const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'pack_integrale', raw: t.title, manual: t.manual ?? false }
+                integraleTorrents.push({ ...t, raw: t.title })
+
+                const resolved = buildResolvedEpisodes(serieData, t.infohash)
+                for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
+
+                const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                for (const ep of resolved) {
+                    if (orgFiles[ep.filename]) organizedEpisodeIds.add(ep.episode_id)
                 }
             }
+
+            // ── Torrents niveau saison (pack_saison) ────────────────────
+            for (const season of serieData.seasons ?? []) {
+                for (const t of (season.torrents ?? [])) {
+                    const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'pack_saison', raw: t.title, manual: t.manual ?? false }
+                    seasonTorrentMapBySn[season.season_number] = ref
+
+                    const resolved = buildResolvedEpisodes(serieData, t.infohash, season.season_number)
+                    for (const ep of resolved) availableEpisodeIds.add(ep.episode_id)
+
+                    const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                    for (const ep of resolved) {
+                        if (orgFiles[ep.filename]) organizedEpisodeIds.add(ep.episode_id)
+                    }
+                }
+
+                // ── Torrents niveau épisode ─────────────────────────────
+                for (const ep of season.episodes ?? []) {
+                    for (const t of (ep.torrents ?? [])) {
+                        const ref = { torrent_url: t.torrent_url, magnet: t.magnet, type: 'episode', raw: t.title, manual: t.manual ?? false }
+                        episodeTorrentMap[ep.id] = ref
+                        availableEpisodeIds.add(ep.id)
+
+                        const orgFiles = organized[t.infohash?.toLowerCase()] ?? {}
+                        const paths: any[] = ep.paths ?? []
+                        const match = paths.find((p: any) => typeof p === 'object' && p.infohash?.toLowerCase() === t.infohash?.toLowerCase())
+                        const filename = match ? match.path.split('/').pop() : null
+                        if (filename && orgFiles[filename]) organizedEpisodeIds.add(ep.id)
+                    }
+                }
+            }
+
+            // Pack_saison multi-saisons → packEpisodesTorrents si couvre plusieurs saisons
+            // (cas où un seul torrent couvre plusieurs saisons mais pas toutes → affiché en hero)
+            // Pour l'instant on le traite comme pack_integrale si au niveau série
         }
 
+        // ── Promotion intégrale ───────────────────────────────────────────
+        // Si pas de pack_integrale explicite mais un pack_saison couvre toutes les saisons
+        // → déjà géré car on met les torrents série en integraleTorrents directement
+
+        // ── Enrichissement des saisons API ───────────────────────────────
         const enrichedSeasons = seasonsWithEpisodes.map((season: any) => {
-            const eps = season.episodes.map((ep: any) => ({
-                ...ep,
-                available : availableEpisodeIds.has(ep.id),
-                torrent   : episodeTorrentMap[ep.id] ?? null,
-                organized : organizedEpisodeIds.has(ep.id),
-            }))
-            // State saison : none / partial / complete
+            const eps = season.episodes.map((ep: any) => {
+                // Chercher le torrent : niveau épisode d'abord, sinon le torrent de saison/intégrale sert juste de disponibilité
+                const epTorrent = episodeTorrentMap[ep.id] ?? null
+                // original_filename vient de l'API Fankai directement
+                return {
+                    ...ep,
+                    available : availableEpisodeIds.has(ep.id),
+                    torrent   : epTorrent,
+                    organized : organizedEpisodeIds.has(ep.id),
+                }
+            })
             const total    = eps.filter((e: any) => e.available).length
             const orgCount = eps.filter((e: any) => e.organized).length
             const seasonOrganizedState =
-                orgCount === 0              ? 'none'     :
-                    orgCount >= total && total > 0 ? 'complete' : 'partial'
+                orgCount === 0                     ? 'none'     :
+                    orgCount >= total && total > 0     ? 'complete' : 'partial'
             return {
                 ...season,
-                torrent              : seasonTorrentMap[season.id] ?? null,
-                organized_state      : seasonOrganizedState,
-                organized_count      : orgCount,
-                episodes             : eps,
+                torrent         : seasonTorrentMapBySn[season.season_number] ?? null,
+                organized_state : seasonOrganizedState,
+                organized_count : orgCount,
+                episodes        : eps,
             }
         })
 
+        // ── Hero bundles ──────────────────────────────────────────────────
+        function packEpisodesLabel(t: any): string {
+            return t.raw ?? t.title ?? 'Pack'
+        }
+
         const heroBundles: any[] = [
-            ...integraleTorrents.map(t => ({ label: 'Intégrale', torrent_url: t.torrent_url, magnet: t.magnet, raw: t.raw })),
-            ...(promotedIntegrale ? [{ label: 'Intégrale', torrent_url: promotedIntegrale.torrent_url, magnet: promotedIntegrale.magnet, raw: promotedIntegrale.raw }] : []),
-            ...packEpisodesTorrents.map(t => ({ label: packEpisodesLabel(t), torrent_url: t.torrent_url, magnet: t.magnet, raw: t.raw }))
+            ...integraleTorrents.map(t => ({ label: 'Intégrale', torrent_url: t.torrent_url, magnet: t.magnet, raw: t.title ?? t.raw })),
+            ...packEpisodesTorrents.map(t => ({ label: packEpisodesLabel(t), torrent_url: t.torrent_url, magnet: t.magnet, raw: t.title ?? t.raw }))
         ]
 
         res.json({ serie, seasons: enrichedSeasons, torrents_integrale: heroBundles })
@@ -317,7 +571,7 @@ app.get('/api/series/:id', requireAuth, async (req, res) => {
 
 // ── Download ───────────────────────────────────────────────────
 app.post('/api/download', requireAuth, async (req, res) => {
-    const url = req.body.torrent_url ?? req.body.magnet
+    const url = req.body.magnet ?? req.body.torrent_url
     if (!url) { res.status(400).json({ error: 'torrent_url ou magnet requis' }); return }
     const results = await dispatchDownload(url)
     res.status(results.every((r: any) => r.ok) ? 200 : 207).json({ results })
@@ -329,38 +583,41 @@ app.get('/api/downloads', requireAuth, async (_req, res) => {
         const { category } = readSettings()
         const torrents = await dispatchList(category ?? 'fankai')
 
-        // Enrichir avec l'état d'organisation
         let organized: Record<string, Record<string, string>> = {}
         try {
-            const orgPath = path.join(process.cwd(), 'data', 'organized.json')
+            const orgPath = path.join(DATA_DIR, 'organized.json')
             if (fs.existsSync(orgPath))
                 organized = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
         } catch {}
 
-        let torrentFinal: any[] = []
-        try {
-            const tfPath = path.join(process.cwd(), 'data', 'torrent_final.json')
-            if (fs.existsSync(tfPath))
-                torrentFinal = JSON.parse(fs.readFileSync(tfPath, 'utf-8'))
-        } catch {}
-
-        const enriched = torrents.map((t: any) => {
+        const enriched = await Promise.all(torrents.map(async (t: any) => {
             const orgFiles  = organized[t.hash] ?? {}
-            const meta      = torrentFinal.find((m: any) =>
-                m.infohash?.toLowerCase() === t.hash?.toLowerCase()
-            )
-            const totalFiles = (meta?.torrent_files?.length ?? 0) || 1
+            // Chercher les métadonnées via le cache GitHub
+            let totalFiles = 1
+            try {
+                const availableIds = await readAvailable()
+                for (const id of availableIds) {
+                    const sd = await readSerieData(id)
+                    if (!sd) continue
+                    const allT = extractTorrentsFromSerieData(sd)
+                    const match = allT.find((st: any) => st.infohash?.toLowerCase() === t.hash?.toLowerCase())
+                    if (match) {
+                        const resolved = buildResolvedEpisodes(sd, match.infohash, match.season_number)
+                        totalFiles = resolved.length || 1
+                        break
+                    }
+                }
+            } catch {}
             const doneFiles  = Object.keys(orgFiles).length
             let organizeState: 'none' | 'partial' | 'done' = 'none'
             if (doneFiles >= totalFiles) organizeState = 'done'
             else if (doneFiles > 0)      organizeState = 'partial'
 
-            // Récupérer les erreurs depuis recentOrganized
             const notif = recentOrganized.find(n => n.hash === t.hash)
             const errorFiles = notif?.errorFiles ?? []
 
             return { ...t, organizeState, organizeProgress: { done: doneFiles, total: totalFiles }, errorFiles }
-        })
+        }))
 
         res.json(enriched)
     } catch (err) {
@@ -368,7 +625,7 @@ app.get('/api/downloads', requireAuth, async (_req, res) => {
     }
 })
 
-// ── Résultats d'organisation récents (pour notifications frontend) ──
+// ── Résultats d'organisation récents ──────────────────────────
 interface OrganizeNotif {
     hash       : string
     name       : string
@@ -390,13 +647,11 @@ app.get('/api/organize/recent', requireAuth, (_req, res) => {
     res.json(recentOrganized)
 })
 
-// Vider les notifs lues
 app.post('/api/organize/recent/clear', requireAuth, (_req, res) => {
     recentOrganized.length = 0
     res.json({ ok: true })
 })
 
-
 app.post('/api/organize', requireAuth, async (req, res) => {
     const { hash, name, save_path } = req.body
     if (!hash || !name || !save_path) {
@@ -404,14 +659,14 @@ app.post('/api/organize', requireAuth, async (req, res) => {
         return
     }
     try {
-        const result = await organizeTorrent(hash, name, save_path)
+        const seriesData = await loadEnrichedSeriesData()
+        const result     = await organizeTorrent(hash, name, save_path, seriesData)
         res.json(result)
     } catch (err) {
         res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
     }
 })
 
-// ── Torrents status ────────────────────────────────────────────
 // ── Logs ──────────────────────────────────────────────────────
 app.get('/api/logs', requireAuth, (req, res) => {
     const limit  = Number(req.query.limit)  || 100
@@ -433,33 +688,56 @@ app.get('/api/system', requireAuth, (_req, res) => {
     res.json({ isDocker })
 })
 
-app.get('/api/torrents/status', requireAuth, (_req, res) => {
+app.get('/api/browse', requireAuth, (req, res) => {
+    const dirPath = (req.query.path as string) || '/'
     try {
-        if (!fs.existsSync(TORRENTS_PATH)) { res.json({ exists: false, count: 0, empty: true }); return }
-        const raw = fs.readFileSync(TORRENTS_PATH, 'utf-8').trim()
-        if (!raw || raw === '[]') { res.json({ exists: true, count: 0, empty: true }); return }
-        const data = JSON.parse(raw)
-        const count = Array.isArray(data) ? data.length : 0
-        res.json({ exists: true, count, empty: count === 0 })
+        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))
+        const parent = dirPath === '/' ? null : path.dirname(dirPath)
+        res.json({ path: dirPath, parent, dirs })
+    } catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : 'Erreur lecture dossier' })
+    }
+})
+
+app.get('/api/torrents/status', requireAuth, async (_req, res) => {
+    try {
+        const available = await readAvailable()
+        res.json({ exists: available.length > 0, count: available.length, empty: available.length === 0 })
     } catch { res.json({ exists: false, count: 0, empty: true }) }
 })
 
-// ── Update torrent_final.json ──────────────────────────────────
+// ── Update : vide le cache pour forcer le rechargement depuis GitHub ──────────
 app.post('/api/update', requireAuth, async (_req, res) => {
     try {
-        const response = await fetch(GITHUB_RAW_URL)
-        if (!response.ok) throw new Error(`GitHub a répondu ${response.status}`)
-        const data = await response.json() as unknown[]
-        if (!Array.isArray(data)) throw new Error('Format invalide')
-        fs.mkdirSync(path.dirname(TORRENTS_PATH), { recursive: true })
-        fs.writeFileSync(TORRENTS_PATH, JSON.stringify(data, null, 2), 'utf-8')
-        res.json({ ok: true, count: data.length })
+        cacheClear()
+        // Pré-charger available.json pour vérifier que GitHub répond
+        const availableIds = await readAvailable()
+        if (!Array.isArray(availableIds)) throw new Error('available.json invalide')
+        res.json({ ok: true, count: availableIds.length })
     } catch (err) {
         res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
     }
 })
 
-// ── SPA fallback (prod) — doit être après toutes les routes API ─
+app.post('/api/scan', requireAuth, async (_req, res) => {
+    try {
+        const { mediaPath } = readSettings()
+        const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
+        const seriesData = await loadEnrichedSeriesData()
+        const result = await scanMediaPath(mediaPath, ORGANIZED_PATH, seriesData)
+        logger.info('api', `Scan manuel: ${result.found} fichiers scannés, ${result.added} ajoutés`)
+        res.json({ ok: true, ...result })
+    } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Erreur inconnue' })
+    }
+})
+
+// ── SPA fallback (prod) ────────────────────────────────────────
 if (fs.existsSync(PUBLIC_PATH)) {
     app.get('*path', (_req, res) => {
         res.sendFile(path.join(PUBLIC_PATH, 'index.html'))
@@ -467,21 +745,36 @@ if (fs.existsSync(PUBLIC_PATH)) {
 }
 
 // ── Start ──────────────────────────────────────────────────────
-app.listen(PORT, () => {
-    try {
-        const data  = JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8'))
-        const count = Array.isArray(data) ? data.length : 0
-        if (count === 0) console.warn('[fankarr] ⚠ torrent_final.json est vide')
-        else console.log(`[fankarr] ${count} torrents chargés`)
-    } catch { console.warn('[fankarr] ⚠ torrent_final.json introuvable ou illisible') }
+app.listen(PORT, async () => {
     console.log(`[fankarr] Serveur sur http://localhost:${PORT}`)
+    console.log(`[fankarr] Cache GitHub TTL: 6h — premier fetch au démarrage...`)
 
-    // Auto-organise toutes les 30s
+    // Pré-chauffer le cache available.json au démarrage
+    try {
+        const available = await readAvailable()
+        console.log(`[fankarr] ${available.length} séries disponibles (via GitHub)`)
+    } catch (err) {
+        console.warn(`[fankarr] ⚠ Impossible de charger available.json: ${err instanceof Error ? err.message : err}`)
+    }
+
+    // Scan initial du mediaPath
+    const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
+    const { mediaPath } = readSettings()
+    loadEnrichedSeriesData().then(seriesData =>
+        scanMediaPath(mediaPath, ORGANIZED_PATH, seriesData)
+    ).catch(err =>
+        logger.error('organize', `scanMediaPath échoué: ${err}`)
+    )
+
+    // Auto-organise — polling différentiel toutes les 5 minutes
+    // Le worker ne se lance que si un torrent vient de passer en seeding
     const autoOrganize = async () => {
         try {
             const { category } = readSettings()
+            const seriesData   = await loadEnrichedSeriesData()
             await autoOrganizeAll(
                 () => dispatchList(category ?? 'fankai'),
+                seriesData,
                 (result) => {
                     if (result.done > 0 || result.errors > 0) {
                         pushNotif({ ...result, at: new Date().toISOString() })
@@ -492,9 +785,9 @@ app.listen(PORT, () => {
             console.error('[organize] Erreur auto-organise:', err)
         }
     }
-    // Premier run 30s après démarrage, puis toutes les 30s
+    // Premier run 10s après démarrage, puis toutes les 5 minutes
     setTimeout(() => {
         autoOrganize()
-        setInterval(autoOrganize, 30_000)
-    }, 30_000)
+        setInterval(autoOrganize, 5 * 60_000)
+    }, 10_000)
 })

server/logger.ts

@@ -8,6 +8,7 @@
 
 import fs   from 'fs'
 import path from 'path'
+import { DATA_DIR } from './config.js'
 
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
 
@@ -19,7 +20,7 @@ export interface LogEntry {
     meta?   : Record<string, any>
 }
 
-const LOGS_PATH    = path.join(process.cwd(), 'data', 'logs.jsonl')
+const LOGS_PATH    = path.join(DATA_DIR, 'logs.jsonl')
 const MAX_LINES    = 2000   // rotation auto au-delà
 const IS_PROD      = process.env.NODE_ENV === 'production'
 

server/organize-worker.ts

@@ -4,8 +4,8 @@
  * Worker thread dédié à l'organisation des fichiers.
  * Tourne dans un thread séparé pour ne pas bloquer le event loop Express.
  *
- * Messages reçus  (parentPort.on) : { type: 'run', torrents: TorrentInfo[] }
- * Messages envoyés (parentPort.postMessage) :
+ * Messages reçus  : { type: 'run', torrents: TorrentInfo[], seriesData: SerieData[] }
+ * Messages envoyés :
  *   { type: 'log',    level: 'info'|'warn'|'error', msg: string }
  *   { type: 'result', hash: string, name: string, done, skipped, errors }
  *   { type: 'done' }
@@ -15,28 +15,26 @@ import fs   from 'fs'
 import fsp  from 'fs/promises'
 import path from 'path'
 import { parentPort } from 'worker_threads'
+import { DATA_DIR } from './config.js'
 
-const TORRENTS_PATH  = path.join(process.cwd(), 'data', 'torrent_final.json')
-const ORGANIZED_PATH = path.join(process.cwd(), 'data', 'organized.json')
+const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
 
 // ─── Utils log ────────────────────────────────────────────────
-
 function log(msg: string)   { parentPort?.postMessage({ type: 'log', level: 'info',  msg }) }
 function warn(msg: string)  { parentPort?.postMessage({ type: 'log', level: 'warn',  msg }) }
 function error(msg: string) { parentPort?.postMessage({ type: 'log', level: 'error', msg }) }
+function debug(msg: string) { parentPort?.postMessage({ type: 'log', level: 'debug', msg }) }
 
-// ─── Settings (lu directement, pas d'import circulaire) ──────
-
-function readSettings(): { mediaPath: string; completePath: string; organizeMode: string } {
+// ─── Settings ─────────────────────────────────────────────────
+function readSettings(): { mediaPath: string; completePath: string; organizeMode: string; nfoSupport: boolean } {
     try {
-        const p = path.join(process.cwd(), 'data', 'settings.json')
-        if (!fs.existsSync(p)) return { mediaPath: '/media/Kai', completePath: '/downloads/complete', organizeMode: 'hardlink' }
+        const p = path.join(DATA_DIR, 'settings.json')
+        if (!fs.existsSync(p)) return { mediaPath: '', completePath: '', organizeMode: 'hardlink', nfoSupport: false }
         return JSON.parse(fs.readFileSync(p, 'utf-8'))
-    } catch { return { mediaPath: '/media/Kai', completePath: '/downloads/complete', organizeMode: 'hardlink' } }
+    } catch { return { mediaPath: '', completePath: '', organizeMode: 'hardlink', nfoSupport: false } }
 }
 
 // ─── Organized log ────────────────────────────────────────────
-
 function loadOrganized(): Record<string, Record<string, string>> {
     try {
         if (!fs.existsSync(ORGANIZED_PATH)) return {}
@@ -55,18 +53,89 @@ function isOrganized(hash: string, filename: string): boolean {
     return !!loadOrganized()[hash]?.[filename]
 }
 
-// ─── Torrent lookup ───────────────────────────────────────────
+// ─── Lookup torrent dans les seriesData passées via message ───
+function findTorrentByHash(hash: string, seriesData: any[]): { torrent: any; serieData: any } | null {
+    for (const sd of seriesData) {
+        // Niveau série
+        for (const t of sd.torrents ?? []) {
+            if (t.infohash?.toLowerCase() === hash.toLowerCase())
+                return { torrent: t, serieData: sd }
+        }
+        // Niveau saison
+        for (const season of sd.seasons ?? []) {
+            for (const t of season.torrents ?? []) {
+                if (t.infohash?.toLowerCase() === hash.toLowerCase())
+                    return { torrent: { ...t, _season: season }, serieData: sd }
+            }
+            // Niveau épisode — compter combien d'épisodes partagent ce torrent
+            const matchingEpisodes = season.episodes?.filter((ep: any) =>
+                ep.torrents?.some((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase())
+            ) ?? []
 
-function findTorrentByHash(hash: string): any | null {
-    try {
-        if (!fs.existsSync(TORRENTS_PATH)) return null
-        const torrents = JSON.parse(fs.readFileSync(TORRENTS_PATH, 'utf-8'))
-        return torrents.find((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase()) ?? null
-    } catch { return null }
+            if (matchingEpisodes.length === 1) {
+                // Torrent propre à un seul épisode → cas épisode unique
+                const ep = matchingEpisodes[0]
+                const t  = ep.torrents.find((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase())
+                return { torrent: { ...t, _episode: ep, _season: season }, serieData: sd }
+            } else if (matchingEpisodes.length > 1) {
+                // Même torrent partagé entre plusieurs épisodes → traiter comme pack_saison
+                const t = matchingEpisodes[0].torrents.find((t: any) => t.infohash?.toLowerCase() === hash.toLowerCase())
+                return { torrent: { ...t, _season: season }, serieData: sd }
+            }
+        }
+    }
+    return null
 }
 
-// ─── Dossiers exclus (bonus, musique, images) ────────────────
+// Construit la map filename → { season_number, original_filename, fullPath }
+// Supporte les deux formats : { infohash, path } et string (legacy)
+// destFilename : original_filename si nfoSupport, formatted_name sinon
+function buildFileMap(
+    serieData    : any,
+    hash         : string,
+    nfoSupport   : boolean,
+    seasonFilter?: number
+): Map<string, { season_number: number; original_filename: string; fullPath: string }> {
+    const map = new Map<string, { season_number: number; original_filename: string; fullPath: string }>()
+    const h = hash.toLowerCase()
 
+    for (const season of serieData.seasons ?? []) {
+        if (seasonFilter !== undefined && season.season_number !== seasonFilter) continue
+        for (const ep of season.episodes ?? []) {
+            const paths: any[] = ep.paths ?? []
+            let matchedPath: string | null = null
+
+            for (const p of paths) {
+                if (typeof p === 'string') {
+                    if (!matchedPath) matchedPath = p.replace(/\\/g, '/')
+                } else if (p?.infohash?.toLowerCase() === h) {
+                    matchedPath = p.path.replace(/\\/g, '/')
+                    break
+                }
+            }
+
+            if (!matchedPath) continue
+            const filename = matchedPath.split('/').pop() ?? matchedPath
+
+            // nfoSupport → original_filename (correspond aux .nfo GitLab)
+            // sinon → formatted_name de l'API (nommage Jellyfin/Plex standardisé)
+            const destName = nfoSupport
+                ? (ep.original_filename ?? filename)
+                : (ep.formatted_name
+                    ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '') + '.mkv'
+                    : (ep.original_filename ?? filename))
+
+            map.set(filename, {
+                season_number    : season.season_number,
+                original_filename: destName,
+                fullPath         : matchedPath,
+            })
+        }
+    }
+    return map
+}
+
+// ─── Dossiers exclus ─────────────────────────────────────────
 const EXCLUDED_FOLDERS = new Set([
     'endings', 'ending', 'openings', 'opening', 'ost', 'artworks', 'artwork',
     'bonus', 'extras', 'extra', 'specials', 'special', 'ncop', 'nced',
@@ -84,12 +153,88 @@ function isInExcludedFolder(filePath: string[]): boolean {
     return false
 }
 
-// ─── Filesystem ops ───────────────────────────────────────────
-
-function seasonFolder(n: number): string {
-    return `Saison ${String(n).padStart(3, '0')}`
+// ─── Map correction titres API → titres GitLab ───────────────
+const SERIE_TITLE_GITLAB_MAP: Record<string, string> = {
+    'Enfer Et Paradis Henshū'          : 'Enfer et Paradis Henshū',
+    'Hajime No Ippo Henshū'            : 'Hajime no Ippo Henshū',
+    'Hikaru No Go Henshū'              : 'Hikaru no Go Henshū',
+    'Hokuto No Ken Kaï'                : 'Hokuto no Ken Kaï',
+    'Kaguya-sama : Love is War Henshū' : 'Kaguya-sama - Love is War Henshū',
+    'Kenshin le Vagabond Henshū'       : 'Kenshin le vagabond Henshū',
+    'Kuroko No Basket Henshū'          : 'Kuroko no Basket Henshū',
+    'Shingeki No Kyojin Henshū'        : 'Shingeki no Kyojin Henshū',
+    'Tower Of God Henshū'              : 'Tower of God Henshū',
 }
 
+function getGitlabSerieTitle(serieTitle: string): string {
+    return SERIE_TITLE_GITLAB_MAP[serieTitle] ?? serieTitle
+}
+
+// ─── GitLab NFO downloader ────────────────────────────────────
+const GITLAB_API      = 'https://gitlab.com/api/v4/projects/ElPouki%2Ffankai_pack/repository'
+const GITLAB_RAW_BASE = 'https://gitlab.com/ElPouki/fankai_pack/-/raw/main/pack'
+
+async function fetchJson(url: string): Promise<any> {
+    const { default: nodeFetch } = await import('node-fetch')
+    const res = await (nodeFetch as any)(url, { headers: { 'User-Agent': 'fankarr' } })
+    if (!res.ok) throw new Error(`HTTP ${res.status} — ${url}`)
+    return res.json()
+}
+
+async function fetchBinary(url: string): Promise<Buffer> {
+    const { default: nodeFetch } = await import('node-fetch')
+    const res = await (nodeFetch as any)(url, { headers: { 'User-Agent': 'fankarr' } })
+    if (!res.ok) throw new Error(`HTTP ${res.status} — ${url}`)
+    return Buffer.from(await res.arrayBuffer())
+}
+
+async function downloadGitlabFolder(serieTitle: string, destRoot: string): Promise<void> {
+    const gitlabTitle = getGitlabSerieTitle(serieTitle)
+    const folderPath  = `pack/${gitlabTitle}`
+    log(`[nfo] Récupération dossier GitLab: ${gitlabTitle}`)
+
+    let files: any[] = []
+    try {
+        let page = 1
+        while (true) {
+            const batch = await fetchJson(
+                `${GITLAB_API}/tree?path=${encodeURIComponent(folderPath)}&recursive=true&per_page=100&page=${page}&ref=main`
+            )
+            if (!Array.isArray(batch) || batch.length === 0) break
+            files.push(...batch)
+            if (batch.length < 100) break
+            page++
+        }
+    } catch (err) {
+        warn(`[nfo] Dossier GitLab introuvable pour "${serieTitle}": ${err instanceof Error ? err.message : err}`)
+        return
+    }
+
+    if (files.length === 0) { warn(`[nfo] Aucun fichier trouvé pour "${serieTitle}"`); return }
+
+    const fileEntries = files.filter((f: any) => f.type === 'blob')
+    log(`[nfo] ${fileEntries.length} fichiers à télécharger`)
+
+    for (const entry of fileEntries) {
+        const relativePath = entry.path.replace(`pack/${gitlabTitle}/`, '')
+        const destPath     = path.join(destRoot, relativePath)
+        if (fs.existsSync(destPath)) continue
+        try {
+            fs.mkdirSync(path.dirname(destPath), { recursive: true })
+            const rawUrl = `${GITLAB_RAW_BASE}/${encodeURIComponent(gitlabTitle)}/${relativePath.split('/').map(encodeURIComponent).join('/')}`
+            const data   = await fetchBinary(rawUrl)
+            fs.writeFileSync(destPath, data)
+            log(`[nfo] ✓ ${relativePath}`)
+        } catch (err) {
+            warn(`[nfo] ✗ ${relativePath}: ${err instanceof Error ? err.message : err}`)
+        }
+    }
+    log(`[nfo] GitLab synchronisé pour "${gitlabTitle}"`)
+}
+
+// ─── Filesystem ops ───────────────────────────────────────────
+function seasonFolder(n: number): string { return `Saison ${n}` }
+
 function tryHardlink(src: string, dest: string): boolean {
     try { fs.linkSync(src, dest); return true }
     catch (err) {
@@ -99,40 +244,67 @@ function tryHardlink(src: string, dest: string): boolean {
 }
 
 // ─── Organise un torrent ──────────────────────────────────────
-
-async function organizeTorrent(hash: string, name: string, savePath: string) {
-    const { mediaPath, completePath, organizeMode } = readSettings()
+async function organizeTorrent(hash: string, name: string, savePath: string, seriesData: any[]) {
+    const { mediaPath, completePath, organizeMode, nfoSupport } = readSettings()
     const result = { total: 0, skipped: 0, done: 0, errors: [] as { file: string; error: string }[] }
 
     log(`[organize] ── ${name} ──`)
     log(`[organize] hash=${hash} save_path=${savePath} mode=${organizeMode}`)
 
-    const torrent = findTorrentByHash(hash)
-    if (!torrent) {
-        error(`[organize] ✗ Hash ${hash} introuvable dans torrent_final.json`)
+    const found = findTorrentByHash(hash, seriesData)
+    if (!found) {
+        error(`[organize] ✗ Hash ${hash} introuvable dans les données série`)
         throw new Error(`Torrent introuvable : ${hash}`)
     }
-    log(`[organize] ✓ Trouvé : ${torrent.raw}`)
 
-    const serieTitle   = torrent.serie_title || torrent.show_title || name
-    const torrentFiles: any[] = torrent.torrent_files ?? []
-    log(`[organize] serie=${serieTitle} fichiers=${torrentFiles.length}`)
+    const { torrent, serieData } = found
+    const serieTitle    = serieData.title ?? serieData.show_title ?? name
+    const torrentTitle  = torrent.title ?? name
+    log(`[organize] ✓ Trouvé : ${torrentTitle} — série: ${serieTitle}`)
 
-    // ── Cas fichier unique ────────────────────────────────────
-    if (torrentFiles.length === 0) {
-        log(`[organize] torrent_files vide → tentative fichier unique`)
-        const candidates = [path.join(savePath, name), path.join(completePath, name)]
-        let src: string | null = null
-        for (const c of candidates) {
-            log(`[organize]   candidate: ${c} → ${fs.existsSync(c) ? '✓' : '✗'}`)
-            if (fs.existsSync(c)) { src = c; break }
+    // ── NFO/images depuis GitLab ──────────────────────────────
+    if (nfoSupport) {
+        await downloadGitlabFolder(serieTitle, path.join(mediaPath, serieTitle))
+    }
+
+    // ── Cas torrent épisode unique ────────────────────────────
+    if (torrent._episode) {
+        const ep      = torrent._episode
+        const season  = torrent._season
+        const paths: any[] = ep.paths ?? []
+        let filePath: string | null = null
+        for (const p of paths) {
+            if (typeof p === 'string') { if (!filePath) filePath = p.replace(/\\/g, '/') }
+            else if (p?.infohash?.toLowerCase() === hash.toLowerCase()) { filePath = p.path.replace(/\\/g, '/'); break }
         }
-        if (!src) throw new Error(`Source introuvable pour "${name}"`)
+        const filename = filePath?.split('/').pop() ?? name
+        const destName = nfoSupport
+            ? (ep.original_filename ?? filename)
+            : (ep.formatted_name
+                ? ep.formatted_name.replace(/[<>:"/\\|?*]/g, '') + '.mkv'
+                : (ep.original_filename ?? filename))
+        const destDir  = path.join(mediaPath, serieTitle, seasonFolder(season.season_number ?? 1))
+        const dest     = path.join(destDir, destName)
 
-        const seasonNum = torrent.resolved_episodes?.[0]?.season_number ?? 1
-        const destDir   = path.join(mediaPath, serieTitle, seasonFolder(seasonNum))
-        const dest      = path.join(destDir, name)
-        log(`[organize]   dest: ${dest}`)
+        if (isOrganized(hash, filename)) return { ...result, total: 1, skipped: 1 }
+
+        const candidates = filePath ? [
+            path.join(savePath, filePath),
+            path.join(completePath, filePath),
+            path.join(savePath, filename),
+            path.join(completePath, filename),
+        ] : [
+            path.join(savePath, filename),
+            path.join(completePath, filename),
+        ]
+
+        let src: string | null = null
+        for (const c of candidates) { if (fs.existsSync(c)) { src = c; break } }
+
+        if (!src) {
+            error(`[organize] ✗ ${filename} introuvable`)
+            return { ...result, total: 1, errors: [{ file: filename, error: 'Source introuvable' }] }
+        }
 
         if (!fs.existsSync(dest)) {
             fs.mkdirSync(destDir, { recursive: true })
@@ -142,67 +314,47 @@ async function organizeTorrent(hash: string, name: string, savePath: string) {
                 await fsp.copyFile(src, dest)
                 await fsp.unlink(src)
             }
-            log(`[organize]   ✓ ${organizeMode} OK`)
-        } else {
-            log(`[organize]   → dest existe déjà, skip`)
         }
-        markOrganized(hash, name)
+        markOrganized(hash, filename)
+        log(`[organize] ✓ ${destName} → Saison ${season.season_number}`)
         return { ...result, total: 1, done: 1 }
     }
 
-    // ── Map filename → season ─────────────────────────────────
-    const filenameSeasonMap = new Map<string, number>()
-    for (const ep of torrent.resolved_episodes ?? []) {
-        if (ep.filename && ep.season_number !== undefined)
-            filenameSeasonMap.set(ep.filename, ep.season_number)
+    // ── Pack saison / intégrale ───────────────────────────────
+    const seasonFilter = torrent._season?.season_number
+    const fileMap = buildFileMap(serieData, hash, nfoSupport, seasonFilter)
+
+    if (fileMap.size === 0) {
+        warn(`[organize] Aucun fichier mappé pour ${name}`)
+        return result
     }
 
-    result.total = torrentFiles.length
-
-    for (const tf of torrentFiles) {
-        const filename = tf.filename
-        const filePath: string[] = tf.path
-
-        // Skip les fichiers dans des dossiers bonus/musique/images
-        if (isInExcludedFolder(filePath)) {
-            log(`[organize] skip bonus: ${filename}`)
-            result.skipped++
-            continue
-        }
+    result.total = fileMap.size
 
+    for (const [filename, { season_number, original_filename, fullPath }] of fileMap) {
         if (isOrganized(hash, filename)) { result.skipped++; continue }
 
+        // Source : on utilise save_path + fullPath (chemin relatif exact dans le torrent)
+        // save_path vient de qBittorrent → résiste aux renommages de dossier
         const candidates = [
-            path.join(savePath, name, ...filePath.slice(0, -1), filename),
-            path.join(savePath, ...filePath.slice(0, -1), filename),
-            path.join(savePath, name, filename),
+            path.join(savePath, fullPath),
+            path.join(completePath, fullPath),
             path.join(savePath, filename),
-            path.join(completePath, name, ...filePath.slice(0, -1), filename),
-            path.join(completePath, name, filename),
             path.join(completePath, filename),
         ]
-
         let src: string | null = null
-        for (const c of candidates) {
-            if (fs.existsSync(c)) { src = c; break }
-        }
+        for (const c of candidates) { if (fs.existsSync(c)) { src = c; break } }
 
         if (!src) {
-            const tried = candidates.map(c => `  • ${c}`).join('\n')
-            error(`[organize] ✗ ${filename} introuvable:\n${tried}`)
+            error(`[organize] ✗ ${filename} introuvable`)
             result.errors.push({ file: filename, error: 'Source introuvable' })
             continue
         }
 
-        const seasonNum = filenameSeasonMap.get(filename) ?? 1
-        const destDir   = path.join(mediaPath, serieTitle, seasonFolder(seasonNum))
-        const dest      = path.join(destDir, filename)
+        const destDir = path.join(mediaPath, serieTitle, seasonFolder(season_number))
+        const dest    = path.join(destDir, original_filename)
 
-        if (fs.existsSync(dest)) {
-            markOrganized(hash, filename)
-            result.skipped++
-            continue
-        }
+        if (fs.existsSync(dest)) { markOrganized(hash, filename); result.skipped++; continue }
 
         try {
             fs.mkdirSync(destDir, { recursive: true })
@@ -214,7 +366,7 @@ async function organizeTorrent(hash: string, name: string, savePath: string) {
             }
             markOrganized(hash, filename)
             result.done++
-            log(`[organize] ✓ ${filename} → Saison ${String(seasonNum).padStart(3,'0')}`)
+            log(`[organize] ✓ ${original_filename} → Saison ${season_number}`)
         } catch (err) {
             const msg = err instanceof Error ? err.message : 'Erreur inconnue'
             error(`[organize] ✗ ${filename}: ${msg}`)
@@ -222,37 +374,40 @@ async function organizeTorrent(hash: string, name: string, savePath: string) {
         }
     }
 
-    log(`[organize] ── Résultat ${name}: ${result.done} OK, ${result.skipped} skippés, ${result.errors.length} erreurs`)
+    log(`[organize] ── ${name}: ${result.done} OK, ${result.skipped} skippés, ${result.errors.length} erreurs`)
     return result
 }
 
 // ─── Boucle principale du worker ─────────────────────────────
-
 parentPort?.on('message', async (msg: any) => {
     if (msg.type !== 'run') return
 
-    const torrents: any[] = msg.torrents
+    const torrents: any[]   = msg.torrents
+    const seriesData: any[] = msg.seriesData ?? []
     const organized = loadOrganized()
+    const { nfoSupport } = readSettings()
 
     for (const t of torrents) {
         if (t.state !== 'seeding') continue
 
-        const torrent = findTorrentByHash(t.hash)
-        if (!torrent) {
-            warn(`[organize] hash ${t.hash} (${t.name}) non trouvé`)
+        const found = findTorrentByHash(t.hash, seriesData)
+        if (!found) {
+            warn(`[organize] hash ${t.hash} (${t.name}) non trouvé dans les données série`)
             continue
         }
 
-        const files: any[] = torrent.torrent_files ?? []
-        // Pour fichier unique : vérifier via le name directement
-        const allDone = files.length > 0
-            ? files.every((f: any) => organized[t.hash]?.[f.filename])
+        // Vérifier si déjà tout organisé
+        const { torrent, serieData } = found
+        const seasonFilter   = torrent._season?.season_number
+        const fileMap        = buildFileMap(serieData, t.hash, nfoSupport, seasonFilter)
+        const allDone = fileMap.size > 0
+            ? [...fileMap.keys()].every(f => organized[t.hash]?.[f])
             : !!organized[t.hash]?.[t.name]
 
         if (allDone) continue
 
         try {
-            const result = await organizeTorrent(t.hash, t.name, t.save_path)
+            const result = await organizeTorrent(t.hash, t.name, t.save_path, seriesData)
             parentPort?.postMessage({ type: 'result', hash: t.hash, name: t.name, ...result })
         } catch (err) {
             error(`[organize] Erreur ${t.name}: ${err instanceof Error ? err.message : err}`)

server/organize.ts

@@ -2,15 +2,30 @@
  * organize.ts
  * ===========
  * Lance l'organizer dans un Worker Thread dédié pour ne pas bloquer Express.
- * Le worker gère tout le filesystem (copy, hardlink, move).
  */
 
+import fs     from 'fs'
 import path   from 'path'
 import { Worker } from 'worker_threads'
+import { logger } from './logger.js'
+import { DATA_DIR } from './config.js'
+import { readSettings } from './settings.js'
+
+const ORGANIZED_PATH = path.join(DATA_DIR, 'organized.json')
 
 // Un seul worker à la fois
 let workerRunning = false
 
+// État précédent des torrents pour détecter les passages downloading → seeding
+const _prevStates = new Map<string, string>()
+
+function resolveWorkerPath(): string {
+    if (typeof (globalThis as any).Bun !== 'undefined') {
+        return path.join(path.dirname((process as any).execPath), 'organize-worker.js')
+    }
+    return path.join(path.dirname(new URL(import.meta.url).pathname), 'organize-worker.js')
+}
+
 export interface OrganizeResult {
     total   : number
     skipped : number
@@ -19,14 +34,106 @@ export interface OrganizeResult {
 }
 
 /**
- * Lance l'auto-organisation dans un worker thread.
- * listFn est appelée dans le thread principal (accès qBittorrent),
- * puis les données sont passées au worker.
+ * Scan initial du mediaPath au démarrage.
+ * Construit l'index filename → infohash depuis les seriesData passées en paramètre.
+ */
+export async function scanMediaPath(
+    mediaPath    : string,
+    organizedPath: string,
+    seriesData   : any[] = []
+): Promise<{ found: number; added: number }> {
+    const result = { found: 0, added: 0 }
+
+    if (!fs.existsSync(mediaPath)) {
+        logger.warn('organize', `scanMediaPath: ${mediaPath} inexistant, skip`)
+        return result
+    }
+
+    // Construire index filename → infohash depuis les seriesData
+    const filenameIndex = new Map<string, string>()  // filename → infohash
+    for (const sd of seriesData) {
+        for (const season of sd.seasons ?? []) {
+            for (const ep of season.episodes ?? []) {
+                for (const p of ep.paths ?? []) {
+                    if (typeof p === 'string') {
+                        // Legacy : pas d'infohash disponible, on skip pour le scan
+                        continue
+                    }
+                    const hash = p.infohash?.toLowerCase()
+                    if (!hash || !p.path) continue
+                    const filename = p.path.replace(/\\/g, '/').split('/').pop()
+                    if (filename) filenameIndex.set(filename, hash)
+                }
+            }
+        }
+    }
+
+    // Charger organized.json existant
+    let organized: Record<string, Record<string, string>> = {}
+    try {
+        if (fs.existsSync(organizedPath))
+            organized = JSON.parse(fs.readFileSync(organizedPath, 'utf-8'))
+    } catch {}
+
+    const presentFiles = new Set<string>()
+
+    function walk(dir: string) {
+        let entries: fs.Dirent[]
+        try { entries = fs.readdirSync(dir, { withFileTypes: true }) }
+        catch { return }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name)
+            if (entry.isDirectory()) {
+                walk(full)
+            } else if (entry.isFile() && entry.name.endsWith('.mkv')) {
+                result.found++
+                const hash = filenameIndex.get(entry.name)
+                if (!hash) continue
+                presentFiles.add(`${hash}:${entry.name}`)
+                if (organized[hash]?.[entry.name]) continue
+                if (!organized[hash]) organized[hash] = {}
+                organized[hash][entry.name] = new Date().toISOString()
+                result.added++
+            }
+        }
+    }
+
+    walk(mediaPath)
+
+    // Nettoyer les entrées orphelines
+    let removed = 0
+    for (const [hash, files] of Object.entries(organized)) {
+        for (const filename of Object.keys(files)) {
+            if (!presentFiles.has(`${hash}:${filename}`) && filenameIndex.get(filename) === hash) {
+                delete organized[hash][filename]
+                removed++
+            }
+        }
+        if (Object.keys(organized[hash]).length === 0) delete organized[hash]
+    }
+
+    if (result.added > 0 || removed > 0) {
+        fs.writeFileSync(organizedPath, JSON.stringify(organized, null, 2), 'utf-8')
+        logger.info('organize', `scanMediaPath: ${result.found} fichiers, ${result.added} ajoutés, ${removed} orphelins supprimés`)
+    } else {
+        logger.info('organize', `scanMediaPath: ${result.found} fichiers scannés, rien de nouveau`)
+    }
+
+    return result
+}
+
+/**
+ * Auto-import — appelée depuis index.ts avec les seriesData du cache GitHub.
  */
 export async function autoOrganizeAll(
-    listFn  : () => Promise<any[]>,
-    onResult?: (r: { hash: string; name: string; done: number; skipped: number; errors: number; errorFiles: { file: string; error: string }[] }) => void
+    listFn     : () => Promise<any[]>,
+    seriesData : any[],
+    onResult  ?: (r: { hash: string; name: string; done: number; skipped: number; errors: number; errorFiles: { file: string; error: string }[] }) => void
 ): Promise<void> {
+    // Vérifier si l'import auto est activé
+    const { autoImport } = readSettings()
+    if (!autoImport) return
+
     if (workerRunning) {
         console.log('[organize] Worker déjà en cours, skip')
         return
@@ -42,15 +149,39 @@ export async function autoOrganizeAll(
 
     if (torrents.length === 0) return
 
+    const isFirstRun   = _prevStates.size === 0
     const seedingCount = torrents.filter(t => t.state === 'seeding').length
+
+    const newlySeeding = torrents.filter(t => {
+        const prev = _prevStates.get(t.hash)
+        return t.state === 'seeding' && (prev === undefined || prev !== 'seeding')
+    })
+
+    for (const t of torrents) _prevStates.set(t.hash, t.state)
+
+    // Charger organized.json pour vérifier s'il reste des torrents non organisés
+    let organized: Record<string, Record<string, string>> = {}
+    try {
+        const orgPath = path.join(DATA_DIR, 'organized.json')
+        if (fs.existsSync(orgPath))
+            organized = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
+    } catch {}
+
+    const hasUnorganized = torrents.some(t =>
+        t.state === 'seeding' && !organized[t.hash?.toLowerCase()]
+    )
+
+    if (!isFirstRun && newlySeeding.length === 0 && !hasUnorganized) return
     if (seedingCount === 0) return
 
-    console.log(`[organize] Lancement worker (${seedingCount} torrents en seeding)`)
+    if (newlySeeding.length > 0 && !isFirstRun) {
+        console.log(`[organize] ${newlySeeding.length} nouveau(x) torrent(s) terminé(s) → lancement worker`)
+    } else {
+        console.log(`[organize] Lancement worker (${seedingCount} torrents en seeding)`)
+    }
     workerRunning = true
 
-    const workerPath = path.join(path.dirname(new URL(import.meta.url).pathname), 'organize-worker.js')
-
-    const worker = new Worker(workerPath)
+    const worker = new Worker(resolveWorkerPath())
 
     worker.on('message', (msg: any) => {
         if (msg.type === 'log') {
@@ -60,12 +191,12 @@ export async function autoOrganizeAll(
         } else if (msg.type === 'result') {
             console.log(`[organize] ${msg.name} → ${msg.done} OK, ${msg.skipped} skippés, ${msg.errors.length} erreurs`)
             onResult?.({
-                hash       : msg.hash,
-                name       : msg.name,
-                done       : msg.done,
-                skipped    : msg.skipped,
-                errors     : msg.errors.length,
-                errorFiles : msg.errors,
+                hash      : msg.hash,
+                name      : msg.name,
+                done      : msg.done,
+                skipped   : msg.skipped,
+                errors    : msg.errors.length,
+                errorFiles: msg.errors,
             })
         } else if (msg.type === 'done') {
             console.log('[organize] Worker terminé')
@@ -74,34 +205,23 @@ export async function autoOrganizeAll(
         }
     })
 
-    worker.on('error', (err) => {
-        console.error('[organize] Worker erreur:', err)
-        workerRunning = false
-    })
+    worker.on('error', (err) => { console.error('[organize] Worker erreur:', err); workerRunning = false })
+    worker.on('exit',  (code) => { if (code !== 0) console.error(`[organize] Worker exit ${code}`); workerRunning = false })
 
-    worker.on('exit', (code) => {
-        if (code !== 0) console.error(`[organize] Worker exit code ${code}`)
-        workerRunning = false
-    })
-
-    // Envoyer les torrents au worker
-    worker.postMessage({ type: 'run', torrents })
+    worker.postMessage({ type: 'run', torrents, seriesData })
 }
 
 /**
- * Organisation manuelle d'un torrent (appelée depuis l'API /organize).
- * Lance aussi dans un worker thread.
+ * Organisation manuelle d'un torrent.
  */
 export async function organizeTorrent(
-    hash    : string,
-    name    : string,
-    savePath: string
+    hash      : string,
+    name      : string,
+    savePath  : string,
+    seriesData: any[]
 ): Promise<OrganizeResult> {
     return new Promise((resolve, reject) => {
-        const workerPath = path.join(path.dirname(new URL(import.meta.url).pathname), 'organize-worker.js')
-        const worker = new Worker(workerPath)
-
-        // On envoie un seul torrent "fictif seeding"
+        const worker      = new Worker(resolveWorkerPath())
         const fakeTorrent = { hash, name, save_path: savePath, state: 'seeding' }
         const result: OrganizeResult = { total: 0, skipped: 0, done: 0, errors: [] }
 
@@ -124,6 +244,6 @@ export async function organizeTorrent(
         worker.on('error', (err) => { worker.terminate(); reject(err) })
         worker.on('exit',  (code) => { if (code !== 0) reject(new Error(`Worker exit ${code}`)) })
 
-        worker.postMessage({ type: 'run', torrents: [fakeTorrent] })
+        worker.postMessage({ type: 'run', torrents: [fakeTorrent], seriesData })
     })
 }

server/secret.ts

@@ -0,0 +1,45 @@
+/**
+ * secret.ts
+ * =========
+ * Génère et persiste le JWT secret dans data/secret.key
+ * Si JWT_SECRET est défini en variable d'environnement, il est utilisé tel quel.
+ * Sinon, on lit data/secret.key — s'il n'existe pas, on en génère un et on le sauvegarde.
+ */
+
+import fs       from 'fs'
+import path     from 'path'
+import crypto   from 'crypto'
+import { DATA_DIR } from './config.js'
+
+const SECRET_PATH = path.join(DATA_DIR, 'secret.key')
+
+function generateSecret(): string {
+    return crypto.randomBytes(48).toString('hex')
+}
+
+function loadOrCreateSecret(): string {
+    // 1. Variable d'environnement — priorité absolue
+    if (process.env.JWT_SECRET && process.env.JWT_SECRET !== 'fankarr-secret-change-me') {
+        return process.env.JWT_SECRET
+    }
+
+    // 2. Fichier existant
+    if (fs.existsSync(SECRET_PATH)) {
+        const secret = fs.readFileSync(SECRET_PATH, 'utf-8').trim()
+        if (secret.length > 0) return secret
+    }
+
+    // 3. Génération + sauvegarde
+    const secret = generateSecret()
+    try {
+        fs.mkdirSync(path.dirname(SECRET_PATH), { recursive: true })
+        fs.writeFileSync(SECRET_PATH, secret, { encoding: 'utf-8', mode: 0o600 })
+        console.log('[auth] JWT secret généré et sauvegardé dans data/secret.key')
+    } catch (err) {
+        console.error('[auth] Impossible de sauvegarder le secret:', err)
+    }
+
+    return secret
+}
+
+export const JWT_SECRET: string = loadOrCreateSecret()

server/settings.ts

@@ -1,20 +1,25 @@
 import fs from 'fs'
 import path from 'path'
+import { DATA_DIR } from './config.js'
 
-const DATA_PATH = path.join(process.cwd(), 'data', 'settings.json')
+const DATA_PATH = path.join(DATA_DIR, 'settings.json')
 
 export interface Settings {
-    mediaPath     : string   // dossier Jellyfin destination ex: /media/Kai
-    completePath  : string   // dossier qB complétion ex: /downloads/complete
+    mediaPath     : string
+    completePath  : string
     organizeMode  : 'hardlink' | 'move'
-    category      : string   // catégorie qBittorrent
+    category      : string
+    nfoSupport    : boolean
+    autoImport    : boolean   // import automatique quand un torrent passe en seeding
 }
 
 const defaults: Settings = {
-    mediaPath    : '/media/Kai',
-    completePath : '/downloads/complete',
+    mediaPath    : '',
+    completePath : '',
     organizeMode : 'hardlink',
     category     : 'fankai',
+    nfoSupport   : false,
+    autoImport   : true,
 }
 
 export function readSettings(): Settings {

server/torrent-clients/index.ts

@@ -9,6 +9,7 @@
 import { randomUUID } from 'crypto'
 import fs from 'fs'
 import path from 'path'
+import { DATA_DIR } from '../config.js'
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -77,7 +78,7 @@ export function getAvailableClients(): TorrentClientDefinition[] {
 
 // ─── Persistence (clients enregistrés) ────────────────────────────────────────
 
-const CLIENTS_PATH = path.join(process.cwd(), 'data', 'torrent_clients.json')
+const CLIENTS_PATH = path.join(DATA_DIR, 'torrent_clients.json')
 
 function loadClients(): SavedClient[] {
     try {
@@ -168,7 +169,9 @@ export async function dispatchList(category?: string): Promise<(TorrentInfo & {
         const driver = getDriver(client.type)
         if (!driver) continue
         try {
-            const torrents = await driver.list(client.config, category)
+            // La catégorie du client est prioritaire sur la catégorie globale
+            const clientCategory = (client.config.category as string) || category
+            const torrents = await driver.list(client.config, clientCategory)
             for (const t of torrents) {
                 results.push({ ...t, client_uuid: client.uuid, client_name: client.name })
             }

src/App.vue

@@ -1,8 +1,8 @@
 <template>
   <div class="min-h-screen bg-[#080c10] text-[#c8d8e8] font-mono">
-    <RouterView v-slot="{ Component, route }">
+    <RouterView v-slot="{ Component }">
       <keep-alive include="CatalogView">
-        <component :is="Component" :key="route.path" />
+        <component :is="Component" />
       </keep-alive>
     </RouterView>
     <ToastContainer />

src/components/FolderPicker.vue

@@ -0,0 +1,117 @@
+<template>
+  <!-- Overlay -->
+  <div class="fixed inset-0 bg-black/70 flex items-center justify-center z-50 px-4" @click.self="$emit('cancel')">
+    <div class="bg-[#0d1219] border border-[#1e2d3d] w-full max-w-lg flex flex-col" style="max-height: 70vh">
+
+      <!-- Header -->
+      <div class="flex items-center justify-between px-5 py-4 border-b border-[#1e2d3d] shrink-0">
+        <div>
+          <div class="text-[10px] text-[#e8513a] tracking-widest mb-0.5">CHOISIR UN DOSSIER</div>
+          <div class="text-xs text-[#5a7a94] font-mono truncate max-w-xs">{{ current }}</div>
+        </div>
+        <button @click="$emit('cancel')" class="text-[#5a7a94] hover:text-white transition-colors cursor-pointer text-lg leading-none">✕</button>
+      </div>
+
+      <!-- Chemin éditable -->
+      <div class="px-5 py-3 border-b border-[#1e2d3d] shrink-0 flex gap-2">
+        <input
+            v-model="inputPath"
+            @keydown.enter="navigateTo(inputPath)"
+            class="flex-1 bg-[#121920] border border-[#1e2d3d] text-xs text-white px-3 py-2 font-mono outline-none focus:border-[#e8513a] transition-colors"
+            placeholder="/"
+        />
+        <button @click="navigateTo(inputPath)"
+                class="border border-[#1e2d3d] text-[#5a7a94] px-3 py-2 text-xs tracking-widest hover:border-[#e8513a] hover:text-[#e8513a] transition-colors cursor-pointer">
+          OK
+        </button>
+      </div>
+
+      <!-- Navigation retour -->
+      <div v-if="parent !== null" class="px-5 shrink-0">
+        <button @click="navigateTo(parent)"
+                class="flex items-center gap-2 w-full py-2.5 text-xs text-[#5a7a94] hover:text-white transition-colors cursor-pointer border-b border-[#1e2d3d]">
+          <svg width="12" height="12" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+            <path d="M19 12H5M12 5l-7 7 7 7"/>
+          </svg>
+          ..
+        </button>
+      </div>
+
+      <!-- Liste dossiers -->
+      <div class="overflow-y-auto flex-1">
+        <div v-if="loading" class="flex items-center justify-center py-10 text-[#5a7a94] text-xs">
+          <div class="w-4 h-4 border border-white/10 border-t-[#e8513a] rounded-full animate-spin mr-2"/>
+          Chargement...
+        </div>
+        <div v-else-if="error" class="px-5 py-4 text-xs text-red-400">{{ error }}</div>
+        <div v-else-if="dirs.length === 0" class="px-5 py-4 text-xs text-[#5a7a94]">Aucun sous-dossier</div>
+        <button
+            v-for="dir in dirs"
+            :key="dir"
+            @click="navigateTo(joinPath(current, dir))"
+            class="flex items-center gap-3 w-full px-5 py-2.5 text-xs text-[#c8d8e8] hover:bg-white/5 transition-colors cursor-pointer border-b border-[#1e2d3d]/50 text-left"
+        >
+          <svg width="14" height="14" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
+            <path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V7z"/>
+          </svg>
+          {{ dir }}
+        </button>
+      </div>
+
+      <!-- Footer -->
+      <div class="flex items-center justify-between px-5 py-4 border-t border-[#1e2d3d] shrink-0">
+        <span class="text-[10px] text-[#5a7a94] font-mono truncate max-w-xs">{{ current }}</span>
+        <button @click="$emit('select', current)"
+                class="bg-[#e8513a] text-white px-5 py-2 text-xs tracking-widest hover:opacity-85 transition-opacity cursor-pointer">
+          CHOISIR
+        </button>
+      </div>
+
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+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('')
+
+function joinPath(base: string, name: string): string {
+  return base === '/' ? `/${name}` : `${base}/${name}`
+}
+
+async function navigateTo(p: string) {
+  if (!p) return
+  loading.value = true
+  error.value   = ''
+  try {
+    const res = await fetch(`/api/browse?path=${encodeURIComponent(p)}`, { credentials: 'include' })
+    if (!res.ok) {
+      const data = await res.json()
+      error.value = data.error ?? 'Erreur'
+      return
+    }
+    const data = await res.json()
+    current.value   = data.path
+    inputPath.value = data.path
+    parent.value    = data.parent
+    dirs.value      = data.dirs
+  } catch {
+    error.value = 'Impossible de lire ce dossier'
+  } finally {
+    loading.value = false
+  }
+}
+
+watch(() => props.initialPath, v => {
+  if (v) navigateTo(v)
+}, { immediate: true })
+</script>

src/stores/series.ts

@@ -61,6 +61,8 @@ export const useSeriesStore = defineStore('series', () => {
     const loadingDetail = ref(false)
     const error = ref<string | null>(null)
 
+    const _imageCache = new Set<string>()
+
     async function fetchSeries() {
         loadingSeries.value = true
         error.value = null
@@ -69,6 +71,13 @@ export const useSeriesStore = defineStore('series', () => {
             if (!res.ok) throw new Error(`Erreur ${res.status}`)
             const data = await res.json()
             series.value = data.series
+            // Précache des posters en arrière-plan
+            for (const s of data.series as Serie[]) {
+                if (s.poster_image && !_imageCache.has(s.poster_image)) {
+                    _imageCache.add(s.poster_image)
+                    new Image().src = s.poster_image
+                }
+            }
         } catch (err) {
             error.value = err instanceof Error ? err.message : 'Erreur inconnue'
         } finally {

src/views/CatalogView.vue

@@ -4,14 +4,12 @@
     <!-- Header -->
     <header class="sticky top-0 z-50 bg-zinc-950/90 backdrop-blur border-b border-white/5">
       <div class="max-w-7xl mx-auto px-6 h-16 flex items-center justify-between">
-        <span class="text-2xl font-serif tracking-tight">
+        <router-link to="/" class="text-2xl font-serif tracking-tight hover:opacity-80 transition">
           <span class="text-zinc-100">Fan</span><span class="text-orange-500">karr</span>
-        </span>
+        </router-link>
         <div class="flex items-center gap-2">
-          <!-- Icône logs -->
           <router-link to="/logs"
-                       class="p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition"
-          >
+                       class="p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition">
             <svg width="18" height="18" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
               <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
               <polyline points="14 2 14 8 20 8"/>
@@ -21,32 +19,25 @@
             </svg>
           </router-link>
           <router-link to="/downloads"
-                       class="relative p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition"
-          >
+                       class="relative p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition">
             <svg width="18" height="18" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
               <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
               <polyline points="7 10 12 15 17 10"/>
               <line x1="12" y1="15" x2="12" y2="3"/>
             </svg>
-            <!-- Badge compteur -->
             <span v-if="activeDownloads > 0"
                   class="absolute -top-0.5 -right-0.5 min-w-[16px] h-4 bg-orange-500 text-white text-[9px] font-bold rounded-full flex items-center justify-center px-1 leading-none">
               {{ activeDownloads }}
             </span>
           </router-link>
-          <router-link
-              to="/settings"
-              class="p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition"
-          >
+          <router-link to="/settings"
+                       class="p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition">
             <svg width="18" height="18" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
               <circle cx="12" cy="12" r="3"/>
               <path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"/>
             </svg>
           </router-link>
-          <button
-              class="p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition"
-              @click="handleLogout"
-          >
+          <button class="p-2 rounded-lg text-zinc-500 hover:text-zinc-100 hover:bg-white/5 transition" @click="handleLogout">
             <svg width="18" height="18" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
               <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/>
             </svg>
@@ -54,44 +45,56 @@
         </div>
       </div>
 
-      <!-- Search + Filters -->
+      <!-- Search + Filters + Sort -->
       <div class="max-w-7xl mx-auto px-6 pb-3 flex flex-wrap items-center gap-3">
         <div class="relative flex-1 min-w-48 max-w-sm">
           <svg class="absolute left-3 top-1/2 -translate-y-1/2 text-zinc-600 pointer-events-none" width="15" height="15" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
             <circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/>
           </svg>
-          <input
-              v-model="search"
-              type="text"
-              placeholder="Rechercher…"
-              class="w-full bg-white/5 border border-white/[0.08] rounded-lg pl-9 pr-4 py-2 text-sm placeholder-zinc-600 outline-none focus:border-orange-500/50 transition"
-          />
+          <input v-model="search" type="text" placeholder="Rechercher…"
+                 class="w-full bg-white/5 border border-white/[0.08] rounded-lg pl-9 pr-4 py-2 text-sm placeholder-zinc-600 outline-none focus:border-orange-500/50 transition"/>
         </div>
-        <div class="flex gap-1">
-          <button
-              v-for="f in filters"
-              :key="f.value"
-              class="px-3 py-1.5 rounded-lg text-xs font-medium border transition"
-              :class="activeFilter === f.value
-              ? 'bg-orange-500 border-orange-500 text-white'
-              : 'bg-transparent border-white/[0.08] text-zinc-500 hover:text-zinc-100 hover:border-white/20'"
-              @click="activeFilter = f.value"
-          >{{ f.label }}</button>
+
+        <div class="flex items-center gap-1">
+          <button v-for="f in filtersGroupe1" :key="f.value"
+                  class="px-3 py-1.5 rounded-lg text-xs font-medium border transition"
+                  :class="activeFilter === f.value
+                    ? 'bg-orange-500 border-orange-500 text-white'
+                    : 'bg-transparent border-white/[0.08] text-zinc-500 hover:text-zinc-100 hover:border-white/20'"
+                  @click="activeFilter = f.value">{{ f.label }}</button>
+
+          <span class="w-px h-5 bg-white/10 mx-1" />
+
+          <button v-for="f in filtersGroupe2" :key="f.value"
+                  class="px-3 py-1.5 rounded-lg text-xs font-medium border transition"
+                  :class="activeFilter === f.value
+                    ? 'bg-blue-500 border-blue-500 text-white'
+                    : 'bg-transparent border-white/[0.08] text-zinc-500 hover:text-zinc-100 hover:border-white/20'"
+                  @click="activeFilter = f.value">{{ f.label }}</button>
         </div>
-        <span class="text-xs text-zinc-600 ml-auto">{{ filtered.length }} série{{ filtered.length > 1 ? 's' : '' }}</span>
+
+        <!-- Tri -->
+        <div class="flex items-center gap-1 ml-auto">
+          <button v-for="s in sortOptions" :key="s.value"
+                  class="px-3 py-1.5 rounded-lg text-xs font-medium border transition"
+                  :class="activeSort === s.value
+                    ? 'bg-white/10 border-white/20 text-zinc-100'
+                    : 'bg-transparent border-white/[0.08] text-zinc-500 hover:text-zinc-100 hover:border-white/20'"
+                  @click="activeSort = s.value">{{ s.label }}</button>
+        </div>
+
+        <span class="text-xs text-zinc-600">{{ filtered.length }} série{{ filtered.length > 1 ? 's' : '' }}</span>
       </div>
     </header>
 
     <!-- Main -->
     <main class="max-w-7xl mx-auto px-6 py-8">
 
-      <!-- Loading -->
       <div v-if="store.loadingSeries" class="flex flex-col items-center justify-center gap-4 min-h-96 text-zinc-600">
         <div class="w-8 h-8 border-2 border-white/10 border-t-orange-500 rounded-full animate-spin" />
         <p class="text-sm">Chargement du catalogue…</p>
       </div>
 
-      <!-- Error -->
       <div v-else-if="store.error" class="flex flex-col items-center justify-center gap-4 min-h-96 text-orange-400">
         <svg width="36" height="36" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
           <circle cx="12" cy="12" r="10"/><path d="M12 8v4M12 16h.01"/>
@@ -102,12 +105,10 @@
         </button>
       </div>
 
-      <!-- Empty -->
       <div v-else-if="filtered.length === 0" class="flex flex-col items-center justify-center gap-3 min-h-96 text-zinc-600">
         <p class="text-sm">Aucune série trouvée</p>
       </div>
 
-      <!-- Grid -->
       <div v-else class="grid grid-cols-[repeat(auto-fill,minmax(150px,1fr))] gap-5">
         <router-link
             v-for="serie in filtered"
@@ -116,15 +117,9 @@
             class="group flex flex-col gap-2 transition-transform duration-200 hover:-translate-y-1"
             :class="{ 'opacity-40': !serie.has_torrents }"
         >
-          <!-- Poster -->
           <div class="relative aspect-[2/3] rounded-xl overflow-hidden bg-zinc-900 border border-white/5">
-            <img
-                v-if="serie.poster_image"
-                :src="serie.poster_image"
-                :alt="serie.title"
-                loading="lazy"
-                class="w-full h-full object-cover"
-            />
+            <img v-if="serie.poster_image" :src="serie.poster_image" :alt="serie.title"
+                 loading="lazy" class="w-full h-full object-cover"/>
             <div v-else class="w-full h-full flex items-center justify-center text-zinc-700">
               <svg width="28" height="28" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
                 <rect x="2" y="2" width="20" height="20" rx="2"/>
@@ -132,18 +127,12 @@
               </svg>
             </div>
 
-            <!-- Badge torrents dispo -->
-            <div v-if="serie.has_torrents" class="absolute top-2 right-2 bg-orange-500 text-white text-[10px] font-bold px-1.5 py-0.5 rounded-full leading-none">
-              {{ serie.torrent_count }}
-            </div>
-
-            <!-- Badge état téléchargement -->
+            <!-- Badge état -->
             <div v-if="serie.download_state !== 'none'"
                  class="absolute bottom-2 left-2 flex items-center gap-1 px-1.5 py-0.5 rounded-full text-[9px] font-bold leading-none backdrop-blur-sm"
                  :class="serie.download_state === 'complete'    ? 'bg-green-500/90 text-white' :
                         serie.download_state === 'partial'     ? 'bg-orange-500/90 text-white' :
                         serie.download_state === 'downloading' ? 'bg-blue-500/90 text-white'   : ''">
-              <!-- Icône -->
               <svg v-if="serie.download_state === 'complete'" width="9" height="9" viewBox="0 0 24 24" stroke="currentColor" stroke-width="3">
                 <polyline points="20 6 9 17 4 12"/>
               </svg>
@@ -155,70 +144,97 @@
                 <polyline points="7 10 12 15 17 10"/>
                 <line x1="12" y1="15" x2="12" y2="3"/>
               </svg>
-              {{ serie.download_state === 'complete' ? 'ORGANISÉ' : serie.download_state === 'downloading' ? 'EN COURS' : 'PARTIEL' }}
+              {{ serie.download_state === 'complete' ? 'IMPORTÉ' : serie.download_state === 'downloading' ? 'EN COURS' : 'PARTIEL' }}
             </div>
 
-            <!-- Overlay hover -->
             <div class="absolute inset-0 bg-black/60 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity duration-200">
               <span class="text-xs text-white border border-white/40 px-3 py-1.5 rounded-md">Voir</span>
             </div>
           </div>
 
-          <!-- Info -->
           <div>
             <p class="text-xs font-medium truncate leading-snug">{{ serie.title }}</p>
             <div class="flex items-center gap-1.5 mt-0.5">
               <span v-if="serie.year" class="text-[11px] text-zinc-600">{{ serie.year }}</span>
-              <span
-                  v-if="serie.status"
-                  class="text-[10px] px-1.5 py-0.5 rounded"
-                  :class="serie.status.toLowerCase() === 'continuing'
-                  ? 'bg-green-500/10 text-green-400'
-                  : 'bg-white/5 text-zinc-600'"
-              >{{ serie.status }}</span>
+              <span v-if="serie.status" class="text-[10px] px-1.5 py-0.5 rounded"
+                    :class="serie.status.toLowerCase() === 'continuing'
+                    ? 'bg-green-500/10 text-green-400'
+                    : 'bg-white/5 text-zinc-600'">{{ serie.status }}</span>
             </div>
           </div>
         </router-link>
       </div>
-
     </main>
   </div>
 </template>
 
 <script setup lang="ts">
-import { ref, computed, onMounted, onUnmounted } from 'vue'
+import { ref, computed, onMounted, onUnmounted, onActivated } from 'vue'
 import { useRouter } from 'vue-router'
 import { useSeriesStore } from '@/stores/series'
 import { useAuthStore } from '@/stores/auth'
 import { useToast } from '@/composables/useToast'
 
-const store = useSeriesStore()
-const auth = useAuthStore()
+const store  = useSeriesStore()
+const auth   = useAuthStore()
 const router = useRouter()
 const { add: toast } = useToast()
 
-const search = ref('')
+const search       = ref('')
 const activeFilter = ref('all')
+const activeSort   = ref('alpha')
 const activeDownloads = ref(0)
 
-const filters = [
-  { label: 'Toutes',      value: 'all' },
-  { label: 'Disponibles', value: 'available' },
-  { label: 'Téléchargés', value: 'complete' },
-  { label: 'En cours',    value: 'downloading' },
+const filtersGroupe1 = [
+  { label: 'Toutes',       value: 'all' },
+  { label: 'Disponibles',  value: 'available' },
   { label: 'Sans torrent', value: 'unavailable' },
 ]
 
+const filtersGroupe2 = [
+  { label: 'Importés',  value: 'complete' },
+  { label: 'En cours',  value: 'downloading' },
+]
+
+const sortOptions = [
+  { label: 'A→Z',        value: 'alpha' },
+  { label: 'Z→A',        value: 'alpha-desc' },
+  { label: 'Récents',    value: 'recent' },
+  { label: 'Importés',   value: 'imported' },
+]
+
 const filtered = computed(() => {
-  let list = store.series
-  if (activeFilter.value === 'available')    list = list.filter(s => s.has_torrents)
-  if (activeFilter.value === 'unavailable')  list = list.filter(s => !s.has_torrents)
-  if (activeFilter.value === 'complete')     list = list.filter(s => s.download_state === 'complete')
-  if (activeFilter.value === 'downloading')  list = list.filter(s => s.download_state === 'downloading' || s.download_state === 'partial')
+  let list = [...store.series]
+
+  // Filtres
+  if (activeFilter.value === 'available')   list = list.filter(s => s.has_torrents)
+  if (activeFilter.value === 'unavailable') list = list.filter(s => !s.has_torrents)
+  if (activeFilter.value === 'complete')    list = list.filter(s => s.download_state === 'complete')
+  if (activeFilter.value === 'downloading') list = list.filter(s => s.download_state === 'downloading' || s.download_state === 'partial')
+
   if (search.value.trim()) {
     const q = search.value.toLowerCase()
     list = list.filter(s => s.title.toLowerCase().includes(q))
   }
+
+  // Tri
+  switch (activeSort.value) {
+    case 'alpha':
+      list.sort((a, b) => a.title.localeCompare(b.title, 'fr'))
+      break
+    case 'alpha-desc':
+      list.sort((a, b) => b.title.localeCompare(a.title, 'fr'))
+      break
+    case 'recent':
+      list.sort((a, b) => (b.year ?? 0) - (a.year ?? 0))
+      break
+    case 'imported':
+      // Importés en premier, puis partiel, puis reste
+      const order: Record<string, number> = { complete: 0, partial: 1, downloading: 2, none: 3 }
+      list.sort((a, b) => (order[a.download_state] ?? 3) - (order[b.download_state] ?? 3))
+      break
+  }
+
   return list
 })
 
@@ -227,7 +243,7 @@ async function handleLogout() {
   router.push('/auth')
 }
 
-// ── Polling downloads actifs + notifications organisation ──────
+// ── Polling downloads + notifs import ─────────────────────────
 let dlInterval: ReturnType<typeof setInterval> | null = null
 const seenNotifs = new Set<string>()
 
@@ -245,22 +261,26 @@ async function fetchOrganizeNotifs() {
     const res = await fetch('/api/organize/recent', { credentials: 'include' })
     if (!res.ok) return
     const notifs: any[] = await res.json()
+    let hasNew = false
     for (const n of notifs) {
       const key = `${n.hash}-${n.at}`
       if (seenNotifs.has(key)) continue
       seenNotifs.add(key)
+      hasNew = true
       if (n.done > 0) {
         const msg = n.errors > 0
-            ? `${n.name} — ${n.done} fichier(s) organisé(s), ${n.errors} erreur(s)`
-            : `${n.name} — ${n.done} fichier(s) organisé(s) ✓`
+            ? `${n.name} — ${n.done} fichier(s) importé(s), ${n.errors} erreur(s)`
+            : `${n.name} — ${n.done} fichier(s) importé(s) ✓`
         toast(msg, n.errors > 0 ? 'error' : 'success')
       }
     }
+    // Rafraîchir le catalogue si de nouveaux imports ont eu lieu
+    if (hasNew) await store.fetchSeries()
   } catch {}
 }
 
-onMounted(() => {
-  if (store.series.length === 0) store.fetchSeries()
+onMounted(async () => {
+  if (store.series.length === 0) await store.fetchSeries()
   fetchActiveDownloads()
   fetchOrganizeNotifs()
   dlInterval = setInterval(() => {
@@ -269,6 +289,11 @@ onMounted(() => {
   }, 10000)
 })
 
+onActivated(async () => {
+  await store.fetchSeries()
+  fetchActiveDownloads()
+})
+
 onUnmounted(() => {
   if (dlInterval) clearInterval(dlInterval)
 })

src/views/DownloadsView.vue

@@ -10,7 +10,10 @@
         <h1 class="text-xl font-black text-white font-sans">Téléchargements</h1>
       </div>
       <div class="flex items-center gap-3">
-        <!-- Indicateur de polling -->
+        <button @click="importAll" :disabled="importingAll"
+                class="border border-[#1e2d3d] text-[#5a7a94] px-4 py-1.5 text-xs tracking-widest hover:border-green-500 hover:text-green-500 transition-colors cursor-pointer disabled:opacity-50">
+          {{ importingAll ? '...' : 'IMPORTER TOUT' }}
+        </button>
         <div class="flex items-center gap-2 text-[10px] text-[#5a7a94] tracking-widest">
           <div class="w-1.5 h-1.5 rounded-full" :class="polling ? 'bg-green-500 animate-pulse' : 'bg-[#1e2d3d]'"/>
           {{ polling ? 'EN DIRECT' : 'PAUSE' }}
@@ -30,11 +33,42 @@
       </div>
     </div>
 
+    <!-- Onglets -->
+    <div class="flex items-center justify-between mb-4">
+      <div class="flex gap-0 border border-[#1e2d3d]">
+        <button @click="activeTab = 'active'"
+                class="px-5 py-2 text-xs tracking-widest transition-colors cursor-pointer"
+                :class="activeTab === 'active' ? 'bg-[#e8513a] text-white' : 'text-[#5a7a94] hover:text-white'">
+          EN COURS
+          <span v-if="activeTorrents.length > 0" class="ml-1.5 bg-white/20 text-[9px] px-1.5 py-0.5 rounded-full">
+            {{ activeTorrents.length }}
+          </span>
+        </button>
+        <button @click="activeTab = 'done'"
+                class="px-5 py-2 text-xs tracking-widest transition-colors cursor-pointer border-l border-[#1e2d3d]"
+                :class="activeTab === 'done' ? 'bg-[#e8513a] text-white' : 'text-[#5a7a94] hover:text-white'">
+          TERMINÉS
+          <span v-if="doneTorrents.length > 0" class="ml-1.5 bg-white/20 text-[9px] px-1.5 py-0.5 rounded-full">
+            {{ doneTorrents.length }}
+          </span>
+        </button>
+      </div>
+
+      <div v-if="activeTab === 'done'" class="flex items-center gap-2">
+        <button @click="hideImported = !hideImported"
+                class="relative shrink-0 w-8 h-4 rounded-full transition-colors cursor-pointer"
+                :class="hideImported ? 'bg-[#e8513a]' : 'bg-[#1e2d3d]'">
+          <span class="absolute top-0.5 left-0.5 w-3 h-3 rounded-full bg-white transition-transform duration-200"
+                :class="hideImported ? 'translate-x-4' : 'translate-x-0'" />
+        </button>
+        <span class="text-[10px] text-[#5a7a94] tracking-widest">MASQUER IMPORTÉS</span>
+      </div>
+    </div>
+
     <!-- Pas de clients -->
     <div v-if="noClients" class="flex flex-col items-center justify-center gap-3 min-h-64 text-[#5a7a94]">
       <p class="text-sm">Aucun client torrent configuré</p>
-      <router-link to="/settings"
-                   class="text-[10px] tracking-widest text-[#e8513a] hover:opacity-75 transition-opacity">
+      <router-link to="/settings" class="text-[10px] tracking-widest text-[#e8513a] hover:opacity-75 transition-opacity">
         CONFIGURER →
       </router-link>
     </div>
@@ -46,41 +80,37 @@
     </div>
 
     <!-- Vide -->
-    <div v-else-if="!loading && torrents.length === 0" class="flex flex-col items-center justify-center gap-3 min-h-64 text-[#5a7a94]">
-      <p class="text-sm">Aucun téléchargement en cours</p>
-      <p class="text-[11px]">Les torrents lancés depuis Fankarr apparaîtront ici</p>
+    <div v-else-if="!loading && visibleTorrents.length === 0" class="flex flex-col items-center justify-center gap-3 min-h-64 text-[#5a7a94]">
+      <p class="text-sm">
+        {{ activeTab === 'active' ? 'Aucun téléchargement en cours' : 'Aucun torrent terminé' }}
+      </p>
+      <p class="text-[11px]">
+        {{ activeTab === 'active'
+          ? 'Les torrents avec la catégorie « fankai » apparaîtront ici'
+          : hideImported ? 'Tous les torrents terminés sont importés' : '' }}
+      </p>
     </div>
 
     <!-- Liste torrents -->
     <div v-else class="flex flex-col gap-2">
-      <div v-for="t in torrents" :key="t.hash"
-           class="bg-[#0d1219] border border-[#1e2d3d] p-4">
+      <div v-for="t in visibleTorrents" :key="t.hash" class="bg-[#0d1219] border border-[#1e2d3d] p-4">
 
-        <!-- Ligne principale -->
         <div class="flex items-start justify-between gap-4 mb-3">
           <div class="flex-1 min-w-0">
             <p class="text-sm text-white font-medium truncate">{{ t.name }}</p>
             <div class="flex items-center gap-3 mt-1">
-              <!-- Badge état -->
-              <span class="text-[10px] tracking-widest px-2 py-0.5 border"
-                    :class="stateBadge(t.state).class">
+              <span class="text-[10px] tracking-widest px-2 py-0.5 border" :class="stateBadge(t.state).class">
                 {{ stateBadge(t.state).label }}
               </span>
-              <!-- Client -->
               <span class="text-[10px] text-[#5a7a94]">{{ t.client_name }}</span>
             </div>
           </div>
-
-          <!-- Infos droite -->
           <div class="text-right shrink-0">
             <p class="text-sm font-bold text-white">{{ t.progress }}%</p>
-            <p class="text-[10px] text-[#5a7a94] mt-0.5">
-              {{ formatSize(t.downloaded) }} / {{ formatSize(t.size) }}
-            </p>
+            <p class="text-[10px] text-[#5a7a94] mt-0.5">{{ formatSize(t.downloaded) }} / {{ formatSize(t.size) }}</p>
           </div>
         </div>
 
-        <!-- Barre de progression -->
         <div class="h-1 bg-[#1e2d3d] rounded-full overflow-hidden mb-2">
           <div class="h-full rounded-full transition-all duration-500"
                :class="t.state === 'seeding' ? 'bg-green-500' :
@@ -89,29 +119,18 @@
                :style="{ width: `${t.progress}%` }"/>
         </div>
 
-        <!-- Infos bas -->
         <div class="flex items-center justify-between">
           <div class="flex items-center gap-4 text-[10px] text-[#5a7a94]">
-            <span v-if="t.state === 'downloading'">
-              ↓ {{ formatSpeed(t.speed) }}
-            </span>
-            <span v-if="t.state === 'downloading' && t.eta > 0">
-              ETA {{ formatEta(t.eta) }}
-            </span>
-            <span v-if="t.state === 'seeding'" class="text-green-500">
-              ✓ Complété
-            </span>
+            <span v-if="t.state === 'downloading'">↓ {{ formatSpeed(t.speed) }}</span>
+            <span v-if="t.state === 'downloading' && t.eta > 0">ETA {{ formatEta(t.eta) }}</span>
+            <span v-if="t.state === 'seeding'" class="text-green-500">✓ Complété</span>
           </div>
 
-          <!-- Badge organisation -->
           <div v-if="t.state === 'seeding'" class="flex items-center gap-2">
-
-            <!-- Badge erreurs avec tooltip -->
             <div v-if="t.errorFiles?.length > 0" class="relative group/err">
               <span class="text-[9px] tracking-widest px-2 py-0.5 border border-red-500/40 text-red-400 cursor-default">
                 {{ t.errorFiles.length }} ERREUR{{ t.errorFiles.length > 1 ? 'S' : '' }}
               </span>
-              <!-- Tooltip -->
               <div class="absolute bottom-full right-0 mb-2 hidden group-hover/err:block z-10 w-80">
                 <div class="bg-[#0d1219] border border-red-500/30 p-3 text-[10px] shadow-xl">
                   <div class="text-red-400 tracking-widest mb-2">FICHIERS EN ERREUR</div>
@@ -123,22 +142,20 @@
               </div>
             </div>
 
-            <!-- Badge statut organisation -->
             <span class="text-[9px] tracking-widest px-2 py-0.5 border"
-                  :class="t.organizeState === 'done'    ? 'border-green-500/40 text-green-500' :
-                        t.organizeState === 'partial'  ? 'border-yellow-500/40 text-yellow-500' :
-                                                         'border-[#1e2d3d] text-[#5a7a94]'">
-              {{ t.organizeState === 'done'    ? `ORGANISÉ (${t.organizeProgress?.done}/${t.organizeProgress?.total})` :
+                  :class="t.organizeState === 'done'   ? 'border-green-500/40 text-green-500' :
+                        t.organizeState === 'partial' ? 'border-yellow-500/40 text-yellow-500' :
+                                                        'border-red-500/40 text-red-400'">
+              {{ t.organizeState === 'done'   ? `IMPORTÉ (${t.organizeProgress?.done}/${t.organizeProgress?.total})` :
                 t.organizeState === 'partial' ? `EN COURS (${t.organizeProgress?.done}/${t.organizeProgress?.total})` :
-                    'NON ORGANISÉ' }}
+                    'NON IMPORTÉ' }}
             </span>
 
-            <!-- Bouton organiser si pas encore fait -->
             <button v-if="t.organizeState !== 'done'"
-                    @click="organize(t)"
-                    :disabled="organizing[t.hash]"
+                    @click="importTorrent(t)"
+                    :disabled="importing[t.hash]"
                     class="text-[9px] tracking-widest px-3 py-1 border transition-colors cursor-pointer border-[#1e2d3d] text-[#5a7a94] hover:border-[#e8513a] hover:text-[#e8513a] disabled:opacity-50">
-              {{ organizing[t.hash] ? '...' : 'ORGANISER' }}
+              {{ importing[t.hash] ? '...' : 'IMPORTER' }}
             </button>
           </div>
         </div>
@@ -153,15 +170,31 @@ import { useToast } from '@/composables/useToast'
 
 const { add: toast } = useToast()
 
-const torrents   = ref<any[]>([])
-const loading    = ref(true)
-const polling    = ref(true)
-const noClients  = ref(false)
-const organizing = ref<Record<string, boolean>>({})
+const torrents     = ref<any[]>([])
+const loading      = ref(true)
+const polling      = ref(true)
+const noClients    = ref(false)
+const importing    = ref<Record<string, boolean>>({})
+const importingAll = ref(false)
+const activeTab    = ref<'active' | 'done'>('active')
+const hideImported = ref(false)
 
 let pollInterval: ReturnType<typeof setInterval> | null = null
 
-// ── Stats ──────────────────────────────────────────────────────
+const activeTorrents = computed(() =>
+    torrents.value.filter(t => ['downloading', 'paused', 'checking', 'error', 'unknown'].includes(t.state))
+)
+
+const doneTorrents = computed(() =>
+    torrents.value.filter(t => t.state === 'seeding')
+)
+
+const visibleTorrents = computed(() => {
+  if (activeTab.value === 'active') return activeTorrents.value
+  if (hideImported.value) return doneTorrents.value.filter(t => t.organizeState !== 'done')
+  return doneTorrents.value
+})
+
 const stats = computed(() => [
   { label: 'EN COURS',  value: torrents.value.filter(t => t.state === 'downloading').length },
   { label: 'COMPLÉTÉS', value: torrents.value.filter(t => t.state === 'seeding').length },
@@ -169,7 +202,6 @@ const stats = computed(() => [
   { label: 'ERREURS',   value: torrents.value.filter(t => t.state === 'error').length },
 ])
 
-// ── Fetch ──────────────────────────────────────────────────────
 async function fetchTorrents() {
   try {
     const res = await fetch('/api/downloads', { credentials: 'include' })
@@ -178,7 +210,6 @@ async function fetchTorrents() {
     torrents.value  = await res.json()
     noClients.value = false
   } catch {
-    // silencieux en polling
   } finally {
     loading.value = false
   }
@@ -202,31 +233,62 @@ function togglePolling() {
 onMounted(startPolling)
 onUnmounted(stopPolling)
 
-// ── Organiser ──────────────────────────────────────────────────
-async function organize(torrent: any) {
-  organizing.value[torrent.hash] = true
+async function importTorrent(torrent: any) {
+  importing.value[torrent.hash] = true
   try {
     const res = await fetch('/api/organize', {
-      method : 'POST',
+      method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       credentials: 'include',
       body: JSON.stringify({ hash: torrent.hash, save_path: torrent.save_path, name: torrent.name })
     })
     if (res.ok) {
-      organized.value[torrent.hash] = true
-      toast(`${torrent.name} organisé ✓`, 'success')
+      toast(`${torrent.name} importé ✓`, 'success')
+      await fetchTorrents()
     } else {
       const { error } = await res.json()
-      toast(error ?? 'Erreur lors de l\'organisation', 'error')
+      toast(error ?? "Erreur lors de l'import", 'error')
     }
   } catch {
     toast('Impossible de contacter le serveur', 'error')
   } finally {
-    organizing.value[torrent.hash] = false
+    importing.value[torrent.hash] = false
   }
 }
 
-// ── Helpers affichage ──────────────────────────────────────────
+async function importAll() {
+  const toImport = doneTorrents.value.filter(t => t.organizeState !== 'done')
+  if (toImport.length === 0) {
+    toast('Tous les torrents sont déjà importés', 'success')
+    return
+  }
+
+  importingAll.value = true
+  let done = 0
+  let errors = 0
+
+  for (const t of toImport) {
+    try {
+      const res = await fetch('/api/organize', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ hash: t.hash, save_path: t.save_path, name: t.name })
+      })
+      if (res.ok) done++
+      else errors++
+    } catch {
+      errors++
+    }
+  }
+
+  importingAll.value = false
+  await fetchTorrents()
+
+  if (errors === 0) toast(`${done} torrent(s) importé(s) ✓`, 'success')
+  else toast(`${done} OK, ${errors} erreur(s)`, 'error')
+}
+
 function stateBadge(state: string) {
   const map: Record<string, { label: string; class: string }> = {
     downloading: { label: 'TÉLÉCHARGEMENT', class: 'border-[#e8513a]/40 text-[#e8513a]' },
@@ -246,9 +308,7 @@ function formatSize(bytes: number): string {
   return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`
 }
 
-function formatSpeed(bps: number): string {
-  return `${formatSize(bps)}/s`
-}
+function formatSpeed(bps: number): string { return `${formatSize(bps)}/s` }
 
 function formatEta(seconds: number): string {
   if (seconds < 0 || seconds > 86400 * 7) return '∞'

src/views/SerieView.vue

@@ -27,7 +27,8 @@
       <!-- Hero -->
       <div class="relative">
         <div v-if="data.serie.fanart_image" class="absolute inset-0 h-72 overflow-hidden pointer-events-none">
-          <img :src="data.serie.fanart_image" class="w-full h-full object-cover opacity-20" />
+          <img :src="data.serie.fanart_image" class="w-full h-full object-cover opacity-20"
+               @error="e => ((e.target as HTMLElement).closest('div') as HTMLElement).style.display = 'none'" />
           <div class="absolute inset-0 bg-gradient-to-b from-transparent to-zinc-950" />
         </div>
 
@@ -64,17 +65,40 @@
               <button
                   v-for="(t, i) in data.torrents_integrale"
                   :key="i"
+                  :title="t.raw"
                   class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium rounded-lg transition"
-                  :class="t.label === 'Intégrale'
-                  ? 'bg-orange-500 hover:bg-orange-600 text-white'
-                  : 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border border-orange-500/20'"
-                  :disabled="downloading === `integrale-${i}`"
+                  :class="[
+                  t.label === 'Intégrale'
+                    ? 'bg-orange-500 hover:bg-orange-600 text-white'
+                    : 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border border-orange-500/20',
+                  (downloading.has(`integrale-${i}`) || downloaded.has(`integrale-${i}`) || isAlreadyQueued(t)) ? 'opacity-50 cursor-not-allowed' : ''
+                ]"
+                  :disabled="downloading.has(`integrale-${i}`) || downloaded.has(`integrale-${i}`) || isAlreadyQueued(t)"
                   @click="download(`integrale-${i}`, t.torrent_url, t.magnet)"
               >
-                <DownloadIcon :spinning="downloading === `integrale-${i}`" />
-                {{ t.label }}
+                <DownloadIcon :spinning="downloading.has(`integrale-${i}`)" />
+                {{ isAlreadyQueued(t) ? 'Déjà ajouté' : downloaded.has(`integrale-${i}`) ? 'Envoyé ✓' : t.label }}
               </button>
             </div>
+            <!-- Barre progression intégrale -->
+            <template v-for="(t, i) in data.torrents_integrale" :key="`prog-${i}`">
+              <template v-if="torrentProgress(extractHash(t))">
+                <span v-if="torrentProgress(extractHash(t))!.progress === 100"
+                      class="mt-2 inline-flex items-center gap-1.5 text-[10px] px-2.5 py-1 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
+                  ✓ Téléchargé
+                </span>
+                <div v-else class="mt-2 w-full max-w-sm">
+                  <div class="flex items-center justify-between text-[10px] text-zinc-500 mb-1">
+                    <span>Téléchargement</span>
+                    <span>{{ torrentProgress(extractHash(t))!.progress }}%</span>
+                  </div>
+                  <div class="h-1 bg-white/10 rounded-full overflow-hidden">
+                    <div class="h-full bg-orange-500 rounded-full transition-all duration-500"
+                         :style="{ width: `${torrentProgress(extractHash(t))!.progress}%` }" />
+                  </div>
+                </div>
+              </template>
+            </template>
           </div>
         </div>
       </div>
@@ -124,76 +148,132 @@
             <!-- Bouton pack_saison sur le header -->
             <button
                 class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border transition"
-                :class="season.torrent
-                ? 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border-orange-500/20'
-                : 'bg-white/[0.03] text-zinc-600 border-white/8 cursor-not-allowed'"
-                :disabled="!season.torrent || downloading === `season-${season.id}`"
+                :class="[
+                season.torrent && !downloaded.has(`season-${season.id}`) && !isAlreadyQueued(season.torrent) && season.organized_state !== 'complete'
+                  ? 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border-orange-500/20'
+                  : 'bg-white/[0.03] text-zinc-600 border-white/8 cursor-not-allowed'
+              ]"
+                :disabled="!season.torrent || downloading.has(`season-${season.id}`) || downloaded.has(`season-${season.id}`) || isAlreadyQueued(season.torrent) || season.organized_state === 'complete'"
                 @click="season.torrent && download(`season-${season.id}`, season.torrent.torrent_url, season.torrent.magnet)"
             >
-              <DownloadIcon :spinning="downloading === `season-${season.id}`" :size="12" />
-              Saison entière
+              <DownloadIcon :spinning="downloading.has(`season-${season.id}`)" :size="12" />
+              {{ season.organized_state === 'complete' ? 'Organisé ✓' : isAlreadyQueued(season.torrent) ? 'Déjà ajouté' : downloaded.has(`season-${season.id}`) ? 'Envoyé ✓' : 'Saison entière' }}
             </button>
           </div>
 
+          <!-- Barre progression saison -->
+          <template v-if="torrentProgress(extractHash(season.torrent))">
+            <div v-if="torrentProgress(extractHash(season.torrent))!.progress === 100"
+                 class="px-5 py-2 border-b border-white/5">
+              <span class="inline-flex items-center gap-1.5 text-[10px] px-2.5 py-1 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
+                ✓ Téléchargé
+              </span>
+            </div>
+            <div v-else class="px-5 py-2 border-b border-white/5">
+              <div class="flex items-center justify-between text-[10px] text-zinc-500 mb-1">
+                <span>Téléchargement en cours</span>
+                <span>{{ torrentProgress(extractHash(season.torrent))!.progress }}%</span>
+              </div>
+              <div class="h-1 bg-white/10 rounded-full overflow-hidden">
+                <div class="h-full bg-orange-500 rounded-full transition-all duration-500"
+                     :style="{ width: `${torrentProgress(extractHash(season.torrent))!.progress}%` }" />
+              </div>
+            </div>
+          </template>
+
           <!-- Episodes -->
           <div v-if="!collapsedSeasons.has(season.id)" class="divide-y divide-white/[0.04]">
             <div
                 v-for="ep in season.episodes"
                 :key="ep.id"
-                class="flex items-center gap-4 px-5 py-3 hover:bg-white/[0.02] transition"
+                class="px-5 py-3 hover:bg-white/[0.02] transition"
             >
-              <!-- Thumbnail -->
-              <div class="shrink-0 w-24 aspect-video rounded-lg overflow-hidden bg-zinc-800 hidden sm:block">
-                <img v-if="ep.thumb_image" :src="ep.thumb_image" class="w-full h-full object-cover" loading="lazy" />
-                <div v-else class="w-full h-full flex items-center justify-center text-zinc-700 text-xs font-mono">
-                  {{ season.season_number === 0 ? 'SP' : `E${ep.episode_number}` }}
+              <!-- Ligne principale -->
+              <div class="flex items-center gap-4">
+                <!-- Thumbnail -->
+                <div class="shrink-0 w-24 aspect-video rounded-lg overflow-hidden bg-zinc-800 hidden sm:block">
+                  <img v-if="ep.thumb_image" :src="ep.thumb_image" class="w-full h-full object-cover" loading="lazy" />
+                  <div v-else class="w-full h-full flex items-center justify-center text-zinc-700 text-xs font-mono">
+                    {{ season.season_number === 0 ? 'SP' : `E${ep.episode_number}` }}
+                  </div>
                 </div>
-              </div>
 
-              <!-- Info -->
-              <div class="flex-1 min-w-0">
-                <div class="flex items-center gap-2">
-                  <span class="text-xs text-zinc-600 shrink-0 font-mono">
-                    {{ season.season_number === 0 ? 'SP' : `E${String(ep.episode_number).padStart(2,'0')}` }}
+                <!-- Info -->
+                <div class="flex-1 min-w-0">
+                  <div class="flex items-center gap-2">
+                    <span class="text-xs text-zinc-600 shrink-0 font-mono">
+                      {{ season.season_number === 0 ? 'SP' : `E${String(ep.episode_number).padStart(2,'0')}` }}
+                    </span>
+                    <span class="text-sm font-medium truncate">{{ ep.title || `Épisode ${ep.episode_number}` }}</span>
+                  </div>
+                  <div class="flex items-center gap-3 mt-0.5">
+                    <span v-if="ep.aired" class="text-xs text-zinc-600">{{ formatDate(ep.aired) }}</span>
+                    <span v-if="ep.duration" class="text-xs text-zinc-600">{{ ep.duration }} min</span>
+                  </div>
+                </div>
+
+                <!-- Badges + bouton download -->
+                <div class="shrink-0 flex items-center gap-2">
+
+                  <!-- Badge Hors Fankai (torrent manuel) -->
+                  <span
+                      v-if="ep.torrent?.manual"
+                      title="Ce fichier ne provient pas du catalogue Fan-Kai officiel"
+                      class="text-[10px] px-2 py-0.5 rounded-full border bg-purple-500/10 text-purple-400 border-purple-500/20"
+                  >
+                    Hors Fankai
                   </span>
-                  <span class="text-sm font-medium truncate">{{ ep.title || `Épisode ${ep.episode_number}` }}</span>
-                </div>
-                <div class="flex items-center gap-3 mt-0.5">
-                  <span v-if="ep.aired" class="text-xs text-zinc-600">{{ formatDate(ep.aired) }}</span>
-                  <span v-if="ep.duration" class="text-xs text-zinc-600">{{ ep.duration }} min</span>
+
+                  <!-- Badge organisé -->
+                  <span v-if="ep.organized"
+                        class="text-[10px] px-2 py-0.5 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
+                    ✓ organisé
+                  </span>
+
+                  <!-- Badge téléchargé à 100% -->
+                  <span v-if="torrentProgress(extractHash(ep.torrent))?.progress === 100"
+                        class="text-[10px] px-2 py-0.5 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
+                    ✓ téléchargé
+                  </span>
+
+                  <!-- Badge dispo/indispo -->
+                  <span
+                      class="inline-block text-[10px] px-2 py-0.5 rounded-full border"
+                      :class="ep.available
+                        ? 'bg-blue-500/10 text-blue-400 border-blue-500/20'
+                        : 'bg-white/5 text-zinc-600 border-white/8'"
+                  >
+                    {{ ep.available ? 'dispo' : 'indispo' }}
+                  </span>
+
+                  <!-- Bouton download -->
+                  <button
+                      class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border transition"
+                      :class="[
+                        ep.torrent && !downloaded.has(`ep-${ep.id}`) && !isAlreadyQueued(ep.torrent) && !ep.organized
+                          ? 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border-orange-500/20'
+                          : 'bg-white/[0.03] text-zinc-600 border-white/8 cursor-not-allowed'
+                      ]"
+                      :disabled="!ep.torrent || downloading.has(`ep-${ep.id}`) || downloaded.has(`ep-${ep.id}`) || isAlreadyQueued(ep.torrent) || ep.organized"
+                      @click="ep.torrent && download(`ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet)"
+                  >
+                    <DownloadIcon :spinning="downloading.has(`ep-${ep.id}`)" :size="12" />
+                    {{ ep.organized ? '✓' : isAlreadyQueued(ep.torrent) ? '✓' : downloaded.has(`ep-${ep.id}`) ? '✓' : 'Ep.' }}
+                  </button>
                 </div>
               </div>
 
-              <!-- Bouton épisode (type episode uniquement) -->
-              <div class="shrink-0 flex items-center gap-2">
-                <!-- Badge organisé -->
-                <span v-if="ep.organized"
-                      class="text-[10px] px-2 py-0.5 rounded-full border bg-green-500/10 text-green-400 border-green-500/20">
-                  ✓ organisé
-                </span>
-
-                <!-- Badge dispo/indispo basé sur available (episode résolu dans un torrent) -->
-                <span
-                    class="inline-block text-[10px] px-2 py-0.5 rounded-full border"
-                    :class="ep.available
-                    ? 'bg-green-500/10 text-green-400 border-green-500/20'
-                    : 'bg-white/5 text-zinc-600 border-white/8'"
-                >
-                  {{ ep.available ? 'dispo' : 'indispo' }}
-                </span>
-
-                <!-- Bouton download — visible seulement si type=episode, sinon grisé -->
-                <button
-                    class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border transition"
-                    :class="ep.torrent
-                    ? 'bg-orange-500/10 hover:bg-orange-500/20 text-orange-400 border-orange-500/20'
-                    : 'bg-white/[0.03] text-zinc-600 border-white/8 cursor-not-allowed'"
-                    :disabled="!ep.torrent || downloading === `ep-${ep.id}`"
-                    @click="ep.torrent && download(`ep-${ep.id}`, ep.torrent.torrent_url, ep.torrent.magnet)"
-                >
-                  <DownloadIcon :spinning="downloading === `ep-${ep.id}`" :size="12" />
-                  Ep.
-                </button>
+              <!-- Barre progression épisode (seulement si < 100%) -->
+              <div v-if="torrentProgress(extractHash(ep.torrent)) && torrentProgress(extractHash(ep.torrent))!.progress < 100"
+                   class="mt-2 sm:pl-28">
+                <div class="flex items-center justify-between text-[10px] text-zinc-500 mb-1">
+                  <span>Téléchargement</span>
+                  <span>{{ torrentProgress(extractHash(ep.torrent))!.progress }}%</span>
+                </div>
+                <div class="h-0.5 bg-white/10 rounded-full overflow-hidden">
+                  <div class="h-full bg-orange-500 rounded-full transition-all duration-500"
+                       :style="{ width: `${torrentProgress(extractHash(ep.torrent))!.progress}%` }" />
+                </div>
               </div>
             </div>
           </div>
@@ -223,7 +303,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, computed, onMounted, defineComponent, h } from 'vue'
+import { ref, computed, onMounted, onUnmounted, defineComponent, h } from 'vue'
 import { useRoute } from 'vue-router'
 import { useSeriesStore } from '@/stores/series'
 import type { Season } from '@/stores/series'
@@ -245,9 +325,42 @@ const route = useRoute()
 const store = useSeriesStore()
 
 const collapsedSeasons = ref<Set<number>>(new Set())
-const downloading = ref<string | null>(null)
-const toast = ref<{ type: 'success' | 'error'; message: string } | null>(null)
+const downloading      = ref<Set<string>>(new Set())
+const downloaded       = ref<Set<string>>(new Set())
+const toast            = ref<{ type: 'success' | 'error'; message: string } | null>(null)
 
+// ── Progression downloads ──────────────────────────────────────
+interface ActiveTorrent { hash: string; progress: number; state: string; name: string }
+const activeTorrents = ref<ActiveTorrent[]>([])
+let pollTimer: ReturnType<typeof setInterval> | null = null
+
+async function fetchActiveDownloads() {
+  try {
+    const res = await fetch('/api/downloads', { credentials: 'include' })
+    if (!res.ok) return
+    const list: any[] = await res.json()
+    activeTorrents.value = list.map(t => ({
+      hash    : t.hash,
+      progress: t.progress ?? 0,
+      state   : t.state,
+      name    : t.name,
+    }))
+  } catch {}
+}
+
+function torrentProgress(hash: string | null | undefined): ActiveTorrent | null {
+  if (!hash) return null
+  return activeTorrents.value.find(t => t.hash.toLowerCase() === hash.toLowerCase()) ?? null
+}
+
+function extractHash(torrent: { magnet?: string | null; torrent_url?: string | null } | null | undefined): string | null {
+  if (!torrent) return null
+  const magnet = torrent.magnet ?? ''
+  const m = magnet.match(/xt=urn:btih:([a-fA-F0-9]{40})/i)
+  return m ? m[1].toLowerCase() : null
+}
+
+// ── Data ───────────────────────────────────────────────────────
 const data = computed(() => store.currentSerie)
 
 function seasonAvailableCount(season: Season) {
@@ -269,19 +382,39 @@ function showToast(type: 'success' | 'error', message: string) {
   setTimeout(() => { toast.value = null }, 3500)
 }
 
+function isAlreadyQueued(torrent: { magnet?: string | null; torrent_url?: string | null } | null | undefined): boolean {
+  const hash = extractHash(torrent)
+  if (!hash) return false
+  return activeTorrents.value.some(t => t.hash.toLowerCase() === hash.toLowerCase())
+}
+
 async function download(key: string, torrent_url: string | null, magnet: string | null) {
-  downloading.value = key
+  if (downloading.value.has(key) || downloaded.value.has(key)) return
+  downloading.value = new Set([...downloading.value, key])
   const result = await store.download(torrent_url, magnet)
-  downloading.value = null
-  if (result.success) showToast('success', 'Ajouté à qBittorrent !')
-  else showToast('error', result.error ?? 'Erreur inconnue')
+  downloading.value = new Set([...downloading.value].filter(k => k !== key))
+  if (result.success) {
+    downloaded.value = new Set([...downloaded.value, key])
+    showToast('success', 'Téléchargement lancé')
+    fetchActiveDownloads()
+  } else {
+    showToast('error', result.error ?? 'Erreur inconnue')
+  }
 }
 
 function load() {
   store.fetchSerieDetail(Number(route.params.id))
 }
 
-onMounted(load)
+onMounted(() => {
+  load()
+  fetchActiveDownloads()
+  pollTimer = setInterval(fetchActiveDownloads, 5000)
+})
+
+onUnmounted(() => {
+  if (pollTimer) clearInterval(pollTimer)
+})
 </script>
 
 <style scoped>

src/views/SettingsView.vue

@@ -15,7 +15,7 @@
       <div>
         <div class="text-[10px] text-[#e8513a] tracking-widest mb-1">DONNÉES MANQUANTES</div>
         <p class="text-sm text-[#a0b4c4]">
-          {{ torrentsStatus.exists ? 'Le fichier de torrents est vide.' : 'Aucun fichier de torrents trouvé.' }}
+          {{ torrentsStatus.exists ? 'Le catalogue est vide.' : 'Aucun catalogue trouvé.' }}
           Téléchargez les données pour utiliser Fankarr.
         </p>
       </div>
@@ -28,9 +28,9 @@
     <!-- Données torrents -->
     <div class="bg-[#0d1219] border border-[#1e2d3d] p-6 mb-4">
       <div class="text-[10px] text-[#e8513a] tracking-widest mb-1">DONNÉES</div>
-      <h2 class="text-sm font-bold text-white mb-1">Torrents Fankai</h2>
+      <h2 class="text-sm font-bold text-white mb-1">Catalogue Fankai</h2>
       <p class="text-[11px] text-[#5a7a94] mb-5">
-        {{ torrentsStatus.empty ? 'Aucune donnée chargée' : `${torrentsStatus.count} torrents chargés` }}
+        {{ torrentsStatus.empty ? 'Aucune donnée chargée' : `${torrentsStatus.count} séries disponibles` }}
       </p>
       <button @click="update" :disabled="updating"
               class="bg-[#e8513a] text-white px-6 py-2.5 text-xs tracking-widest hover:opacity-85 transition-opacity disabled:opacity-50 cursor-pointer">
@@ -78,48 +78,44 @@
       </div>
     </div>
 
-    <!-- Médias & Organisation -->
+    <!-- Médias & Import -->
     <div class="bg-[#0d1219] border border-[#1e2d3d] p-6 mb-4">
       <div class="text-[10px] text-[#e8513a] tracking-widest mb-1">MÉDIAS</div>
-      <h2 class="text-sm font-bold text-white mb-6">Organisation</h2>
+      <h2 class="text-sm font-bold text-white mb-6">Import</h2>
 
       <div class="flex flex-col gap-5">
 
         <!-- Dossier complétion -->
         <div>
           <div class="flex items-center gap-2 mb-1.5">
-            <label class="text-[10px] text-[#5a7a94] tracking-widest">DOSSIER COMPLÉTION</label>
+            <label class="text-[10px] text-[#5a7a94] tracking-widest">DOSSIER TÉLÉCHARGEMENTS</label>
             <span v-if="isDocker" class="text-[9px] tracking-widest text-[#3a8fe8] border border-[#3a8fe8]/40 px-1.5 py-0.5">DOCKER</span>
           </div>
-          <input v-model="form.completePath" :disabled="isDocker"
-                 class="w-full bg-[#121920] border border-[#1e2d3d] text-sm px-3 py-2.5 outline-none transition-colors"
-                 :class="isDocker ? 'text-[#5a7a94] cursor-not-allowed opacity-60' : 'text-white focus:border-[#e8513a]'"
-                 placeholder="/downloads/complete"/>
-          <p class="text-[10px] text-[#5a7a94] mt-1.5">
-            <span v-if="isDocker">Défini par le volume Docker — non modifiable ici</span>
-            <span v-else>Dossier de complétion de qBittorrent</span>
-          </p>
+          <button @click="openPicker('completePath')"
+                  class="w-full bg-[#121920] border border-[#1e2d3d] text-sm px-3 py-2.5 text-left hover:border-[#e8513a] transition-colors cursor-pointer font-mono truncate"
+                  :class="form.completePath ? 'text-white' : 'text-[#5a7a94]'">
+            {{ form.completePath || '/' }}
+          </button>
+          <p class="text-[10px] text-[#5a7a94] mt-1.5">Dossier où sont déposés les fichiers téléchargés</p>
         </div>
 
-        <!-- Dossier Jellyfin -->
+        <!-- Dossier médiathèque -->
         <div>
           <div class="flex items-center gap-2 mb-1.5">
-            <label class="text-[10px] text-[#5a7a94] tracking-widest">DOSSIER JELLYFIN</label>
+            <label class="text-[10px] text-[#5a7a94] tracking-widest">MÉDIATHÈQUE FANKAI</label>
             <span v-if="isDocker" class="text-[9px] tracking-widest text-[#3a8fe8] border border-[#3a8fe8]/40 px-1.5 py-0.5">DOCKER</span>
           </div>
-          <input v-model="form.mediaPath" :disabled="isDocker"
-                 class="w-full bg-[#121920] border border-[#1e2d3d] text-sm px-3 py-2.5 outline-none transition-colors"
-                 :class="isDocker ? 'text-[#5a7a94] cursor-not-allowed opacity-60' : 'text-white focus:border-[#e8513a]'"
-                 placeholder="/media/Kai"/>
-          <p class="text-[10px] text-[#5a7a94] mt-1.5">
-            <span v-if="isDocker">Défini par le volume Docker — non modifiable ici</span>
-            <span v-else>Dossier racine de la bibliothèque Fankai dans Jellyfin</span>
-          </p>
+          <button @click="openPicker('mediaPath')"
+                  class="w-full bg-[#121920] border border-[#1e2d3d] text-sm px-3 py-2.5 text-left hover:border-[#e8513a] transition-colors cursor-pointer font-mono truncate"
+                  :class="form.mediaPath ? 'text-white' : 'text-[#5a7a94]'">
+            {{ form.mediaPath || '/' }}
+          </button>
+          <p class="text-[10px] text-[#5a7a94] mt-1.5">Dossier racine de votre médiathèque Fankai (Jellyfin, Kodi, Plex…)</p>
         </div>
 
-        <!-- Mode organisation -->
+        <!-- Mode import -->
         <div>
-          <label class="text-[10px] text-[#5a7a94] tracking-widest block mb-2">MODE</label>
+          <label class="text-[10px] text-[#5a7a94] tracking-widest block mb-2">MODE D'IMPORT</label>
           <div class="flex gap-2">
             <button @click="form.organizeMode = 'hardlink'"
                     class="px-5 py-2 text-xs tracking-widest border transition-colors cursor-pointer"
@@ -133,19 +129,62 @@
                     :class="form.organizeMode === 'move'
                   ? 'border-[#e8513a] text-[#e8513a] bg-[#e8513a]/5'
                   : 'border-[#1e2d3d] text-[#5a7a94] hover:border-[#5a7a94]'">
-              MOVE
+              DÉPLACER
             </button>
           </div>
           <p class="text-[10px] text-[#5a7a94] mt-1.5">
-            <span class="text-white">Hardlink recommandé</span> — le fichier reste dans qBittorrent pour le ratio
+            <span class="text-white">Hardlink recommandé</span> — le fichier reste dans le client torrent pour le ratio
           </p>
         </div>
 
-        <div class="pt-1">
+        <!-- Import automatique -->
+        <div>
+          <label class="text-[10px] text-[#5a7a94] tracking-widest block mb-2">IMPORT AUTOMATIQUE</label>
+          <div class="flex items-center gap-3">
+            <button @click="form.autoImport = !form.autoImport"
+                    class="relative shrink-0 w-11 h-6 rounded-full transition-colors cursor-pointer"
+                    :class="form.autoImport ? 'bg-[#e8513a]' : 'bg-[#1e2d3d]'">
+              <span class="absolute top-1 left-1 w-4 h-4 rounded-full bg-white transition-transform duration-200"
+                    :class="form.autoImport ? 'translate-x-5' : 'translate-x-0'" />
+            </button>
+            <span class="text-xs text-[#c8d8e8]">Importer automatiquement dès qu'un téléchargement est terminé</span>
+          </div>
+          <p class="text-[10px] text-[#5a7a94] mt-1.5">
+            Vérifie toutes les 5 minutes si de nouveaux fichiers sont prêts à être importés
+          </p>
+        </div>
+
+        <!-- Support NFO -->
+        <div>
+          <label class="text-[10px] text-[#5a7a94] tracking-widest block mb-2">NFO / MÉTADONNÉES</label>
+          <div class="flex items-center gap-3">
+            <button @click="form.nfoSupport = !form.nfoSupport"
+                    class="relative shrink-0 w-11 h-6 rounded-full transition-colors cursor-pointer"
+                    :class="form.nfoSupport ? 'bg-[#e8513a]' : 'bg-[#1e2d3d]'">
+              <span class="absolute top-1 left-1 w-4 h-4 rounded-full bg-white transition-transform duration-200"
+                    :class="form.nfoSupport ? 'translate-x-5' : 'translate-x-0'" />
+            </button>
+            <span class="text-xs text-[#c8d8e8]">Télécharger les NFO et images depuis GitLab</span>
+          </div>
+          <p class="text-[10px] text-[#5a7a94] mt-1.5">
+            Pour les lecteurs sans agent Fankai (Kodi, Infuse, etc.) — télécharge les métadonnées depuis
+            <span class="text-white">fankai_pack</span> lors de l'import
+          </p>
+        </div>
+
+        <div class="pt-1 flex items-center gap-3">
           <button type="button" @click="save" :disabled="saving"
                   class="bg-[#e8513a] text-white px-6 py-2.5 text-xs tracking-widest hover:opacity-85 transition-opacity disabled:opacity-50 cursor-pointer">
             {{ saving ? '...' : 'SAUVEGARDER' }}
           </button>
+          <button type="button" @click="scan" :disabled="scanning"
+                  class="border border-[#1e2d3d] text-[#5a7a94] px-6 py-2.5 text-xs tracking-widest hover:border-[#e8513a] hover:text-[#e8513a] transition-colors disabled:opacity-50 cursor-pointer">
+            {{ scanning ? 'SCAN...' : 'ANALYSER MÉDIATHÈQUE' }}
+          </button>
+          <span v-if="scanResult" class="text-[10px]"
+                :class="scanResult.added > 0 ? 'text-green-400' : 'text-[#5a7a94]'">
+            {{ scanResult.found }} fichiers · {{ scanResult.added }} ajoutés
+          </span>
         </div>
       </div>
     </div>
@@ -160,6 +199,14 @@
       </button>
     </div>
 
+    <!-- Folder Picker -->
+    <FolderPicker
+        v-if="picker.open"
+        :initial-path="picker.currentPath"
+        @select="onPickerSelect"
+        @cancel="picker.open = false"
+    />
+
     <!-- Modal ajout client -->
     <div v-if="modal.open" class="fixed inset-0 bg-black/70 flex items-center justify-center z-50 px-4">
       <div class="bg-[#0d1219] border border-[#1e2d3d] w-full max-w-md p-6">
@@ -170,7 +217,7 @@
 
         <div class="mb-4">
           <label class="text-[10px] text-[#5a7a94] tracking-widest block mb-1.5">NOM</label>
-          <input v-model="modal.name" placeholder="Mon qBittorrent"
+          <input v-model="modal.name" placeholder="Mon client torrent"
                  class="w-full bg-[#121920] border border-[#1e2d3d] text-white px-3 py-2.5 text-sm outline-none focus:border-[#e8513a] transition-colors"/>
         </div>
 
@@ -217,6 +264,7 @@ import { ref, computed, onMounted } from 'vue'
 import { useRouter } from 'vue-router'
 import { useAuthStore } from '@/stores/auth'
 import { useToast } from '@/composables/useToast'
+import FolderPicker from '@/components/FolderPicker.vue'
 
 const router = useRouter()
 const auth   = useAuthStore()
@@ -224,19 +272,37 @@ const { add: toast } = useToast()
 
 // ── State ──────────────────────────────────────────────────────
 const form = ref({
-  mediaPath   : '/media/Kai',
-  completePath: '/downloads/complete',
+  mediaPath   : '',
+  completePath: '',
   organizeMode: 'hardlink' as 'hardlink' | 'move',
+  nfoSupport  : false,
+  autoImport  : true,
 })
 
-const saving    = ref(false)
-const updating  = ref(false)
-const isDocker  = ref(false)
-const torrentsStatus = ref({ exists: false, count: 0, empty: true })
+const saving     = ref(false)
+const updating   = ref(false)
+const scanning   = ref(false)
+const scanResult = ref<{ found: number; added: number } | null>(null)
 
-const clients          = ref<any[]>([])
+// ── Folder picker ──────────────────────────────────────────────
+const picker = ref<{ open: boolean; field: 'completePath' | 'mediaPath'; currentPath: string }>({
+  open: false, field: 'completePath', currentPath: '/'
+})
+
+function openPicker(field: 'completePath' | 'mediaPath') {
+  picker.value = { open: true, field, currentPath: (form.value as any)[field] || '/' }
+}
+
+function onPickerSelect(path: string) {
+  (form.value as any)[picker.value.field] = path
+  picker.value.open = false
+}
+
+const isDocker       = ref(false)
+const torrentsStatus = ref({ exists: false, count: 0, empty: true })
+const clients        = ref<any[]>([])
 const availableClients = ref<any[]>([])
-const healthStatus     = ref<Record<string, boolean | null>>({})
+const healthStatus   = ref<Record<string, boolean | null>>({})
 
 const modal = ref({
   open   : false,
@@ -272,7 +338,7 @@ onMounted(async () => {
   if (availRes.ok)    availableClients.value = await availRes.json()
   if (systemRes.ok)   isDocker.value = (await systemRes.json()).isDocker
 
-  for (const c of clients.value) await refreshHealth(c.uuid)
+  for (const c of clients.value) refreshHealth(c.uuid)
 })
 
 // ── Healthcheck ────────────────────────────────────────────────
@@ -281,9 +347,7 @@ async function refreshHealth(uuid: string) {
   try {
     const res = await fetch(`/api/torrent-clients/${uuid}/healthcheck`, { credentials: 'include' })
     healthStatus.value[uuid] = res.ok ? (await res.json()).online : false
-  } catch {
-    healthStatus.value[uuid] = false
-  }
+  } catch { healthStatus.value[uuid] = false }
 }
 
 // ── Test / delete clients ──────────────────────────────────────
@@ -310,9 +374,7 @@ function openAddModal() {
   modal.value = { open: true, name: '', type: '', config: {}, testing: false, saving: false, tested: false }
 }
 
-function closeModal() {
-  modal.value.open = false
-}
+function closeModal() { modal.value.open = false }
 
 function onTypeChange() {
   modal.value.config = {}
@@ -330,9 +392,7 @@ async function testNewClient() {
   modal.value.tested  = false
   try {
     const res = await fetch('/api/torrent-clients/test-config', {
-      method : 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      credentials: 'include',
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
       body: JSON.stringify({ type: modal.value.type, config: modal.value.config })
     })
     const { ok, message } = await res.json()
@@ -350,19 +410,13 @@ async function saveClient() {
   modal.value.saving = true
   try {
     const res = await fetch('/api/torrent-clients', {
-      method : 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      credentials: 'include',
-      body: JSON.stringify({
-        name  : modal.value.name || clientLabel(modal.value.type),
-        type  : modal.value.type,
-        config: modal.value.config
-      })
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+      body: JSON.stringify({ name: modal.value.name || clientLabel(modal.value.type), type: modal.value.type, config: modal.value.config })
     })
     if (res.ok) {
       const client = await res.json()
       clients.value.push(client)
-      await refreshHealth(client.uuid)
+      refreshHealth(client.uuid)
       closeModal()
       toast('Client enregistré ✓', 'success')
     } else {
@@ -374,7 +428,7 @@ async function saveClient() {
   }
 }
 
-// ── Données torrents ───────────────────────────────────────────
+// ── Données ────────────────────────────────────────────────────
 async function update() {
   updating.value = true
   try {
@@ -382,7 +436,7 @@ async function update() {
     if (res.ok) {
       const { count } = await res.json()
       torrentsStatus.value = { exists: true, count, empty: count === 0 }
-      toast(`${count} torrents téléchargés ✓`, 'success')
+      toast(`${count} séries chargées ✓`, 'success')
     } else {
       const { error } = await res.json()
       toast(error ?? 'Erreur lors de la mise à jour', 'error')
@@ -394,14 +448,37 @@ async function update() {
   }
 }
 
-// ── Sauvegarder settings ───────────────────────────────────────
+// ── Scan ───────────────────────────────────────────────────────
+async function scan() {
+  scanning.value  = true
+  scanResult.value = null
+  try {
+    const res = await fetch('/api/scan', { method: 'POST', credentials: 'include' })
+    if (res.ok) {
+      const data = await res.json()
+      scanResult.value = { found: data.found, added: data.added }
+      toast(
+          data.added > 0
+              ? `${data.found} fichiers analysés — ${data.added} ajoutés`
+              : `${data.found} fichiers analysés — rien de nouveau`,
+          'success'
+      )
+    } else {
+      toast('Erreur lors de l\'analyse', 'error')
+    }
+  } catch {
+    toast('Impossible de contacter le serveur', 'error')
+  } finally {
+    scanning.value = false
+  }
+}
+
+// ── Sauvegarder ────────────────────────────────────────────────
 async function save() {
   saving.value = true
   try {
     const res = await fetch('/api/settings', {
-      method : 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      credentials: 'include',
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
       body: JSON.stringify(form.value)
     })
     if (res.ok) toast('Configuration sauvegardée', 'success')

vite.config.ts

@@ -10,10 +10,13 @@ export default defineConfig({
       '@': fileURLToPath(new URL('./src', import.meta.url))
     }
   },
+  build: {
+    outDir: 'dist/client'
+  },
   server: {
-    port: 3000,
+    port: 3000,  // ou autre port fixe
     proxy: {
-      '/api': 'http://localhost:3001'
+      '/api': 'http://localhost:9898'
     }
   }
 })