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

package/README.md

@@ -25,7 +25,7 @@ Consomme [`@nodefony/user`](https://www.npmjs.com/package/@nodefony/user).
   (cookie opaque BFF, révocable, `HttpOnly; Secure; SameSite`) ; les **API/agents** portent leur
   preuve à chaque requête (**JWT** signé / clé API). Jamais « full stateless » : la session reste
   la fondation web (révocation immédiate), le JWT est réservé au sans-état machine-à-machine.
-- **Config type-safe** : schéma **Zod** (18 sections, tout `enabled`), **introspectable** (Studio
+- **Config type-safe** : schéma **Zod** (19 sections, la plupart désactivables par `enabled`), **introspectable** (Studio
   génère son formulaire d'édition). L'app configure via `use("@nodefony/security", { … })`.
 - **En-têtes natifs** (sans la lib `helmet`) — 0 dépendance, nonce CSP par requête.
 
@@ -67,7 +67,8 @@ export default defineConfig((ctx) => ({
 
 > Une zone se déclare idéalement **par module** (override `module-security`, dans la config du
 > module) pour vivre au plus près de ses routes. Authenticators fournis : `anonymous`, `session`,
-> `userpassword`, `jwt`, `apikey`, `webauthn`, plus les providers OAuth2. La chaîne est validée
+> `userpassword`, `jwt`, `external-jwt`, `apikey`. WebAuthn, OAuth2 et TOTP n'en sont pas : ils
+> ouvrent une session BFF, que l'authenticator `session` identifie ensuite. La chaîne est validée
 > au boot (`mode: "first"` par défaut = le premier qui reconnaît authentifie ; `"all"` = tous
 > requis, ex. mTLS + JWT). Config invalide → firewall **fail-closed** (tout rejeté).
 
@@ -117,7 +118,7 @@ csrf: {
 > ouvrir la lecture CORS des réponses au JavaScript tiers. Une origine listée dans `cors.origins` est
 > toutefois aussi acceptée (ce que CORS autorise explicitement n'est pas du CSRF).
 
-Le token synchronizer renforcé (`@CsrfProtect` / `@CsrfExempt`) arrive à l'étape suivante.
+Le token synchronizer renforcé s'active par route avec `@CsrfProtect` ; `@CsrfExempt` en exclut une route.
 
 ### CORS — l'inverse du CSRF
 
@@ -141,8 +142,9 @@ const schema = securityConfigJsonSchema(); // JSON Schema → formulaire d'édit
 ## Journal d'audit (événements de sécurité)
 
 Le journal trace les **transitions d'état** de sécurité (login, refus, jeton émis/révoqué, verrou
-WS) — distinct du log de trafic (1 PDU/requête). Émission **explicite** par point sensible ; le
-**chemin de succès reste muet** (le volume n'est pas un signal), seul l'échec/refus émet (cold-path)
+WS) — distinct du log de trafic (1 PDU/requête). Émission **explicite** par point sensible, sur les
+chemins froids (login, logout, émission ou révocation de jeton, refus) ; jamais par requête nominale :
+le trafic courant ne passe pas par l'audit (cold-path)
 → aucun coût ajouté au hot-path nominal. Activé par défaut (`audit.enabled`, OWASP A09), coût nul si
 désactivé. Lecture : `GET /nodefony/security/api/audit/events` (RBAC `ROLE_NODEFONY_ADMIN`).
 

package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.153.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.153.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/index.js

@@ -1,6 +1,9 @@
+import { JwtKeystore } from "./nodefony/src/token/JwtKeystore.js";
 import config from "./nodefony/config/config.js";
 import { SecuredArea } from "./nodefony/src/SecuredArea.js";
 import { LoginThrottler } from "./nodefony/src/throttle/LoginThrottler.js";
+import { InsecureTransportError } from "./nodefony/errors/InsecureTransportError.js";
+import { CredentialTransportPolicy, shouldEnforceCredentialTransport } from "./nodefony/src/transport/CredentialTransportPolicy.js";
 import { RoleHierarchyWalker } from "./nodefony/src/RoleHierarchyWalker.js";
 import { CsrfTokenManager } from "./nodefony/src/csrfToken.js";
 import { CsrfError } from "./nodefony/errors/CsrfError.js";
@@ -26,13 +29,13 @@ import { getAuthenticatorFactory, listAuthenticatorFactories, registerAuthentica
 import { recordAudit } from "./nodefony/src/audit/recordAudit.js";
 import { readAuditContext } from "./nodefony/src/audit/readAuditContext.js";
 import { Firewall } from "./nodefony/service/firewall.js";
+import { amrForFactor } from "./nodefony/src/sessionAuthentication.js";
 import { AuthFlow } from "./nodefony/service/authFlow.js";
 import { InvalidTargetError } from "./nodefony/errors/InvalidTargetError.js";
 import { TOKEN_DEFAULT_ORDER, TOKEN_SORTABLE_FIELDS } from "./nodefony/src/token/tokenSort.js";
 import { matchesTokenStatus, tokenStatusOf } from "./nodefony/src/token/tokenStatus.js";
 import { MemoryTokenStore } from "./nodefony/src/token/MemoryTokenStore.js";
 import { getTokenStoreFactory, listTokenStores, registerTokenStore } from "./nodefony/src/token/tokenStoreRegistry.js";
-import { JwtKeystore } from "./nodefony/src/token/JwtKeystore.js";
 import { TokenService } from "./nodefony/service/tokenService.js";
 import { RemoteJwtVerifier } from "./nodefony/src/token/RemoteJwtVerifier.js";
 import { AccessTokenVerifierService } from "./nodefony/service/accessTokenVerifier.js";
@@ -44,11 +47,13 @@ import { Authorization } from "./nodefony/service/authorization.js";
 import { MemoryWebAuthnCredentialStore } from "./nodefony/src/webauthn/MemoryWebAuthnCredentialStore.js";
 import { getWebAuthnStoreFactory, listWebAuthnStores, registerWebAuthnStore } from "./nodefony/src/webauthn/webAuthnCredentialStoreRegistry.js";
 import { WebAuthnService } from "./nodefony/service/webAuthn.js";
+import { KeycloakAdminClient, KeycloakAdminError, keycloakAdminTarget, keycloakLoginThemeCheck, readKeycloakLoginTheme } from "./nodefony/keycloak/keycloakAdmin.js";
 import { OAuth2Client, OAuth2RequestError, OAuth2Tokens, createCodeChallenge, generateCodeVerifier, generateState } from "./nodefony/src/oauth/oauth2Client.js";
 import { discoverAuthorizationServer } from "./nodefony/src/oauth/metadata.js";
-import { createDiscoveredOidcProvider, createOidcProvider } from "./nodefony/src/oauth/providers/oidc.js";
+import { createDiscoveredOidcProvider, createOidcProvider, readLogoutTokenClaims } from "./nodefony/src/oauth/providers/oidc.js";
 import { createGithubProvider } from "./nodefony/src/oauth/providers/github.js";
-import { getOAuthProviderFactory, listOAuthProviders, registerOAuthProvider } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+import { getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer, registerOAuthProvider } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+import { diagnoseOAuthProvider } from "./nodefony/src/oauth/providerDiagnosis.js";
 import { OAuth2Service } from "./nodefony/service/oauth2.js";
 import { TOKEN_FACETS } from "./nodefony/src/token/tokenFilters.js";
 import { ApiKeyError } from "./nodefony/errors/ApiKeyError.js";
@@ -69,17 +74,22 @@ import { getWebhookStoreFactory, listWebhookStores, registerWebhookStore } from
 import { SsrfError } from "./nodefony/errors/SsrfError.js";
 import { assertPublicUrl, isBlockedAddress } from "./nodefony/src/net/ssrfGuard.js";
 import { WebhookService } from "./nodefony/service/webhooks.js";
+import { KeycloakService } from "./nodefony/service/keycloak.js";
 import SecuritySecrets from "./nodefony/command/security-secrets.js";
 import SecurityUserAdd from "./nodefony/command/security-user-add.js";
 import SecurityUserList from "./nodefony/command/security-user-list.js";
 import SecurityUserDelete from "./nodefony/command/security-user-delete.js";
 import SecurityUserPassword from "./nodefony/command/security-user-password.js";
+import { publicRoutesNotice } from "./nodefony/src/boot/publicRoutesNotice.js";
 import SecurityToken from "./nodefony/command/security-token.js";
+import SecurityKeycloakRealm from "./nodefony/keycloak/security-keycloak-realm.js";
+import SecurityOAuthDoctor from "./nodefony/command/security-oauth-doctor.js";
 import { createSecurityAdminApi, parseAuditQuery, registerSecurityAdminApi } from "./nodefony/src/admin/SecurityAdminApi.js";
-import { registerUserRevocationCascade } from "./nodefony/src/admin/userRevocationCascade.js";
-import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorate.js";
+import { registerUserRevocationCascade, usersEventBusNotice } from "./nodefony/src/admin/userRevocationCascade.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import { tokenStatusCriteria } from "./nodefony/src/token/tokenCriteria.js";
+import { requestClientCredentialsToken } from "./nodefony/src/oauth/clientCredentials.js";
 import { AccessDeniedError } from "./nodefony/errors/AccessDeniedError.js";
 import "./nodefony/errors/index.js";
 import "./nodefony/contracts/index.js";
@@ -96,7 +106,7 @@ import { registerUserAdminApi } from "@nodefony/user";
 * + 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
@@ -111,6 +121,8 @@ let Security = class Security extends Module {
 		this.addCommand(SecurityUserDelete);
 		this.addCommand(SecurityUserPassword);
 		this.addCommand(SecurityToken);
+		this.addCommand(SecurityKeycloakRealm);
+		this.addCommand(SecurityOAuthDoctor);
 	}
 	/**
 	* JSON Schema de la config security → data plane admin (config riche Studio).
@@ -135,7 +147,28 @@ let Security = class Security extends Module {
 			registerSecurityAdminApi(registry, container);
 			registerUserAdminApi(registry, container);
 		}
-		if (this.kernel && container) registerUserRevocationCascade(this.kernel, container);
+		const kernel = this.kernel;
+		if (kernel && container) {
+			registerUserRevocationCascade(kernel, container);
+			kernel.once("onPostReady", () => {
+				const notice = usersEventBusNotice(container, kernel);
+				if (notice) kernel.reportBootNotice(notice);
+			});
+		}
+		return 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`).
+	*/
+	async onKernelReady() {
+		const firewall = this.kernel?.container?.get("firewall");
+		if (!firewall) return this;
+		const notice = publicRoutesNotice(firewall.describe().zones);
+		if (notice) this.kernel?.reportBootNotice(notice);
 		return this;
 	}
 };
@@ -150,8 +183,9 @@ Security = __decorate([services([
 	OAuth2Service,
 	AuditService,
 	TotpService,
-	WebhookService
+	WebhookService,
+	KeycloakService
 ]), __decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])], Security);
 var security_default = Security;
 //#endregion
-export { AccessDeniedError, AccessTokenVerifierService, AnonymousAuthenticator, AnonymousToken, ApiKeyAuthenticator, ApiKeyError, ApiKeyService, AuditService, AuthFlow, AuthenticationError, Authorization, Cors, Csrf, CsrfError, CsrfTokenManager, ExternalJwtAuthenticator, Firewall, InvalidTargetError, JwtAuthenticator, JwtKeystore, LoginThrottler, MemoryAuditStore, MemoryTokenStore, MemoryTotpSecretStore, MemoryWebAuthnCredentialStore, MemoryWebhookStore, OAuth2Client, OAuth2RequestError, OAuth2Service, OAuth2Tokens, RemoteJwtVerifier, RoleHierarchyWalker, RoleVoter, ScopeVoter, SecuredArea, SecurityHeaders, SessionAuthenticator, SsrfError, TOKEN_DEFAULT_ORDER, TOKEN_FACETS, TOKEN_SORTABLE_FIELDS, ThrottledError, TokenService, TotpService, UnverifiableTokenError, UserPasswordAuthenticator, UserToken, VoterVote, WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS, WebAuthnService, WebhookService, assertPublicUrl, base32Decode, beginTotpEnrollment, confirmTotpEnrollment, createCodeChallenge, createDiscoveredOidcProvider, createGithubProvider, createOidcProvider, createSecurityAdminApi, decryptSecret, security_default as default, defineSecurityConfig, deriveKey, deriveTotpKey, disableTotp, discoverAuthorizationServer, encryptSecret, generateApiKey, generateCodeVerifier, generateEphemeralKey, generateState, getAuditStoreFactory, getAuthenticatorFactory, getOAuthProviderFactory, getTokenStoreFactory, getTotpStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, hashApiKey, isBlockedAddress, listAuditStores, listAuthenticatorFactories, listOAuthProviders, listTokenStores, listTotpStores, listVoterFactories, listWebAuthnStores, listWebhookStores, looksLikeApiKey, matchesTokenStatus, parseApiKey, parseAuditQuery, peekIssuer, readAuditContext, recordAudit, registerAuditStore, registerAuthenticatorFactory, registerOAuthProvider, registerSecurityAdminApi, registerTokenStore, registerTotpStore, registerVoterFactory, registerWebAuthnStore, registerWebhookStore, resolveJwtRuntime, securityConfigJsonSchema, tokenStatusCriteria, tokenStatusOf, totpCode, totpStatus, verifyTotpLogin };
+export { AccessDeniedError, AccessTokenVerifierService, AnonymousAuthenticator, AnonymousToken, ApiKeyAuthenticator, ApiKeyError, ApiKeyService, AuditService, AuthFlow, AuthenticationError, Authorization, Cors, CredentialTransportPolicy, Csrf, CsrfError, CsrfTokenManager, ExternalJwtAuthenticator, Firewall, InsecureTransportError, InvalidTargetError, JwtAuthenticator, JwtKeystore, KeycloakAdminClient, KeycloakAdminError, KeycloakService, LoginThrottler, MemoryAuditStore, MemoryTokenStore, MemoryTotpSecretStore, MemoryWebAuthnCredentialStore, MemoryWebhookStore, OAuth2Client, OAuth2RequestError, OAuth2Service, OAuth2Tokens, RemoteJwtVerifier, RoleHierarchyWalker, RoleVoter, ScopeVoter, SecuredArea, SecurityHeaders, SessionAuthenticator, SsrfError, TOKEN_DEFAULT_ORDER, TOKEN_FACETS, TOKEN_SORTABLE_FIELDS, ThrottledError, TokenService, TotpService, UnverifiableTokenError, UserPasswordAuthenticator, UserToken, VoterVote, WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS, WebAuthnService, WebhookService, amrForFactor, assertPublicUrl, base32Decode, beginTotpEnrollment, confirmTotpEnrollment, createCodeChallenge, createDiscoveredOidcProvider, createGithubProvider, createOidcProvider, createSecurityAdminApi, decryptSecret, security_default as default, defineSecurityConfig, deriveKey, deriveTotpKey, diagnoseOAuthProvider, disableTotp, discoverAuthorizationServer, encryptSecret, generateApiKey, generateCodeVerifier, generateEphemeralKey, generateState, getAuditStoreFactory, getAuthenticatorFactory, getOAuthProviderFactory, getTokenStoreFactory, getTotpStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, hashApiKey, isBlockedAddress, keycloakAdminTarget, keycloakLoginThemeCheck, listAuditStores, listAuthenticatorFactories, listOAuthProviders, listTokenStores, listTotpStores, listVoterFactories, listWebAuthnStores, listWebhookStores, looksLikeApiKey, matchesTokenStatus, oauthProviderRequiresIssuer, parseApiKey, parseAuditQuery, peekIssuer, readAuditContext, readKeycloakLoginTheme, readLogoutTokenClaims, recordAudit, registerAuditStore, registerAuthenticatorFactory, registerOAuthProvider, registerSecurityAdminApi, registerTokenStore, registerTotpStore, registerVoterFactory, registerWebAuthnStore, registerWebhookStore, requestClientCredentialsToken, resolveJwtRuntime, securityConfigJsonSchema, shouldEnforceCredentialTransport, tokenStatusCriteria, tokenStatusOf, totpCode, totpStatus, verifyTotpLogin };

package/dist/nodefony/command/security-oauth-doctor.js

@@ -0,0 +1,66 @@
+import { Command } from "nodefony";
+//#region nodefony/command/security-oauth-doctor.ts
+const options = {
+	helpGroup: "COMPTES ET SECRETS",
+	showBanner: false,
+	kernelEvent: "onReady",
+	quietBoot: true
+};
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+/** Codes de sortie (sysexits). */
+const EXIT_FAILED = 1;
+const EXIT_CONFIG = 78;
+const LABELS = {
+	discovery: "découverte",
+	authorization: "URL de retour",
+	token: "secret",
+	theme: "thème"
+};
+function mark(check) {
+	switch (check.status) {
+		case "ok": return `${GREEN}✓${RESET}`;
+		case "failed": return `${RED}✗${RESET}`;
+		case "inconclusive": return `${YELLOW}?${RESET}`;
+		case "skipped": return `${DIM}–${RESET}`;
+	}
+}
+/**
+* `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.
+*/
+var SecurityOAuthDoctor = class extends Command {
+	constructor(cli) {
+		super("security:oauth:doctor", "diagnostique le branchement des fournisseurs OAuth", cli, options);
+		this.addOption("-p, --provider <nom>", "un seul fournisseur de oauth2.providers");
+		this.addOption("-j, --json", "sortie JSON (scripts/CI)");
+	}
+	async generate(opts) {
+		const oauth = this.kernel?.container?.get("oauth2");
+		const diagnoses = oauth?.isEnabled() === true ? await oauth.diagnose(opts.provider) : [];
+		if (opts.json) process.stdout.write(`${JSON.stringify(diagnoses, null, 2)}\n`);
+		else if (diagnoses.length === 0) process.stderr.write("aucun fournisseur OAuth à diagnostiquer — `security.oauth2` est désactivé ou ne déclare aucun fournisseur\n");
+		else for (const diagnosis of diagnoses) {
+			process.stdout.write(`${diagnosis.ok ? GREEN : RED}${diagnosis.provider}${RESET}\n`);
+			for (const check of diagnosis.checks) process.stdout.write(`  ${mark(check)} ${LABELS[check.name].padEnd(14)}${check.message}\n`);
+		}
+		if (diagnoses.length === 0) process.exitCode = EXIT_CONFIG;
+		else if (diagnoses.some((d) => !d.ok)) process.exitCode = EXIT_FAILED;
+		return this;
+	}
+};
+//#endregion
+export { SecurityOAuthDoctor as default };

package/dist/nodefony/command/security-secrets.js

@@ -1,8 +1,9 @@
 import { readIfPresentSync } from "../src/token/secretFile.js";
-import { Command, diskManifestReader, manifestFileWith, readManifestCode } from "nodefony";
-import { randomBytes } from "node:crypto";
+import { generateKeySet } from "../src/token/JwtKeystore.js";
+import { Command, ENV_FILE, diskManifestReader, manifestFileWith, readManifestCode } from "nodefony";
 import path from "node:path";
 import { appendFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
 //#region nodefony/command/security-secrets.ts
 const options = {
@@ -45,11 +46,11 @@ const ROLES = {
 	},
 	NF_CSRF_SECRET: {
 		protected: "signe les jetons anti-rejeu des mutations (`@CsrfProtect`)",
-		without: "en cluster, le jeton émis par un pod est rejeté par les autres"
+		without: "démarrage REFUSÉ en production (code 78) — une valeur tirée au hasard différerait d'un exemplaire à l'autre"
 	},
-	"jwt.keystore": {
-		protected: "signe les JWT (clé Ed25519, rotation gérée par le keystore)",
-		without: "chaque process signe avec la sienne : un jeton émis par la CLI est refusé par le serveur"
+	NF_JWT_KEYSET: {
+		protected: "signe les jetons JWT (paire Ed25519) — la MÊME pour tous les pods et workers",
+		without: "démarrage REFUSÉ en production dès que l'application émet des jetons — sinon 401 au hasard derrière plusieurs exemplaires, et tous les jetons perdus au redémarrage"
 	}
 };
 /**
@@ -71,22 +72,24 @@ var SecuritySecrets = class extends Command {
 		super("security:secrets", "engendre les clés de chiffrement du module security", cli, options);
 		this.addOption("-j, --json", "sortie JSON (scripts/CI)");
 		this.addOption("-w, --write", "écrit les clés manquantes dans le .env du projet (jamais de remplacement)");
+		this.addOption("-e, --env", "les 4 secrets en lignes CLÉ=valeur (docker run --env-file, gestionnaire de secrets)");
+		this.addOption("-k, --jwt-keyset", "génère la valeur de NF_JWT_KEYSET (une ligne JSON, à ranger dans le gestionnaire de secrets)");
 	}
 	/** Racine du projet (kernel booté) — repli cwd. */
 	#root() {
 		return this.kernel?.path ?? process.cwd();
 	}
 	/**
-	* `true` si `.env.local` est SUIVI par git — y écrire des secrets les mènerait
-	* au commit (convention B : `*.local` doit être gitignoré). Best-effort : git
-	* absent / hors repo → `false` (on écrit).
+	* `true` si `.env` est SUIVI par git — y écrire des secrets les mènerait au
+	* commit (`.env` doit être gitignoré). Best-effort : git absent / hors repo →
+	* `false` (on écrit).
 	*/
 	#dotenvTracked() {
 		try {
 			return spawnSync("git", [
 				"ls-files",
 				"--error-unmatch",
-				".env.local"
+				ENV_FILE
 			], {
 				cwd: this.#root(),
 				stdio: "ignore"
@@ -104,15 +107,24 @@ var SecuritySecrets = class extends Command {
 		}
 	}
 	async generate(opts) {
+		if (opts.jwtKeyset) {
+			process.stdout.write(await generateKeySet() + "\n");
+			return this;
+		}
 		const gen = () => randomBytes(32).toString("base64");
 		const secrets = {};
 		for (const k of KEYS) secrets[k] = gen();
 		if (opts.json) {
+			secrets["NF_JWT_KEYSET"] = await generateKeySet();
 			process.stdout.write(JSON.stringify(secrets, null, 2) + "\n");
 			return this;
 		}
-		const dotenvLocal = this.#read(".env.local");
-		const dotenv = this.#read(".env") + "\n" + dotenvLocal;
+		if (opts.env) {
+			secrets["NF_JWT_KEYSET"] = await generateKeySet();
+			process.stdout.write(Object.entries(secrets).map(([k, v]) => `${k}=${v}`).join("\n") + "\n");
+			return this;
+		}
+		const dotenv = this.#read(ENV_FILE);
 		const envTs = this.#read("env.ts");
 		const cfgTs = readManifestCode(this.#root(), diskManifestReader);
 		const cfgFile = manifestFileWith(this.#root(), diskManifestReader, /satisfies\s+ISecurityConfigInput/);
@@ -130,18 +142,18 @@ var SecuritySecrets = class extends Command {
 			process.stdout.write(s);
 		};
 		w(`\n${BOLD}🔐 Secrets du module security${RESET} ${DIM}— 4 secrets, 3 fichiers${RESET}\n\n`);
-		for (const [name, role] of Object.entries(ROLES)) w(`  ${(name === "jwt.keystore" ? /keystore\s*:/u.test(cfgTs) : new RegExp(`^\\s*${name}\\s*=`, "m").test(dotenv)) ? "\x1B[32m✓" : "\x1B[33m○"}${RESET} ${BOLD}${name.padEnd(16)}${RESET}${DIM}${role.protected}${RESET}\n    ${DIM}sans → ${role.without}${RESET}\n`);
-		const tokenStillThere = /^\s*NF_MCP_TOKEN\s*=/m.test(dotenvLocal);
+		for (const [name, role] of Object.entries(ROLES)) w(`  ${(name === "NF_JWT_KEYSET" ? cfgTs.includes(name) : new RegExp(`^\\s*${name}\\s*=`, "m").test(dotenv)) ? "\x1B[32m✓" : "\x1B[33m○"}${RESET} ${BOLD}${name.padEnd(16)}${RESET}${DIM}${role.protected}${RESET}\n    ${DIM}sans → ${role.without}${RESET}\n`);
+		const tokenStillThere = /^\s*NF_MCP_TOKEN\s*=/m.test(dotenv);
 		w(`\n${DIM}  · NF_MCP_TOKEN n'est PAS un secret de cette application, et n'a rien à\n    faire dans cette liste : c'est un jeton qu'elle ÉMET, présenté par un\n    agent pour entrer. Aucun code d'ici ne le lit. Il se pose chez l'agent\n    qui le porte — nodefony security:token --write.${RESET}\n`);
-		if (tokenStillThere) w(`${YELLOW}  ⚠ une ligne NF_MCP_TOKEN traîne encore dans .env.local — rien ne la lit,\n    tu peux la retirer.${RESET}\n`);
+		if (tokenStillThere) w(`${YELLOW}  ⚠ une ligne NF_MCP_TOKEN traîne encore dans .env — rien ne la lit,\n    tu peux la retirer.${RESET}\n`);
 		w(`\n${YELLOW}⚠ rien ne se tape dans le terminal : chaque bloc se colle dans le fichier indiqué.${RESET}\n\n`);
-		w(`${BOLD}1. Fichier ${CYAN}.env.local${RESET}${BOLD} — les valeurs${RESET} ${DIM}(gitignoré ; .env commité = défauts NON-secrets)${RESET}\n`);
+		w(`${BOLD}1. Fichier ${CYAN}.env${RESET}${BOLD} — les valeurs${RESET} ${DIM}(valeurs du poste, gitignoré ; la notice est .env.example)${RESET}\n`);
 		if (missingInDotenv.length === 0) w(`   ${GREEN}✓ les 3 clés y sont déjà${RESET} ${DIM}(rien à faire — rotation = remplacer la valeur à la main)${RESET}\n\n`);
-		else if (opts.write && this.#dotenvTracked()) w(`   ${YELLOW}⚠ .env.local est suivi par git — je n'y écris PAS de secrets.${RESET}\n   ${DIM}Ajoute \`*.local\` au .gitignore (et \`git rm --cached .env.local\`), puis relance --write ;\n   ou colle les lignes ci-dessous à la main :${RESET}\n\n` + missingInDotenv.map((k) => `   ${k}=${secrets[k]}`).join("\n") + `\n\n`);
+		else if (opts.write && this.#dotenvTracked()) w(`   ${YELLOW}⚠ .env est suivi par git — je n'y écris PAS de secrets.${RESET}\n   ${DIM}Ajoute \`.env\` au .gitignore (et \`git rm --cached .env\`), puis relance --write ;\n   ou colle les lignes ci-dessous à la main :${RESET}\n\n` + missingInDotenv.map((k) => `   ${k}=${secrets[k]}`).join("\n") + `\n\n`);
 		else if (opts.write) {
-			const block = (dotenvLocal && !dotenvLocal.endsWith("\n") ? "\n" : "") + `# clés security — générées par \`nodefony security:secrets\`\n` + missingInDotenv.map((k) => `${k}=${secrets[k]}`).join("\n") + "\n";
-			appendFileSync(path.resolve(this.#root(), ".env.local"), block);
-			w(`   ${GREEN}✓ écrit dans .env.local${RESET} ${DIM}(${missingInDotenv.join(", ")} — les clés déjà présentes n'ont pas été touchées)${RESET}\n\n`);
+			const block = (dotenv && !dotenv.endsWith("\n") ? "\n" : "") + `# clés security — générées par \`nodefony security:secrets\`\n` + missingInDotenv.map((k) => `${k}=${secrets[k]}`).join("\n") + "\n";
+			appendFileSync(path.resolve(this.#root(), ENV_FILE), block);
+			w(`   ${GREEN}✓ écrit dans .env${RESET} ${DIM}(${missingInDotenv.join(", ")} — les clés déjà présentes n'ont pas été touchées)${RESET}\n\n`);
 		} else w(`   colle ces lignes ${DIM}(ou relance avec ${RESET}${CYAN}--write${RESET}${DIM} pour que je les écrive)${RESET} :\n\n` + missingInDotenv.map((k) => `   ${k}=${secrets[k]}`).join("\n") + `\n   ${DIM}(en prod : Secret k8s / vault — jamais en git)${RESET}\n\n`);
 		w(`${BOLD}2. Fichier ${CYAN}env.ts${RESET}${BOLD} — la déclaration typée${RESET} ${DIM}(env.ts est le seul lecteur de process.env)${RESET}\n`);
 		if (missingInEnvTs.length === 0) w(`   ${GREEN}✓ déjà déclarées${RESET}\n\n`);
@@ -150,11 +162,16 @@ var SecuritySecrets = class extends Command {
 		if (missingInCfg.length === 0) w(`   ${GREEN}✓ déjà câblées${RESET}\n\n`);
 		else if (cfgIsFragment) w(`   complète le descripteur ${CYAN}securityConfig${RESET} :\n\n` + missingInCfg.map((k) => WIRING[k]).join("\n") + `\n\n`);
 		else w("   complète l'entrée security du manifeste modules :\n\n   use(\"@nodefony/security\", {\n" + missingInCfg.map((k) => WIRING[k]).join("\n") + `\n   }),\n\n`);
-		const jwtCable = /keystore\s*:/u.test(cfgTs);
-		w(`${BOLD}4. Fichier ${CYAN}nodefony.config.ts${RESET}${BOLD} — les clés de SIGNATURE des jetons${RESET} ${DIM}(jwt.keystore)${RESET}\n`);
-		if (jwtCable) w(`   ${GREEN}✓ déjà câblées${RESET}\n\n`);
-		else w(`   ${YELLOW}⚠ absentes : chaque process signe avec une clé ÉPHÉMÈRE.${RESET}\n   ${DIM}Un jeton émis par la CLI porte alors un \`kid\` que le serveur ne\n   connaît pas, et il est refusé — et un redémarrage invalide les jetons\n   en vol. Ce n'est pas une valeur à coller : c'est une SOURCE à déclarer.${RESET}\n\n   use("@nodefony/security", {\n     jwt: { keystore: ctx.isProd ? {} : { dir: "var/keys" } },\n   }),\n\n   ${DIM}En production, le dossier n'a pas de sens (pods jetables) : la clé vient\n   de l'environnement — jwt.keystore.keySetJson, injecté par ton gestionnaire\n   de secrets et partagé par tous les pods.${RESET}\n\n`);
-		w(`${DIM}Pourquoi 3 fichiers ? .env.local porte la VALEUR (secret machine, gitignoré —\nle .env commité ne porte que des défauts non-secrets) ; env.ts la DÉCLARE\n(catalogue typé, validé au boot) ; nodefony.config.ts la CÂBLE au module.\nLes étapes 2 et 3 ne se font qu'une fois — ensuite seule l'étape 1 vit.\nL'étape 4 sort de ce schéma, et c'est voulu : un keyset n'est pas une valeur\nqu'on colle, mais une source que le keystore gère (rotation, permissions).${RESET}\n\nRelance le serveur : plus aucun warning « clé ÉPHÉMÈRE » au boot.\n\n`);
+		const jwtDeclared = envTs.includes("NF_JWT_KEYSET");
+		const jwtWired = cfgTs.includes("NF_JWT_KEYSET");
+		w(`${BOLD}4. La clé de SIGNATURE des jetons${RESET} ${DIM}(NF_JWT_KEYSET — production seulement)${RESET}\n`);
+		if (jwtDeclared && jwtWired) w(`   ${GREEN}✓ déclarée dans env.ts et câblée dans ${cfgRel}${RESET}\n`);
+		else {
+			if (!jwtDeclared) w(`   ${CYAN}env.ts${RESET}, dans le defineEnv({ … }) :\n\n   NF_JWT_KEYSET: envString({ optional: true }),\n\n`);
+			if (!jwtWired) w(`   ${CYAN}${cfgRel}${RESET}, entrée security :\n\n   jwt: {\n     keystore: {\n       keySetJson: ctx.env.NF_JWT_KEYSET,\n       dir: ctx.isProd ? undefined : "var/keys",\n     },\n   },\n\n`);
+		}
+		w(`   ${DIM}Développement : rien à poser, la clé vit dans var/keys/.\n   Production : UNE valeur pour tous les pods et workers, générée une fois —\n   ${RESET}${CYAN}npx nodefony security:secrets --jwt-keyset${RESET}${DIM} — puis rangée dans le\n   gestionnaire de secrets et injectée en NF_JWT_KEYSET. Jamais dans .env,\n   jamais dans git. STABLE : la changer refuse les jetons en vol ; pour une\n   rotation, ajouter la nouvelle clé au jeu, la rendre « active », garder l'ancienne.${RESET}\n\n`);
+		w(`${DIM}Pourquoi 3 fichiers ? .env porte la VALEUR (secret du poste, gitignoré ;\nen production, le gestionnaire de secrets) ; env.ts la DÉCLARE\n(catalogue typé, validé au boot) ; ${cfgRel} la CÂBLE au module.\nLes étapes 2 et 3 ne se font qu'une fois — ensuite seule l'étape 1 vit.${RESET}\n\nRelance le serveur : plus aucun warning « clé ÉPHÉMÈRE » au boot.\n\n`);
 		return this;
 	}
 };

package/dist/nodefony/command/security-token.js

@@ -38,6 +38,36 @@ function ttlSeconds(raw) {
 	if (minutes > TTL_MAX_MINUTES) return /* @__PURE__ */ new Error(`--ttl est borné à ${TTL_MAX_MINUTES} minutes (30 jours) — un jeton posé dans un fichier est une clé, et une clé se remplace`);
 	return minutes * 60;
 }
+/**
+* Durée d'un jeton POSÉ dans un agent : 8 h, une journée de travail.
+*
+* L'en-tête d'un agent est figé, rien ne le rafraîchit : le défaut de la
+* configuration (15 min, taillé pour un client d'API qui renouvelle son jeton)
+* y produisait un 401 au bout d'un quart d'heure, qui n'accusait pas
+* l'expiration. Huit heures évitent la relance dans la journée et bornent une
+* fuite à quelques heures. Le défaut global (`jwt.accessTtlS`) ne bouge pas :
+* le relever allongerait TOUS les jetons de l'application.
+*/
+const AGENT_TTL_MINUTES = 480;
+/**
+* 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
+*/
+function tokenTtlSeconds(raw, write) {
+	if (raw !== void 0) return ttlSeconds(raw);
+	return write ? AGENT_TTL_MINUTES * 60 : void 0;
+}
+/** « 8 h », « 1 h 30 », « 15 min » — la durée telle qu'on la dit. */
+function humanDuration(seconds) {
+	const minutes = Math.round(seconds / 60);
+	if (minutes < 60) return `${minutes} min`;
+	const rest = minutes % 60;
+	return rest === 0 ? `${minutes / 60} h` : `${Math.floor(minutes / 60)} h ${rest}`;
+}
 const GREEN = "\x1B[32m";
 const YELLOW = "\x1B[33m";
 const DIM = "\x1B[2m";
@@ -69,7 +99,7 @@ var SecurityToken = class extends Command {
 		this.addOption("-s, --scope <scopes>", `scopes demandés, séparés par des espaces (défaut : « ${ADMIN_SCOPE_READ} » ; ajouter « ${ADMIN_SCOPE_WRITE} » pour les mutations)`);
 		this.addOption("-r, --resource <uri>", "audience visée (défaut : la porte MCP de cette application)");
 		this.addOption("-a, --agent <noms>", "agents à servir, séparés par des virgules (défaut : ceux détectés ; « none » pour aucun)");
-		this.addOption("-t, --ttl <duree>", "durée de validité, en minutes (défaut : celle de la config, 15 min)");
+		this.addOption("-t, --ttl <duree>", "durée de validité, en minutes (défaut : 8 h avec --write, sinon celle de la config, 15 min)");
 		this.addOption("-w, --write", `pose ${MCP_TOKEN_ENV} dans la configuration des agents présents`);
 		this.addOption("-j, --json", "sortie JSON (scripts/CI)");
 	}
@@ -239,7 +269,15 @@ var SecurityToken = class extends Command {
 		const resource = opts.resource ?? this.#defaultResource();
 		const requestedScopes = (opts.scope ?? "").split(/\s+/u).filter(Boolean);
 		const scopes = requestedScopes.length > 0 ? requestedScopes : [ADMIN_SCOPE_READ];
-		const ttlS = ttlSeconds(opts.ttl);
+		let write = opts.write === true;
+		if (!write && !opts.json && process.stdin.isTTY) {
+			await this.loadPrompts();
+			write = await this.prompts.confirm({
+				message: `Poser ${MCP_TOKEN_ENV} dans la configuration des agents présents ?`,
+				default: true
+			});
+		}
+		const ttlS = tokenTtlSeconds(opts.ttl, write);
 		if (ttlS instanceof Error) {
 			this.log(ttlS.message, "ERROR");
 			process.exitCode = 1;
@@ -271,30 +309,23 @@ var SecurityToken = class extends Command {
 		const token = issued.access_token;
 		const accordes = issued.scope.split(/\s+/u).filter(Boolean);
 		const nonAccordes = scopes.filter((s) => !accordes.includes(s));
+		const expiresAt = new Date(Date.now() + issued.expires_in * 1e3);
 		if (opts.json) {
 			process.stdout.write(`${JSON.stringify({
 				access_token: token,
 				resource,
 				scopes: accordes,
 				requested: scopes,
-				expires_in: issued.expires_in
+				expires_in: issued.expires_in,
+				expires_at: expiresAt.toISOString()
 			}, null, 2)}\n`);
 			return this;
 		}
 		const w = (s) => {
 			process.stdout.write(s);
 		};
-		let write = opts.write === true;
-		if (!write && process.stdin.isTTY) {
-			await this.loadPrompts();
-			write = await this.prompts.confirm({
-				message: `Poser ${MCP_TOKEN_ENV} dans la configuration des agents présents ?`,
-				default: true
-			});
-		}
-		if (this.#ephemeralKey()) w(`\n${YELLOW}⚠ Clé de signature ÉPHÉMÈRE — ce jeton sera REFUSÉ.${RESET}\n${DIM}  Cette application n'a pas de clé persistante : chaque process en génère\n  une au démarrage. Le jeton ci-dessous n'est vérifiable que par le process\n  qui vient de le signer — pas par le serveur en marche, qui a la sienne.\n  → déclare une source de clés dans nodefony.config.ts :\n      use("@nodefony/security", { jwt: { keystore: { dir: "var/keys" } } })\n    ou, en production, keySetJson depuis l'environnement.${RESET}\n`);
-		const minutes = Math.round(issued.expires_in / 60);
-		w(`\n${BOLD}🔑 Jeton d'accès${RESET} ${DIM}— compte ${identifier}, audience ${resource}${RESET}\n${DIM}   valable ${minutes} min${accordes.length ? `, scopes : ${accordes.join(" ")}` : ", aucun scope"}${RESET}\n\n`);
+		if (this.#ephemeralKey()) w(`\n${YELLOW}⚠ Clé de signature ÉPHÉMÈRE — ce jeton sera REFUSÉ.${RESET}\n${DIM}  Cette application n'a pas de clé persistante : chaque process en génère\n  une au démarrage. Le jeton ci-dessous n'est vérifiable que par le process\n  qui vient de le signer — pas par le serveur en marche, qui a la sienne.\n  → déclare une source de clés dans nodefony.config.ts :\n      use("@nodefony/security", { jwt: { keystore: { dir: "var/keys" } } })\n    ou, en production, keySetJson depuis l'environnement (NF_JWT_KEYSET —\n    npx nodefony security:secrets --jwt-keyset).${RESET}\n`);
+		w(`\n${BOLD}🔑 Jeton d'accès${RESET} ${DIM}— compte ${identifier}, audience ${resource}${RESET}\n${DIM}   valable ${humanDuration(issued.expires_in)}, expire le ${expiresAt.toLocaleString()}${accordes.length ? `, scopes : ${accordes.join(" ")}` : ", aucun scope"}${RESET}\n\n`);
 		if (nonAccordes.length > 0) w(`${DIM}   ⚠️  non accordé(s) : ${nonAccordes.join(" ")} — réservé(s) au rôle d'administration, que le compte « ${identifier} » ne porte pas.${RESET}\n\n`);
 		if (write) {
 			const requested = requestedAgents(opts.agent);
@@ -333,4 +364,4 @@ var SecurityToken = class extends Command {
 	}
 };
 //#endregion
-export { SecurityToken as default, ttlSeconds };
+export { SecurityToken as default, tokenTtlSeconds, ttlSeconds };

package/dist/nodefony/command/security-user-delete.js

@@ -30,9 +30,10 @@ const ADMIN_ROLE = "ROLE_NODEFONY_ADMIN";
 * 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.
 */
 var SecurityUserDelete = class extends Command {
 	constructor(cli) {
@@ -95,7 +96,7 @@ var SecurityUserDelete = class extends Command {
 			process.exitCode = 1;
 			return this;
 		}
-		w(`${GREEN}✓ compte supprimé${RESET} — ${BOLD}${identifier}${RESET}\n${DIM}  ses sessions et ses jetons sont révoqués (event onUserRevoked).${RESET}\n\n`);
+		w(`${GREEN}✓ compte supprimé${RESET} — ${BOLD}${identifier}${RESET}\n${DIM}  ses sessions, ses jetons et ses facteurs (2FA, passkeys) sont retirés.${RESET}\n\n`);
 		return this;
 	}
 };

package/dist/nodefony/command/security-user-password.js

@@ -1,5 +1,4 @@
 import { AUTH_LOGIN_PATH, CONSOLE_DATA_RUN_PROFILE, Command, askPasswordMasked } from "nodefony";
-import { USER_REVOKED_EVENT } from "@nodefony/user";
 //#region nodefony/command/security-user-password.ts
 const options = {
 	runProfile: CONSOLE_DATA_RUN_PROFILE,
@@ -34,10 +33,10 @@ const RESET = "\x1B[0m";
 *
 * 🔒 **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.
 */
 var SecurityUserPassword = class extends Command {
 	constructor(cli) {
@@ -100,12 +99,6 @@ var SecurityUserPassword = class extends Command {
 			process.exitCode = 1;
 			return this;
 		}
-		this.kernel?.fire(USER_REVOKED_EVENT, {
-			id: user.id,
-			identifier: user.identifier,
-			tenantId: null,
-			reason: "password_changed"
-		});
 		process.stdout.write(`\n${GREEN}✓ mot de passe changé${RESET} — ${BOLD}${user.identifier}${RESET}\n${DIM}  ses sessions et ses jetons sont révoqués : il devra se reconnecter.${RESET}\n${DIM}  connexion : POST ${AUTH_LOGIN_PATH}${RESET}\n` + (opts.password ? `  ${YELLOW}⚠ mot de passe passé en argument — pense à purger l'historique shell${RESET}\n` : "") + "\n");
 		return this;
 	}