@nodefony/security 10.0.0-alpha.3 → 10.0.0-alpha.5

package/README.md

@@ -179,4 +179,4 @@ Un **secret n'entre jamais** dans un événement — seule sa _présence_ est tr
 
 ## Licence
 
-CeCILL-B — Christophe CAMENSULI.
+Apache 2.0 — Christophe CAMENSULI.

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

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.149.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.148.0 → _@oxc-project_runtime@0.149.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.149.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

@@ -73,11 +73,12 @@ 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 SecurityToken from "./nodefony/command/security-token.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.148.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorate.js";
 import { tokenStatusCriteria } from "./nodefony/src/token/tokenCriteria.js";
 import { AccessDeniedError } from "./nodefony/errors/AccessDeniedError.js";
 import "./nodefony/errors/index.js";
@@ -108,6 +109,7 @@ let Security = class Security extends Module {
 		this.addCommand(SecurityUserAdd);
 		this.addCommand(SecurityUserList);
 		this.addCommand(SecurityUserDelete);
+		this.addCommand(SecurityUserPassword);
 		this.addCommand(SecurityToken);
 	}
 	/**

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

@@ -1,5 +1,5 @@
 import { readIfPresentSync } from "../src/token/secretFile.js";
-import { Command } from "nodefony";
+import { Command, diskManifestReader, manifestFileWith, readManifestCode } from "nodefony";
 import { randomBytes } from "node:crypto";
 import path from "node:path";
 import { appendFileSync } from "node:fs";
@@ -114,7 +114,10 @@ var SecuritySecrets = class extends Command {
 		const dotenvLocal = this.#read(".env.local");
 		const dotenv = this.#read(".env") + "\n" + dotenvLocal;
 		const envTs = this.#read("env.ts");
-		const cfgTs = this.#read("nodefony.config.ts");
+		const cfgTs = readManifestCode(this.#root(), diskManifestReader);
+		const cfgFile = manifestFileWith(this.#root(), diskManifestReader, /satisfies\s+ISecurityConfigInput/);
+		const cfgRel = path.relative(this.#root(), cfgFile).split(path.sep).join("/");
+		const cfgIsFragment = cfgRel !== "nodefony.config.ts";
 		const missingInDotenv = KEYS.filter((k) => !new RegExp(`^\\s*${k}\\s*=`, "m").test(dotenv));
 		const missingInEnvTs = KEYS.filter((k) => !envTs.includes(k));
 		const WIRING = {
@@ -143,8 +146,9 @@ var SecuritySecrets = class extends Command {
 		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`);
 		else w(`   ajoute dans le defineEnv({ … }) :\n\n` + missingInEnvTs.map((k) => `   ${k}: envString({ optional: true }),`).join("\n") + `\n\n`);
-		w(`${BOLD}3. Fichier ${CYAN}nodefony.config.ts${RESET}${BOLD} — le câblage vers le module security${RESET}\n`);
+		w(`${BOLD}3. Fichier ${CYAN}${cfgRel}${RESET}${BOLD} — le câblage vers le module security${RESET}\n`);
 		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`);

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

@@ -306,10 +306,10 @@ var SecurityToken = class extends Command {
 			let targets = requested ?? [];
 			if (requested === void 0) {
 				const presents = this.#agentsPresents();
-				const porteurs = presents.filter((c) => alreadyHasKey(c.forme, this.#contentOf(c), MCP_TOKEN_ENV));
-				const added = presents.filter((c) => !porteurs.includes(c));
-				targets = porteurs;
-				if (porteurs.length === 0 && added.length > 0 && process.stdin.isTTY) {
+				const carriers = presents.filter((c) => alreadyHasKey(c.forme, this.#contentOf(c), MCP_TOKEN_ENV));
+				const added = presents.filter((c) => !carriers.includes(c));
+				targets = carriers;
+				if (carriers.length === 0 && added.length > 0 && process.stdin.isTTY) {
 					const { checkbox } = await chargePrompts();
 					const chosen = await checkbox({
 						message: "Poser le jeton chez quels agents ?",
@@ -320,7 +320,7 @@ var SecurityToken = class extends Command {
 						}))
 					});
 					targets = added.filter((c) => chosen.includes(c.key));
-				} else if (porteurs.length === 0) targets = added;
+				} else if (carriers.length === 0) targets = added;
 				else if (added.length > 0) w(`${DIM}  ${added.map((c) => c.name).join(", ")} ${added.length > 1 ? "sont présents" : "est présent"} mais ne porte${added.length > 1 ? "nt" : ""} pas encore le jeton — ajoute --agent ${added.map((c) => c.key).join(",")}.${RESET}\n\n`);
 			}
 			if (this.#writeForAgents(token, w, targets) === 0) w(`${YELLOW}⚠ aucun agent reconnu dans ce projet — rien n'est écrit.${RESET}\n${DIM}  Les agents connus rangent leur configuration ici :${RESET}\n` + AGENT_TARGETS.map((c) => `${DIM}    ${c.name} : ${c.scope === "projet" ? c.file : `$${c.home ?? "HOME"}/${c.file}`}${RESET}\n`).join("") + `\n  Le geste qui vaut pour TOUS — dans le shell d'où tu lances l'agent :\n\n  ${BOLD}export ${MCP_TOKEN_ENV}=${token}${RESET}\n\n`);

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

@@ -16,6 +16,22 @@ const ADMIN_ROLES = ["ROLE_ADMIN", "ROLE_NODEFONY_ADMIN"];
 /** Rôle de base, toujours proposé même si l'application n'en déclare aucun. */
 const ROLE_BASE = "ROLE_USER";
 /**
+* La route qui échange un compte contre une SESSION — le geste qui manquait.
+*
+* Créer un compte ne sert à rien tant qu'on ne sait pas s'en servir : mesuré,
+* 33 minutes d'un essai réel se sont passées entre un premier refus et
+* l'abandon, faute de savoir quoi appeler. La commande dit donc l'étape
+* suivante au moment où elle a un sens.
+*
+* ⚠️ La route est MONTÉE ailleurs — `mountSessionAuthRoutes` du module
+* framework — et ce paquet ne peut pas l'importer pour la lire (le montage est
+* conditionné au service `authFlow`, et la valeur ne vit dans aucune constante
+* exportée). La copie est donc assumée, et un test la CONFRONTE à la table du
+* controller : deux copies qui divergent en silence, c'est précisément ce
+* qu'on refuse.
+*/
+const AUTH_LOGIN_PATH = "/nodefony/security/api/auth/login";
+/**
 * `nodefony security:user:add [identifier]` — crée un compte utilisateur via le
 * service applicatif `users` (hash Argon2id fait par `UserService.createUser`,
 * jamais de mot de passe stocké en clair).
@@ -55,9 +71,9 @@ var SecurityUserAdd = class extends Command {
 	#knownRoles() {
 		const hierarchy = ((this.kernel?.modules)?.security?.options)?.roleHierarchy;
 		const all = /* @__PURE__ */ new Set([ROLE_BASE]);
