@nodefony/devkit 10.0.0-beta.2 → 10.0.0-beta.4

package/README.md

@@ -75,13 +75,64 @@ navigateur — d'où la commande, qui reste la porte utile.
 npx nodefony ai:mcp        # écrit .mcp.json ; --dry-run pour voir sans écrire
 ```
 
-Sept outils : **`nodefony_inspect`** (ce qui est monté), **`nodefony_check`**
+Neuf outils : **`nodefony_inspect`** (ce qui est monté), **`nodefony_check`**
 (ce qui manque — la commande s'appelle `doctor`), **`nodefony_symbols`** (ce qu'une
 API du framework signifie), **`nodefony_card`** (par où commencer),
 **`nodefony_docs`** (la documentation des modules installés), **`nodefony_admin_list`**
 et **`nodefony_admin_call`** (lectures du data plane d'administration, jeton porteur
-du scope `admin:read` exigé). Ce sont les mêmes briques que les commandes — une
-source, plusieurs portes.
+du scope `admin:read` exigé), **`nodefony_observe`** (ce que l'application fait réellement de ses requêtes, mesuré pendant qu'elle tourne) et **`nodefony_profile_route`** (une route mesurée par l'outil lui-même, au nom d'un compte s'il le faut). Ce sont les mêmes
+briques que les commandes — une source, plusieurs portes.
+
+### Mesurer l'application qui tourne — `nodefony_observe`
+
+L'outil observe l'application pendant une fenêtre de 1 à 50 secondes (10 par
+défaut) et rend ce que son profileur de développement a mesuré : où part le
+temps de chaque route, les requêtes SQL répétées dans une boucle (N+1), les
+erreurs `5xx` avec leurs lignes de journal, et les blocages de la boucle
+d'événements. **Il ne génère aucun trafic** : on ouvre la page, on joue les
+tests ou on envoie des requêtes pendant que la fenêtre court.
+
+```jsonc
+// tools/call
+{ "name": "nodefony_observe", "arguments": { "durationSec": 10 } }
+// optionnel : "route": "<nom de la route>", "includeTooling": true
+```
+
+Extrait d'un rapport réel (une route qui plante, sur une application démarrée
+depuis dix secondes) :
+
+```text
+Verdict : anomalies (2) — observation complète
+Fenêtre : 6.0 s sur 6.0 s · 3 relevé(s) · 39 requête(s) (39 HTTP, 0 WebSocket) · 0 perdue(s) · 0 de l'outillage écartée(s)
+Process : pid 46402, démarré il y a 10 s · boucle d'événements : retard moyen 4.0 ms, pire blocage 665 ms · tas -10.0 Mo (indicatif, sans GC)
+
+Anomalies (les plus coûteuses d'abord) :
+1. Erreurs — route `crash-sync` (DefaultController.crashSync) : 13 sur 13 — « simulated sync crash ». requestId : d706bfef-…, 577adac2-…, 207f8121-… — journal ci-dessous.
+2. Boucle d'événements bloquée — jusqu'à 665 ms d'un tenant (retard moyen 4.0 ms) : […] Le process a démarré il y a 10 s : ce blocage peut venir du démarrage […]
+
+Journal des requêtes en erreur (syslog de l'application, lu au relevé qui les a vues) :
+- requestId d706bfef-… — route `crash-sync`, statut 500 :
+    ERROR [req] GET 500 http://127.0.0.1:5151/nodefony/test/crash/sync 1.4ms 127.0.0.1 [d706bfef] simulated sync crash
+```
+
+C'est un outil **long** : un instantané part en progression toutes les deux
+secondes, un client qui l'annule l'arrête au relevé suivant — qu'il ferme le flux de la réponse (révision courante de MCP) ou envoie une notification d'annulation (révision précédente, celle du SDK officiel) —, et un
+rechargement du serveur pendant la fenêtre rend un rapport partiel qui le dit.
+Ce qu'il faut savoir pour s'en servir sans conclure à tort :
+
+- les durées et le temps « par requête » portent sur les requêtes **servies** ;
+  les refus `401`/`403` sont comptés à part ;
+- `action.self` est le temps de l'action et des services qu'elle appelle, une
+  fois retirés le rendu, l'initialisation et le SQL ; « SQL (cumul) » additionne
+  les requêtes, même lancées en parallèle ;
+- les valeurs SQL sont masquées (`?`) : le rapport montre la forme d'une requête,
+  jamais une donnée ; le journal n'en garde que les lignes WARNING et plus graves ;
+- le journal des erreurs n'est lu que pour un appel **authentifié** (scope
+  `admin:read`) ; les routes `/nodefony/…` (outillage) sont écartées, sauf
+  `includeTooling`.
+
+La façon de lire chaque anomalie et le geste qui la corrige sont dans le skill
+d'agent `nodefony-troubleshoot` (§ « Mesurer l'application qui tourne »).
 
 **Ce n'est pas un process de plus.** Depuis la révision `2026-07-28` du transport
 « Streamable HTTP », un serveur MCP est un simple endpoint `POST` sans session :
@@ -89,6 +140,15 @@ c'est donc une **route de votre application**. Elle n'existe que pendant qu'elle
 tourne, suit chaque rechargement du serveur de développement, et n'a aucun cache
 à invalider.
 
+**Et sans serveur ?** Un agent qui travaille là où personne n'a lancé
+`nodefony dev` — en CI, dans le runner d'un agent cloud — ne joint pas cette
+route. Il lance lui-même `npx nodefony ai:stdio` (commande de `@nodefony/ai`) et
+lui parle sur l'entrée et la sortie standard : mêmes outils, mais le code du
+démarrage, sans rechargement à chaud, et aucun trafic à mesurer —
+`nodefony_observe` et `nodefony_profile_route` le disent et renvoient ici. En
+local, la route reste le bon choix. Les deux transports, côte à côte :
+[`@nodefony/ai` — Deux transports](https://github.com/nodefony/nodefony-core/blob/main/src/packages/@nodefony/ai/docs/mcp.md#-deux-transports--http-ou-stdio).
+
 **Ce qui la protège**, et il faut le savoir avant de s'étonner d'un `403` :
 
 - toute **adresse non locale** est refusée (`mcp.allowRemote`) ;
@@ -100,6 +160,76 @@ tourne, suit chaque rechargement du serveur de développement, et n'a aucun cach
 - les outils sont en **lecture seule**, et la liste est une allowlist
   (`mcp.tools`).
 
+### Mesurer une route — `nodefony_profile_route`
+
+Là où `nodefony_observe` attend le trafic, `nodefony_profile_route` le **produit** :
+il envoie lui-même N requêtes `GET` (ou `HEAD`) sur un chemin de l'application,
+retrouve leurs profils par l'identifiant qu'il pose (`x-request-id`) et rend le
+même rapport. C'est la boucle « je modifie → je mesure » en un appel.
+
+```jsonc
+// tools/call
+{
+  "name": "nodefony_profile_route",
+  "arguments": { "path": "/orders?page=2", "count": 50 },
+}
+// optionnel : "concurrency" (défaut 4, max 8), "warmup" (défaut 3, hors mesures),
+//             "method": "HEAD", "as": "<identifiant>", "anonymous": true
+```
+
+`path` est un **chemin**, jamais une URL : hôte, schéma et `//` sont refusés,
+l'outil ne vise que l'application elle-même. Au plus 200 requêtes par appel —
+sous les 500 profils que garde le profileur — et 45 secondes de tir.
+
+**Au nom de qui.** Une page protégée vue sans compte ne rend que des refus.
+Quand le jeton MCP porte le scope `admin:write`, l'outil joue son
+**propriétaire** : il ouvre une vraie session à son nom par le flux de connexion
+de l'application (un ticket à usage unique, présenté en boucle locale à
+`POST /nodefony/devkit/profile-session`), tire avec, puis la détruit — l'audit
+l'écrit sous la raison `devkit`. `as` joue un autre compte, à condition que ses
+rôles soient inclus dans ceux du propriétaire, hiérarchie comprise : jouer un
+compte ne monte jamais en droits ; sans `admin:write`, `as` reçoit sur une porte
+protégée un défi `403 insufficient_scope` qui nomme le scope à demander. Sans ce
+scope, l'outil joue l'anonyme et le rapport donne la commande :
+
+```bash
+npx nodefony security:mcp:token --scope "admin:read admin:write" --write
+```
+
+Extrait de deux appels réels, avant puis après la correction d'un N+1 (la même
+lecture, une requête par compte, puis une seule requête `$in`) :
+
+```text
+Verdict : anomalies (1) — observation complète
+Tir : 30/30 requête(s) GET /nodefony/test/db/n-plus-one · concurrence 4 · 106 ms · chauffe de 3 requête(s) hors mesures (p50 1.5 ms, max 2.5 ms)
+Joué en tant que : `admin` (ROLE_ADMIN, ROLE_NODEFONY_ADMIN, ROLE_DEV, ROLE_SUPERVISOR)
+Reçu par le client : 2xx 30 · 3xx 0 · 401 0 · 403 0 · autres 4xx 0 · 5xx 0 · sans réponse 0
+
+Anomalies (les plus coûteuses d'abord) :
+1. N+1 — route `DbController::nPlusOne` (DbController.nPlusOne) : `select … from "User" where "User"."id" = ? …` répétée ×16 dans une requête (30 requête(s) touchée(s), 14 ms cumulés). […] Remède habituel : charger la relation en une requête (`relations`, `$in`).
+
+route | type | n | p50 | p95 | max | 2xx/3xx/4xx/5xx | SQL par requête moy/max | temps par requête
+`DbController::nPlusOne` (DbController.nPlusOne) | http | 30 | 1.2 ms | 1.7 ms | 1.7 ms | 30/0/0/0 | 18.0/18 | SQL (cumul) 0.7 ms · action.self 0.2 ms · send 0.1 ms
+
+— après correction —
+Verdict : ok — observation complète
+`DbController::nPlusOneFixed` (DbController.nPlusOneFixed) | http | 30 | 0.7 ms | 0.9 ms | 2.1 ms | 30/0/0/0 | 3.0/3 | SQL (cumul) 0.4 ms · send 0.1 ms · action.self 0.1 ms
+```
+
+Ce que le rapport dit **en tête**, avant tout chiffre : les requêtes refusées
+(`401`/`403` — verdict « rien à juger »), redirigées (vers la page de
+connexion), restées sans réponse, et les profils non retrouvés. Une mesure qui ne
+porte pas sur ce qui était demandé le dit d'abord.
+
+À savoir :
+
+- ce sont de **vraies requêtes** : une page qui écrit en `GET` écrit N fois — un
+  compteur, ou une session créée pour chaque visiteur anonyme ;
+- les zones à jeton (`jwt`, `external-jwt`) ne sont pas jouées : leurs requêtes
+  rendent `401`, et le rapport le dit ;
+- un tir plus court que cinq périodes de la sonde laisse la boucle d'événements
+  « non mesurée » plutôt que d'afficher un zéro trompeur.
+
 ### Protéger la porte par OAuth 2.1
 
 Par défaut la porte est anonyme, et ce qui la borne est le périmètre ci-dessus.
