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

chore(main): release 1.4.0

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [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)
 
 

README.md

@@ -1,5 +1,168 @@
-# 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
+
+### Prérequis
+
+- Docker + Docker Compose
+- qBittorrent accessible en réseau
+- Un dossier de téléchargements complétés (`/downloads/complete` ou équivalent)
+- Un dossier médiathèque pour Jellyfin (`/media/Kai` ou équivalent)
+
+### Docker Compose
+
+```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:
+      - ./data:/app/data                        # Config, logs, base de données
+      - /votre/chemin/media:/media/Kai          # Destination Jellyfin
+      - /votre/chemin/complete:/downloads/complete  # Dossier complétés qBittorrent
+    ports:
+      - 3001:3001
+    restart: unless-stopped
+```
+
+```bash
+docker compose up -d
+```
+
+Fankarr sera accessible sur `http://localhost:3001`.
+
+### Variables d'environnement
+
+| Variable | Défaut | Description |
+|---|---|---|
+| `PUID` | `1000` | UID utilisateur pour les permissions fichiers |
+| `PGID` | `1000` | GID utilisateur pour les permissions fichiers |
+| `TZ` | — | Timezone (ex: `Europe/Paris`) |
+| `GITHUB_RAW_URL` | repo scraper | URL du `torrent_final.json` à utiliser |
+
+### Premier démarrage
+
+1. Ouvrir `http://localhost:3001`
+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 001/
+        ├── 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 |
+| Permissions | gosu (PUID/PGID) |
+
+---
+
+## 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

server/index.ts

@@ -10,7 +10,7 @@ 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'
 
 registerDriver(qbittorrentDriver)