-		for (const [porteur, couverts] of Object.entries(hierarchy ?? {})) {
-			all.add(porteur);
-			for (const c of couverts) all.add(c);
+		for (const [role, covered] of Object.entries(hierarchy ?? {})) {
+			all.add(role);
+			for (const c of covered) all.add(c);
 		}
 		return [ROLE_BASE, ...[...all].filter((r) => r !== ROLE_BASE).sort()];
 	}
@@ -80,7 +96,7 @@ var SecurityUserAdd = class extends Command {
 			return this;
 		}
 		if (await users.findByIdentifier(identifier)) {
-			this.log(`le compte « ${identifier} » existe déjà.\n  · le voir       : nodefony security:user:list -q ${identifier}\n  · le supprimer  : nodefony security:user:delete ${identifier}\n  · mot de passe oublié : par Studio (/nodefony) — la commande n'existe pas encore.`, "ERROR");
+			this.log(`le compte « ${identifier} » existe déjà.\n  · le voir       : nodefony security:user:list -q ${identifier}\n  · le supprimer  : nodefony security:user:delete ${identifier}\n  · mot de passe oublié : nodefony security:user:password ${identifier}`, "ERROR");
 			process.exitCode = 1;
 			return this;
 		}
@@ -124,9 +140,9 @@ var SecurityUserAdd = class extends Command {
 			plainPassword: password,
 			roles
 		});