@@ -170,7 +300,8 @@ module de votre application peut publier les siens en implémentant
 `getMcpTools(): IMcpTool[]` :
 
 ```ts
-import { Module, mcpText, type IMcpTool } from "nodefony";
+import { Module, type IMcpTool } from "nodefony";
+import { mcpText } from "@nodefony/ai";
 
 class Shop extends Module {
   getMcpTools(): IMcpTool[] {
@@ -185,6 +316,8 @@ class Shop extends Module {
           properties: { sku: { type: "string" } },
           required: ["sku"],
         },
+        // Lecture dans la base de l'application : rien n'est modifié.
+        annotations: { readOnlyHint: true, openWorldHint: false },
         handler: async (args) => mcpText(await this.stock(String(args.sku))),
       },
     ];
@@ -197,6 +330,15 @@ Rien ne s'enregistre au démarrage : la liste est relue à chaque requête, et
 est déclaré. Un outil écarté (nom hors forme, nom déjà pris, handler absent) le
 dit en `WARNING`, jamais en silence.
 
+Chaque outil **dit ce qu'il fait** par ses `annotations` : `readOnlyHint: true`
+pour une lecture, et un outil qui modifie quoi que ce soit DOIT se déclarer
+`readOnlyHint: false`, avec `destructiveHint` (`true` s'il efface ou écrase).
+Sans annotation, la spécification MCP tient l'outil pour une écriture
+destructive : l'agent de code demande alors confirmation pour la moindre
+lecture. Les sept outils intégrés se publient `readOnlyHint: true`,
+`openWorldHint: false`. Grille de choix et erreurs à éviter :
+`node_modules/@nodefony/ai/docs/mcp.md`, « Dire ce que fait l'outil ».
+
 Un outil peut aussi se **réserver** — `scopes: ["shop:read"]` (tous exigés) ou
 `requiresAuth: true` — et son handler reçoit alors l'appelant en second
 paramètre. Il est alors absent de `tools/list` **et** inappelable en le nommant.
@@ -228,13 +370,17 @@ npx nodefony ai:sync            # --dry-run pour voir sans écrire, --json pour
   = nodefony-add-crud              @nodefony/devkit
   = nodefony-add-realtime-channel  @nodefony/devkit
   = nodefony-add-service           @nodefony/devkit
+  = nodefony-authentication        @nodefony/devkit
   = nodefony-browser               @nodefony/devkit
   = nodefony-dev                   @nodefony/devkit
   = nodefony-devops                @nodefony/devkit
   = nodefony-migrate-schema        @nodefony/devkit
   = nodefony-protect-route         @nodefony/devkit
+  = nodefony-security-review       @nodefony/devkit
+  = nodefony-troubleshoot          @nodefony/devkit
+  = nodefony-upgrade               @nodefony/devkit
 
-  0 posé(s) · 0 mis à jour · 8 inchangé(s)
+  0 posé(s) · 0 mis à jour · 12 inchangé(s)
 ```
 
 **Le préfixe `nodefony-` vous laisse la place.** Ces pointeurs arrivent dans

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

