@nodefony/security 10.0.0-alpha.1

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

@@ -0,0 +1,335 @@
+import { messageNonRestreint, modeNonRestreint, readIfPresentSync, writeSecretSync } from "../src/token/secretFile.js";
+import { ADMIN_SCOPE_READ, ADMIN_SCOPE_WRITE, AGENT_TARGETS, Command, MCP_ENDPOINT_PATH, MCP_TOKEN_ENV, agentRoot, agentsPresents, alreadyHasKey, chargePrompts, poseVariable, requestedAgents } from "nodefony";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+//#region nodefony/command/security-token.ts
+const options = {
+	helpGroup: "COMPTES ET SECRETS",
+	showBanner: false,
+	kernelEvent: "onReady",
+	quietBoot: true
+};
+/**
+* La table des agents, leurs emplacements de secret et la façon de leur
+* déclarer la porte vivent dans le CŒUR (`nodefony/cli/agentTargets`) : ce sont
+* `ai:mcp` et `create app` — des commandes du cœur — qui déclarent la porte,
+* quand cette commande-ci pose le jeton. Deux tables recopiées auraient divergé
+* au premier agent ajouté d'un seul côté, et la divergence se serait vue chez
+* l'utilisateur, sous la forme d'un agent servi par l'une et ignoré par l'autre.
+*/
+/** Plafond d'une durée demandée en ligne de commande : 30 jours. */
+const TTL_MAX_MINUTES = 43200;
+/**
+* Traduit `--ttl` en secondes, ou rend l'erreur à afficher.
+*
+* Exportée pour être ÉPROUVÉE : c'est une fonction pure dont chaque verdict est
+* binaire, et dont l'échec — une durée acceptée alors qu'elle est aberrante —
+* ne se verrait qu'au moment où un jeton refuse de mourir.
+*
+* @param raw - la valeur telle que tapée, ou rien
+* @returns les secondes, `undefined` si rien n'est demandé, une `Error` sinon
+*/
+function ttlSeconds(raw) {
+	if (raw === void 0) return void 0;
+	const minutes = Number.parseInt(raw, 10);
+	if (!Number.isFinite(minutes) || minutes <= 0) return /* @__PURE__ */ new Error(`--ttl attend un nombre de MINUTES supérieur à zéro (reçu « ${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;
+}
+const GREEN = "\x1B[32m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const BOLD = "\x1B[1m";
+const RESET = "\x1B[0m";
+/**
+* `nodefony security:token` — émet un jeton d'accès pour une porte de cette
+* application (la porte MCP par défaut).
+*
+* **Pourquoi une commande, et pas un `curl`.** Le jeton s'obtenait par un appel
+* au grant : trouver l'URL, composer un JSON, y mettre un mot de passe en clair
+* dans l'historique du shell, et surtout AVOIR un serveur en marche. Personne ne
+* fait ça deux fois. Ici l'application SIGNE elle-même — elle possède la clé —
+* donc : pas de serveur, pas de mot de passe, pas de réseau.
+*
+* **L'audience est celle de la porte, et ce n'est pas un détail** (RFC 8707) :
+* un jeton d'audience différente est refusé, à juste titre — c'est toute la
+* raison d'être de la liaison d'audience. La commande la vise d'elle-même,
+* `--resource` ne sert qu'à en viser une autre.
+*
+* Suit `security:secrets` : `--write` pose la valeur là où l'AGENT la lit
+* (gitignoré), jamais dans le `.env` commité, et ne remplace jamais une valeur
+* existante — une rotation est un geste explicite.
+*/
+var SecurityToken = class extends Command {
+	constructor(cli) {
+		super("security:token", `émet un jeton d'accès pour la porte MCP`, cli, options);
+		this.addArgument("[identifier]", "compte porteur du jeton (défaut : admin)");
+		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("-w, --write", `pose ${MCP_TOKEN_ENV} dans la configuration des agents présents`);
+		this.addOption("-j, --json", "sortie JSON (scripts/CI)");
+	}
+	/** Racine du projet (le kernel la connaît ; repli sur le cwd). */
+	#root() {
+		return this.kernel?.path ?? process.cwd();
+	}
+	/** Ce fichier est-il couvert par un `.gitignore` ? */
+	#gitIgnored(file) {
+		try {
+			return spawnSync("git", [
+				"check-ignore",
+				"-q",
+				file
+			], {
+				cwd: this.#root(),
+				stdio: "ignore"
+			}).status === 0;
+		} catch {
+			return false;
+		}
+	}
+	/** Ce fichier est-il SUIVI par git ? Un secret n'entre pas dans un suivi. */
+	#tracked(file) {
+		try {
+			return spawnSync("git", [
+				"ls-files",
+				"--error-unmatch",
+				file
+			], {
+				cwd: this.#root(),
+				stdio: "ignore"
+			}).status === 0;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Racine où vit la configuration d'une cible (projet, ou dossier maison).
+	*
+	* La résolution elle-même vit dans le cœur, avec la table : recopiée ici,
+	* elle aurait cessé d'honorer `CODEX_HOME`/`VIBE_HOME` le jour où l'une des
+	* deux copies aurait bougé — et le symptôme aurait été un jeton posé dans un
+	* dossier que l'agent ne lit pas, donc un 401 qui accuse le jeton.
+	*/
+	#rootOf(target) {
+		return agentRoot(target, { projectRoot: this.#root() });
+	}
+	/** Contenu du fichier d'une cible, "" s'il n'existe pas. */
+	#contentOf(target) {
+		try {
+			const abs = path.resolve(this.#rootOf(target), target.file);
+			return readIfPresentSync(abs) ?? "";
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* Agents dont la présence est CONSTATÉE — on ne crée pas la configuration
+	* d'un outil que personne n'utilise ici.
+	*/
+	#agentsPresents() {
+		return agentsPresents({
+			projectRoot: this.#root(),
+			exists: existsSync
+		});
+	}
+	/**
+	* Pose le jeton dans la configuration des agents PRÉSENTS dans ce projet.
+	*
+	* Un agent n'est servi que si son marqueur existe : on ne crée pas la
+	* configuration d'un outil que personne n'utilise ici. Et jamais dans un
+	* fichier SUIVI par git — un jeton commité est un jeton publié, et c'est la
+	* seule faute de cette commande qui serait irrattrapable.
+	*
+	* @param token - le jeton à poser
+	* @param w - la sortie où rendre compte
+	* @param targets - agents à servir (déjà filtrés par le choix de l'appelant)
+	* @returns le nombre d'agents effectivement servis
+	*/
+	#writeForAgents(token, w, targets) {
+		let servis = 0;
+		for (const target of targets) {
+			const root = this.#rootOf(target);
+			if (target.scope === "projet" && this.#tracked(target.file)) {
+				w(`${YELLOW}⚠ ${target.file} est SUIVI par git — rien n'est écrit.${RESET}\n${DIM}  Un jeton commité est un jeton publié.${RESET}\n\n`);
+				continue;
+			}
+			const abs = path.resolve(root, target.file);
+			const pose = poseVariable(target.forme, readIfPresentSync(abs) ?? "", MCP_TOKEN_ENV, token);
+			if (pose instanceof Error) {
+				w(`${YELLOW}⚠ ${target.file} : ${pose.message} — rien n'est écrit.${RESET}\n\n`);
+				continue;
+			}
+			try {
+				writeSecretSync(abs, pose);
+			} catch (error) {
+				w(`${YELLOW}⚠ ${target.file} : écriture impossible — ${error.message}${RESET}\n\n`);
+				continue;
+			}
+			const resolvedMode = modeNonRestreint(abs);
+			if (typeof resolvedMode === "number") w(`${YELLOW}⚠ ${messageNonRestreint(abs, resolvedMode)}${RESET}\n`);
+			w(`${GREEN}✓ ${MCP_TOKEN_ENV} posé pour ${target.name}${RESET} ${DIM}(${target.scope === "projet" ? target.file : abs})${RESET}\n${DIM}  RELANCE-le : il lit sa configuration au démarrage.${RESET}\n`);
+			if (target.scope === "projet" && !this.#gitIgnored(target.file)) w(`${YELLOW}  ⚠ ${target.file} n'est PAS couvert par .gitignore — un « git add -A » l'emporterait.${RESET}\n`);
+			w("\n");
+			servis += 1;
+		}
+		return servis;
+	}
+	/**
+	* Audience par défaut : la porte MCP de CETTE application.
+	*
+	* Lue de la configuration quand elle y est écrite — c'est elle qui fait foi,
+	* et elle doit l'être : dérivée d'un en-tête `Host`, un `Host` forgé
+	* obtiendrait un jeton d'audience arbitraire. À défaut, on compose l'adresse
+	* locale, qui est celle du développement.
+	*/
+	#defaultResource() {
+		const declaree = ((this.kernel?.modules)?.devkit?.options)?.mcp?.authorization?.resource;
+		if (typeof declaree === "string" && declaree.length > 0) return declaree;
+		return `http://localhost:${process.env.NF_PORT ?? "5151"}${MCP_ENDPOINT_PATH}`;
+	}
+	/**
+	* `true` si l'application signe avec une clé ÉPHÉMÈRE (ni `keySetJson` ni
+	* `dir` déclarés dans `security.jwt.keystore`).
+	*
+	* 🔴 C'est le piège que cette commande doit annoncer : le jeton produit est
+	* parfaitement valide et n'est vérifiable par PERSONNE d'autre que le process
+	* qui vient de le signer — celui-ci. Le serveur en marche a généré la sienne
+	* au démarrage, et refusera ce jeton en « autorisation requise ». Mesuré :
+	* deux `kid` distincts pour la même application, et un troisième après un
+	* redémarrage.
+	*/
+	#ephemeralKey() {
+		const ks = (((this.kernel?.modules)?.security?.options)?.jwt)?.keystore;
+		return !ks?.keySetJson && !ks?.dir;
+	}
+	async generate(identifierArg, opts) {
+		const tokens = this.kernel?.container?.get("tokenService");
+		const users = this.kernel?.container?.get("users");
+		if (!tokens || !users) {
+			this.log(`service « ${!tokens ? "tokenService" : "users"} » absent — cette application ne provisionne pas d'émetteur de jetons.`, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		let identifier = identifierArg?.trim() ?? "";
+		if (!identifier && process.stdin.isTTY) {
+			const page = await users.listPage({ limit: 25 });
+			if (page.items.length > 0) {
+				await this.loadPrompts();
+				identifier = await this.prompts.select({
+					message: "Compte porteur du jeton :",
+					choices: page.items.map((u) => ({
+						name: `${u.identifier}${(u.roles ?? []).length ? ` ${DIM}(${(u.roles ?? []).join(", ")})${RESET}` : ""}`,
+						value: u.identifier
+					}))
+				});
+			}
+		}
+		if (!identifier) identifier = "admin";
+		const user = await users.findByIdentifier(identifier);
+		if (!user) {
+			this.log(`compte « ${identifier} » introuvable — crée-le : nodefony security:user:add ${identifier}`, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		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);
+		if (ttlS instanceof Error) {
+			this.log(ttlS.message, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		let issued;
+		try {
+			issued = await tokens.issueTokens(user, scopes, resource, ttlS);
+		} catch (e) {
+			if (e.oauthError === "invalid_target") {
+				const env = this.kernel?.environment ?? "?";
+				const enDev = env === "development";
+				this.log(`impossible d'émettre un jeton pour cette porte ici.
+
+  Ce n'est PAS un problème de serveur : cette commande n'en a pas
+  besoin, elle signe le jeton elle-même.
+
+  La porte visée : ${resource}\n  Environnement CONSTATÉ : ${env}\n\n` + (enDev ? `  Cette application n'accepte pas cette audience. Une audience se
+  DÉCLARE — c'est une liste blanche (RFC 8707), sans quoi tout
+  porteur obtiendrait un jeton pour la ressource de son choix :
+
+      use("@nodefony/security", {
+        jwt: { audiences: ["${resource}"] },\n      })\n\n  → puis npm run build (le runtime lit le dist)\n` : `  La porte est servie par un module de DÉVELOPPEMENT, absent en\n  « ${env} » : un jeton pour une porte absente n'aurait personne\n  pour l'accepter.\n\n  → NODE_ENV=development nodefony security:token${opts.write ? " --write" : ""}\n`) + `  → ou vise une autre porte : --resource <uri>`, "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+			throw e;
+		}
+		const token = issued.access_token;
+		const accordes = (issued.scope ?? "").split(/\s+/u).filter(Boolean);
+		const nonAccordes = scopes.filter((s) => !accordes.includes(s));
+		if (opts.json) {
+			process.stdout.write(`${JSON.stringify({
+				access_token: token,
+				resource,
+				scopes: accordes,
+				requested: scopes,
+				expires_in: issued.expires_in
+			}, null, 2)}\n`);
+			return this;
+		}
+		const w = (s) => {
+			process.stdout.write(s);
+		};
+		let write = opts.write === true;
+		if (!write && process.stdin.isTTY && !opts.json) {
+			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 ?? 0) / 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 (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);
+			if (requested instanceof Error) {
+				this.log(requested.message, "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+			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 { checkbox } = await chargePrompts();
+					const chosen = await checkbox({
+						message: "Poser le jeton chez quels agents ?",
+						choices: added.map((c) => ({
+							name: `${c.name} — ${c.scope === "projet" ? c.file : `$${c.home}/${c.file}`}`,
+							value: c.key,
+							checked: true
+						}))
+					});
+					targets = added.filter((c) => chosen.includes(c.key));
+				} else if (porteurs.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`);
+			w(`${DIM}  Vibe et Codex prennent le NOM de la variable, pas le secret — déclare la porte une fois :${RESET}\n\n  ${DIM}vibe mcp add nodefony --transport streamable-http \\${RESET}\n  ${DIM}  --url ${resource} --api-key-env ${MCP_TOKEN_ENV}${RESET}\n  ${DIM}codex mcp add nodefony --url ${resource} \\${RESET}\n  ${DIM}  --bearer-token-env-var ${MCP_TOKEN_ENV}${RESET}\n\n`);
+			return this;
+		}
+		w(`  export ${MCP_TOKEN_ENV}=${token}\n\n`);
+		w(`${DIM}  --write pose la valeur chez les agents présents · nodefony ai:mcp --auth câble .mcp.json${RESET}\n\n`);
+		return this;
+	}
+};
+//#endregion
+export { SecurityToken as default, ttlSeconds };

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

@@ -0,0 +1,131 @@
+import { Command, askPasswordMasked } from "nodefony";
+//#region nodefony/command/security-user-add.ts
+const options = {
+	helpGroup: "COMPTES ET SECRETS",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+const GREEN = "\x1B[32m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const BOLD = "\x1B[1m";
+const RESET = "\x1B[0m";
+/** Rôles du raccourci `--admin` — À PLAT (ne dépend pas d'une hiérarchie). */
+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";
+/**
+* `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).
+*
+* Identifiant : en argument, ou DEMANDÉ quand un terminal est là — la commande
+* est proposée au menu, où personne ne peut taper d'argument. Hors terminal
+* (CI, script), l'absence reste une erreur, avec la ligne exacte à taper.
+*
+* Mot de passe : `--password` (visible dans l'historique shell — accepté pour
+* les scripts) ou PROMPT MASQUÉ en TTY (recommandé). Rôles : `--roles a,b,c`
+* (CSV) ou `--admin` (raccourci `ROLE_ADMIN + ROLE_NODEFONY_ADMIN` → accès
+* console Studio). Défaut : `ROLE_USER`.
+*
+* Le service `users` est posé par l'APPLICATION (cf `provisionUsers` du
+* template d'app) — absent = message actionnable, pas de stack.
+*/
+var SecurityUserAdd = class extends Command {
+	constructor(cli) {
+		super("security:user:add", "crée un compte (mot de passe demandé masqué)", cli, options);
+		this.addArgument("[identifier]", "identifiant (login) du compte");
+		this.addOption("-p, --password <password>", "mot de passe (sinon : prompt masqué en TTY)");
+		this.addOption("-r, --roles <roles>", "rôles CSV (ex: ROLE_USER,ROLE_DEV) — défaut ROLE_USER");
+		this.addOption("-a, --admin", `compte administrateur (${ADMIN_ROLES.join(" + ")} — accès Studio)`);
+	}
+	/**
+	* Rôles que CETTE application connaît, lus de sa hiérarchie déclarée.
+	*
+	* 🔴 Jamais une liste recopiée ici : une constante en dur diverge dès que
+	* l'application déclare un rôle métier, et la commande proposerait alors des
+	* rôles qui n'existent pas tout en taisant ceux qui existent. La hiérarchie
+	* (`security.roleHierarchy`) est la seule source — ses clés sont les rôles
+	* qui couvrent, ses valeurs ceux qui sont couverts.
+	*
+	* Un rôle inconnu du RBAC n'est pas une faute : il est simplement inerte.
+	* On ne refuse donc rien, on PROPOSE ce qu'on sait.
+	*/
+	#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);
+		}
+		return [ROLE_BASE, ...[...all].filter((r) => r !== ROLE_BASE).sort()];
+	}
+	async generate(identifierArg, opts) {
+		let identifier;
+		try {
+			identifier = await this.askArgument(identifierArg, {
+				name: "identifier",
+				message: "Identifiant (login) du compte :"
+			});
+		} catch (e) {
+			this.log(e.message, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		const users = this.kernel?.container?.get("users");
+		if (!users) {
+			this.log("service \"users\" absent — l'application ne provisionne pas son annuaire utilisateurs. Ajoute-le (cf nodefony/security/provisionUsers.ts d'une app générée : container.set(\"users\", new UserService(repo, encoder)) à onKernelReady).", "ERROR");
+			process.exitCode = 1;
+			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");
+			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}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 été créé.", "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+		}
+		if (!password) {
+			this.log("mot de passe vide — rien n'a été créé.", "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		let roles;
+		if (opts.admin) roles = ADMIN_ROLES;
+		else if (opts.roles) roles = opts.roles.split(",").map((r) => r.trim()).filter(Boolean);
+		else if (process.stdin.isTTY) {
+			await this.loadPrompts();
+			const chosen = await this.prompts.checkbox({
+				message: `Rôles de « ${identifier} » :`,
+				choices: this.#knownRoles().map((r) => ({
+					name: r,
+					value: r,
+					checked: r === ROLE_BASE
+				}))
+			});
+			roles = chosen.length > 0 ? chosen : [ROLE_BASE];
+		} else roles = [ROLE_BASE];
+		const user = await users.createUser({
+			identifier,
+			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` : ""));
+		return this;
+	}
+};
+//#endregion
+export { SecurityUserAdd as default };

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

@@ -0,0 +1,102 @@
+import { Command } from "nodefony";
+//#region nodefony/command/security-user-delete.ts
+const options = {
+	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";
+/**
+* Rôle qui donne la main sur l'instance — celui dont il faut toujours garder un
+* porteur actif, sinon plus personne ne peut administrer l'application.
+*/
+const ADMIN_ROLE = "ROLE_NODEFONY_ADMIN";
+/**
+* `nodefony security:user:delete <identifiant>` — retire un compte.
+*
+* **Un geste destructeur ne se fait pas sur une frappe.** La commande MONTRE ce
+* qu'elle va supprimer (identifiant, rôles, identifiant interne), puis demande
+* une confirmation. Hors terminal, elle exige `--yes` : un script qui supprime
+* doit le dire dans sa ligne, jamais l'obtenir d'un prompt sauté.
+*
+* **Garde-fou anti-lockout** : le DERNIER administrateur actif ne se supprime
+* pas. Sans lui, plus personne n'accède à la console d'administration, et le
+* 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.
+*/
+var SecurityUserDelete = class extends Command {
+	constructor(cli) {
+		super("security:user:delete", "supprime un compte, après confirmation", cli, options);
+		this.addArgument("[identifier]", "identifiant (login) du compte à retirer");
+		this.addOption("-y, --yes", "ne pas demander confirmation (obligatoire hors terminal)");
+	}
+	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.", "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		let identifier;
+		try {
+			identifier = await this.askArgument(identifierArg, {
+				name: "identifier",
+				message: "Compte à SUPPRIMER :"
+			});
+		} 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;
+		}
+		if ((user.roles ?? []).includes(ADMIN_ROLE)) {
+			if (await users.countActiveAdmins(ADMIN_ROLE) <= 1) {
+				this.log(`« ${identifier} » est le DERNIER administrateur actif — refus.\n  Sans lui, plus personne n'administre cette application.\n  Crée d'abord un autre admin : nodefony security:user:add <id> --admin`, "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+		}
+		const w = (t) => {
+			process.stdout.write(t);
+		};
+		w(`\n${BOLD}Compte à supprimer${RESET}\n  identifiant : ${BOLD}${user.identifier}${RESET}\n  rôles       : ${(user.roles ?? []).join(", ") || "—"}\n  id interne  : ${DIM}${user.id}${RESET}\n\n`);
+		if (!opts.yes) {
+			if (!process.stdin.isTTY) {
+				this.log("confirmation impossible sans terminal — relance avec --yes si c'est voulu.", "ERROR");
+				process.exitCode = 1;
+				return this;
+			}
+			await this.loadPrompts();
+			if (!await this.prompts.confirm({
+				message: `Supprimer définitivement « ${identifier} » ?`,
+				default: false
+			})) {
+				w(`${YELLOW}annulé — rien n'a été supprimé.${RESET}\n\n`);
+				return this;
+			}
+		}
+		if (await users.delete({ id: user.id }) === 0) {
+			this.log(`aucune ligne supprimée pour « ${identifier} » — le compte a-t-il disparu entre-temps ?`, "ERROR");
+			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`);
+		return this;
+	}
+};
+//#endregion
+export { SecurityUserDelete as default };

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

@@ -0,0 +1,77 @@
+import { Command } from "nodefony";
+//#region nodefony/command/security-user-list.ts
+const options = {
+	helpGroup: "COMPTES ET SECRETS",
+	showBanner: false,
+	kernelEvent: "onReady",
+	quietBoot: true
+};
+const DIM = "\x1B[2m";
+const BOLD = "\x1B[1m";
+const RESET = "\x1B[0m";
+/** Défaut volontairement BORNÉ — une liste se borne, toujours. */
+const DEFAULT_LIMIT = 50;
+/**
+* `nodefony security:user:list` — qui a un compte dans cette application.
+*
+* **Lister n'est pas une fuite, et c'était la question.** Cette commande
+* s'exécute sur la machine qui possède déjà la base : elle ne divulgue rien que
+* son utilisateur ne puisse lire avec un client SQL. Ce qui serait dangereux est
+* ailleurs, et gardé ici : **jamais le hachage du mot de passe**, jamais les
+* secrets de second facteur, jamais les jetons d'un fournisseur social. La
+* sortie est composée champ par champ — un `console.table(user)` livrerait le
+* credential, parce que le repository, lui, le voit.
+*
+* Le contraire — ne pas pouvoir lister — a un coût réel : on crée un compte, on
+* ne voit pas ce qu'on a créé, et on recommence en doublon.
+*
+* La pagination est NATIVE (`users.listPage`) : jamais un `find()` complet
+* ramené en mémoire, indolore sur trois comptes et fatal sur cent mille.
+*/
+var SecurityUserList = class extends Command {
+	constructor(cli) {
+		super("security:user:list", "liste les comptes : identifiant, rôles, état", cli, options);
+		this.addOption("-q, --query <texte>", "filtre sur l'identifiant (sous-chaîne, insensible à la casse)");
+		this.addOption("-r, --role <role>", "n'affiche que les porteurs d'un rôle");
+		this.addOption("-l, --limit <n>", `nombre maximum de comptes (défaut ${DEFAULT_LIMIT})`);
+		this.addOption("-j, --json", "sortie JSON (scripts/CI)");
+	}
+	async generate(opts) {
+		const users = this.kernel?.container?.get("users");
+		if (!users) {
+			this.log("service « users » absent — l'application ne provisionne pas son annuaire utilisateurs.", "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		const limit = Number.parseInt(opts.limit ?? "", 10);
+		const page = await users.listPage({
+			limit: Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_LIMIT,
+			...opts.query ? { q: opts.query } : {},
+			...opts.role ? { role: opts.role } : {}
+		});
+		const rows = page.items.map((u) => ({
+			identifiant: u.identifier,
+			rôles: (u.roles ?? []).join(", ") || "—",
+			actif: u.isActive() ? "oui" : "non",
+			verrouillé: u.isLocked() ? "OUI" : "—",
+			id: u.id
+		}));
+		if (opts.json) {
+			process.stdout.write(`${JSON.stringify({
+				items: rows,
+				hasNext: page.hasNext
+			}, null, 2)}\n`);
+			return this;
+		}
+		if (rows.length === 0) {
+			process.stdout.write(`aucun compte${opts.query || opts.role ? " pour ce filtre" : ""} — nodefony security:user:add <identifiant>\n`);
+			return this;
+		}
+		process.stdout.write(`\n${BOLD}👤 Comptes${RESET}\n`);
+		console.table(rows);
+		process.stdout.write(`${rows.length} compte(s)` + (page.hasNext ? `${DIM} — page bornée, il y en a d'autres (--limit)${RESET}` : "") + `\n\n`);
+		return this;
+	}
+};
+//#endregion
+export { SecurityUserList as default };