-		process.stdout.write(`\n${GREEN}✓ compte créé${RESET} — ${BOLD}${user.identifier}${RESET} ${DIM}(id ${user.id})${RESET}\n  rôles : ${roles.join(" · ")}\n` + (opts.admin ? `  ${DIM}accès console Studio : /nodefony${RESET}\n` : "") + (opts.password ? `  ${YELLOW}⚠ mot de passe passé en argument — pense à purger l'historique shell${RESET}\n` : ""));
+		process.stdout.write(`\n${GREEN}✓ compte créé${RESET} — ${BOLD}${user.identifier}${RESET} ${DIM}(id ${user.id})${RESET}\n  rôles : ${roles.join(" · ")}\n` + (opts.admin ? `  ${DIM}accès console Studio : /nodefony${RESET}\n` : "") + `  ${DIM}pour t'authentifier : POST ${AUTH_LOGIN_PATH}${RESET}\n  ${DIM}  body JSON {"username","password"} → cookie de session ; l'identité courante se relit sur GET /nodefony/security/api/auth/me${RESET}\n` + (opts.password ? `  ${YELLOW}⚠ mot de passe passé en argument — pense à purger l'historique shell${RESET}\n` : ""));
 		return this;
 	}
 };
 //#endregion
-export { SecurityUserAdd as default };
+export { AUTH_LOGIN_PATH, SecurityUserAdd as default };

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