@@ -1,9 +1,8 @@
-//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorate.js
+// \0@oxc-project+runtime@0.155.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);
 	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-//#endregion
 export { __decorate as default };

package/dist/_virtual/{_@oxc-project_runtime@0.152.0 → _@oxc-project_runtime@0.155.0}/helpers/esm/decorateParam.js

@@ -1,8 +1,7 @@
-//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorateParam.js
+// \0@oxc-project+runtime@0.155.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
 	};
 }
-//#endregion
 export { __decorateParam as default };

package/dist/index.js

@@ -1,14 +1,15 @@
+import { BUILTIN_MCP_TOOL_KEYS, builtinMcpTools, selectBuiltinMcpTools } from "./nodefony/mcp/tools.js";
 import defaults, { devkitConfigSchema } from "./nodefony/config/config.js";
 import { defineDevkitConfig } from "./nodefony/config/defineModuleConfig.js";
 import { buildCard } from "./nodefony/src/card.js";
-import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
 import DevkitService_default from "./nodefony/service/DevkitService.js";
 import DevkitController_default from "./nodefony/controllers/DevkitController.js";
 import McpController_default from "./nodefony/controllers/McpController.js";
-import { Kernel, Module, services } from "nodefony";
+import ProfileSessionController_default from "./nodefony/controllers/ProfileSessionController.js";
+import { Module, services } from "nodefony";
 import { controllers } from "@nodefony/framework";
