feat(auth): connexion avec un compte Jellyfin (#154)

* fix(jellyfin): vérifier que le jeton Jellyfin appartient à l'utilisateur annoncé

L'échange du plugin (POST /api/v1/auth/jellyfin) validait le jeton avec
GET /Users/{jellyfinUserId}, que Jellyfin accepte avec le jeton de
n'importe quel utilisateur. Un utilisateur Jellyfin pouvait ainsi obtenir
le jeton d'API FanKarr d'un autre compte, administrateur compris.

Le jeton est maintenant vérifié avec GET /Users/Me, et son propriétaire
doit correspondre à jellyfinUserId.

* feat(auth): connexion avec un compte Jellyfin

Les utilisateurs Jellyfin se connectent à l'interface web avec leurs
identifiants Jellyfin, vérifiés par Jellyfin (POST /Users/AuthenticateByName).

- Import des utilisateurs Jellyfin au choix depuis Paramètres › Jellyfin et
  API ; l'import automatique horaire devient un réglage (activé par défaut).
  Un compte FanKarr du même nom est lié au lieu d'être recréé.
- Seuls les comptes importés peuvent se connecter avec Jellyfin, sauf si
  « Autoriser les comptes pas encore importés » est activé (désactivé par
  défaut) : le compte invité est alors créé à la première connexion, depuis
  l'interface web ou le plugin.
- Interrupteur « Connexion à FanKarr avec un compte Jellyfin » (activé par
  défaut).
- L'identifiant du serveur Jellyfin est enregistré et vérifié à chaque
  connexion ; la session Jellyfin ouverte pour la vérification est fermée
  aussitôt.
- Connexion limitée à 5 échecs en 15 minutes par nom d'utilisateur et adresse.
- Les comptes importés n'ont pas de mot de passe FanKarr : la page Profil
  l'indique, l'administrateur peut toujours en définir un.

README.md

@@ -87,13 +87,13 @@ Inspiré de Radarr et Sonarr, pour les éditions Kai et Yabai
 
 ### Utilisateurs et Jellyfin
 - Plusieurs comptes, avec deux rôles (administrateur et invité) et des liens d'invitation
-- Synchronisation Jellyfin : un compte FanKarr est créé pour chaque utilisateur Jellyfin, toutes les heures ou à la demande
-- Connexion depuis le plugin Jellyfin avec le compte Jellyfin
+- Import des utilisateurs Jellyfin, au choix ou automatiquement toutes les heures
+- Connexion à FanKarr avec le compte Jellyfin, depuis l'interface web ou le plugin Jellyfin
 - Un jeton d'API personnel par utilisateur pour l'API publique
 
 ### Système
 - Journaux filtrables par niveau et par source, avec rotation automatique, que vous pouvez vider depuis l'interface
-- Authentification par mot de passe, session JWT
+- Authentification par mot de passe FanKarr ou Jellyfin, session JWT, tentatives limitées
 - Clients torrent pris en charge : qBittorrent, Transmission, Deluge, rTorrent, uTorrent, Synology Download Station et Real-Debrid. Vous pouvez en configurer plusieurs.
 - Installation avec Docker, Runtipi ou un binaire autonome
 
@@ -264,6 +264,26 @@ Le fichier garde environ les 2 000 dernières lignes. Les messages `debug` ne so
 
 ---
 
+## Comptes Jellyfin
+
+Vos utilisateurs Jellyfin peuvent se connecter à FanKarr avec leurs identifiants Jellyfin. Il faut renseigner l'adresse du serveur et une clé API dans **Paramètres › Jellyfin et API**.
+
+### Import des utilisateurs
+
+Un utilisateur Jellyfin importé reçoit un compte invité, sans mot de passe FanKarr. Si un compte FanKarr porte déjà son nom, ce compte est lié à l'utilisateur Jellyfin au lieu d'être recréé. Pour importer :
+- choisissez les comptes depuis **Paramètres › Jellyfin et API › Importer des utilisateurs** ;
+- ou laissez l'import automatique, qui importe toutes les heures chaque utilisateur Jellyfin actif (activé par défaut).
+
+### Connexion
+
+Sur l'écran de connexion, un utilisateur importé saisit son nom et son mot de passe Jellyfin. FanKarr les fait vérifier par Jellyfin et ne les conserve pas. Deux réglages dans **Paramètres › Jellyfin et API** :
+- **Connexion à FanKarr avec un compte Jellyfin** (activé par défaut) ;
+- **Autoriser les comptes pas encore importés** (désactivé par défaut) : un compte invité est créé à la première connexion.
+
+Un compte FanKarr qui n'a pas été importé ou lié ne peut pas s'ouvrir avec un mot de passe Jellyfin. Après 5 échecs en 15 minutes pour un même nom d'utilisateur depuis la même adresse, FanKarr bloque les tentatives jusqu'à la fin de ces 15 minutes. Un mot de passe erroné saisi dans FanKarr compte aussi comme un échec dans Jellyfin. Si le verrouillage après plusieurs échecs est activé pour un utilisateur dans Jellyfin (désactivé par défaut), son compte y est désactivé une fois la limite atteinte.
+
+---
+
 ## Plugin Jellyfin FanKarr Search
 
 Un plugin Jellyfin intègre la recherche FanKarr à l'interface de votre serveur : vos utilisateurs parcourent le catalogue et demandent des séries sans quitter Jellyfin.
@@ -272,13 +292,7 @@ Un plugin Jellyfin intègre la recherche FanKarr à l'interface de votre serveur
 
 Le plugin nécessite **[Jellyfin JavaScript Injector](https://github.com/n00bcodr/Jellyfin-JavaScript-Injector)**. Les instructions d'installation sont dans le README du plugin.
 
-### Synchronisation des utilisateurs
-
-FanKarr crée un compte invité pour chaque utilisateur Jellyfin actif qui n'en a pas encore (même nom d'utilisateur). La synchronisation se fait :
-- automatiquement toutes les heures, si Jellyfin est configuré ;
-- à la demande, depuis **Paramètres › Jellyfin et API › Synchroniser les utilisateurs**.
-
-Les comptes ainsi créés reçoivent un mot de passe aléatoire. Ces utilisateurs se connectent par le plugin, qui échange leur session Jellyfin contre leur jeton FanKarr.
+Les utilisateurs se connectent au plugin avec leur compte Jellyfin : le plugin échange leur session Jellyfin contre leur jeton FanKarr. Le compte doit être importé (voir [Comptes Jellyfin](#comptes-jellyfin)), sauf si les comptes pas encore importés sont autorisés.
 
 ---
 
@@ -306,7 +320,7 @@ Content-Type: application/json
 { "jellyfinUserId": "...", "jellyfinToken": "..." }
 ```
 
-Renvoie `{ token, username, role }`. Le `token` s'utilise ensuite en `Bearer` pour tous les autres appels. Si aucun compte FanKarr ne porte le nom de l'utilisateur Jellyfin, la réponse est une erreur 404 : lancez la synchronisation Jellyfin.
+Renvoie `{ token, username, role }`. Le `token` s'utilise ensuite en `Bearer` pour tous les autres appels. FanKarr vérifie auprès de Jellyfin (`/Users/Me`) que le jeton appartient bien à `jellyfinUserId`. Si l'utilisateur Jellyfin n'est pas encore importé, la réponse est une erreur 404, sauf si les comptes pas encore importés sont autorisés : le compte est alors créé.
 
 ### Recherche
 

server/auth.ts

@@ -7,12 +7,14 @@ import { JWT_SECRET } from './secret.js'
 import { DATA_DIR }   from './config.js'
 import { logger }     from './logger.js'
 import {
-    findByUsername, findById, findByApiToken,
+    findByUsername, findById, findByApiToken, findByJellyfinId, importJellyfinUser,
     createUser, changePassword, regenerateApiToken, safeUser, hasUsers, markTourSeen, markLogin,
     type User,
 } from './users.js'
-import { readSettings } from './settings.js'
+import { readSettings, type Settings } from './settings.js'
 import { startOnboarding } from './onboarding.js'
+import { isJellyfinConfigured, authenticateJellyfinUser, getJellyfinServerId } from './lib/jellyfin.js'
+import { loginRetryAfter, recordLoginFailure, clearLoginFailures } from './lib/login-throttle.js'
 
 // ── Typage Express étendu ─────────────────────────────────────
 declare global {
@@ -42,24 +44,30 @@ function setCookieAndRespond(res: Response, user: User): void {
 
 // ── Routes ────────────────────────────────────────────────────
 
+function jellyfinLoginEnabled(s: Settings): boolean {
+    return s.jellyfinLogin && isJellyfinConfigured(s)
+}
+
 // GET /api/auth/status
 export function authStatus(req: Request, res: Response): void {
-    const setup = hasUsers()
-    const token = req.cookies?.fankarr_token
+    const settings      = readSettings()
+    const setup         = hasUsers()
+    const jellyfinLogin = jellyfinLoginEnabled(settings)
+    const token         = req.cookies?.fankarr_token
 
-    if (!token) { res.json({ setup, loggedIn: false }); return }
+    if (!token) { res.json({ setup, loggedIn: false, jellyfinLogin }); return }
 
     try {
         const payload = jwt.verify(token, JWT_SECRET) as any
         const user    = findById(payload.id)
-        if (!user) { res.json({ setup, loggedIn: false }); return }
+        if (!user) { res.json({ setup, loggedIn: false, jellyfinLogin }); return }
         res.json({
-            setup, loggedIn: true, role: user.role, username: user.username, userId: user.id,
-            onboardingDone: !!readSettings().onboardingCompletedAt,
+            setup, loggedIn: true, jellyfinLogin, role: user.role, username: user.username, userId: user.id,
+            onboardingDone: !!settings.onboardingCompletedAt,
             tourSeen      : !!user.tourSeenAt,
         })
     } catch {
-        res.json({ setup, loggedIn: false })
+        res.json({ setup, loggedIn: false, jellyfinLogin })
     }
 }
 
@@ -88,25 +96,84 @@ export function authSetup(req: Request, res: Response): void {
     }
 }
 
+// Compte FanKarr lié à l'utilisateur Jellyfin authentifié, ou undefined si refusé
+async function loginWithJellyfin(username: string, password: string, ip: string): Promise<{ user?: User; unreachable?: boolean }> {
+    const result = await authenticateJellyfinUser(username, password, ip)
+    if (!result.ok) {
+        if (result.reason === 'unreachable') {
+            logger.warn('auth', `Connexion Jellyfin de « ${username} » impossible : ${result.error}`)
+            return { unreachable: true }
+        }
+        return {}
+    }
+
+    const serverId = await getJellyfinServerId()
+    if (!serverId) {
+        logger.error('auth', `Connexion Jellyfin de « ${username} » refusée : impossible de lire l'identifiant du serveur Jellyfin avec la clé API`)
+        return {}
+    }
+    if (result.serverId !== serverId) {
+        logger.error('auth', `Connexion Jellyfin de « ${username} » refusée : la réponse vient d'un autre serveur Jellyfin que celui configuré`)
+        return {}
+    }
+
+    const linked = findByJellyfinId(result.id)
+    if (linked) return { user: linked }
+
+    if (!readSettings().jellyfinNewUserLogin) {
+        logger.warn('auth', `Connexion Jellyfin de « ${result.name} » refusée : compte pas encore importé`)
+        return {}
+    }
+    const imported = importJellyfinUser({ Id: result.id, Name: result.name })
+    if (imported?.action === 'created') logger.info('auth', `Compte créé pour « ${result.name} » à sa première connexion Jellyfin`)
+    return { user: imported?.user }
+}
+
 // POST /api/auth/login
-export function authLogin(req: Request, res: Response): void {
+export async function authLogin(req: Request, res: Response): Promise<void> {
     if (!hasUsers()) {
         res.status(400).json({ error: 'Aucun compte configuré' }); return
     }
 
-    const { username, password } = req.body
-    if (!username || !password) {
+    const { username, password } = req.body ?? {}
+    if (typeof username !== 'string' || typeof password !== 'string' || !username || !password) {
         res.status(400).json({ error: 'Nom d\'utilisateur et mot de passe requis' }); return
     }
 
-    const user = findByUsername(username)
-    if (!user || !bcrypt.compareSync(password, user.passwordHash)) {
-        logger.warn('auth', `Échec de la connexion de « ${username} »`)
-        res.status(401).json({ error: 'Identifiants incorrects' }); return
+    const ip   = req.ip ?? ''
+    const wait = loginRetryAfter(ip, username)
+    if (wait > 0) {
+        logger.warn('auth', `Connexion de « ${username} » bloquée : trop de tentatives depuis ${ip}`)
+        res.set('Retry-After', String(wait))
+        res.status(429).json({ error: `Trop de tentatives. Réessayez dans ${Math.ceil(wait / 60)} min.` }); return
     }
 
-    logger.info('auth', `Connexion de « ${username} » (rôle : ${user.role}, session : ${NO_EXPIRY ? 'sans expiration' : TOKEN_EXPIRY})`)
-    setCookieAndRespond(res, user)
+    const session = NO_EXPIRY ? 'sans expiration' : TOKEN_EXPIRY
+    const user    = findByUsername(username)
+    if (user && bcrypt.compareSync(password, user.passwordHash)) {
+        clearLoginFailures(ip, username)
+        logger.info('auth', `Connexion de « ${username} » (rôle : ${user.role}, session : ${session})`)
+        setCookieAndRespond(res, user); return
+    }
+
+    // Jellyfin n'est interrogé que pour un compte importé, ou un nouveau compte si le réglage l'autorise
+    const settings = readSettings()
+    const tryJellyfin = jellyfinLoginEnabled(settings) && (user ? !!user.jellyfinId : settings.jellyfinNewUserLogin)
+    if (tryJellyfin) {
+        const jf = await loginWithJellyfin(username, password, ip)
+        if (jf.user) {
+            clearLoginFailures(ip, username)
+            logger.info('auth', `Connexion de « ${jf.user.username} » via Jellyfin (rôle : ${jf.user.role}, session : ${session})`)
+            setCookieAndRespond(res, jf.user); return
+        }
+        if (jf.unreachable) {
+            res.status(503).json({ error: 'Connexion Jellyfin impossible : Jellyfin ne répond pas.' }); return
+        }
+    }
+
+    recordLoginFailure(ip, username)
+    logger.warn('auth', `Échec de la connexion de « ${username} »`)
+    res.status(401).json({ error: 'Identifiants incorrects' })
 }
 
 // POST /api/auth/logout

server/index.ts

@@ -25,7 +25,7 @@ import { pushNotif } from './lib/notifs.js'
 import { AUTO_IMPORT_INTERVAL_MS, autoImportSchedule, planNextAutoImport } from './lib/schedule.js'
 import { readRequests, completeRequest } from './requests.js'
 import { checkNfoUpdates } from './lib/nfo.js'
-import { runJellyfinSync } from './routes/jellyfin.js'
+import { runJellyfinImport } from './routes/jellyfin.js'
 import cors from 'cors';
 
 import usersRouter         from './routes/users.js'
@@ -266,11 +266,13 @@ server.listen(PORT, async () => {
         }, 6 * 60 * 60_000)
     }, 60_000)
 
-    // Sans effet si Jellyfin n'est pas configuré
+    // Sans effet si Jellyfin n'est pas configuré ou si l'import automatique est coupé
+    const autoImportJellyfin = () => {
+        if (!readSettings().jellyfinAutoImport) return
+        runJellyfinImport().catch(err => logger.error('jellyfin', `Échec de l'import des utilisateurs Jellyfin : ${err instanceof Error ? err.message : err}`))
+    }
     setTimeout(() => {
-        runJellyfinSync().catch(err => logger.error('jellyfin', `Échec de la synchronisation Jellyfin : ${err instanceof Error ? err.message : err}`))
-        setInterval(() => {
-            runJellyfinSync().catch(err => logger.error('jellyfin', `Échec de la synchronisation Jellyfin : ${err instanceof Error ? err.message : err}`))
-        }, 60 * 60_000)
+        autoImportJellyfin()
+        setInterval(autoImportJellyfin, 60 * 60_000)
     }, 2 * 60_000)
 })