@@ -476,6 +476,13 @@ app.listen(PORT, () => {
     } catch { console.warn('[fankarr] ⚠ torrent_final.json introuvable ou illisible') }
     console.log(`[fankarr] Serveur sur http://localhost:${PORT}`)
 
+    // Scan initial du mediaPath pour reconnaître les fichiers déjà présents
+    const ORGANIZED_PATH = path.join(process.cwd(), 'data', 'organized.json')
+    const { mediaPath } = readSettings()
+    scanMediaPath(mediaPath, TORRENTS_PATH, ORGANIZED_PATH).catch(err =>
+        logger.error('organize', `scanMediaPath échoué: ${err}`)
+    )
+
     // Auto-organise toutes les 30s
     const autoOrganize = async () => {
         try {

server/organize.ts

@@ -5,8 +5,10 @@
  * 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'
 
 // Un seul worker à la fois
 let workerRunning = false
@@ -18,6 +20,88 @@ export interface OrganizeResult {
     errors  : { file: string; error: string }[]
 }
 
+/**
+ * Scan initial du mediaPath au démarrage.
+ * Parcourt récursivement le dossier Jellyfin et marque dans organized.json
+ * tous les fichiers déjà présents qui correspondent à un torrent connu.
+ */
+export async function scanMediaPath(
+    mediaPath   : string,
+    torrentsPath: string,
+    organizedPath: string
+): Promise<{ found: number; added: number }> {
+    const result = { found: 0, added: 0 }
+
+    if (!fs.existsSync(mediaPath)) {
+        logger.warn('organize', `scanMediaPath: ${mediaPath} inexistant, skip`)
+        return result
+    }
+
+    // Charger torrent_final.json
+    let torrents: any[] = []
+    try {
+        if (!fs.existsSync(torrentsPath)) return result
+        torrents = JSON.parse(fs.readFileSync(torrentsPath, 'utf-8'))
+    } catch {
+        logger.error('organize', 'scanMediaPath: impossible de lire torrent_final.json')
+        return result
+    }
+
+    // Construire un index filename → { hash, infohash }
+    const filenameIndex = new Map<string, string>()  // filename → infohash
+    for (const t of torrents) {
+        const hash = t.infohash?.toLowerCase()
+        if (!hash) continue
+        for (const f of t.torrent_files ?? []) {
+            if (f.filename) filenameIndex.set(f.filename, hash)
+        }
+        // Fichier unique (torrent_files vide) → on indexe par raw name
+        if ((t.torrent_files ?? []).length === 0 && t.raw) {
+            filenameIndex.set(t.raw, 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 {}
+
+    // Parcourir récursivement mediaPath
+    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
+                if (organized[hash]?.[entry.name]) continue  // déjà connu
+                // Marquer comme organisé
+                if (!organized[hash]) organized[hash] = {}
+                organized[hash][entry.name] = new Date().toISOString()
+                result.added++
+            }
+        }
+    }
+
+    walk(mediaPath)
+
+    if (result.added > 0) {
+        fs.writeFileSync(organizedPath, JSON.stringify(organized, null, 2), 'utf-8')
+        logger.info('organize', `scanMediaPath: ${result.found} fichiers scannés, ${result.added} ajoutés à organized.json`)
+    } else {
+        logger.info('organize', `scanMediaPath: ${result.found} fichiers scannés, rien de nouveau`)
+    }
+
+    return result
+}
+
 /**
  * Lance l'auto-organisation dans un worker thread.
  * listFn est appelée dans le thread principal (accès qBittorrent),
@@ -28,7 +112,7 @@ export async function autoOrganizeAll(
     onResult?: (r: { hash: string; name: string; done: number; skipped: number; errors: number; errorFiles: { file: string; error: string }[] }) => void
 ): Promise<void> {
     if (workerRunning) {
-        console.log('[organize] Worker déjà en cours, skip')
+        logger.debug('organize', 'Worker déjà en cours, skip')
         return
     }
 
@@ -36,7 +120,7 @@ export async function autoOrganizeAll(
     try {
         torrents = await listFn()
     } catch (err) {
-        console.error('[organize] Impossible de récupérer la liste des torrents:', err)
+        logger.error('organize', "Impossible de récupérer la liste des torrents:", err)
         return
     }
 
@@ -45,7 +129,7 @@ export async function autoOrganizeAll(
     const seedingCount = torrents.filter(t => t.state === 'seeding').length
     if (seedingCount === 0) return
 
-    console.log(`[organize] Lancement worker (${seedingCount} torrents en seeding)`)
+    logger.info('organize', `Lancement worker (${seedingCount} torrents en seeding)`)
     workerRunning = true
 
     const workerPath = path.join(path.dirname(new URL(import.meta.url).pathname), 'organize-worker.js')
@@ -54,11 +138,9 @@ export async function autoOrganizeAll(
 
     worker.on('message', (msg: any) => {
         if (msg.type === 'log') {
-            if (msg.level === 'error') console.error(msg.msg)
-            else if (msg.level === 'warn') console.warn(msg.msg)
-            else console.log(msg.msg)
+            logger[msg.level as 'debug'|'info'|'warn'|'error']('organize', msg.msg)
         } else if (msg.type === 'result') {
-            console.log(`[organize] ${msg.name} → ${msg.done} OK, ${msg.skipped} skippés, ${msg.errors.length} erreurs`)
+            logger.info('organize', `${msg.name} → ${msg.done} OK, ${msg.skipped} skippés, ${msg.errors.length} erreurs`)
             onResult?.({
                 hash       : msg.hash,
                 name       : msg.name,
@@ -68,19 +150,19 @@ export async function autoOrganizeAll(
                 errorFiles : msg.errors,
             })
         } else if (msg.type === 'done') {
-            console.log('[organize] Worker terminé')
+            logger.debug('organize', 'Worker terminé')
             workerRunning = false
             worker.terminate()
         }
     })
 
     worker.on('error', (err) => {
-        console.error('[organize] Worker erreur:', err)
+        logger.error('organize', `Worker erreur: ${err instanceof Error ? err.message : err}`)
         workerRunning = false
     })
 
     worker.on('exit', (code) => {
-        if (code !== 0) console.error(`[organize] Worker exit code ${code}`)
+        if (code !== 0) logger.error('organize', `Worker exit code ${code}`)
         workerRunning = false
     })
 
@@ -107,9 +189,7 @@ export async function organizeTorrent(
 
         worker.on('message', (msg: any) => {
             if (msg.type === 'log') {
-                if (msg.level === 'error') console.error(msg.msg)
-                else if (msg.level === 'warn') console.warn(msg.msg)
-                else console.log(msg.msg)
+                logger[msg.level as 'debug'|'info'|'warn'|'error']('organize', msg.msg)
             } else if (msg.type === 'result') {
                 result.total   = msg.total
                 result.skipped = msg.skipped