-//#region index.ts
+// index.ts
 let DevkitModule = class DevkitModule extends Module {
 	/**
 	* ⚠️ Ce module ne pose PLUS de commande CLI.
@@ -37,12 +38,24 @@ let DevkitModule = class DevkitModule extends Module {
 		this.options = defineDevkitConfig(input ?? {});
 		return this;
 	}
+	/**
+	* Déclare les outils `nodefony_*` — comme n'importe quel module.
+	*
+	* Aucun cas particulier côté collecte : `@nodefony/ai` les ramasse avec ceux
+	* de l'application, et seul le préfixe `nodefony_`, réservé aux modules
+	* `@nodefony/*`, les distingue. Un service absent (module en cours de
+	* démontage) ne déclare rien plutôt que de lever.
+	*
+	* @returns les outils retenus par l'allowlist `mcp.tools`
+	*/
+	getMcpTools() {
+		return this.get("devkit")?.mcpTools() ?? [];
+	}
 };
-DevkitModule = __decorate([
-	controllers([DevkitController_default, McpController_default]),
-	services([DevkitService_default]),
-	__decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])
-], DevkitModule);
+DevkitModule = __decorate([controllers([
+	DevkitController_default,
+	McpController_default,
+	ProfileSessionController_default
+]), services([DevkitService_default])], DevkitModule);
 var devkit_default = DevkitModule;
