@nodefony/security 10.0.0-beta.2 → 10.0.0-beta.3

package/dist/nodefony/src/token/JwtKeystore.js

@@ -1,4 +1,4 @@
-import { messageNonRestreint, modeNonRestreintAsync, readIfPresent, writeSecret } from "./secretFile.js";
+import { createSecretExclusive, messageNonRestreint, modeNonRestreintAsync, readIfPresent } from "./secretFile.js";
 import { join } from "node:path";
 //#region nodefony/src/token/JwtKeystore.ts
 /**
@@ -36,6 +36,58 @@ function keystoreLeaksIntoImage(dir) {
 	return `JWT keystore: « ${dir} » n'est PAS sous ${CLEANED_DIRS.map((d) => `\`${d}/\``).join(" ni ")}, les seuls dossiers que le Dockerfile généré efface avant de fabriquer l'image. La clé privée de signature partira donc dans ton image de conteneur, où elle reste lisible par quiconque la télécharge — même effacée par une couche suivante. Deux issues : déplacer le dossier sous \`var/\` (ex. \`var/keys\`), ou injecter la clé par jwt.keystore.keySetJson depuis l'environnement, ce qui est la voie de production.`;
 }
 /**
+* Lit un jeu de clés sérialisé et en vérifie la FORME — la seule lecture du
+* dépôt, appelée par le keystore ET par la validation de configuration.
+*
+* Ne vérifie que la structure (`keys` non vide, un `kid` par clé) : importer
+* les clés exige `jose`, chargé paresseusement au premier jeton. Les messages
+* ne recopient JAMAIS la valeur reçue — elle porte une clé privée.
+*
+* @param json - le jeu de clés, tel que `NF_JWT_KEYSET` ou `keyset.json` le porte.
+* @returns le jeu de clés lu.
+* @throws Error si le JSON est illisible ou la structure incomplète.
+*/
+function parseKeySet(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		throw new Error("JwtKeystore: keyset JSON invalide");
+	}
+	const keyset = parsed;
+	if (!keyset || !Array.isArray(keyset.keys) || keyset.keys.length === 0 || keyset.keys.some((k) => typeof k.kid !== "string")) throw new Error("JwtKeystore: keyset malformé (champ `keys` non vide avec `kid` requis)");
+	return keyset;
+}
+/** Génère une nouvelle paire Ed25519 (extractable pour persistance JWK). */
+async function buildKeySet(jose) {
+	const { publicKey, privateKey } = await jose.generateKeyPair("Ed25519", { extractable: true });
+	const publicJwk = await jose.exportJWK(publicKey);
+	const kid = await jose.calculateJwkThumbprint(publicJwk, "sha256");
+	return {
+		active: kid,
+		keys: [{
+			...await jose.exportJWK(privateKey),
+			kid,
+			alg: "EdDSA",
+			use: "sig",
+			createdAt: Date.now()
+		}]
+	};
+}
+/**
+* Génère un jeu de clés de signature à partager entre tous les process d'une
+* application — la valeur de `NF_JWT_KEYSET`.
+*
+* Même générateur que celui du keystore (une seule implémentation), sérialisé
+* en JSON COMPACT : une ligne, sans quote simple, qu'un `.env` porte entre
+* quotes simples et qu'un gestionnaire de secrets stocke tel quel.
+*
+* @returns le jeu de clés sérialisé — il contient la clé PRIVÉE.
+*/
+async function generateKeySet() {
+	return JSON.stringify(await buildKeySet(await import("jose")));
+}
+/**
 * Keystore Ed25519 — implémentation de référence d'{@link IJwtKeystore}.
 *
 * Résout la clé de signature selon une **priorité** (jamais d'auto-génération en
@@ -55,10 +107,15 @@ function keystoreLeaksIntoImage(dir) {
 * usage ; le boot ne paie rien si le JWT n'est jamais sollicité. Le chargement
 * est mémoïsé (une seule résolution concurrente).
 *
-* @remarks Race au 1ᵉʳ boot d'un **cluster** sans clé pré-provisionnée : deux
-* workers peuvent générer puis écrire des clés différentes (le dernier `rename`
-* gagne). En prod, provisionner la clé hors-bande (`keySetJson`/SecretProvider
-* P16) élimine ce cas — c'est précisément la source recommandée.
+* @remarks Plusieurs process qui servent la MÊME application doivent signer
+* avec la même clé, sinon un jeton signé par l'un est refusé par l'autre :
+* - **pods** (aucun disque partagé) → source `env` obligatoire, la même valeur
+*   injectée partout (`NF_JWT_KEYSET`, générée par `security:secrets`) ;
+* - **workers de `nodefony cluster`** → la source `env` est héritée au fork ; à
+*   défaut, la source `fichier` est sûre : la création de `keyset.json` est
+*   EXCLUSIVE ({@link createSecretExclusive}), un seul worker la génère et les
+*   autres relisent la sienne ;
+* - source `mémoire` → une clé par process, jamais cohérente.
 */
 var JwtKeystore = class {
 	#source;
@@ -91,7 +148,7 @@ var JwtKeystore = class {
 	async #load() {
 		const jose = await import("jose");
 		if (this.#source.keySetJson) {
-			await this.#importKeyset(jose, this.#parseKeyset(this.#source.keySetJson));
+			await this.#importKeyset(jose, parseKeySet(this.#source.keySetJson));
 			return;
 		}
 		if (this.#source.dir) {
@@ -101,32 +158,24 @@ var JwtKeystore = class {
 			const existing = await this.#readFile(file);
 			if (existing) {
 				await this.#checkRestricted(file);
-				await this.#importKeyset(jose, this.#parseKeyset(existing));
+				await this.#importKeyset(jose, parseKeySet(existing));
 				return;
 			}
-			const keyset = await this.#generate(jose);
-			await this.#writeAtomic(file, JSON.stringify(keyset));
-			await this.#importKeyset(jose, keyset);
+			const keyset = await buildKeySet(jose);
+			if (await createSecretExclusive(file, JSON.stringify(keyset))) {
+				this.#log(`JWT keystore: clé Ed25519 générée et persistée (${file}).`, "INFO");
+				await this.#checkRestricted(file);
+				await this.#importKeyset(jose, keyset);
+				return;
+			}
+			const winner = await this.#readFile(file);
+			if (winner === null) throw new Error(`JwtKeystore: ${file} a disparu juste après sa création`);
+			await this.#checkRestricted(file);
+			await this.#importKeyset(jose, parseKeySet(winner));
 			return;
 		}
-		this.#log("JWT keystore: clé de signature ÉPHÉMÈRE en mémoire (perdue au redémarrage → refresh tokens invalidés, incohérente en cluster). Configurez jwt.keystore.dir (dev/VPS) ou jwt.keystore.keySetJson depuis l'env (prod).", "WARNING");
-		await this.#importKeyset(jose, await this.#generate(jose));
-	}
-	/** Génère une nouvelle paire Ed25519 (extractable pour persistance JWK). */
-	async #generate(jose) {
-		const { publicKey, privateKey } = await jose.generateKeyPair("Ed25519", { extractable: true });
-		const publicJwk = await jose.exportJWK(publicKey);
-		const kid = await jose.calculateJwkThumbprint(publicJwk, "sha256");
-		return {
-			active: kid,
-			keys: [{
-				...await jose.exportJWK(privateKey),
-				kid,
-				alg: "EdDSA",
-				use: "sig",
-				createdAt: Date.now()
-			}]
-		};
+		this.#log("JWT keystore: clé de signature ÉPHÉMÈRE en mémoire — perdue au redémarrage (jetons en vol invalidés) et propre à CE process : derrière plusieurs pods ou workers, un jeton signé par l'un est refusé par l'autre (401 au hasard). Production : poser jwt.keystore.keySetJson depuis l'environnement (NF_JWT_KEYSET dans une application générée — `npx nodefony security:secrets --jwt-keyset`). Développement : jwt.keystore.dir.", "WARNING");
+		await this.#importKeyset(jose, await buildKeySet(jose));
 	}
 	/** Importe un keyset persisté : privée → `CryptoKey`, public → JWK sans `d`. */
 	async #importKeyset(jose, keyset) {
@@ -153,27 +202,10 @@ var JwtKeystore = class {
 		this.#keys = loaded;
 		this.#activeKid = keyset.active && loaded.some((k) => k.kid === keyset.active) ? keyset.active : firstKey.kid;
 	}
-	#parseKeyset(json) {
-		let parsed;
-		try {
-			parsed = JSON.parse(json);
-		} catch {
-			throw new Error("JwtKeystore: keyset JSON invalide");
-		}
-		const keyset = parsed;
-		if (!keyset || !Array.isArray(keyset.keys) || keyset.keys.length === 0 || keyset.keys.some((k) => typeof k.kid !== "string")) throw new Error("JwtKeystore: keyset malformé (champ `keys` non vide avec `kid` requis)");
-		return keyset;
-	}
 	/** Lit un fichier ; `null` si absent (ENOENT), relance toute autre erreur. */
 	async #readFile(file) {
 		return readIfPresent(file);
 	}
