@liorian/sdk 0.28.3-alpha.ed82e18 → 0.29.0-alpha.bdbe320

package/README.md

@@ -322,7 +322,9 @@ import {motionVariants, transitionEasing} from "@liorian/sdk/infrastructure/libr
 ### Hooks (`infrastructure/hooks/`)
 
 `use-auth`, `use-notifications`, `use-mobile`, `use-is-desktop`, `use-is-tauri`,
-`use-activity-lock-draft`, `use-elastic-interaction`, `use-recent-colors`, `use-recent-modules`.
+`use-activity-lock-draft`, `use-elastic-interaction`, `use-recent-colors`, `use-recent-modules`,
+`use-sso-login` (déclenche le flux SSO selon `AuthConfig.sso.mode` — `redirect` par défaut,
+`popup` sur option — et reçoit le résultat via `postMessage` + repli `storage`).
 
 ### Stores zustand (`infrastructure/stores/`)
 
@@ -361,7 +363,10 @@ manager. Reprendre la même source de vérité côté SDK et côté manager.
 - `permission.util`, `format.util`, `strings.util`, `classname.util` (`cn`/`CommonClassName`) ;
 - `encryption.service`, `activity-tracker.service`, `activity-lock.service` (verrouillage d'écran),
   `form-snapshot.service` (brouillons de formulaire au verrouillage) ;
-- `sso-auth.util`, `auth-logout.util`, `route-access` (accès par route), `media-label.service`,
+- `sso-auth.util` — client SSO OAuth 2.0 + PKCE vers Liorian Auth : `startSsoLogin`
+  (redirection, mode par défaut), `startSsoLoginPopup` (optionnel), `handleSsoCallback`,
+  `isSsoCallbackInPopup`, `SSO_MODE`, `SSO_RESULT_STORAGE_KEY` ;
+- `auth-logout.util`, `route-access` (accès par route), `media-label.service`,
   `push-permission.util`, `tauri.util`, `modules.ts`.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liorian/sdk",
-  "version": "0.28.3-alpha.ed82e18",
+  "version": "0.29.0-alpha.bdbe320",
   "description": "Core package for the Liorian (application shell, domain, infrastructure, UI design system).",
   "type": "module",
   "license": "MIT",

package/schemas/module.schema.json

@@ -3,7 +3,7 @@
   "$id": "module-manifest.schema.json",
   "$comment": "Schéma canonique du manifest.json des modules Liorian (@liorian/sdk). Référencé par les modules du socle (frontend/liorian-socle/src/modules/*) et les modules externes (frontend/liorian-socle/library/modules/*).",
   "title": "Module Manifest (Liorian)",
-  "description": "Manifeste d'installation et de déclaration d'un module Liorian. Ce fichier décrit l'identité du module, sa compatibilité (plateformes, versions manager/API), ses permissions, ses prérequis fonctionnels (requirements/optionalRequirements) et ses dépendances runtime (dependencies/devDependencies). Il est la source de vérité des métadonnées techniques d'un module, consommée par le Module Store et l'outillage de distribution.",
+  "description": "Manifeste d'installation et de déclaration d'un module Liorian. Ce fichier décrit l'identité du module, sa compatibilité (plateformes, versions manager/API), ses permissions et ses prérequis fonctionnels (requirements/optionalRequirements). Les dépendances npm d'exécution et de développement sont portées par le `package.json` du module. Il est la source de vérité des métadonnées techniques d'un module, consommée par le Module Store et l'outillage de distribution.",
   "type": "object",
   "default": {},
   "examples": [
@@ -45,15 +45,6 @@
         "identity": ">=1.0.0"
       },
       "optionalRequirements": {},
-      "dependencies": {
-        "@liorian/sdk": "workspace:*",
-        "react": "^19.0.0",
-        "react-dom": "^19.0.0"
-      },
-      "devDependencies": {
-        "@types/react": "^19.2.17",
-        "typescript": "^6.0.3"
-      },
       "widgets": ["analytics"],
       "routines": ["helloWorldAnalyticsRoutine"],
       "providers": ["layout"]
@@ -81,9 +72,7 @@
     "isEnabled",
     "isDefault",
     "requirements",
-    "optionalRequirements",
-    "dependencies",
-    "devDependencies"
+    "optionalRequirements"
   ],
   "additionalProperties": true,
   "properties": {
@@ -263,18 +252,6 @@
       "description": "Modules optionnels dont le module enrichit le comportement s'ils sont présents (intégrations facultatives). La valeur `{}` indique aucun prérequis optionnel.",
       "examples": [{"messenger": ">=1.0.0"}]
     },