server/lib/jellyfin.ts

@@ -1,8 +1,14 @@
 
-import { readSettings } from '../settings.js'
+import crypto from 'crypto'
+import { readSettings, writeSettings, type Settings } from '../settings.js'
 import { logger }       from '../logger.js'
 
 const CLIENT_HEADER = 'MediaBrowser Client="FanKarr", Device="Server", DeviceId="fankarr-server", Version="1.0"'
+const TIMEOUT_MS    = 10_000
+
+export function isJellyfinConfigured(s: Settings = readSettings()): boolean {
+    return !!(s.jellyfinUrl && s.jellyfinAdminToken)
+}
 
 function adminHeaders(token: string): Record<string, string> {
     return {
@@ -24,6 +30,7 @@ function userHeaders(token: string): Record<string, string> {
 export interface JellyfinUser {
     Id          : string
     Name        : string
+    ServerId?   : string
     HasPassword : boolean
     Policy      : { IsAdministrator: boolean; IsDisabled: boolean }
 }
@@ -55,6 +62,82 @@ export async function fetchJellyfinUsers(): Promise<JellyfinUser[]> {
     return res.json()
 }
 
+// ── Identifiant du serveur ────────────────────────────────────
+
+export async function getJellyfinServerId(): Promise<string | null> {
+    const { jellyfinUrl, jellyfinAdminToken, jellyfinServerId } = readSettings()
+    if (jellyfinServerId) return jellyfinServerId
+    if (!jellyfinUrl || !jellyfinAdminToken) return null
+
+    try {
+        const res = await fetch(`${jellyfinUrl.replace(/\/$/, '')}/System/Info`, {
+            headers: adminHeaders(jellyfinAdminToken),
+            signal : AbortSignal.timeout(TIMEOUT_MS),
+        })
+        if (!res.ok) return null
+        const data = await res.json()
+        if (!data?.Id) return null
+        const id = normalizeJellyfinId(data.Id)
+        writeSettings({ jellyfinServerId: id })
+        logger.info('jellyfin', `Identifiant du serveur Jellyfin enregistré (${id.slice(0, 8)}…)`)
+        return id
+    } catch {
+        return null
+    }
+}
+
+// ── Authentification par nom et mot de passe ──────────────────
+
+export type JellyfinAuthResult =
+    | { ok: true;  id: string; name: string; serverId: string }
+    | { ok: false; reason: 'credentials' | 'unreachable'; error?: string }
+
+export async function authenticateJellyfinUser(username: string, password: string, clientIp?: string): Promise<JellyfinAuthResult> {
+    const { jellyfinUrl } = readSettings()
+    if (!jellyfinUrl) return { ok: false, reason: 'unreachable', error: 'Jellyfin non configuré' }
+
+    const base     = jellyfinUrl.replace(/\/$/, '')
+    const deviceId = `fankarr-web-${crypto.createHash('sha256').update(username.toLowerCase()).digest('hex').slice(0, 16)}`
+    const client   = `MediaBrowser Client="FanKarr", Device="FanKarr (connexion web)", DeviceId="${deviceId}", Version="1.0"`
+
+    let data: any
+    try {
+        const res = await fetch(`${base}/Users/AuthenticateByName`, {
+            method : 'POST',
+            headers: {
+                'Authorization': client,
+                'Content-Type' : 'application/json',
+                ...(clientIp ? { 'X-Forwarded-For': clientIp.replace(/^::ffff:/, '') } : {}),
+            },
+            body  : JSON.stringify({ Username: username, Pw: password }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        })
+        if (res.status === 401 || res.status === 403) return { ok: false, reason: 'credentials' }
+        if (!res.ok) return { ok: false, reason: 'unreachable', error: `Jellyfin a répondu HTTP ${res.status}` }
+        data = await res.json()
+    } catch (err) {
+        return { ok: false, reason: 'unreachable', error: err instanceof Error ? err.message : 'Erreur réseau' }
+    }
+
+    if (!data?.User?.Id) return { ok: false, reason: 'unreachable', error: 'Réponse Jellyfin inattendue' }
+
+    // Session fermée aussitôt : FanKarr ne garde aucun jeton Jellyfin
+    if (data.AccessToken) {
+        fetch(`${base}/Sessions/Logout`, {
+            method : 'POST',
+            headers: { 'Authorization': `${client}, Token="${data.AccessToken}"` },
+            signal : AbortSignal.timeout(TIMEOUT_MS),
+        }).catch(() => {})
+    }
+
+    return {
+        ok      : true,
+        id      : normalizeJellyfinId(data.User.Id),
+        name    : data.User.Name,
+        serverId: normalizeJellyfinId(data.ServerId ?? data.User.ServerId ?? ''),
+    }
+}
+
 // ── Validation d'un jeton utilisateur Jellyfin ────────────────
 
 export interface JellyfinTokenInfo {
@@ -64,21 +147,36 @@ export interface JellyfinTokenInfo {
     error?  : string
 }
 
+export function normalizeJellyfinId(id: string): string {
+    return String(id).replace(/-/g, '').toLowerCase()
+}
+
 export async function validateJellyfinToken(jellyfinUserId: string, jellyfinToken: string): Promise<JellyfinTokenInfo> {
     const { jellyfinUrl } = readSettings()
     if (!jellyfinUrl) return { valid: false, error: 'Jellyfin non configuré sur ce serveur FanKarr' }
 
     try {
         const base = jellyfinUrl.replace(/\/$/, '')
-        const res  = await fetch(`${base}/Users/${jellyfinUserId}`, {
+        // /Users/{id}
+        const res  = await fetch(`${base}/Users/Me`, {
             headers: userHeaders(jellyfinToken),
         })
         if (res.status === 401 || res.status === 403) return { valid: false, error: 'Jeton Jellyfin invalide ou expiré' }
         if (!res.ok) return { valid: false, error: `Jellyfin a répondu HTTP ${res.status}` }
 
         const user: JellyfinUser = await res.json()
+        if (normalizeJellyfinId(user.Id) !== normalizeJellyfinId(jellyfinUserId)) {
+            logger.warn('jellyfin', `Jeton de « ${user.Name} » présenté pour un autre utilisateur Jellyfin (${String(jellyfinUserId).slice(0, 8)}…)`)
+            return { valid: false, error: 'Ce jeton Jellyfin appartient à un autre utilisateur' }
+        }
         if (user.Policy?.IsDisabled) return { valid: false, error: 'Compte Jellyfin désactivé' }
 
+        const serverId = await getJellyfinServerId()
+        if (serverId && user.ServerId && normalizeJellyfinId(user.ServerId) !== serverId) {
+            logger.error('jellyfin', `Jeton de « ${user.Name} » refusé : il vient d'un autre serveur Jellyfin que celui configuré`)
+            return { valid: false, error: 'Ce jeton vient d\'un autre serveur Jellyfin' }
+        }
+
         logger.debug('jellyfin', `Jeton valide pour « ${user.Name} » (${user.Id.slice(0, 8)}…)`)
         return { valid: true, userId: user.Id, username: user.Name }
     } catch (err) {

server/lib/login-throttle.ts

@@ -0,0 +1,37 @@
+const MAX_FAILURES = 5
+const WINDOW_MS    = 15 * 60_000
+
+const failures = new Map<string, { count: number; firstAt: number }>()
+
+function keyOf(ip: string, username: string): string {
+    return `${ip}|${username.toLowerCase()}`
+}
+
+function sweep(now: number): void {
+    for (const [key, entry] of failures) {
+        if (now - entry.firstAt >= WINDOW_MS) failures.delete(key)
+    }
+}
+
+// Secondes avant une nouvelle tentative, 0 si la connexion est permise
+export function loginRetryAfter(ip: string, username: string): number {
+    const key   = keyOf(ip, username)
+    const entry = failures.get(key)
+    if (!entry) return 0
+    const elapsed = Date.now() - entry.firstAt
+    if (elapsed >= WINDOW_MS) { failures.delete(key); return 0 }
+    return entry.count >= MAX_FAILURES ? Math.ceil((WINDOW_MS - elapsed) / 1000) : 0
+}
+
+export function recordLoginFailure(ip: string, username: string): void {
+    const now = Date.now()
+    if (failures.size > 10_000) sweep(now)
+    const key   = keyOf(ip, username)
+    const entry = failures.get(key)
+    if (!entry || now - entry.firstAt >= WINDOW_MS) failures.set(key, { count: 1, firstAt: now })
+    else entry.count++
+}
+
+export function clearLoginFailures(ip: string, username: string): void {
+    failures.delete(keyOf(ip, username))
+}

server/routes/jellyfin.ts

@@ -1,27 +1,39 @@
 import { Router }       from 'express'
-import { readSettings, writeSettings } from '../settings.js'
-import { readUsers, createUser, safeUser } from '../users.js'
-import { testJellyfinConnection, fetchJellyfinUsers } from '../lib/jellyfin.js'
+import { readSettings, writeSettings, type Settings } from '../settings.js'
+import { readUsers, importJellyfinUser } from '../users.js'
+import { testJellyfinConnection, fetchJellyfinUsers, getJellyfinServerId, normalizeJellyfinId, type JellyfinUser } from '../lib/jellyfin.js'
 import { logger } from '../logger.js'
 
 const router = Router()
 
+function settingsView(s: Settings) {
+    return {
+        jellyfinUrl         : s.jellyfinUrl,
+        hasToken            : !!s.jellyfinAdminToken,
+        jellyfinLogin       : s.jellyfinLogin,
+        jellyfinNewUserLogin: s.jellyfinNewUserLogin,
+        jellyfinAutoImport  : s.jellyfinAutoImport,
+    }
+}
+
 router.get('/jellyfin/settings', (_req, res) => {
-    const { jellyfinUrl, jellyfinAdminToken } = readSettings()
-    res.json({
-        jellyfinUrl,
-        // Clé API jamais renvoyée : seulement sa présence
-        hasToken: !!jellyfinAdminToken,
-    })
+    res.json(settingsView(readSettings()))
 })
 
 router.post('/jellyfin/settings', (req, res) => {
-    const { jellyfinUrl, jellyfinAdminToken } = req.body
-    const update: Record<string, string> = {}
+    const { jellyfinUrl, jellyfinAdminToken } = req.body ?? {}
+    const current = readSettings()
+    const update: Partial<Settings> = {}
     if (jellyfinUrl        !== undefined) update.jellyfinUrl        = String(jellyfinUrl).trim()
     if (jellyfinAdminToken !== undefined) update.jellyfinAdminToken = String(jellyfinAdminToken).trim()
-    const updated = writeSettings(update)
-    res.json({ jellyfinUrl: updated.jellyfinUrl, hasToken: !!updated.jellyfinAdminToken })
+    for (const key of ['jellyfinLogin', 'jellyfinNewUserLogin', 'jellyfinAutoImport'] as const) {
+        if (typeof req.body?.[key] === 'boolean') update[key] = req.body[key]
+    }
+    if ((update.jellyfinUrl        !== undefined && update.jellyfinUrl        !== current.jellyfinUrl) ||
+        (update.jellyfinAdminToken !== undefined && update.jellyfinAdminToken !== current.jellyfinAdminToken)) {
+        update.jellyfinServerId = ''
+    }
+    res.json(settingsView(writeSettings(update)))
 })
 
 router.post('/jellyfin/test', async (req, res) => {
@@ -45,40 +57,78 @@ router.post('/jellyfin/test', async (req, res) => {
     res.json(result)
 })
 
-export async function runJellyfinSync(): Promise<{ created: number; skipped: number; users: string[] }> {
-    const { jellyfinUrl, jellyfinAdminToken } = readSettings()
-    if (!jellyfinUrl || !jellyfinAdminToken) return { created: 0, skipped: 0, users: [] }
+// ── Import des utilisateurs ───────────────────────────────────
 
-    const jellyfinUsers = await fetchJellyfinUsers()
-    const fankarrUsers  = readUsers()
-    const results = { created: 0, skipped: 0, users: [] as string[] }
+export type JellyfinImportResult = { created: number; linked: number; skipped: number; users: string[] }
+
+function importJellyfinUsers(jellyfinUsers: JellyfinUser[]): JellyfinImportResult {
+    const results: JellyfinImportResult = { created: 0, linked: 0, skipped: 0, users: [] }
 
     for (const jUser of jellyfinUsers) {
         if (jUser.Policy?.IsDisabled) { results.skipped++; continue }
-
-        const exists = fankarrUsers.some(u =>
-            u.username.toLowerCase() === jUser.Name.toLowerCase()
-        )
-        if (exists) { results.skipped++; continue }
-
-        const randomPass = Math.random().toString(36).slice(2, 10) +
-                           Math.random().toString(36).slice(2, 10)
-        createUser(jUser.Name, randomPass, 'user')
-        results.created++
-        results.users.push(jUser.Name)
-        logger.info('jellyfin', `Compte créé pour « ${jUser.Name} » (synchronisation Jellyfin)`)
+        const imported = importJellyfinUser(jUser)
+        if (!imported || imported.action === 'existing') { results.skipped++; continue }
+        results[imported.action]++
+        results.users.push(imported.user.username)
     }
 
-    logger.info('jellyfin', `Synchronisation Jellyfin : ${results.created} compte(s) créé(s), ${results.skipped} ignoré(s) (existant ou désactivé)`)
+    logger.info('jellyfin', `Import Jellyfin : ${results.created} compte(s) créé(s), ${results.linked} lié(s), ${results.skipped} ignoré(s) (déjà importé, désactivé ou nom déjà pris)`)
     return results
 }
 
+export async function runJellyfinImport(): Promise<JellyfinImportResult> {
+    const { jellyfinUrl, jellyfinAdminToken } = readSettings()
+    if (!jellyfinUrl || !jellyfinAdminToken) return { created: 0, linked: 0, skipped: 0, users: [] }
+
+    await getJellyfinServerId()
+    return importJellyfinUsers(await fetchJellyfinUsers())
+}
+
+router.get('/jellyfin/users', async (_req, res) => {
+    try {
+        const jellyfinUsers = await fetchJellyfinUsers()
+        const users         = readUsers()
+        res.json(jellyfinUsers.map(j => {
+            const id       = normalizeJellyfinId(j.Id)
+            const linked   = users.find(u => u.jellyfinId === id)
+            const sameName = users.find(u => u.username.toLowerCase() === j.Name.toLowerCase())
+            const status   = linked               ? 'imported'
+                           : j.Policy?.IsDisabled ? 'disabled'
+                           : sameName?.jellyfinId ? 'conflict'
+                           : sameName             ? 'match'
+                           :                        'new'
+            return {
+                id,
+                name           : j.Name,
+                status,
+                fankarrUsername: (linked ?? sameName)?.username ?? null,
+            }
+        }))
+    } catch (err) {
+        res.status(502).json({ error: err instanceof Error ? err.message : 'Impossible de récupérer les utilisateurs Jellyfin' })
+    }
+})
+
+router.post('/jellyfin/import', async (req, res) => {
+    const ids = Array.isArray(req.body?.ids) ? req.body.ids.map((id: unknown) => normalizeJellyfinId(String(id))) : []
+    if (ids.length === 0) {
+        res.status(400).json({ error: 'Aucun utilisateur sélectionné' }); return
+    }
+    try {
+        await getJellyfinServerId()
+        const selected = (await fetchJellyfinUsers()).filter(j => ids.includes(normalizeJellyfinId(j.Id)))
+        res.json(importJellyfinUsers(selected))
+    } catch (err) {
+        res.status(502).json({ error: err instanceof Error ? err.message : 'Échec de l\'import des utilisateurs Jellyfin' })
+    }
+})
+
+// Import de tous les comptes actifs (assistant d'installation)
 router.post('/jellyfin/sync', async (_req, res) => {
     try {
-        const results = await runJellyfinSync()
-        res.json(results)
+        res.json(await runJellyfinImport())
     } catch (err) {
-        res.status(500).json({ error: err instanceof Error ? err.message : 'Échec de la synchronisation Jellyfin' })
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Échec de l\'import des utilisateurs Jellyfin' })
     }
 })
 

server/routes/public-api.ts

@@ -1,8 +1,7 @@
 
 import { Router }                from 'express'
-import { findByApiToken }        from '../users.js'
+import { findByApiToken, findByJellyfinId, importJellyfinUser, safeUser } from '../users.js'
 import { validateJellyfinToken } from '../lib/jellyfin.js'
-import { readUsers, safeUser }   from '../users.js'
 import { upsertRequest, approveRequest, getRequestsForUser } from '../requests.js'
 import { autoDownloadRequest } from './requests.js'
 import { readSettings }        from '../settings.js'
@@ -41,12 +40,14 @@ router.post('/v1/auth/jellyfin', async (req, res) => {
         res.status(401).json({ error: info.error ?? 'Échec de l\'authentification Jellyfin' }); return
     }
 
-    const users    = readUsers()
-    const fanUser  = users.find(u => u.username.toLowerCase() === info.username!.toLowerCase())
+    let fanUser = findByJellyfinId(info.userId!)
+    if (!fanUser && readSettings().jellyfinNewUserLogin) {
+        fanUser = importJellyfinUser({ Id: info.userId!, Name: info.username! })?.user
+    }
     if (!fanUser) {
-        logger.warn('public-api', `Connexion via Jellyfin : aucun compte FanKarr pour « ${info.username} » : synchronisation Jellyfin nécessaire`)
+        logger.warn('public-api', `Connexion via Jellyfin : « ${info.username} » n'est pas encore importé dans FanKarr`)
         res.status(404).json({
-            error: `Aucun compte FanKarr pour « ${info.username} ». Demandez à l'administrateur de lancer la synchronisation Jellyfin.`,
+            error: `Aucun compte FanKarr pour « ${info.username} ». Demandez à l'administrateur de l'importer depuis Paramètres › Jellyfin et API.`,
         }); return
     }
 

server/settings.ts

@@ -15,8 +15,12 @@ export interface Settings {
     deleteTorrentOnMove : boolean
     requestAutoDownloadUsers: 'all' | string[]  // Utilisateurs dont les demandes sont approuvées et téléchargées automatiquement ; [] = aucun
     jellyfinUrl         : string   // URL du serveur Jellyfin (ex. http://jellyfin:8096)
-    jellyfinAdminToken  : string   // Clé API Jellyfin pour la synchronisation
-    englishDirectory    : boolean  // Dossiers de saison en anglais (« Season 01 » au lieu de « Saison 1 »)
+    jellyfinAdminToken  : string   // Clé API Jellyfin pour l'import des utilisateurs
+    jellyfinLogin       : boolean  // Connexion à l'interface web avec un compte Jellyfin importé
+    jellyfinNewUserLogin: boolean  // Connexion des comptes Jellyfin pas encore importés (compte créé à la première connexion)
+    jellyfinAutoImport  : boolean  // Import horaire de tous les utilisateurs Jellyfin actifs
+    jellyfinServerId    : string   // Identifiant du serveur Jellyfin, comparé à chaque connexion
+    englishDirectory   : boolean  // Dossiers de saison en anglais (« Season 01 » au lieu de « Saison 1 »)
     autoUnimportMissing : boolean
     onboardingStep      : string | null   // étape la plus avancée atteinte dans l'assistant
     onboardingCompletedAt: string | null
@@ -34,7 +38,11 @@ const defaults: Settings = {
     requestAutoDownloadUsers: [],
     jellyfinUrl        : '',
     jellyfinAdminToken : '',
-    englishDirectory   : false,
+    jellyfinLogin      : true,
+    jellyfinNewUserLogin: false,
+    jellyfinAutoImport : true,
+    jellyfinServerId   : '',
+    englishDirectory  : false,
     autoUnimportMissing: false,
     onboardingStep     : null,
     onboardingCompletedAt: null,

server/users.ts

@@ -5,6 +5,7 @@ import crypto from 'crypto'
 import bcrypt from 'bcryptjs'
 import { DATA_DIR } from './config.js'
 import { logger }   from './logger.js'
+import { normalizeJellyfinId } from './lib/jellyfin.js'
 
 export type UserRole = 'admin' | 'user'
 
@@ -17,6 +18,7 @@ export interface User {
     createdAt   : string
     tourSeenAt? : string | null
     lastLoginAt?: string | null
+    jellyfinId? : string | null
 }
 
 const USERS_PATH  = path.join(DATA_DIR, 'users.json')
@@ -69,15 +71,20 @@ export function hasAdmin():  boolean { return readUsers().some(u => u.role === '
 export function findById(id: string):             User | undefined { return readUsers().find(u => u.id === id) }
 export function findByUsername(username: string): User | undefined { return readUsers().find(u => u.username.toLowerCase() === username.toLowerCase()) }
 export function findByApiToken(token: string):    User | undefined { return readUsers().find(u => u.apiToken === token) }
+export function findByJellyfinId(id: string):     User | undefined {
+    const jellyfinId = normalizeJellyfinId(id)
+    return readUsers().find(u => !!u.jellyfinId && u.jellyfinId === jellyfinId)
+}
 
 export function safeUser(user: User) {
-    const { passwordHash: _, ...safe } = user
-    return safe
+    const { passwordHash, ...safe } = user
+    return { ...safe, hasPassword: !!passwordHash }
 }
 
 // ── Gestion des comptes ───────────────────────────────────────
 
-export function createUser(username: string, password: string, role: UserRole = 'user'): User {
+// Mot de passe vide : compte sans mot de passe FanKarr (import Jellyfin)
+export function createUser(username: string, password: string, role: UserRole = 'user', jellyfinId: string | null = null): User {
     const users = readUsers()
     if (users.some(u => u.username.toLowerCase() === username.toLowerCase())) {
         throw new Error(`Nom d'utilisateur « ${username} » déjà utilisé`)
@@ -85,17 +92,43 @@ export function createUser(username: string, password: string, role: UserRole =
     const user: User = {
         id          : crypto.randomUUID(),
         username,
-        passwordHash: bcrypt.hashSync(password, SALT_ROUNDS),
+        passwordHash: password ? bcrypt.hashSync(password, SALT_ROUNDS) : '',
         role,
         apiToken    : crypto.randomBytes(32).toString('hex'),
         createdAt   : new Date().toISOString(),
         tourSeenAt  : null,
+        jellyfinId  : jellyfinId ? normalizeJellyfinId(jellyfinId) : null,
     }
     writeUsers([...users, user])
     logger.info('users', `Utilisateur « ${username} » créé (rôle : ${role})`)
     return user
 }
 
+export type JellyfinImportAction = 'existing' | 'linked' | 'created'
+
+// null : nom déjà pris par un compte lié à un autre utilisateur Jellyfin
+export function importJellyfinUser(jUser: { Id: string; Name: string }): { user: User; action: JellyfinImportAction } | null {
+    const users      = readUsers()
+    const jellyfinId = normalizeJellyfinId(jUser.Id)
+
+    const linked = users.find(u => u.jellyfinId === jellyfinId)
+    if (linked) return { user: linked, action: 'existing' }
+
+    const sameName = users.find(u => u.username.toLowerCase() === jUser.Name.toLowerCase())
+    if (sameName?.jellyfinId) {
+        logger.warn('users', `Import Jellyfin de « ${jUser.Name} » impossible : le compte FanKarr de ce nom est lié à un autre utilisateur Jellyfin`)
+        return null
+    }
+    if (sameName) {
+        sameName.jellyfinId = jellyfinId
+        writeUsers(users)
+        logger.info('users', `Compte « ${sameName.username} » lié à l'utilisateur Jellyfin « ${jUser.Name} »`)
+        return { user: sameName, action: 'linked' }
+    }
+
+    return { user: createUser(jUser.Name, '', 'user', jellyfinId), action: 'created' }
+}
+
 export function updateUser(
     id     : string,
     changes: Partial<{ username: string; password: string; role: UserRole }>,
@@ -132,6 +165,7 @@ export function changePassword(id: string, currentPassword: string, newPassword:
     const users = readUsers()
     const user  = users.find(u => u.id === id)
     if (!user) throw new Error('Utilisateur introuvable')
+    if (!user.passwordHash) throw new Error('Ce compte se connecte avec Jellyfin : il n\'a pas de mot de passe FanKarr')
     if (!bcrypt.compareSync(currentPassword, user.passwordHash)) {
         throw new Error('Mot de passe actuel incorrect')
     }

src/components/settings/JellyfinImportModal.vue

@@ -0,0 +1,132 @@
+<template>
+  <Teleport to="body">
+    <div class="modal-backdrop" @click.self="emit('close')">
+      <div class="modal max-w-md" role="dialog" aria-modal="true" aria-labelledby="jellyfin-import-title">
+        <div class="flex flex-col gap-1">
+          <h3 id="jellyfin-import-title" class="card-title">Importer des utilisateurs Jellyfin</h3>
+          <p class="text-meta text-muted">Chaque utilisateur importé reçoit un compte invité et se connecte avec ses identifiants Jellyfin.</p>
+        </div>
+
+        <p v-if="loading" class="text-body text-muted">Chargement…</p>
+        <p v-else-if="loadError" class="text-meta text-err">{{ loadError }}</p>
+        <div v-else class="flex flex-col gap-2">
+          <label v-if="importable.length > 1" class="flex items-center gap-3 min-h-9 cursor-pointer select-none">
+            <input type="checkbox" :checked="allSelected" @change="toggleAll" class="w-4 h-4 rounded" />
+            <span class="text-body text-secondary">Tout sélectionner</span>
+          </label>
+          <div class="flex flex-col max-h-[50vh] overflow-y-auto">
+            <label
+                v-for="u in users" :key="u.id"
+                class="flex items-center gap-3 min-h-10 select-none"
+                :class="isImportable(u) ? 'cursor-pointer' : 'opacity-60'"
+                :title="statusTitle(u)"
+            >
+              <input type="checkbox" :value="u.id" v-model="selected" :disabled="!isImportable(u)" class="w-4 h-4 rounded" />
+              <span class="flex-1 min-w-0 truncate text-body text-primary">{{ u.name }}</span>
+              <span v-if="STATUS_LABELS[u.status]" class="pill h-[22px] px-2 text-[10.5px] shrink-0" :class="u.status === 'imported' ? 'pill-ok' : u.status === 'match' ? 'pill-wait' : 'pill-muted'">
+                {{ STATUS_LABELS[u.status] }}
+              </span>
+            </label>
+            <p v-if="users.length === 0" class="text-body text-muted">Aucun utilisateur sur ce serveur Jellyfin.</p>
+          </div>
+        </div>
+
+        <p v-if="error" class="text-meta text-err">{{ error }}</p>
+
+        <div class="flex gap-2.5 justify-end">
+          <button @click="emit('close')" class="btn-ghost">Annuler</button>
+          <button @click="submit" :disabled="submitting || selected.length === 0" class="btn-primary">
+            {{ submitting ? 'Import…' : selected.length > 0 ? `Importer ${plural(selected.length, 'compte')}` : 'Importer' }}
+          </button>
+        </div>
+      </div>
+    </div>
+  </Teleport>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted } from 'vue'
+import { useToast } from '@/composables/useToast'
+import { plural } from '@/utils/format'
+
+type Status = 'imported' | 'match' | 'new' | 'disabled' | 'conflict'
+
+interface JellyfinAccount {
+  id             : string
+  name           : string
+  status         : Status
+  fankarrUsername: string | null
+}
+
+const STATUS_LABELS: Record<Status, string> = {
+  imported: 'Importé',
+  match   : 'Compte existant',
+  new     : '',
+  disabled: 'Désactivé dans Jellyfin',
+  conflict: 'Nom déjà pris',
+}
+
+const emit = defineEmits<{ close: []; imported: [] }>()
+
+const toast      = useToast()
+const users      = ref<JellyfinAccount[]>([])
+const selected   = ref<string[]>([])
+const loading    = ref(true)
+const loadError  = ref<string | null>(null)
+const submitting = ref(false)
+const error      = ref<string | null>(null)
+
+const importable  = computed(() => users.value.filter(isImportable))
+const allSelected = computed(() => importable.value.length > 0 && selected.value.length === importable.value.length)
+
+function isImportable(u: JellyfinAccount) {
+  return u.status === 'new' || u.status === 'match'
+}
+
+function statusTitle(u: JellyfinAccount) {
+  if (u.status === 'match')    return `Le compte FanKarr « ${u.fankarrUsername} » sera lié à cet utilisateur Jellyfin.`
+  if (u.status === 'conflict') return `Le compte FanKarr « ${u.fankarrUsername} » est déjà lié à un autre utilisateur Jellyfin.`
+  if (u.status === 'imported') return `Compte FanKarr : « ${u.fankarrUsername} »`
+  return undefined
+}
+
+function toggleAll() {
+  selected.value = allSelected.value ? [] : importable.value.map(u => u.id)
+}
+
+onMounted(async () => {
+  try {
+    const res  = await fetch('/api/jellyfin/users', { credentials: 'include' })
+    const data = await res.json()
+    if (res.ok) users.value = data
+    else loadError.value = data.error ?? 'Impossible de récupérer les utilisateurs Jellyfin.'
+  } catch {
+    loadError.value = 'Impossible de contacter le serveur.'
+  }
+  loading.value = false
+})
+
+async function submit() {
+  submitting.value = true
+  error.value      = null
+  try {
+    const res  = await fetch('/api/jellyfin/import', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+      body: JSON.stringify({ ids: selected.value }),
+    })
+    const data = await res.json()
+    if (!res.ok) { error.value = data.error ?? 'Impossible d\'importer les utilisateurs.'; return }
+
+    const parts: string[] = []
+    if (data.created > 0) parts.push(plural(data.created, 'compte créé', 'comptes créés'))
+    if (data.linked  > 0) parts.push(plural(data.linked,  'compte lié',  'comptes liés'))
+    toast.add(parts.length > 0 ? parts.join(', ') : 'Aucun compte importé', parts.length > 0 ? 'success' : 'info')
+    emit('imported')
+    emit('close')
+  } catch {
+    error.value = 'Impossible de contacter le serveur.'
+  } finally {
+    submitting.value = false
+  }
+}
+</script>

src/components/setup/SetupMediaServerStep.vue

@@ -12,7 +12,7 @@
             <span v-if="jellyfin?.test?.ok" class="pill pill-ok h-5 px-2 text-[10.5px]">Connecté</span>
           </p>
           <p class="text-meta text-muted mt-0.5 leading-relaxed">
-            Vos utilisateurs Jellyfin se connectent à FanKarr et font leurs demandes depuis le plugin FanKarr Search.
+            Vos utilisateurs Jellyfin se connectent à FanKarr avec leur compte Jellyfin, depuis l'interface web ou le plugin FanKarr Search.
           </p>
         </div>
         <button @click="jellyfinOpen = !jellyfinOpen" :aria-expanded="jellyfinOpen" class="btn-secondary btn-sm shrink-0">
@@ -26,15 +26,15 @@
 
         <div v-if="jellyfin?.test?.ok" class="flex flex-col gap-2">
           <div class="flex items-center gap-3 flex-wrap">
-            <button @click="syncUsers" :disabled="syncing" class="btn-secondary btn-sm">
-              {{ syncing ? 'Synchronisation…' : 'Synchroniser les utilisateurs' }}
+            <button @click="importUsers" :disabled="importing" class="btn-secondary btn-sm">
+              {{ importing ? 'Import…' : 'Importer les utilisateurs' }}
             </button>
-            <span v-if="syncResult" class="text-meta text-ok">
-              {{ plural(syncResult.created, 'créé', 'créés') }} · {{ plural(syncResult.skipped, 'déjà existant', 'déjà existants') }}
+            <span v-if="importResult" class="text-meta text-ok">
+              {{ plural(importResult.created, 'créé', 'créés') }}<template v-if="importResult.linked > 0"> · {{ plural(importResult.linked, 'lié', 'liés') }}</template> · {{ plural(importResult.skipped, 'ignoré', 'ignorés') }}
             </span>
-            <span v-if="syncError" class="text-meta text-err">{{ syncError }}</span>
+            <span v-if="importError" class="text-meta text-err">{{ importError }}</span>
           </div>
-          <p class="text-meta text-muted">Crée un compte FanKarr pour chaque utilisateur Jellyfin. La synchronisation se relance ensuite toutes les heures.</p>
+          <p class="text-meta text-muted">Crée un compte FanKarr pour chaque utilisateur Jellyfin actif. L'import se relance ensuite toutes les heures : vous pourrez choisir les comptes à la place dans Paramètres › Jellyfin et API.</p>
         </div>
       </template>
     </section>
@@ -82,9 +82,9 @@ const context = inject(setupContextKey)!
 
 const jellyfinOpen = ref(false)
 const jellyfin     = ref<{ jellyfinUrl: string; hasToken: boolean; test: { ok: boolean } | null } | null>(null)
-const syncing      = ref(false)
-const syncResult   = ref<{ created: number; skipped: number } | null>(null)
-const syncError    = ref<string | null>(null)
+const importing    = ref(false)
+const importResult = ref<{ created: number; linked: number; skipped: number } | null>(null)
+const importError  = ref<string | null>(null)
 const plexOpen     = ref(false)
 
 function openPlex() {
@@ -92,19 +92,19 @@ function openPlex() {
   context.plexOpened = true
 }
 
-async function syncUsers() {
-  syncing.value    = true
-  syncError.value  = null
-  syncResult.value = null
+async function importUsers() {
+  importing.value    = true
+  importError.value  = null
+  importResult.value = null
   try {
     const res  = await fetch('/api/jellyfin/sync', { method: 'POST', credentials: 'include' })
     const data = await res.json()
-    if (res.ok) syncResult.value = data
-    else        syncError.value  = data.error ?? 'Impossible de synchroniser les utilisateurs Jellyfin'
+    if (res.ok) importResult.value = data
+    else        importError.value  = data.error ?? 'Impossible d\'importer les utilisateurs Jellyfin'
   } catch {
-    syncError.value = 'Impossible de contacter le serveur'
+    importError.value = 'Impossible de contacter le serveur'
   } finally {
-    syncing.value = false
+    importing.value = false
   }
 }
 </script>

src/stores/auth.ts

@@ -11,6 +11,7 @@ export const useAuthStore = defineStore('auth', () => {
 
     const onboardingDone = ref(true)
     const tourSeen       = ref(true)
+    const jellyfinLogin  = ref(false)
 
     const isAdmin = computed(() => role.value === 'admin')
 
@@ -25,6 +26,7 @@ export const useAuthStore = defineStore('auth', () => {
             userId.value   = data.userId   ?? null
             onboardingDone.value = data.onboardingDone ?? true
             tourSeen.value       = data.tourSeen       ?? true
+            jellyfinLogin.value  = data.jellyfinLogin  ?? false
         } catch {
             loggedIn.value = false
         } finally {
@@ -94,7 +96,7 @@ export const useAuthStore = defineStore('auth', () => {
 
     return {
         loggedIn, setup, loading, role, username, userId, isAdmin,
-        onboardingDone, tourSeen,
+        onboardingDone, tourSeen, jellyfinLogin,
         checkStatus, login, setupAccount, logout, markTourSeen, completeOnboarding,
     }
 })

src/views/AuthView.vue

@@ -35,6 +35,9 @@
           <button @click="submit" :disabled="submitting" class="btn-primary w-full h-11 mt-1">
             {{ submitting ? (isSetup ? 'Création…' : 'Connexion…') : isSetup ? 'Créer le compte' : 'Se connecter' }}
           </button>
+          <p v-if="!isSetup && auth.jellyfinLogin" class="text-meta text-muted text-center">
+            Vous pouvez aussi vous connecter avec votre compte Jellyfin.
+          </p>
         </div>
       </div>
 

src/views/settings/JellyfinView.vue

@@ -2,31 +2,57 @@
   <div class="flex flex-col gap-4">
 
     <Teleport defer to="#settings-actions">
-      <button @click="syncUsers" :disabled="syncing || !hasToken" class="btn-secondary pointer-fine:h-[38px]" :title="hasToken ? undefined : 'Renseignez d\'abord la clé API Jellyfin.'">
-        <RefreshCw :size="15" :class="{ 'animate-spin': syncing }" />
-        {{ syncing ? 'Synchronisation…' : 'Synchroniser les utilisateurs' }}
+      <button @click="importOpen = true" :disabled="!configured" class="btn-secondary pointer-fine:h-[38px]" :title="configured ? undefined : NOT_CONFIGURED">
+        <UserPlus :size="15" /> Importer des utilisateurs
       </button>
     </Teleport>
 
-    <SettingsSection title="Jellyfin" description="La connexion au serveur Jellyfin sert à synchroniser les comptes et à authentifier les utilisateurs du plugin FanKarr Search.">
-      <JellyfinConnectionForm @change="hasToken = $event.hasToken" />
+    <SettingsSection title="Jellyfin" description="La connexion au serveur Jellyfin sert à importer les comptes et à connecter leurs utilisateurs à FanKarr, depuis l'interface web ou le plugin FanKarr Search.">
+      <JellyfinConnectionForm @change="configured = !!$event.jellyfinUrl && $event.hasToken" />
     </SettingsSection>
 
     <SettingsSection
-        title="Synchronisation des utilisateurs"
-        description="Crée un compte FanKarr pour chaque utilisateur Jellyfin actif (les comptes existants ne sont pas modifiés). Synchronisation automatique toutes les heures."
+        title="Utilisateurs Jellyfin"
+        description="Un utilisateur importé reçoit un compte invité. Si un compte FanKarr porte déjà son nom, ce compte est lié au lieu d'être recréé."
     >
+      <template #actions>
+        <span v-if="savedSection === 'users'" class="text-meta text-ok flex items-center gap-1.5"><Check :size="14" /> Enregistré</span>
+      </template>
+
       <div class="flex items-center gap-3 flex-wrap">
-        <button @click="syncUsers" :disabled="syncing || !hasToken" class="btn-secondary pointer-fine:h-[38px]">
-          {{ syncing ? 'Synchronisation…' : 'Synchroniser les utilisateurs' }}
+        <button @click="importOpen = true" :disabled="!configured" class="btn-secondary pointer-fine:h-[38px]">
+          Importer des utilisateurs
         </button>
-        <span v-if="!hasToken" class="text-meta text-muted">Renseignez d'abord la clé API Jellyfin.</span>
-        <span v-else-if="syncError" class="text-meta text-err">{{ syncError }}</span>
-        <span v-else-if="syncResult" class="text-meta text-secondary">
-          <span class="text-ok">{{ plural(syncResult.created, 'compte créé', 'comptes créés') }}</span>
-          · {{ plural(syncResult.skipped, 'déjà existant ou désactivé', 'déjà existants ou désactivés') }}<template v-if="syncResult.users.length > 0"> · nouveaux : {{ syncResult.users.join(', ') }}</template>
-        </span>
+        <span v-if="!configured" class="text-meta text-muted">{{ NOT_CONFIGURED }}</span>
       </div>
+      <SettingsToggle
+          :model-value="options.jellyfinAutoImport"
+          @update:model-value="save('jellyfinAutoImport', $event, 'users')"
+          label="Importer automatiquement tous les utilisateurs"
+          description="Toutes les heures, chaque utilisateur Jellyfin actif sans compte FanKarr est importé."
+      />
+    </SettingsSection>
+
+    <SettingsSection title="Connexion avec Jellyfin" description="Jellyfin vérifie le mot de passe : FanKarr ne le conserve pas.">
+      <template #actions>
+        <span v-if="savedSection === 'login'" class="text-meta text-ok flex items-center gap-1.5"><Check :size="14" /> Enregistré</span>
+      </template>
+
+      <SettingsToggle
+          :model-value="options.jellyfinLogin"
+          @update:model-value="save('jellyfinLogin', $event, 'login')"
+          label="Connexion à FanKarr avec un compte Jellyfin"
+          description="Les comptes importés se connectent à l'interface web avec leurs identifiants Jellyfin."
+      />
+      <SettingsToggle
+          :model-value="options.jellyfinNewUserLogin"
+          @update:model-value="save('jellyfinNewUserLogin', $event, 'login')"
+          label="Autoriser les comptes pas encore importés"
+          description="Un compte invité est créé à la première connexion, depuis l'interface web ou le plugin FanKarr Search."
+      />
+      <p class="text-xs text-muted">
+        Un mot de passe erroné saisi dans FanKarr compte aussi comme un échec dans Jellyfin. Si le verrouillage après plusieurs échecs est activé pour un utilisateur dans Jellyfin, son compte y est désactivé une fois la limite atteinte.
+      </p>
     </SettingsSection>
 
     <section class="bg-card rounded-card">
@@ -46,20 +72,30 @@
       </div>
     </section>
 
+    <JellyfinImportModal v-if="importOpen" @close="importOpen = false" />
+
   </div>
 </template>
 
 <script setup lang="ts">
-import { ref } from 'vue'
-import { RefreshCw } from 'lucide-vue-next'
+import { ref, onMounted } from 'vue'
+import { Check, UserPlus } from 'lucide-vue-next'
 import JellyfinConnectionForm from '@/components/settings/JellyfinConnectionForm.vue'
+import JellyfinImportModal from '@/components/settings/JellyfinImportModal.vue'
 import SettingsSection from '@/components/settings/SettingsSection.vue'
-import { plural } from '@/utils/format'
+import SettingsToggle from '@/components/settings/SettingsToggle.vue'
+import { useToast } from '@/composables/useToast'
 
-const hasToken           = ref(false)
-const syncing            = ref(false)
-const syncResult         = ref<{ created: number; skipped: number; users: string[] } | null>(null)
-const syncError          = ref<string | null>(null)
+type Option = 'jellyfinLogin' | 'jellyfinNewUserLogin' | 'jellyfinAutoImport'
+
+const NOT_CONFIGURED = 'Renseignez d\'abord l\'adresse et la clé API Jellyfin.'
+
+const toast        = useToast()
+const configured   = ref(false)
+const importOpen   = ref(false)
+const options      = ref<Record<Option, boolean>>({ jellyfinLogin: true, jellyfinNewUserLogin: false, jellyfinAutoImport: true })
+const savedSection = ref<'users' | 'login' | null>(null)
+let   savedTimer: ReturnType<typeof setTimeout> | null = null
 
 const apiBase = `${window.location.origin}/api/v1`
 
@@ -72,14 +108,27 @@ const apiEndpoints = [
   { method: 'GET',  path: '/auth/me',          desc: 'Vérifier le jeton utilisé' },
 ]
 
-async function syncUsers() {
-  syncing.value    = true
-  syncError.value  = null
-  syncResult.value = null
-  const res = await fetch('/api/jellyfin/sync', { method: 'POST', credentials: 'include' })
-  const data = await res.json()
-  if (res.ok) syncResult.value = data
-  else syncError.value = data.error ?? 'Impossible de synchroniser les utilisateurs Jellyfin.'
-  syncing.value = false
+onMounted(async () => {
+  const res = await fetch('/api/jellyfin/settings', { credentials: 'include' }).catch(() => null)
+  if (!res?.ok) return
+  const d = await res.json()
+  options.value = { jellyfinLogin: d.jellyfinLogin, jellyfinNewUserLogin: d.jellyfinNewUserLogin, jellyfinAutoImport: d.jellyfinAutoImport }
+})
+
+async function save(key: Option, value: boolean, section: 'users' | 'login') {
+  const previous = options.value[key]
+  options.value[key] = value
+  const res = await fetch('/api/jellyfin/settings', {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, credentials: 'include',
+    body: JSON.stringify({ [key]: value }),
+  }).catch(() => null)
+  if (!res?.ok) {
+    options.value[key] = previous
+    toast.add('Impossible d\'enregistrer le réglage.', 'error')
+    return
+  }
+  savedSection.value = section
+  if (savedTimer) clearTimeout(savedTimer)
+  savedTimer = setTimeout(() => { savedSection.value = null }, 2000)
 }
 </script>

src/views/settings/ProfileView.vue

@@ -20,7 +20,13 @@
       </div>
     </SettingsSection>
 
-    <SettingsSection title="Mot de passe" description="Au moins 6 caractères.">
+    <SettingsSection
+        v-if="me?.hasPassword === false"
+        title="Mot de passe"
+        description="Vous vous connectez avec votre compte Jellyfin. Le mot de passe se change dans Jellyfin."
+    />
+
+    <SettingsSection v-else title="Mot de passe" description="Au moins 6 caractères.">
       <div class="grid sm:grid-cols-3 gap-4">
         <div class="flex flex-col gap-[7px]">
           <label for="pwd-current" class="field-label">Mot de passe actuel</label>
@@ -91,7 +97,7 @@ import SettingsSection           from '@/components/settings/SettingsSection.vue
 
 const auth = useAuthStore()
 
-const me = ref<{ createdAt?: string; lastLoginAt?: string | null } | null>(null)
+const me = ref<{ createdAt?: string; lastLoginAt?: string | null; hasPassword?: boolean } | null>(null)
 
 function formatDate(iso: string) {
   return new Date(iso).toLocaleDateString('fr-FR', { day: 'numeric', month: 'long', year: 'numeric' })
@@ -153,7 +159,7 @@ async function loadMe() {
   if (res.ok) {
     const d = await res.json()
     myToken.value = d.apiToken ?? ''
-    me.value = { createdAt: d.createdAt, lastLoginAt: d.lastLoginAt }
+    me.value = { createdAt: d.createdAt, lastLoginAt: d.lastLoginAt, hasPassword: d.hasPassword }
   }
 }
 

src/views/settings/SettingsLayout.vue

@@ -63,7 +63,7 @@ const pages: Record<string, { title: string; description: string }> = {
   '/settings/import-management': { title: 'Gestion des séries',          description: 'Renommage, métadonnées NFO et vérification des fichiers déjà importés.' },
   '/settings/catalogue'        : { title: 'Catalogue Fankai',            description: 'Sources du catalogue et surveillance des nouveaux épisodes.' },
   '/settings/download-client'  : { title: 'Clients torrent',             description: 'Les clients qui reçoivent les torrents envoyés par FanKarr.' },
-  '/settings/jellyfin'         : { title: 'Jellyfin et API',             description: 'Connexion Jellyfin, synchronisation des comptes et API pour les applications tierces.' },
+  '/settings/jellyfin'         : { title: 'Jellyfin et API',             description: 'Connexion Jellyfin, import des comptes et API pour les applications tierces.' },
   '/settings/logs'             : { title: 'Journaux',                    description: 'Événements du serveur, du plus récent au plus ancien.' },
   '/settings/advanced'         : { title: 'Avancé',                      description: 'Mises à jour, diagnostic, mode développeur, assistant et visite guidée.' },
 }

src/views/settings/UsersView.vue

@@ -164,7 +164,7 @@
             <div class="flex flex-col gap-[7px]">
               <label for="user-pwd" class="field-label">{{ userModal.mode === 'create' ? 'Mot de passe' : 'Nouveau mot de passe' }}</label>
               <input id="user-pwd" v-model="userModal.password" type="password" class="field" autocomplete="new-password"
-                :placeholder="userModal.mode === 'edit' ? 'Laissez vide pour le conserver' : '••••••••'" />
+                :placeholder="userModal.mode === 'create' ? '••••••••' : userModal.hasPassword ? 'Laissez vide pour le conserver' : 'Aucun mot de passe FanKarr (connexion Jellyfin)'" />
             </div>
             <div class="flex flex-col gap-[7px]">
               <span class="field-label">Rôle</span>
@@ -241,6 +241,8 @@ interface User {
   apiToken    : string
   createdAt   : string
   lastLoginAt?: string | null
+  jellyfinId? : string | null
+  hasPassword : boolean
 }
 
 interface Invite {
@@ -275,6 +277,7 @@ const userModal = ref<{
   username: string
   password: string
   role    : 'admin' | 'user'
+  hasPassword: boolean
   error   : string | null
   loading : boolean
 } | null>(null)
@@ -358,11 +361,11 @@ onUnmounted(() => document.removeEventListener('click', closeUserMenu))
 
 // ── Utilisateurs ──
 function openCreateUser() {
-  userModal.value = { mode: 'create', username: '', password: '', role: 'user', error: null, loading: false }
+  userModal.value = { mode: 'create', username: '', password: '', role: 'user', hasPassword: true, error: null, loading: false }
 }
 
 function openEditUser(u: User) {
-  userModal.value = { mode: 'edit', id: u.id, username: u.username, password: '', role: u.role, error: null, loading: false }
+  userModal.value = { mode: 'edit', id: u.id, username: u.username, password: '', role: u.role, hasPassword: u.hasPassword, error: null, loading: false }
 }
 
 async function submitUserModal() {
@@ -399,6 +402,7 @@ function userSubtitle(u: User) {
   if (u.id === currentUserId.value) parts.push('vous')
   if (pending > 0) parts.push(`${plural(pending, 'demande')} en attente`)
   if (parts.length === 0) parts.push(`créé le ${formatDate(u.createdAt)}`)
+  if (u.jellyfinId) parts.push('Jellyfin')
   return parts.join(' · ')
 }