-//#endregion
-export { DevkitController_default as DevkitController, DevkitService_default as DevkitService, McpController_default as McpController, buildCard, devkit_default as default, defineDevkitConfig, devkitConfigSchema };
+export { BUILTIN_MCP_TOOL_KEYS, DevkitController_default as DevkitController, DevkitService_default as DevkitService, McpController_default as McpController, ProfileSessionController_default as ProfileSessionController, buildCard, builtinMcpTools, devkit_default as default, defineDevkitConfig, devkitConfigSchema, selectBuiltinMcpTools };

package/dist/nodefony/config/config.js

@@ -1,6 +1,7 @@
-import { BUILTIN_MCP_TOOL_KEYS, canonicalResourceUri } from "nodefony";
+import { BUILTIN_MCP_TOOL_KEYS } from "../mcp/tools.js";
 import { z } from "zod";
-//#region nodefony/config/config.ts
+import { mcpConfigSchema } from "@nodefony/ai";
+// nodefony/config/config.ts
 /**
 * @nodefony/devkit — CONFIGURATION DU MODULE (schéma Zod = source unique).
 *
@@ -26,146 +27,25 @@ import { z } from "zod";
 * la métadonnée. Ces flags ressortent dans le JSON Schema lu par Studio.
 */
 /**
-* Rôle **serveur de ressource OAuth 2.1** de la porte MCP — éteint par défaut.
-*
-* ⭐ **Un seul réglage commande : {@link authorizationServers}.** Vide, la porte
-* se comporte exactement comme avant — anonyme, aucune métadonnée publiée,
-* aucun `401`. Non vide, le rôle s'allume ENTIÈREMENT. Un interrupteur séparé
-* aurait permis deux états qui se contredisent (« protégé mais sans serveur
-* d'autorisation », « métadonnées publiées mais jetons ignorés »), et c'est
-* précisément ce genre d'état que personne ne diagnostique.
-*
-* ⚠️ **Allumer ce rôle ne suffit pas à protéger quoi que ce soit** : il faut
-* aussi qu'un service du conteneur sache VÉRIFIER un jeton. S'il n'y en a pas,
-* la porte refuse de servir (et le dit fort) plutôt que d'accepter n'importe
-* quel porteur.
-*/
-const mcpAuthorizationSchema = z.strictObject({
-	/**
-	* Serveurs d'autorisation capables d'émettre un jeton pour cette porte.
-	*
-	* Vide (défaut) = rôle éteint. Non vide, la spécification MCP impose que le
-	* document de métadonnées les publie (« MUST include the
-	* `authorization_servers` field containing at least one authorization
-	* server ») : sans eux, un client apprendrait qu'un jeton est nécessaire
-	* sans jamais pouvoir en obtenir un.
-	*/
-	authorizationServers: z.array(z.string()).default([]).describe("Émetteurs de jetons acceptés (issuer OAuth) ; vide = aucune autorisation"),
-	/**
-	* URI canonique publique de cette porte — l'audience que les jetons doivent
-	* porter (RFC 8707).
-	*
-	* 🔴 **Elle s'écrit, elle ne se devine pas depuis l'en-tête `Host`.** Si
-	* l'URI publiée et l'audience attendue venaient toutes deux de la requête,
-	* un `Host` forgé obtiendrait un jeton d'audience arbitraire *et* passerait
-	* la vérification : la liaison d'audience, dont c'est l'unique raison
-	* d'être, ne protégerait plus rien.
-	*
-	* Ex. `https://mon-app.example/nodefony/mcp`.
-	*/
-	resource: z.string().default("").describe("URI publique de la porte MCP (audience attendue des jetons)"),
-	/**
-	* Autres adresses de CETTE MÊME porte, dont les jetons sont aussi acceptés.
-	*
-	* Le cas courant : l'application sert la porte en clair sur un port et en
-	* TLS sur un autre. Un jeton émis pour l'une était alors refusé sur l'autre
-	* — la liaison d'audience (RFC 8707) faisant son travail. Nommer la seconde
-	* adresse est la bonne réponse ; relâcher la liaison n'en serait pas une.
-	*
-	* 🔴 Ces valeurs s'ÉCRIVENT. Dérivées du `Host`, un en-tête forgé
-	* obtiendrait un jeton d'audience arbitraire ET passerait la vérification.
-	* Seule `resource` est publiée en RFC 9728 : le document n'admet qu'une
-	* valeur, et un client n'a besoin que d'une adresse.
-	*
-	* ⚠️ L'ÉMETTEUR doit servir ces audiences (`security.jwt.audiences`), sinon
-	* il refuse de les émettre — `invalid_target`, et à juste titre.
-	*/
-	additionalResources: z.array(z.string()).default([]).describe("Autres URI de la même porte dont les jetons sont acceptés (jamais dérivées du Host)"),
-	/** Nom lisible, affiché pendant le consentement. */
-	resourceName: z.string().optional().describe("Nom affiché au consentement"),
-	/** Page de documentation destinée à un humain. */
-	resourceDocumentation: z.string().optional().describe("URL de documentation de la ressource"),
-	/**
-	* Servir une requête SANS jeton comme anonyme, au lieu de la refuser.
-	*
-	* `false` (défaut) : sans jeton, `401` + `WWW-Authenticate` — c'est ce qui
-	* apprend au client qu'une autorisation existe et où l'obtenir.
-	* `true` : la porte reste ouverte aux outils publics, et les outils
-	* réservés restent retenus. Utile en développement ; c'est un choix qui
-	* s'écrit, jamais un comportement dont on hérite.
-	*/
-	anonymous: z.boolean().default(false).describe("Tolérer les requêtes sans jeton (outils publics seulement)")
-}).superRefine((value, ctx) => {
-	if (value.authorizationServers.length === 0) return;
-	if (value.resource.length === 0) {
-		ctx.addIssue({
-			code: "custom",
-			path: ["resource"],
-			message: "`mcp.authorization.resource` est requis dès qu'un serveur d'autorisation est déclaré : c'est l'URI publique de la porte, et l'audience que les jetons doivent porter (RFC 8707)."
-		});
-		return;
-	}
-	try {
-		canonicalResourceUri(value.resource);
-	} catch (error) {
-		ctx.addIssue({
-			code: "custom",
-			path: ["resource"],
-			message: error.message
-		});
-	}
-});
-/**
-* Réglages du serveur MCP — extrait en constante pour une raison mécanique.
+* Réglages du serveur MCP — le schéma de la porte vient de `@nodefony/ai`
+* (source unique, {@link mcpConfigSchema}) ; devkit n'y ajoute que l'allowlist
+* de ses outils intégrés.
 *
 * ⚠️ **Piège Zod 4** : un `.default({})` posé à plat sur un sous-objet NE
 * ré-applique PAS les défauts de ses champs. Le pattern du dépôt est donc
 * `sous.default(() => sous.parse({}))` — le callback force la ré-évaluation, et
 * une application qui n'écrit rien obtient bien les valeurs d'usine.
 */