@@ -0,0 +1,111 @@
+import { 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,
+	helpGroup: "COMPTES ET SECRETS",
+	showBanner: false,
+	kernelEvent: "onPostReady",
+	quietBoot: true
+};
+const GREEN = "\x1B[32m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const BOLD = "\x1B[1m";
+const RESET = "\x1B[0m";
+/**
+* `nodefony security:user:password [identifiant]` — change le mot de passe d'un
+* compte.
+*
+* Le geste d'exploitation qui manquait : `user:add`, `user:list` et
+* `user:delete` existaient, mais un mot de passe perdu n'avait aucun recours en
+* ligne de commande — seule la console d'administration savait le faire, ce qui
+* suppose d'y être déjà entré. Sur un serveur, c'est précisément le cas où l'on
+* ne peut pas.
+*
+* Mot de passe : `--password` (visible dans l'historique shell — accepté pour
+* les scripts) ou PROMPT MASQUÉ en TTY, demandé deux fois. Le hachage est celui
+* du service (`UserService.changePassword` → Argon2id) : jamais de clair
+* persisté, et la liste de mots de passe interdits s'applique comme à la
+* création.
+*
+* 🔒 **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.
+*/
+var SecurityUserPassword = class extends Command {
+	constructor(cli) {
+		super("security:user:password", "change le mot de passe d'un compte", cli, options);
+		this.addArgument("[identifier]", "identifiant (login) du compte");
+		this.addOption("-p, --password <password>", "nouveau mot de passe (sinon : prompt masqué en TTY)");
+	}
+	async generate(identifierArg, opts) {
+		const users = this.kernel?.container?.get("users");
+		if (!users) {
+			this.log("service « users » absent — l'application ne provisionne pas son annuaire utilisateurs (cf nodefony/security/provisionUsers.ts d'une app générée).", "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		let identifier;
+		try {
+			identifier = await this.askArgument(identifierArg, {
+				name: "identifier",
+				message: "Compte dont changer le mot de passe :"
+			});
+		} catch (e) {
+			this.log(e.message, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		const user = await users.findByIdentifier(identifier);
+		if (!user) {
+			this.log(`aucun compte « ${identifier} » — nodefony security:user:list`, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		let password = opts.password;
+		if (!password) {
+			if (!process.stdin.isTTY) {
+				this.log("mot de passe requis : --password <pwd> (pas de prompt hors terminal).", "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+			password = await askPasswordMasked(`${BOLD}Nouveau mot de passe de « ${identifier} »${RESET} ${DIM}(frappe masquée)${RESET} : `);
+			const confirmed = await askPasswordMasked(`${BOLD}Confirme le mot de passe${RESET} : `);
+			if (password !== confirmed) {
+				this.log("les deux saisies diffèrent — rien n'a changé.", "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+		}
+		if (!password) {
+			this.log("mot de passe vide — rien n'a changé.", "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		try {
+			if (await users.changePassword(user.id, password) === null) {
+				this.log(`aucune ligne modifiée pour « ${identifier} » — le compte a-t-il disparu entre-temps ?`, "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+		} catch (e) {
+			this.log(e.message, "ERROR");
+			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 /nodefony/security/api/auth/login${RESET}\n` + (opts.password ? `  ${YELLOW}⚠ mot de passe passé en argument — pense à purger l'historique shell${RESET}\n` : "") + "\n");
+		return this;
+	}
+};
+//#endregion
+export { SecurityUserPassword as default };

package/dist/nodefony/config/config.js

@@ -309,7 +309,9 @@ const oauthProviderSchema = z.strictObject({
 	scopes: z.array(z.string()).default([]).describe("Scopes demandés. Vide = défauts du fournisseur (Google: openid/profile/email ; GitHub: read:user/user:email)."),
 	successRedirect: z.string().optional().describe("Redirection succès — surcharge le global pour CE fournisseur."),
 	failureRedirect: z.string().optional().describe("Redirection échec — surcharge le global pour CE fournisseur."),
-	defaultRoles: z.array(z.string()).optional().describe("Rôles du Shadow User à la création — surcharge le global pour CE fournisseur.")
+	defaultRoles: z.array(z.string()).optional().describe("Rôles du Shadow User à la création — surcharge le global pour CE fournisseur."),
+	label: z.string().min(1).optional().describe("Libellé du bouton sur l'écran de connexion. OMIS = dérivé du nom du fournisseur (`keycloak` → « Keycloak », `oidc` → « OIDC », `mon-idp` → « Mon Idp »). À poser quand la marque ne se devine pas du nom de la clé (« Connexion agent », « Annuaire interne »)."),
+	hidden: z.boolean().default(false).describe("Retire le bouton de l'écran de connexion SANS désactiver le fournisseur : le flux `/authorize` reste ouvert et fonctionnel. C'est la seule différence avec le fait de ne pas le configurer. Deux usages : une FIXTURE de développement qui pointe vers un serveur fictif (bouton mort), et un fournisseur réservé à un point d'entrée particulier (lien direct, sous-domaine) plutôt qu'offert à tout visiteur.")
 }).describe("Fournisseur OAuth/OIDC (secrets via env).");
 const oauth2Schema = z.strictObject({
 	enabled: z.boolean().default(true).describe("Active le social login (les routes ne montent que si ≥1 provider)."),

package/dist/nodefony/service/auditService.js

@@ -1,6 +1,6 @@
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { getAuditStoreFactory, listAuditStores } from "../src/audit/auditStoreRegistry.js";
-import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, readStoreLocation, resolveAutoStore } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, durableStoreRemedy, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
 import { randomBytes } from "node:crypto";
 //#region nodefony/service/auditService.ts
 const serviceName = "auditService";
@@ -50,7 +50,7 @@ var AuditService = class extends Service {
 		let storeName = config.audit.store;
 		let reason = `store explicitement configuré ("${storeName}")`;
 		if (storeName === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listAuditStores());
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listAuditStores(), "memory", runNeedsExternalServices(this.kernel));
 			storeName = auto.store;
 			reason = auto.reason;
 			this.log(`audit.store "auto" → "${storeName}" (${auto.reason})`, "INFO");
@@ -62,7 +62,7 @@ var AuditService = class extends Service {
 			this.log(`${msg} — audit désactivé (journal de sécurité non collecté)`, "CRITIC");
 			return;
 		}
-		if (storeName === "memory" && this.kernel?.environment === "production") this.log("audit.store \"memory\" en PRODUCTION — journal de sécurité volatil et per-pod : perdu au redémarrage, invisible des autres pods, rétention de conformité impossible. Déclarer une infra durable (NF_DATABASE_URL).", "WARNING");
+		if (storeName === "memory" && this.kernel?.environment === "production") this.log("audit.store \"memory\" en PRODUCTION — journal de sécurité volatil et per-pod : perdu au redémarrage, invisible des autres pods, rétention de conformité impossible. " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
 		this.#enabled = true;
 		this.#idPrefix = randomBytes(4).toString("hex");
 		this.#store = factory({

package/dist/nodefony/service/oauth2.js

@@ -6,6 +6,58 @@ import { Service } from "nodefony";
 //#region nodefony/service/oauth2.ts
 const serviceName = "oauth2";
 /**
+* Sigles qui se lisent en capitales — les capitaliser mot à mot rendrait
+* « Oidc », « Sso », qu'aucun utilisateur ne reconnaît comme la technologie.
+*/
+const ACRONYMS = /* @__PURE__ */ new Set([
+	"oidc",
+	"sso",
+	"saml",
+	"ldap",
+	"cas",
+	"adfs",
+	"iam"
+]);
+/**
+* Marques dont la casse INTERNE ne se devine pas d'un nom en minuscules.
+*
+* Capitaliser la première lettre rendrait « Github », que la marque n'écrit
+* jamais ainsi — et c'est précisément le nom que l'utilisateur cherche des yeux
+* sur un bouton. Vu à l'écran, pas déduit : la première version de cette
+* fonction affichait « Github » là où la console montrait « GitHub » avant.
+*/
+const CANONICAL_LABELS = {
+	github: "GitHub",
+	gitlab: "GitLab",
+	google: "Google",
+	keycloak: "Keycloak",
+	microsoft: "Microsoft",
+	auth0: "Auth0",
+	okta: "Okta",
+	linkedin: "LinkedIn",
+	paypal: "PayPal",
+	youtube: "YouTube"
+};
+/**
+* Libellé affichable d'un fournisseur, quand sa configuration n'en donne pas.
+*
+* Un écran de connexion ne doit JAMAIS montrer un identifiant technique brut :
+* `mon-idp-interne` sur un bouton ne dit rien à qui doit cliquer. À défaut de
+* marque connue, le nom de la clé de configuration est ce qui s'en rapproche le
+* plus — mais rendu lisible : séparateurs en espaces, initiales en capitales,
+* sigles préservés.
+*
+* Fonction PURE, donc éprouvable sans boot ni réseau.
+*
+* @param name - nom du fournisseur, tel qu'il est écrit dans la configuration
+* @returns le libellé à afficher sur le bouton
+*/
+function oauthDisplayLabel(name) {
+	const canonical = CANONICAL_LABELS[name.toLowerCase()];
+	if (canonical !== void 0) return canonical;
+	return name.split(/[-_.\s]+/).filter((word) => word.length > 0).map((word) => ACRONYMS.has(word.toLowerCase()) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+/**
 * **Social login OAuth 2.0** (P6 J9) — orchestrateur du flux *Authorization Code*.
 *
 * Posture OAuth 2.1 (RFC 9700) : Authorization Code uniquement (jamais implicit /
@@ -57,13 +109,38 @@ var OAuth2Service = class extends Service {
 	isEnabled() {
 		return this.#ready;
 	}
-	/** Noms des fournisseurs configurés ET connus du registre (UI : boutons à afficher). */
+	/**
+	* Noms des fournisseurs OPÉRATIONNELS — configurés ET connus du registre.
+	*
+	* 🔴 C'est la **garde d'autorisation** : `/authorize` refuse en 404 tout nom
+	* absent de cette liste. Elle répond donc à « ce flux peut-il s'ouvrir ? »,
+	* jamais à « ce bouton doit-il s'afficher ? » — pour l'écran, voir
+	* {@link listDisplayProviders}. Confondre les deux ferait d'un masquage une
+	* désactivation, et couperait les bancs qui exercent une fixture masquée.
+	*/
 	listProviders() {
 		if (!this.#ready || this.#config === null) return [];
 		const known = new Set(listOAuthProviders());
 		return Object.keys(this.#config.oauth2.providers).filter((n) => known.has(n));
 	}
 	/**
+	* Fournisseurs à MONTRER sur l'écran de connexion, libellés compris.
+	*
+	* Rend TOUT fournisseur opérationnel — y compris ceux dont le framework ne
+	* connaît pas la marque, qui sont précisément ceux qu'une application
+	* enregistre elle-même. Le seul retrait possible est explicite et se lit dans
+	* la configuration du fournisseur (`hidden: true`), à côté de la raison qui
+	* l'a motivé ; il ne désactive rien.
+	*/
+	listDisplayProviders() {
+		if (this.#config === null) return [];
+		const configured = this.#config.oauth2.providers;
+		return this.listProviders().filter((name) => configured[name]?.hidden !== true).map((name) => ({
+			name,
+			label: configured[name]?.label ?? oauthDisplayLabel(name)
+		}));
+	}
+	/**
 	* Redirections post-login (succès / échec) — lues par le controller.
 	* Surcharge PAR FOURNISSEUR si fournie, sinon valeur globale, sinon défaut.
 	*/
@@ -159,4 +236,4 @@ var OAuth2Service = class extends Service {
 	}
 };
 //#endregion
-export { OAuth2Service, OAuth2Service as default };
+export { OAuth2Service, OAuth2Service as default, oauthDisplayLabel };

package/dist/nodefony/service/tokenService.js

@@ -6,7 +6,7 @@ import { recordAudit } from "../src/audit/recordAudit.js";
 import { InvalidTargetError } from "../errors/InvalidTargetError.js";
 import { getTokenStoreFactory, listTokenStores } from "../src/token/tokenStoreRegistry.js";
 import { JwtKeystore } from "../src/token/JwtKeystore.js";
-import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, readStoreLocation, refusedAdminScopes, resolveAutoStore } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, durableStoreRemedy, readStoreLocation, refusedAdminScopes, resolveAutoStore, runNeedsExternalServices } from "nodefony";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 //#region nodefony/service/tokenService.ts
 const serviceName = "tokenService";
@@ -59,7 +59,7 @@ var TokenService = class extends Service {
 		let storeName = config.tokenStore.store;
 		let reason = `store explicitement configuré ("${storeName}")`;
 		if (storeName === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTokenStores());
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTokenStores(), "memory", runNeedsExternalServices(this.kernel));
 			storeName = auto.store;
 			reason = auto.reason;
 			this.log(`tokenStore "auto" → "${storeName}" (${auto.reason})`, "INFO");
@@ -71,7 +71,7 @@ var TokenService = class extends Service {
 			this.log(`${msg} — JWT/clés API indisponibles`, "CRITIC");
 			return;
 		}
-		if (storeName === "memory" && this.kernel?.environment === "production") this.log("tokenStore \"memory\" en PRODUCTION — denylist JWT, refresh tokens et clés API per-pod et volatils : révocation non partagée entre pods, tout est perdu au redémarrage. Déclarer une infra durable (NF_DATABASE_URL) ou un store persistant.", "WARNING");
+		if (storeName === "memory" && this.kernel?.environment === "production") this.log("tokenStore \"memory\" en PRODUCTION — denylist JWT, refresh tokens et clés API per-pod et volatils : révocation non partagée entre pods, tout est perdu au redémarrage. " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
 		this.#store = factory({
 			container: this.container,
 			config

package/dist/nodefony/service/totp.js

@@ -3,7 +3,7 @@ import { getTotpStoreFactory, listTotpStores } from "../src/totp/totpSecretStore
 import { generateEphemeralKey } from "../src/crypto/secretCipher.js";
 import { deriveTotpKey } from "../src/totp/totpCipher.js";
 import { beginTotpEnrollment, confirmTotpEnrollment, disableTotp, totpStatus, verifyTotpLogin } from "../src/totp/totpOperations.js";
-import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, readStoreLocation, resolveAutoStore } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
 //#region nodefony/service/totp.ts
 const serviceName = "totp";
 function isFlushable(s) {
@@ -90,7 +90,7 @@ var TotpService = class extends Service {
 		let driver = config.totp.store;
 		let reason = `store explicitement configuré ("${driver}")`;
 		if (driver === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTotpStores());
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTotpStores(), "memory", runNeedsExternalServices(this.kernel));
 			driver = auto.store;
 			reason = auto.reason;
 			this.log(`totp.store "auto" → "${driver}" (${auto.reason})`, "INFO");
@@ -102,7 +102,7 @@ var TotpService = class extends Service {
 			this.log(`${msg} — 2FA indisponible`, "CRITIC");
 			return null;
 		}
-		if (driver === "memory" && this.kernel?.environment === "production") this.log("totp.store \"memory\" en PRODUCTION — secrets 2FA volatils : perdus au redémarrage (utilisateurs verrouillés). Déclarer une infra durable (NF_DATABASE_URL) ou charger @nodefony/drizzle.", "WARNING");
+		if (driver === "memory" && this.kernel?.environment === "production") this.log("totp.store \"memory\" en PRODUCTION — secrets 2FA volatils : perdus au redémarrage (utilisateurs verrouillés). " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
 		const store = factory({
 			container: this.container,
 			config

package/dist/nodefony/service/webAuthn.js

@@ -2,7 +2,7 @@ import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { WebAuthnError } from "../errors/WebAuthnError.js";
 import { getWebAuthnStoreFactory, listWebAuthnStores } from "../src/webauthn/webAuthnCredentialStoreRegistry.js";
-import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, readStoreLocation, resolveAutoStore } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
 import { Buffer } from "node:buffer";
 //#region nodefony/service/webAuthn.ts
 const serviceName = "webauthn";
@@ -74,7 +74,7 @@ var WebAuthnService = class extends Service {
 			let driver = config.passkeys.store;
 			reason = `store explicitement configuré ("${driver}")`;
 			if (driver === AUTO_STORE) {
-				const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebAuthnStores());
+				const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebAuthnStores(), "memory", runNeedsExternalServices(this.kernel));
 				driver = auto.store;
 				reason = auto.reason;
 				this.log(`passkeys.store "auto" → "${driver}" (${auto.reason})`, "INFO");
@@ -86,7 +86,7 @@ var WebAuthnService = class extends Service {
 				this.log(`${msg} — passkeys indisponibles`, "CRITIC");
 				return;
 			}
-			if (driver === "memory" && this.kernel?.environment === "production") this.log("passkeys.store \"memory\" en PRODUCTION — credentials WebAuthn volatils : tous les passkeys enregistrés sont perdus au redémarrage (utilisateurs verrouillés hors de leur compte). Déclarer une infra durable (NF_DATABASE_URL).", "WARNING");
+			if (driver === "memory" && this.kernel?.environment === "production") this.log("passkeys.store \"memory\" en PRODUCTION — credentials WebAuthn volatils : tous les passkeys enregistrés sont perdus au redémarrage (utilisateurs verrouillés hors de leur compte). " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
 			this.#store = factory({
 				container: this.container,
 				config

package/dist/nodefony/service/webhooks.js

@@ -6,7 +6,7 @@ import { deriveWebhookKey } from "../src/webhook/webhookCipher.js";
 import { assertPublicUrl } from "../src/net/ssrfGuard.js";
 import { WebhookDispatcher } from "../src/webhook/WebhookDispatcher.js";
 import { deliverWebhook } from "../src/webhook/webhookDelivery.js";
-import { AUTO_STORE, EMPTY_INFRA, Service, countFacets, deriveStoreBackend, readStoreLocation, resolveAutoStore } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, Service, countFacets, deriveStoreBackend, durableStoreRemedy, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
 import { randomBytes } from "node:crypto";
 import { Buffer } from "node:buffer";
 import { schemaMismatchOf } from "@nodefony/http";
@@ -153,7 +153,7 @@ var WebhookService = class extends Service {
 		let driver = config.webhooks.store;
 		let reason = `store explicitement configuré ("${driver}")`;
 		if (driver === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebhookStores());
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebhookStores(), "memory", runNeedsExternalServices(this.kernel));
 			driver = auto.store;
 			reason = auto.reason;
 			this.log(`webhooks.store "auto" → "${driver}" (${auto.reason})`, "INFO");
@@ -165,7 +165,7 @@ var WebhookService = class extends Service {
 			this.log(`${msg} — webhooks indisponibles`, "CRITIC");
 			return null;
 		}
-		if (driver === "memory" && this.kernel?.environment === "production") this.log("webhooks.store \"memory\" en PRODUCTION — abonnements volatils et per-pod : perdus au redémarrage, non partagés entre pods. Déclarer une infra durable (NF_DATABASE_URL).", "WARNING");
+		if (driver === "memory" && this.kernel?.environment === "production") this.log("webhooks.store \"memory\" en PRODUCTION — abonnements volatils et per-pod : perdus au redémarrage, non partagés entre pods. " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
 		const store = factory({
 			container: this.container,
 			config

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

@@ -2,6 +2,40 @@ import { messageNonRestreint, modeNonRestreintAsync, readIfPresent, writeSecret
 import { join } from "node:path";
 //#region nodefony/src/token/JwtKeystore.ts
 /**
+* Dossiers que le `Dockerfile` généré EFFACE à l'étage de construction.
+*
+* La liste est ici parce que c'est ici qu'on s'en sert ; elle est tenue honnête
+* par le test qui la confronte au gabarit — deux copies d'une même règle
+* divergent en silence, et c'est une clé privée qui paierait la dérive.
+*/
+const CLEANED_DIRS = ["var", "tmp"];
+/**
+* Le trousseau va-t-il partir dans l'image de conteneur ?
+*
+* ⭐ **Pourquoi cet avertissement existe.** Le trousseau est une clé privée
+* Ed25519. Elle ne sort pas de l'image aujourd'hui pour UNE seule raison : le
+* gabarit a choisi `var/keys`, et le `Dockerfile` généré efface `var/`. Rien
+* n'attache cette sécurité à la configuration — un utilisateur qui écrit
+* `keystore: { dir: "nodefony/config/keys" }`, chemin parfaitement raisonnable,
+* publie sa clé privée sans qu'aucun signal n'existe. C'est exactement le
+* chemin par lequel une clé TLS est déjà partie dans une image publiée.
+*
+* ⚠️ **Les chemins ABSOLUS ne sont pas jugés**, et c'est délibéré : `/etc/…` ou
+* un point de montage sont des choix d'exploitation qui sortent du contexte de
+* construction, et prétendre les évaluer ferait crier ce contrôle sur la
+* pratique la plus saine. Un contrôle qui crie faux apprend à passer outre.
+*
+* @param dir - la valeur de `jwt.keystore.dir`, telle que configurée.
+* @returns le message à journaliser, ou `null` quand le dossier est nettoyé.
+*/
+function keystoreLeaksIntoImage(dir) {
+	const normalized = dir.replace(/\\/gu, "/").replace(/^\.\//u, "");
+	if (normalized.startsWith("/") || /^[A-Za-z]:/u.test(normalized)) return null;
+	const first = normalized.split("/")[0];
+	if (CLEANED_DIRS.includes(first)) return null;
+	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.`;
+}
+/**
 * 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
@@ -61,6 +95,8 @@ var JwtKeystore = class {
 			return;
 		}
 		if (this.#source.dir) {
+			const risk = keystoreLeaksIntoImage(this.#source.dir);
+			if (risk) this.#log(risk, "WARNING");
 			const file = join(this.#source.dir, "keyset.json");
 			const existing = await this.#readFile(file);
 			if (existing) {
@@ -157,4 +193,4 @@ var JwtKeystore = class {
 	}
 };
 //#endregion
-export { JwtKeystore, JwtKeystore as default };
+export { JwtKeystore, JwtKeystore as default, keystoreLeaksIntoImage };

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

@@ -1,4 +1,20 @@
 import { CliKernel, Command } from "nodefony";
+/**
+ * La route qui échange un compte contre une SESSION — le geste qui manquait.
+ *
+ * Créer un compte ne sert à rien tant qu'on ne sait pas s'en servir : mesuré,
+ * 33 minutes d'un essai réel se sont passées entre un premier refus et
+ * l'abandon, faute de savoir quoi appeler. La commande dit donc l'étape
+ * suivante au moment où elle a un sens.
+ *
+ * ⚠️ La route est MONTÉE ailleurs — `mountSessionAuthRoutes` du module
+ * framework — et ce paquet ne peut pas l'importer pour la lire (le montage est
+ * conditionné au service `authFlow`, et la valeur ne vit dans aucune constante
+ * exportée). La copie est donc assumée, et un test la CONFRONTE à la table du
+ * controller : deux copies qui divergent en silence, c'est précisément ce
+ * qu'on refuse.
+ */
+export declare const AUTH_LOGIN_PATH = "/nodefony/security/api/auth/login";
 /**
  * `nodefony security:user:add [identifier]` — crée un compte utilisateur via le
  * service applicatif `users` (hash Argon2id fait par `UserService.createUser`,

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

@@ -0,0 +1,31 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * `nodefony security:user:password [identifiant]` — change le mot de passe d'un
+ * compte.
+ *
+ * Le geste d'exploitation qui manquait : `user:add`, `user:list` et
+ * `user:delete` existaient, mais un mot de passe perdu n'avait aucun recours en
+ * ligne de commande — seule la console d'administration savait le faire, ce qui
+ * suppose d'y être déjà entré. Sur un serveur, c'est précisément le cas où l'on
+ * ne peut pas.
+ *
+ * Mot de passe : `--password` (visible dans l'historique shell — accepté pour
+ * les scripts) ou PROMPT MASQUÉ en TTY, demandé deux fois. Le hachage est celui
+ * du service (`UserService.changePassword` → Argon2id) : jamais de clair
+ * persisté, et la liste de mots de passe interdits s'applique comme à la
+ * création.
+ *
+ * 🔒 **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.
+ */
+declare class SecurityUserPassword extends Command {
+    constructor(cli: CliKernel);
+    generate(identifierArg: string | undefined, opts: {
+        password?: string;
+    }): Promise<this>;
+}
+export default SecurityUserPassword;