-    "dependencies": {
-      "$ref": "#/definitions/dependency-map",
-      "title": "Dépendances npm",
-      "description": "Dépendances de packages npm nécessaires à l'exécution du module (nom de package -> plage de versions ou `workspace:*` pour les packages du monorepo).",
-      "examples": [{"@liorian/sdk": "workspace:*", "@tanstack/react-query": "^5.101.2"}]
-    },
-    "devDependencies": {
-      "$ref": "#/definitions/dependency-map",
-      "title": "Dépendances de développement",
-      "description": "Dépendances npm nécessaires uniquement au développement et à la compilation du module (types, toolchain).",
-      "examples": [{"typescript": "^6.0.3", "@types/react": "^19.2.17"}]
-    },
     "widgets": {
       "type": "array",
       "items": {
@@ -413,21 +390,6 @@
       "description": "Association d'identifiants de modules (`requirements` / `optionalRequirements`) à des plages de versions acceptées.",
       "examples": [{"organization": ">=1.0.0", "media-library": ">=1.0.0"}]
     },
-    "dependency-map": {
-      "type": "object",
-      "propertyNames": {
-        "pattern": "^(?:@[a-z0-9-~][a-z0-9-._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$"
-      },
-      "patternProperties": {
-        "^(?:@[a-z0-9-~][a-z0-9-._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$": {
-          "$ref": "#/definitions/semver-range"
-        }
-      },
-      "additionalProperties": false,
-      "title": "Carte package npm -> version",
-      "description": "Association de noms de packages npm (avec ou sans scope `@scope/package`) à des plages de versions acceptées.",
-      "examples": [{"@liorian/sdk": "workspace:*", "react": "^19.0.0"}]
-    },
     "publisher": {
       "type": "object",
       "required": ["id", "name"],

package/src/domain/config/auth.config.ts

@@ -21,6 +21,13 @@ export const AuthConfig = {
         clientId: process.env.NEXT_PUBLIC_AUTH_CLIENT_ID || 'liorian-socle',
         /** Chemin de rappel SSO de l'application (code + state). */
         redirectPath: '/auth/callback',
+        /**
+         * Mode de déclenchement du SSO :
+         *  - `redirect` (défaut) : redirection pleine page vers Liorian Auth ;
+         *  - `popup` : fenêtre popup, avec repli automatique en redirection si bloquée.
+         * Configurable par application via `NEXT_PUBLIC_AUTH_SSO_MODE`.
+         */
+        mode: (process.env.NEXT_PUBLIC_AUTH_SSO_MODE === 'popup' ? 'popup' : 'redirect') as 'popup' | 'redirect',
     },
     excludes: [
         '/auth',

package/src/infrastructure/hooks/index.ts

@@ -7,4 +7,5 @@ export * from "./use-is-tauri";
 export * from "./use-mobile";
 export * from "./use-notifications";
 export * from "./use-recent-colors";
-export * from "./use-recent-modules";
+export * from "./use-recent-modules";
+export * from "./use-sso-login";

package/src/infrastructure/hooks/use-sso-login.ts

@@ -0,0 +1,126 @@
+"use client"
+
+import {useCallback, useEffect, useRef, useState} from "react"
+import {
+    SSO_CALLBACK_MESSAGE,
+    SSO_MODE,
+    SSO_RESULT_STORAGE_KEY,
+    startSsoLogin,
+    startSsoLoginPopup,
+} from "../utilities/sso-auth.util"
+
+export interface UseSsoLoginOptions {
+    /** Destination après une authentification réussie (navigation complète). Par défaut, recharge la page courante. */
+    redirectUrl?: string
+    /** Callback invoqué après une authentification réussie. */
+    onAuthenticated?: () => void
+    /** Callback invoqué en cas d'échec (popup fermé/refusé, redirection impossible). */
+    onError?: (error?: unknown) => void
+}
+
+export interface UseSsoLoginResult {
+    /** Vrai pendant le lancement et l'attente du flux SSO. */
+    connecting: boolean
+    /** Démarre le flux SSO selon le mode configuré (`redirect` par défaut, `popup` sur option). */
+    start: () => Promise<void>
+}
+
+/**
+ * Gère le déclenchement du SSO Liorian et la réception de son résultat.
+ *
+ * Le mode est lu depuis `AuthConfig.sso.mode` (`NEXT_PUBLIC_AUTH_SSO_MODE`) :
+ *  - `redirect` (défaut) : redirection pleine page, aucun écouteur requis ;
+ *  - `popup` : fenêtre popup (repli automatique en redirection si bloquée).
+ *
+ * En mode popup, le résultat est reçu via `postMessage` et, en repli lorsque
+ * `window.opener` a été neutralisé (COOP), via l'événement `storage`.
+ */
+export function useSsoLogin({redirectUrl, onAuthenticated, onError}: UseSsoLoginOptions = {}): UseSsoLoginResult {
+    const [connecting, setConnecting] = useState(false)
+    const settled = useRef(false)
+    const watcher = useRef<ReturnType<typeof setInterval> | null>(null)
+
+    const stopWatcher = useCallback(() => {
+        if (watcher.current) {
+            clearInterval(watcher.current)
+            watcher.current = null
+        }
+    }, [])
+
+    const finish = useCallback((success: boolean, error?: unknown) => {
+        if (settled.current) return
+        settled.current = true
+        stopWatcher()
+        setConnecting(false)
+
+        if (!success) {
+            onError?.(error)
+            return
+        }
+
+        onAuthenticated?.()
+        if (redirectUrl) {
+            window.location.assign(redirectUrl)
+        } else {
+            window.location.reload()
+        }
+    }, [redirectUrl, onAuthenticated, onError, stopWatcher])
+
+    useEffect(() => {
+        // En mode redirection, la navigation quitte la page : aucun écouteur requis.
+        if (SSO_MODE !== 'popup') return
+
+        const onMessage = (event: MessageEvent) => {
+            if (event.origin !== window.location.origin) return
+            if (event.data?.source !== 'liorian-auth') return
+            if (event.data?.type !== SSO_CALLBACK_MESSAGE) return
+            finish(Boolean(event.data?.success))
+        }
+        const onStorage = (event: StorageEvent) => {
+            if (event.key !== SSO_RESULT_STORAGE_KEY || !event.newValue) return
+            try {
+                finish(Boolean(JSON.parse(event.newValue)?.success))
+            } catch {
+                // Valeur illisible : ignorer.
+            }
+        }
+
+        window.addEventListener('message', onMessage)
+        window.addEventListener('storage', onStorage)
+        return () => {
+            window.removeEventListener('message', onMessage)
+            window.removeEventListener('storage', onStorage)
+            stopWatcher()
+        }
+    }, [finish, stopWatcher])
+
+    const start = useCallback(async () => {
+        if (connecting) return
+        settled.current = false
+        setConnecting(true)
+
+        try {
+            if (SSO_MODE !== 'popup') {
+                await startSsoLogin()
+                return
+            }
+
+            const popup = await startSsoLoginPopup()
+            if (!popup) {
+                await startSsoLogin()
+                return
+            }
+
+            // Popup fermé sans résultat : réactiver le bouton côté onglet d'origine.
+            watcher.current = setInterval(() => {
+                if (popup.closed) {
+                    finish(false, new Error('Fenêtre d’authentification fermée.'))
+                }
+            }, 500)
+        } catch (error) {
+            finish(false, error)
+        }
+    }, [connecting, finish])
+
+    return {connecting, start}
+}

package/src/infrastructure/utilities/sso-auth.util.ts

@@ -10,28 +10,47 @@ import {authUserConnectedStore} from "../stores/auth-user-connected.store";
  * Client OAuth 2.0 (Authorization Code + PKCE) vers Liorian Auth.
  *
  * Utilisé par les applications consommatrices (ex. liorian-socle) pour
- * s'authentifier via le SSO de `liorian-auth`. Deux modes de déclenchement :
- *  - fenêtre popup (`startSsoLoginPopup`) — privilégié ;
- *  - redirection complète (`startSsoLogin`) — solution de repli si le popup est bloqué.
+ * s'authentifier via le SSO de `liorian-auth`. Deux modes de déclenchement,
+ * choisis par `NEXT_PUBLIC_AUTH_SSO_MODE` (défaut : redirection) :
+ *  - redirection complète (`startSsoLogin`) — mode par défaut ;
+ *  - fenêtre popup (`startSsoLoginPopup`) — optionnel, repli en redirection si bloquée.
  *
  * Les secrets PKCE (`code_verifier`/`state`) sont stockés en `localStorage`
  * (et non en `sessionStorage`) afin d'être partagés entre l'onglet principal
- * et le popup de la même origine.
+ * et le popup de la même origine. Le mode courant y est également mémorisé afin
+ * de fermer le popup de façon fiable, même lorsque `window.opener` est neutralisé
+ * (Cross-Origin-Opener-Policy). Le résultat est alors aussi publié via
+ * `localStorage` pour prévenir l'onglet d'origine.
  */
 
+/** Mode de déclenchement du SSO (voir `AuthConfig.sso.mode`). */
+export type SsoMode = 'redirect' | 'popup';
+
 /** Identifiant OAuth de l'application consommatrice (configurable par application). */
 export const SSO_CLIENT_ID = AuthConfig.sso.clientId;
 export const SSO_SCOPE = 'openid profile email organizations';
 export const SSO_REDIRECT_PATH = AuthConfig.sso.redirectPath;
 
+/** Mode SSO effectif de l'application (`redirect` par défaut, `popup` sur option). */
+export const SSO_MODE: SsoMode = AuthConfig.sso.mode;
+
 const SSO_STORAGE = {
     codeVerifier: 'sso.code_verifier',
     state: 'sso.state',
+    mode: 'sso.mode',
+    result: 'sso.result',
 } as const;
 
 /** Type de message posté par le popup de callback vers l'onglet d'origine. */
 export const SSO_CALLBACK_MESSAGE = 'SSO_CALLBACK';
 
+/**
+ * Clé `localStorage` publiée par le popup à la fin du callback. Sert de repli
+ * à `postMessage` : l'onglet d'origine écoute l'événement `storage` pour savoir
+ * si l'authentification a réussi.
+ */
+export const SSO_RESULT_STORAGE_KEY = SSO_STORAGE.result;
+
 function ssoOrigin(): string {
     return (AppConfig.AUTH_HOST || 'https://localhost:5050').replace(/\/$/, '');
 }
@@ -54,6 +73,10 @@ async function sha256Base64url(input: string): Promise<string> {
     return base64url(digest);
 }
 
+function randomId(): string {
+    return Math.random().toString(36).slice(2);
+}
+
 /** Construit l'URL d'autorisation vers Liorian Auth (PKCE S256). */
 export async function buildSsoLoginUrl(clientId: string = AuthConfig.sso.clientId): Promise<string> {
     const codeVerifier = randomBase64url(64);
@@ -75,19 +98,22 @@ export async function buildSsoLoginUrl(clientId: string = AuthConfig.sso.clientI
     return url.toString();
 }
 
-/** Redirige toute la fenêtre vers Liorian Auth. */
+/** Redirige toute la fenêtre vers Liorian Auth (mode redirection, par défaut). */
 export async function startSsoLogin(clientId?: string): Promise<void> {
+    localStorage.removeItem(SSO_STORAGE.mode);
     window.location.assign(await buildSsoLoginUrl(clientId));
 }
 
 /**
- * Ouvre un popup Liorian Auth pour se connecter.
+ * Ouvre un popup Liorian Auth pour se connecter (mode popup, optionnel).
  * Retourne la référence de la fenêtre, ou `null` si le popup a été bloqué
- * (appelant doit alors basculer sur une redirection).
+ * (l'appelant doit alors basculer sur une redirection).
  */
 export async function startSsoLoginPopup(clientId?: string): Promise<Window | null> {
     const url = await buildSsoLoginUrl(clientId);
 
+    localStorage.setItem(SSO_STORAGE.mode, 'popup');
+
     const width = 480;
     const height = 720;
     const left = window.screenX + (window.outerWidth - width) / 2;
@@ -100,16 +126,33 @@ export async function startSsoLoginPopup(clientId?: string): Promise<Window | nu
     );
 }
 
-/** Vrai si la page de callback s'exécute dans un popup ouvert par `startSsoLoginPopup`. */
+/**
+ * Vrai si la page de callback s'exécute dans un popup ouvert par `startSsoLoginPopup`.
+ *
+ * Seul le marqueur mémorisé par `startSsoLoginPopup` fait foi : une redirection
+ * pleine page (`startSsoLogin`) doit toujours ramener l'utilisateur dans
+ * l'onglet courant, même si ce dernier possède un `window.opener` (onglet ouvert
+ * par un lien `_blank`, webview Tauri, etc.). Se fier à `window.opener` ferait
+ * passer ce callback pour un popup : la session serait installée mais la
+ * navigation jamais déclenchée, laissant l'utilisateur bloqué sur le callback.
+ */
 export function isSsoCallbackInPopup(): boolean {
-    return typeof window !== 'undefined' && !!window.opener && window.location !== window.opener.location;
+    if (typeof window === 'undefined') return false;
+    try {
+        return window.localStorage.getItem(SSO_STORAGE.mode) === 'popup';
+    } catch {
+        // Stockage indisponible : on retombe sur la détection par `window.opener`.
+        return !!window.opener && window.opener !== window;
+    }
 }
 
 /**
  * Échange le code d'autorisation (callback) contre une session et l'installe.
  *
- * En mode popup, le résultat est renvoyé à l'onglet d'origine via `postMessage`
- * puis le popup est refermé (retourne `false` pour empêcher la navigation).
+ * En mode popup, le résultat est renvoyé à l'onglet d'origine (`postMessage` +
+ * repli `localStorage`) puis le popup est refermé : la méthode retourne `false`
+ * pour empêcher la navigation. En mode redirection, elle retourne `true` en cas
+ * de succès et lève une erreur en cas d'échec pour laisser l'appelant rediriger.
  */
 export async function handleSsoCallback(): Promise<boolean> {
     const params = new URLSearchParams(window.location.search);
@@ -121,10 +164,10 @@ export async function handleSsoCallback(): Promise<boolean> {
 
     if (error || !code) {
         if (isPopup) {
-            postResult(window.opener, false);
-            window.close();
+            finishPopup(false);
+            return false;
         }
-        return false;
+        throw new Error(params.get('error_description') || error || 'Code d’autorisation manquant.');
     }
 
     try {
@@ -158,31 +201,49 @@ export async function handleSsoCallback(): Promise<boolean> {
         authUserConnectedStore.getState().setCurrentUser(authData.user);
         authUserConnectedStore.getState().setOrganizations(authData.organizations || []);
 
-        localStorage.removeItem(SSO_STORAGE.codeVerifier);
-        localStorage.removeItem(SSO_STORAGE.state);
-
-        if (isPopup && window.opener) {
-            postResult(window.opener, true);
-            window.close();
+        if (isPopup) {
+            finishPopup(true);
             return false;
         }
 
+        localStorage.removeItem(SSO_STORAGE.codeVerifier);
+        localStorage.removeItem(SSO_STORAGE.state);
         return true;
     } catch (e) {
-        // En mode popup : signaler l'échec à l'onglet d'origine et refermer le popup,
-        // sinon l'écran reste bloqué sur « Finalisation de la connexion… ».
-        if (isPopup && window.opener) {
-            postResult(window.opener, false);
-            window.close();
+        // En mode popup : signaler l'échec puis refermer, sinon l'écran reste
+        // bloqué sur « Finalisation de la connexion… ».
+        if (isPopup) {
+            finishPopup(false);
             return false;
         }
         throw e;
     }
 }
 
-function postResult(opener: Window, success: boolean): void {
-    opener.postMessage(
-        {source: 'liorian-auth', type: SSO_CALLBACK_MESSAGE, success},
-        window.location.origin,
-    );
-}
+/**
+ * Clôt le popup : notifie l'onglet d'origine puis referme la fenêtre.
+ *
+ * Le résultat est publié à la fois par `postMessage` (si `window.opener` est
+ * disponible) et via `localStorage`, dont l'événement `storage` est reçu par
+ * l'onglet d'origine même lorsque COOP a neutralisé l'opener.
+ */
+function finishPopup(success: boolean): void {
+    localStorage.removeItem(SSO_STORAGE.codeVerifier);
+    localStorage.removeItem(SSO_STORAGE.state);
+    localStorage.removeItem(SSO_STORAGE.mode);
+    localStorage.setItem(SSO_STORAGE.result, JSON.stringify({success, id: randomId()}));
+
+    const opener = window.opener;
+    if (opener) {
+        try {
+            opener.postMessage(
+                {source: 'liorian-auth', type: SSO_CALLBACK_MESSAGE, success},
+                window.location.origin,
+            );
+        } catch {
+            // Opener cross-origin : le résultat reste disponible via `localStorage`.
+        }
+    }
+
+    window.close();
+}

package/src/presentation/components/auth/sso-callback.view.tsx

@@ -2,7 +2,7 @@
 
 import {useEffect, useRef} from "react";
 import {useRouter} from "next/navigation";
-import {handleSsoCallback, isSsoCallbackInPopup} from "../../../infrastructure/utilities/sso-auth.util";
+import {handleSsoCallback} from "../../../infrastructure/utilities/sso-auth.util";
 import {Activity} from "../activity";
 
 export interface SsoCallbackViewProps {
@@ -27,11 +27,12 @@ export function SsoCallbackView({successRedirect = '/', errorRedirect = '/auth/s
         }
         done.current = true;
         handleSsoCallback()
-            .then(() => {
-                if (!isSsoCallbackInPopup()) router.replace(successRedirect);
+            .then((handledInPage) => {
+                // `false` : le résultat a été renvoyé au popup appelant, la fenêtre se ferme.
+                if (handledInPage) router.replace(successRedirect);
             })
             .catch(() => {
-                if (!isSsoCallbackInPopup()) router.replace(errorRedirect);
+                router.replace(errorRedirect);
             });
     }, [router, successRedirect, errorRedirect]);
 

package/src/presentation/components/auth/sso-sign-in.view.tsx

@@ -1,24 +1,34 @@
 "use client";
 
-import {useEffect} from "react";
-import {startSsoLogin} from "../../../infrastructure/utilities/sso-auth.util";
+import {useEffect, useRef} from "react";
+import {useSsoLogin} from "../../../infrastructure/hooks/use-sso-login";
 import {Activity} from "../activity";
 
 export interface SsoSignInViewProps {
+    /** Destination après une authentification réussie en mode popup. */
+    successRedirect?: string
     /** Destination si le SSO ne peut pas être démarré (popup/redirection bloquée). */
     fallbackRedirect?: string
 }
 
 /**
- * Écran de connexion SSO : redirige vers Liorian Auth (flux Authorization Code
- * + PKCE) dès le montage. Réutilisable par toutes les applications consommatrices.
+ * Écran de connexion SSO : lance le flux Liorian Auth (Authorization Code + PKCE)
+ * dès le montage, selon le mode configuré (`NEXT_PUBLIC_AUTH_SSO_MODE` :
+ * `redirect` par défaut, `popup` sur option). Réutilisable par toutes les
+ * applications consommatrices.
  */
-export function SsoSignInView({fallbackRedirect = '/auth/sign-up'}: SsoSignInViewProps) {
+export function SsoSignInView({successRedirect = '/', fallbackRedirect = '/auth/sign-up'}: SsoSignInViewProps) {
+    const {start} = useSsoLogin({
+        redirectUrl: successRedirect,
+        onError: () => window.location.assign(fallbackRedirect),
+    });
+    const started = useRef(false);
+
     useEffect(() => {
-        startSsoLogin().catch(() => {
-            window.location.assign(fallbackRedirect);
-        });
-    }, [fallbackRedirect]);
+        if (started.current) return;
+        started.current = true;
+        void start();
+    }, [start]);
 
     return (
         <div className="flex min-h-svh flex-col items-center justify-center gap-4 bg-background">
@@ -26,4 +36,4 @@ export function SsoSignInView({fallbackRedirect = '/auth/sign-up'}: SsoSignInVie
             <p className="text-sm text-muted-foreground">Connexion…</p>
         </div>
     );
-}
+}

package/src/presentation/components/auth-lock-screen.tsx

@@ -7,7 +7,7 @@ import {AppConfig} from "../../domain/config/app.config"
 import {AuthUserService} from "../../application/service/auth-user.service"
 import {AuthApiService, webauthnBytes} from "../../application/service/auth-api-service"
 import {ActivityLockService} from "../../infrastructure/utilities/activity-lock.service"
-import {startSsoLogin, startSsoLoginPopup, SSO_CALLBACK_MESSAGE} from "../../infrastructure/utilities/sso-auth.util"
+import {useSsoLogin} from "../../infrastructure/hooks/use-sso-login"
 import {Avatar, AvatarFallback} from "../ui/avatar"
 import {Button} from "../ui/button"
 import {Input} from "../ui/input"
@@ -49,7 +49,6 @@ export function AuthLockScreen(
         onUnlocked,
         actionLabel = 'Se connecter avec Liorian Auth',
     }: AuthLockScreenProps) {
-    const [connecting, setConnecting] = useState(false)
     const [user, setUser] = useState<UserInterface | null>(null)
     const [mode, setMode] = useState<'sso' | 'unlock'>(() => AuthUserService.isAuthenticated() ? 'unlock' : 'sso')
     const [password, setPassword] = useState('')
@@ -57,6 +56,11 @@ export function AuthLockScreen(
     const [unlocking, setUnlocking] = useState(false)
     const [error, setError] = useState<string | null>(null)
 
+    // Connexion SSO Liorian : déléguée au hook partagé (redirection par défaut,
+    // popup sur option). Le hook gère le repli, la fermeture du popup et la
+    // réception du résultat, puis déclenche `onAuthenticated` / la navigation.
+    const {connecting, start: startSsoLoginFlow} = useSsoLogin({redirectUrl, onAuthenticated})
+
     useEffect(() => {
         setUser(AuthUserService.getUser())
     }, [])
@@ -81,52 +85,8 @@ export function AuthLockScreen(
         return {name, avatarId, initials};
     }, [user]);
 
-    useEffect(() => {
-        const onMessage = (event: MessageEvent) => {
-            if (event.origin !== window.location.origin) return;
-            if (event.data?.source !== 'liorian-auth') return;
-            if (event.data?.type !== SSO_CALLBACK_MESSAGE) return;
-
-            if (event.data?.success) {
-                setConnecting(false);
-                onAuthenticated?.();
-                // La session a été installée dans le `localStorage` partagé : on force une
-                // navigation complète pour que `AuthProvider` ré-hydrate le store depuis le stockage.
-                if (redirectUrl) {
-                    window.location.assign(redirectUrl);
-                } else {
-                    window.location.reload();
-                }
-            } else {
-                setConnecting(false);
-            }
-        };
-        window.addEventListener('message', onMessage);
-        return () => window.removeEventListener('message', onMessage);
-    }, [redirectUrl, onAuthenticated]);
-
-    const handleAuthenticate = async () => {
-        if (connecting) return;
-        setConnecting(true);
-        try {
-            const popup = await startSsoLoginPopup();
-            if (!popup) {
-                await startSsoLogin();
-                return;
-            }
-
-            // Si le popup est fermé sans message de succès, réactiver le bouton.
-            const watchPopup = setInterval(() => {
-                if (popup.closed) {
-                    clearInterval(watchPopup);
-                    setConnecting(false);
-                }
-            }, 500);
-            window.addEventListener('beforeunload', () => clearInterval(watchPopup));
-        } catch (e) {
-            console.error('Impossible de démarrer l’authentification SSO', e);
-            setConnecting(false);
-        }
+    const handleAuthenticate = () => {
+        void startSsoLoginFlow();
     };
 
     const handleUnlockWithPassword = async (e: React.FormEvent<HTMLFormElement>) => {