-const mcpSchema = z.strictObject({
-	/** Répond-on aux requêtes MCP ? Coupé, la route rend `404`. */
-	enabled: z.boolean().default(true).describe("Active l'endpoint MCP (POST /nodefony/mcp)"),
-	/**
-	* Origines acceptées quand l'en-tête `Origin` est PRÉSENT.
-	*
-	* ⭐ La subtilité qui fait toute la sécurité : un client MCP natif est un
-	* process, pas un navigateur — **il n'envoie pas d'`Origin`**. Une page web
-	* malveillante, elle, en envoie toujours un vers `localhost`. La règle est
-	* donc : *absent → on passe* ; *présent et hors de cette liste → `403`*.
-	* C'est ce que la spec exige (`transports/streamable-http` §Security :
-	* « Servers MUST validate the `Origin` header […] MUST respond with HTTP 403
-	* Forbidden »), et c'est ce qui ferme le DNS rebinding.
-	*
-	* Vide (défaut) = aucune origine de navigateur n'est admise.
-	*/
-	allowedOrigins: z.array(z.string()).default([]).describe("Origines navigateur admises ; vide = aucune"),
-	/**
-	* Accepter un appel dont l'adresse distante n'est pas locale.
-	*
-	* La spec recommande de n'écouter que sur la boucle locale ; le serveur de
-	* l'application, lui, écoute pour le développement. La garde est donc portée
-	* par la route : toute adresse non locale reçoit `403`.
-	*/
-	allowRemote: z.boolean().default(false).describe("Autorise les appels depuis une adresse non locale"),
-	/**
-	* Outils exposés — **allowlist**, et lecture seule.
-	*
-	* Tant qu'aucun outil n'écrit, le pire qu'obtienne un appelant illégitime est
-	* la description de l'application. Le jour où un générateur sera exposé, ce
-	* sera un ajout explicite ici — et cette ligne sera l'endroit où quelqu'un
-	* décide de donner à un agent le droit d'écrire des fichiers.
-	*/
-	tools: z.array(z.string()).default([...BUILTIN_MCP_TOOL_KEYS]).describe("Outils MCP activés (allowlist, lecture seule)"),
-	/**
-	* Rôle serveur de ressource OAuth 2.1 — **éteint par défaut**.
-	*
-	* Tant qu'aucun serveur d'autorisation n'est déclaré, la porte se comporte
-	* comme elle l'a toujours fait : anonyme, protégée par son seul périmètre
-	* (`policy: "dev"` + gardes `Origin`/localité).
-	*/
-	authorization: mcpAuthorizationSchema.default(() => mcpAuthorizationSchema.parse({})).describe("Serveur de ressource OAuth 2.1 (RFC 9728/6750/8707)")
-});
+const mcpSchema = mcpConfigSchema.extend({ 
+/**
+* Outils exposés — **allowlist**, et lecture seule.
+*
+* Tant qu'aucun outil n'écrit, le pire qu'obtienne un appelant illégitime est
+* la description de l'application. Le jour où un générateur sera exposé, ce
+* sera un ajout explicite ici — et cette ligne sera l'endroit où quelqu'un
+* décide de donner à un agent le droit d'écrire des fichiers.
+*/
+tools: z.array(z.string()).default([...BUILTIN_MCP_TOOL_KEYS]).describe("Outils MCP activés (allowlist, lecture seule)") });
 const devkitConfigSchema = z.strictObject({
 	/** Interrupteur du module — l'app peut le charger sans l'activer. */
 	enabled: z.boolean().default(true).describe("Active les fonctionnalités du module devkit"),
@@ -196,5 +76,4 @@ const devkitConfigSchema = z.strictObject({
 });
 /** Défauts matérialisés (passés au `super()` du Module). */
 const defaults = devkitConfigSchema.parse({});
-//#endregion
 export { defaults as default, devkitConfigSchema };

package/dist/nodefony/config/defineModuleConfig.js

@@ -1,7 +1,7 @@
 import { devkitConfigSchema } from "./config.js";
 import { parseModuleConfig } from "nodefony";
 import { z } from "zod";
-//#region nodefony/config/defineModuleConfig.ts
+// nodefony/config/defineModuleConfig.ts
 /**
 * @nodefony/devkit — LE COMMENT : builder PUR de la config.
 *
@@ -32,5 +32,4 @@ function defineDevkitConfig(config = {}) {
 function devkitConfigJsonSchema() {
 	return z.toJSONSchema(devkitConfigSchema);
 }
-//#endregion
 export { defineDevkitConfig, devkitConfigJsonSchema };

package/dist/nodefony/controllers/DevkitController.js

@@ -1,7 +1,6 @@
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
 import { Controller, controller, route } from "@nodefony/framework";
-//#region nodefony/controllers/DevkitController.ts
+// nodefony/controllers/DevkitController.ts
 /**
 * La carte de visite de l'application, servie en HTTP.
 *
@@ -45,16 +44,10 @@ let DevkitController = class DevkitController extends Controller {
 		return this.renderJson(this.#service().getCard());
 	}
 };
-__decorate([
-	route("devkit-card", {
-		path: "/card",
-		method: "GET"
-	}),
-	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", []),
-	__decorateMetadata("design:returntype", Promise)
-], DevkitController.prototype, "card", null);
-DevkitController = __decorate([controller("/nodefony/devkit/api"), __decorateMetadata("design:paramtypes", [Object])], DevkitController);
+__decorate([route("devkit-card", {
+	path: "/card",
+	method: "GET"
+})], DevkitController.prototype, "card", null);
+DevkitController = __decorate([controller("/nodefony/devkit/api")], DevkitController);
 var DevkitController_default = DevkitController;
-//#endregion
 export { DevkitController_default as default };