-	/** Écriture atomique (tmp + rename) en mode 600 — pas de fichier partiel lu. */
-	async #writeAtomic(file, data) {
-		await writeSecret(file, data);
-		this.#log(`JWT keystore: clé Ed25519 générée et persistée (${file}).`, "INFO");
-		await this.#checkRestricted(file);
-	}
 	/**
 	* Constate le mode EFFECTIF du fichier de clés et avertit s'il n'est pas 0600.
 	*
@@ -194,4 +226,4 @@ var JwtKeystore = class {
 	}
 };
 //#endregion
-export { JwtKeystore, JwtKeystore as default, keystoreLeaksIntoImage };
+export { JwtKeystore, JwtKeystore as default, generateKeySet, keystoreLeaksIntoImage, parseKeySet };

package/dist/nodefony/src/token/RemoteJwtVerifier.js

@@ -1,4 +1,4 @@
-import { canonicalIssuer, extractScopes, issuerMetadataUrls, validateIssuerMetadata } from "nodefony";
+import { canonicalIssuer, extractScopes, metadataCandidateUrls, parseDiscoveryUrl, validateIssuerMetadata } from "nodefony";
 //#region nodefony/src/token/RemoteJwtVerifier.ts
 /**
 * Codes d'erreur `jose` qui désignent un **jeton fautif** — la liste est
@@ -65,8 +65,8 @@ var RemoteJwtVerifier = class {
 	#jose = null;
 	/**
 	* @param options - émetteurs de confiance et réglages réseau
-	* @throws Error si un émetteur est invalide, dupliqué, ou déclare un
-	*         algorithme à secret partagé
+	* @throws Error si un émetteur est invalide, dupliqué, déclare un
+	*         algorithme à secret partagé ou une `discoveryUrl` invalide
 	*/
 	constructor(options) {
 		this.#options = options;
@@ -75,6 +75,7 @@ var RemoteJwtVerifier = class {
 			const issuer = canonicalIssuer(trusted.issuer);
 			if (this.#issuers.has(issuer)) throw new Error(`émetteur « ${issuer} » déclaré deux fois — deux politiques pour un même émetteur ne peuvent pas coexister : la seconde serait ignorée en silence.`);
 			assertAsymmetric(issuer, trusted.algorithms);
+			if (trusted.discoveryUrl !== void 0) parseDiscoveryUrl(trusted.discoveryUrl);
 			this.#issuers.set(issuer, {
 				...trusted,
 				issuer
@@ -101,6 +102,36 @@ var RemoteJwtVerifier = class {
 	*         « jeton invalide »
 	*/
 	async verify(token, audience) {
+		const verified = await this.verifyClaims(token, audience);
+		if (verified === null) return null;
+		const { issuer, payload } = verified;
+		return {
+			issuer,
+			subject: typeof payload.sub === "string" ? payload.sub : void 0,
+			scopes: extractScopes(payload),
+			expiresAt: typeof payload.exp === "number" ? payload.exp : void 0,
+			issuedAt: typeof payload.iat === "number" ? payload.iat : void 0,
+			tokenId: typeof payload.jti === "string" ? payload.jti : void 0,
+			claims: payload
+		};
+	}
+	/**
+	* Vérifie un jeton et rend ses claims BRUTS — pour un jeton qui n'est pas un
+	* jeton d'accès (jeton de déconnexion OpenID Connect, par exemple), dont le
+	* sens se lit dans des claims que {@link verify} ne remonte pas.
+	*
+	* Mêmes garanties et même contrat d'erreur que {@link verify} : signature,
+	* émetteur de la liste fermée, algorithme imposé, audience obligatoire,
+	* claims exigés par l'émetteur ; un refus est un `null`, une panne lève.
+	*
+	* @param token - le jeton brut, tel que présenté
+	* @param audience - audience que le jeton DOIT porter dans `aud`
+	* @returns l'émetteur canonique et les claims vérifiés, ou `null` si le jeton
+	*          est refusé
+	* @throws Error si l'émetteur ne peut pas être joint ou publie un jeu de clés
+	*         inutilisable
+	*/
+	async verifyClaims(token, audience) {
 		if (typeof token !== "string" || token.length === 0) return null;
 		const jose = this.#jose ??= await import("jose");
 		let claimedIssuer;
@@ -126,14 +157,9 @@ var RemoteJwtVerifier = class {
 				...trusted.typ ? { typ: trusted.typ } : {},
 				...trusted.requiredClaims?.length ? { requiredClaims: [...trusted.requiredClaims] } : {}
 			});
-			const subject = typeof payload.sub === "string" ? payload.sub : void 0;
 			return {
 				issuer: claimedIssuer,
-				subject,
-				scopes: extractScopes(payload),
-				expiresAt: typeof payload.exp === "number" ? payload.exp : void 0,
-				issuedAt: typeof payload.iat === "number" ? payload.iat : void 0,
-				tokenId: typeof payload.jti === "string" ? payload.jti : void 0
+				payload
 			};
 		} catch (error) {
 			const code = error.code;
@@ -167,7 +193,7 @@ var RemoteJwtVerifier = class {
 			trusted,
 			getKey: jose.createLocalJWKSet(await trusted.localJwks())
 		};
-		const jwksUri = trusted.jwksUri ?? await this.#discover(trusted.issuer);
+		const jwksUri = trusted.jwksUri ?? await this.#discover(trusted);
 		const options = {
 			timeoutDuration: this.#options.timeoutMs ?? 5e3,
 			cooldownDuration: this.#options.cooldownMs ?? 3e4,
@@ -188,11 +214,12 @@ var RemoteJwtVerifier = class {
 	* « meilleure réponse que rien » : il est écarté comme s'il n'avait pas
 	* répondu, et la recherche continue.
 	*/
-	async #discover(issuer) {
+	async #discover(trusted) {
+		const { issuer, discoveryUrl } = trusted;
 		const doFetch = this.#options.fetch ?? globalThis.fetch;
 		const timeout = this.#options.timeoutMs ?? 5e3;
 		const failures = [];
-		for (const url of issuerMetadataUrls(issuer)) try {
+		for (const url of metadataCandidateUrls(issuer, discoveryUrl)) try {
 			const response = await doFetch(url, {
 				signal: AbortSignal.timeout(timeout),
 				redirect: "manual",
@@ -202,7 +229,7 @@ var RemoteJwtVerifier = class {
 				failures.push(`${url} → HTTP ${response.status}`);
 				continue;
 			}
-			const metadata = validateIssuerMetadata(await response.json(), issuer);
+			const metadata = validateIssuerMetadata(await response.json(), issuer, discoveryUrl);
 			this.#audit(`émetteur « ${issuer} » découvert : clés sur ${metadata.jwksUri}.`);
 			return metadata.jwksUri;
 		} catch (error) {

package/dist/nodefony/src/token/secretFile.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { link, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import process from "node:process";
 //#region nodefony/src/token/secretFile.ts
 /**
@@ -113,6 +114,62 @@ async function writeSecret(file, content) {
 		throw e;
 	}
 }
+/**
+* Codes d'un système de fichiers qui ne sait pas poser de lien dur (FAT, exFAT,
+* certains montages réseau) — et non d'une cible déjà présente.
+*/
+const NO_HARD_LINK = /* @__PURE__ */ new Set([
+	"EPERM",
+	"ENOTSUP",
+	"ENOSYS",
+	"EOPNOTSUPP"
+]);
+/**
+* Crée un secret SEULEMENT s'il n'existe pas encore : 0600, atomique, et un
+* seul gagnant quand plusieurs process le tentent en même temps.
+*
+* ⭐ **Pourquoi pas {@link writeSecret}.** `rename` REMPLACE la cible : deux
+* workers de `nodefony cluster` qui génèrent chacun une clé au premier boot
+* l'écrivent tous les deux, le dernier gagne sur le disque — et l'autre garde
+* en mémoire une clé que plus personne ne connaît. Ici, le temporaire est
+* publié par un LIEN DUR, que le système refuse (`EEXIST`) si le nom existe :
+* le perdant le sait, et relit la clé du gagnant. Le lecteur ne voit jamais un
+* fichier à demi écrit, puisque le lien n'apparaît qu'une fois le contenu complet.
+*
+* ⚠️ Un système de fichiers sans liens durs (FAT, exFAT) retombe sur une
+* création exclusive directe (`wx`) : toujours un seul gagnant, mais un lecteur
+* concurrent peut lire le fichier pendant son écriture — il lève alors, au lieu
+* de signer avec une clé divergente.
+*
+* @param file - chemin du secret.
+* @param content - contenu à écrire.
+* @returns `true` si ce process l'a créé, `false` s'il existait déjà.
+*/
+async function createSecretExclusive(file, content) {
+	await mkdir(path.dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	await writeFile(tmp, content, { mode: 384 });
+	try {
+		await link(tmp, file);
+		return true;
+	} catch (e) {
+		const code = e.code ?? "";
+		if (code === "EEXIST") return false;
+		if (!NO_HARD_LINK.has(code)) throw e;
+		try {
+			await writeFile(file, content, {
+				mode: 384,
+				flag: "wx"
+			});
+			return true;
+		} catch (fallback) {
+			if (fallback.code === "EEXIST") return false;
+			throw fallback;
+		}
+	} finally {
+		await rm(tmp, { force: true }).catch(() => {});
+	}
+}
 /** Forme synchrone de {@link writeSecret}. */
 function writeSecretSync(file, content) {
 	mkdirSync(path.dirname(file), { recursive: true });
@@ -131,4 +188,4 @@ function writeSecretSync(file, content) {
 	} catch {}
 }
 //#endregion
-export { MODE_SECRET, messageNonRestreint, modeNonRestreint, modeNonRestreintAsync, readIfPresent, readIfPresentSync, writeSecret, writeSecretSync };
+export { MODE_SECRET, createSecretExclusive, messageNonRestreint, modeNonRestreint, modeNonRestreintAsync, readIfPresent, readIfPresentSync, writeSecret, writeSecretSync };

package/dist/nodefony/src/transport/CredentialTransportPolicy.js

@@ -0,0 +1,51 @@
+import { InsecureTransportError } from "../../errors/InsecureTransportError.js";
+//#region nodefony/src/transport/CredentialTransportPolicy.ts
+/**
+* Dit si un secret de connexion se refuse : en production, sans échappement
+* explicite. Seule source de la décision — le firewall la compose au boot.
+*
+* @param environment - environnement normalisé du kernel.
+* @param allowInsecureCredentials - échappement `security.allowInsecureCredentials`.
+*/
+function shouldEnforceCredentialTransport(environment, allowInsecureCredentials) {
+	return environment === "production" && !allowInsecureCredentials;
+}
+/**
+* Refuse, avant toute vérification, un mot de passe ou un code de second
+* facteur reçu en clair. Une instance partagée au conteneur (`credentialTransport`)
+* sert TOUTES les portes qui reçoivent un secret : formulaire de session, second
+* facteur, Basic, émission de jeton — une porte oubliée serait le canal clair.
+*
+* La décision se prend sur le scheme EFFECTIF (`context.scheme`) : derrière un
+* proxy qui termine TLS et déclaré de confiance, il vaut `https` alors que le
+* pod écoute en HTTP. C'est le cas de la plupart des déploiements ; c'est donc
+* `trustProxy` que nomme le journal, pas « passez en HTTPS ».
+*/
+var CredentialTransportPolicy = class {
+	enforce;
+	#log;
+	#warned = false;
+	constructor(options) {
+		this.enforce = options.enforce;
+		this.#log = options.log ?? null;
+	}
+	/**
+	* Laisse passer un secret reçu sur TLS, ou n'importe lequel hors production.
+	*
+	* @param context - contexte de la requête qui porte le secret.
+	* @param door - porte qui le reçoit, nommée dans le journal.
+	* @throws InsecureTransportError (403) — secret reçu en clair en production.
+	*/
+	assert(context, door) {
+		if (!this.enforce) return;
+		const scheme = context.scheme;
+		if (scheme === "https" || scheme === "wss") return;
+		if (!this.#warned && this.#log !== null) {
+			this.#warned = true;
+			this.#log(`Secret de connexion REFUSÉ (${door}) : la requête est arrivée en ${scheme ?? "scheme inconnu"} en production. Derrière un proxy qui termine TLS, déclarez-le de confiance (\`trustProxy\`, config @nodefony/http) pour que \`X-Forwarded-Proto\` soit lu ; sinon servez l'application en HTTPS. Échappement explicite : \`security.allowInsecureCredentials\`. Les refus suivants ne sont plus journalisés ici (voir l'audit).`);
+		}
+		throw new InsecureTransportError();
+	}
+};
+//#endregion
+export { CredentialTransportPolicy, shouldEnforceCredentialTransport };

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ import ApiKeyService from "./nodefony/service/apiKeys.js";
 import AuditService from "./nodefony/service/auditService.js";
 import TotpService from "./nodefony/service/totp.js";
 import WebhookService from "./nodefony/service/webhooks.js";
+import KeycloakService from "./nodefony/service/keycloak.js";
 import type { ISecurityConfigInput } from "./nodefony/config/defineModuleConfig.js";
 declare module "nodefony" {
     interface NodefonyModuleConfig {
@@ -25,7 +26,7 @@ declare module "nodefony" {
  * + Zod validée au boot (fail-closed si invalide). Consomme `@nodefony/user`
  * (IUser/IUserProvider/IPasswordVerifier) — jamais l'inverse.
  *
- * Livré : firewall (zones, mode first|all, challenge RFC 7235), authenticators
+ * Livré : firewall (zones, mode first|all, challenge RFC 9110 §11), authenticators
  * `anonymous`/`userpassword` (Basic RFC 7617)/`session` (BFF, J3), flux
  * login/logout/me (`AuthFlow`, anti-fixation + throttling partagé).
  * Jwt/oauth2/mtls/apikey, CORS, CSRF, autorisation par décorateurs et data
@@ -48,6 +49,14 @@ declare class Security extends Module {
      * No-op si le broker est absent (Studio non chargé) ou déjà enregistré.
      */
     onKernelBoot(): Promise<this>;
+    /**
+     * Déclare au bilan de démarrage les routes métier laissées PUBLIQUES.
+     *
+     * `onReady` et pas `onBoot` : les zones sont compilées par le pare-feu à son
+     * propre `onBoot`, posé APRÈS celui du module — à `onBoot` la liste est encore
+     * vide. `onReady` précède l'écriture du bilan (`var/last-boot.json`).
+     */
+    onKernelReady(): Promise<this>;
 }
 export default Security;
 export { Firewall };
@@ -63,8 +72,11 @@ export { OAuth2Service };
 export { AuditService };
 export { TotpService };
 export { WebhookService };
+export { KeycloakService };
+export type { IKeycloakRealmPlan, IKeycloakRealmRequest, } from "./nodefony/service/keycloak.js";
 export type { IWebhookRegisterInput, IWebhookSecretReveal, IWebhookDeliveryPolicy, } from "./nodefony/service/webhooks.js";
 export type { ISafeUser, ILoginOutcome } from "./nodefony/service/authFlow.js";
+export { amrForFactor } from "./nodefony/src/sessionAuthentication.js";
 export type { ITokenResponse } from "./nodefony/service/tokenService.js";
 export type { IApiKeyView, IApiKeyCreated, IApiKeyCapabilities, ICreateApiKeyOptions, } from "./nodefony/contracts/IApiKey.js";
 export { ApiKeyError } from "./nodefony/errors/ApiKeyError.js";
@@ -114,14 +126,20 @@ export type { IWebAuthnUser, IWebAuthnAssertionResult, } from "./nodefony/servic
 export type { IWebAuthnCredential } from "./nodefony/contracts/IWebAuthnCredential.js";
 export type { IWebAuthnCredentialStore, IWebAuthnCredentialSummary, IWebAuthnListQuery, WebAuthnAuthUpdate, } from "./nodefony/contracts/IWebAuthnCredentialStore.js";
 export type { IOAuthAuthorization } from "./nodefony/service/oauth2.js";
-export type { IOAuthProvider, IIssuerPolicy, } from "./nodefony/contracts/IOAuthProvider.js";
-export { registerOAuthProvider, getOAuthProviderFactory, listOAuthProviders, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
-export type { OAuthProviderFactory, IOAuthProviderContext, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+export type { IOAuthProvider, IIssuerPolicy, ILogoutRequest, ILogoutTokenClaims, } from "./nodefony/contracts/IOAuthProvider.js";
+export { registerOAuthProvider, getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+export type { OAuthProviderFactory, IOAuthProviderContext, IOAuthProviderRegistration, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
 export { OAuth2Client, OAuth2Tokens, OAuth2RequestError, generateState, generateCodeVerifier, createCodeChallenge, } from "./nodefony/src/oauth/oauth2Client.js";
 export type { IOAuth2ClientOptions } from "./nodefony/src/oauth/oauth2Client.js";
 export { discoverAuthorizationServer } from "./nodefony/src/oauth/metadata.js";
+export { requestClientCredentialsToken } from "./nodefony/src/oauth/clientCredentials.js";
+export type { IClientCredentialsRequest } from "./nodefony/src/oauth/clientCredentials.js";
+export { diagnoseOAuthProvider } from "./nodefony/src/oauth/providerDiagnosis.js";
+export type { IOAuthDiagnosis, IOAuthDiagnosisInput, IOAuthCheck, OAuthCheckName, OAuthCheckStatus, OAuthFailureKind, } from "./nodefony/src/oauth/providerDiagnosis.js";
+export { KeycloakAdminClient, KeycloakAdminError, keycloakAdminTarget, keycloakLoginThemeCheck, readKeycloakLoginTheme, } from "./nodefony/keycloak/keycloakAdmin.js";
+export type { IKeycloakAdminClientOptions, IKeycloakAdminCredentials, IKeycloakAdminTarget, IKeycloakLoginThemeResult, KeycloakLoginThemeOutcome, } from "./nodefony/keycloak/keycloakAdmin.js";
 export type { IDiscoveredAuthorizationServer, IDiscoveryOptions, } from "./nodefony/src/oauth/metadata.js";
-export { createOidcProvider, createDiscoveredOidcProvider, } from "./nodefony/src/oauth/providers/oidc.js";
+export { createOidcProvider, createDiscoveredOidcProvider, readLogoutTokenClaims, } from "./nodefony/src/oauth/providers/oidc.js";
 export type { IOidcPkceClient, IOidcProviderOptions, } from "./nodefony/src/oauth/providers/oidc.js";
 export { createGithubProvider } from "./nodefony/src/oauth/providers/github.js";
 export { MemoryAuditStore } from "./nodefony/src/audit/MemoryAuditStore.js";
@@ -159,6 +177,8 @@ export { defineSecurityConfig, securityConfigJsonSchema, } from "./nodefony/conf
 export type { ISecurityConfig, ISecurityConfigInput, ISecurityAreaConfig, } from "./nodefony/config/defineModuleConfig.js";
 export { LoginThrottler } from "./nodefony/src/throttle/LoginThrottler.js";
 export type { ILoginThrottleOptions } from "./nodefony/src/throttle/LoginThrottler.js";
-export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, } from "./nodefony/errors/index.js";
+export { CredentialTransportPolicy, shouldEnforceCredentialTransport, } from "./nodefony/src/transport/CredentialTransportPolicy.js";
+export type { ICredentialTransportContext, ICredentialTransportPolicyOptions, } from "./nodefony/src/transport/CredentialTransportPolicy.js";
+export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, InsecureTransportError, } from "./nodefony/errors/index.js";
 export { VoterVote } from "./nodefony/contracts/index.js";
 export type { IToken, IAuthenticator, ISecuredArea, IFirewall, IAccessVoter, IAuthorizationService, IAccessTokenRecord, ITokenStore, ITokenListQuery, ITokenUsage, IResourcePermission, TokenRevokeReason, TokenStatus, IJwtKeystore, IJwtSigningKey, } from "./nodefony/contracts/index.js";

package/dist/types/nodefony/command/security-oauth-doctor.d.ts

@@ -0,0 +1,23 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * `nodefony security:oauth:doctor` — dit POURQUOI un fournisseur OAuth refuse
+ * l'application, sans qu'un humain ait à se connecter.
+ *
+ * Trois verdicts distincts là où le journal ne montre qu'un 401 : l'émetteur
+ * se déclare autrement que la configuration ne l'écrit, l'URL de retour n'est
+ * pas enregistrée, le secret est faux. La même analyse alimente
+ * `nodefony doctor --live` (famille « Fournisseurs OAuth ») et l'endpoint
+ * d'administration `security/oauth/diagnosis` : une seule implémentation, celle
+ * du service `oauth2`.
+ *
+ * Valable pour tout fournisseur : les sondes passent par le fournisseur que le
+ * login construit, Keycloak n'y a rien de particulier.
+ */
+declare class SecurityOAuthDoctor extends Command {
+    constructor(cli: CliKernel);
+    generate(opts: {
+        provider?: string;
+        json?: boolean;
+    }): Promise<this>;
+}
+export default SecurityOAuthDoctor;

package/dist/types/nodefony/command/security-secrets.d.ts

@@ -19,6 +19,8 @@ declare class SecuritySecrets extends Command {
     generate(opts: {
         json?: boolean;
         write?: boolean;
+        jwtKeyset?: boolean;
+        env?: boolean;
     }): Promise<this>;
 }
 export default SecuritySecrets;

package/dist/types/nodefony/command/security-token.d.ts

@@ -10,6 +10,15 @@ import { CliKernel, Command } from "nodefony";
  * @returns les secondes, `undefined` si rien n'est demandé, une `Error` sinon
  */
 export declare function ttlSeconds(raw: string | undefined): number | undefined | Error;
+/**
+ * Durée demandée à l'émetteur : `--ttl` explicite, sinon 8 h quand le jeton
+ * part chez les agents, sinon rien — la configuration décide.
+ *
+ * @param raw - la valeur de `--ttl` telle que tapée, ou rien
+ * @param write - le jeton sera posé dans la configuration des agents
+ * @returns les secondes, `undefined` pour le défaut de configuration, une `Error` sinon
+ */
+export declare function tokenTtlSeconds(raw: string | undefined, write: boolean): number | undefined | Error;
 /**
  * `nodefony security:token` — émet un jeton d'accès pour une porte de cette
  * application (la porte MCP par défaut).

package/dist/types/nodefony/command/security-user-delete.d.ts

@@ -12,9 +12,10 @@ import { CliKernel, Command } from "nodefony";
  * seul recours est une écriture directe en base. Le même garde-fou existe côté
  * data plane (`UserAdminApi`) — ici il est constaté, pas supposé.
  *
- * La révocation des sessions et jetons du compte suit d'elle-même : la
- * suppression émet `onUserRevoked`, auquel `@nodefony/security` réagit en
- * éjectant sessions et jetons. Rien à faire de plus ici.
+ * La suppression passe par `users.delete`, qui émet `onUserRevoked`
+ * (`reason: "deleted"`) et ATTEND la cascade de `@nodefony/security` : sessions
+ * et jetons éjectés, secret TOTP et passkeys retirés. La commande n'émet rien
+ * elle-même — le service est le seul émetteur du cycle de vie d'un compte.
  */
 declare class SecurityUserDelete extends Command {
     constructor(cli: CliKernel);

package/dist/types/nodefony/command/security-user-password.d.ts

@@ -20,10 +20,10 @@ import { CliKernel, Command } from "nodefony";
  *
  * 🔒 **Les sessions et les jetons du compte sont RÉVOQUÉS**, et ce n'est pas une
  * option : on change un mot de passe parce qu'il est compromis ou perdu, et
- * laisser vivre les sessions ouvertes laisserait l'accès à qui l'a volé. La
- * révocation passe par l'événement que la suppression emploie déjà — une
- * cascade, un seul canal, et les abonnés futurs (webhooks) en profitent sans
- * rien changer ici.
+ * laisser vivre les sessions ouvertes laisserait l'accès à qui l'a volé.
+ * `UserService.changePassword` émet la révocation lui-même — la même que pour
+ * le plan d'administration et la page « mon mot de passe » : un seul émetteur,
+ * aucun transport ne peut l'oublier.
  */
 declare class SecurityUserPassword extends Command {
     constructor(cli: CliKernel);