@nodefony/devkit 10.0.0-beta.3 → 10.0.0-beta.5

package/dist/nodefony/controllers/McpController.js

@@ -1,17 +1,10 @@
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
-import __decorateParam from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
-import { ACCESS_TOKEN_VERIFIER, JsonRpcError, Nodefony, authorizeProtectedResource, checkMcpAccess, collectMcpTools, createMcpResponseStream, handleMcpMessage, jsonRpcFailure, mcpCallerRoles, protectedResourceMetadataUrl, readBearerHeader } from "nodefony";
-import { Body, Controller, Headers, controller, route } from "@nodefony/framework";
-//#region nodefony/controllers/McpController.ts
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import __decorateParam from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorateParam.js";
+import { Body, Controller, controller, route } from "@nodefony/framework";
+// nodefony/controllers/McpController.ts
 /**
-* Plafond d'un événement sur le flux de réponse MCP, octets UTF-8 — celui de la
-* réponse finale, qui porte le résultat entier de l'outil (16 Mio).
-*/
-const MCP_STREAM_MAX_EVENT_BYTES = 16777216;
-/**
-* Serveur **Model Context Protocol** de l'application — la porte par laquelle
-* un agent externe l'interroge.
+* Porte **Model Context Protocol** de DÉVELOPPEMENT — celle par laquelle
+* l'agent de code du développeur interroge l'application.
 *
 * ## Pourquoi une route, et pas un process
 *
@@ -28,7 +21,7 @@ const MCP_STREAM_MAX_EVENT_BYTES = 16777216;
 *
 * **Par défaut, le périmètre — et lui seul.** Ce module est `policy: "dev"`,
 * donc cette route n'existe pas en production ; restent les deux gardes que la
-* spec impose au transport, portées par {@link checkMcpAccess} : l'en-tête
+* spec impose au transport (`checkMcpAccess`, `@nodefony/ai`) : l'en-tête
 * `Origin` et la localité de l'appelant. Elles visent le seul vecteur réel
 * contre un serveur local — une page web ouverte dans le navigateur du
 * développeur.
@@ -55,12 +48,10 @@ const MCP_STREAM_MAX_EVENT_BYTES = 16777216;
 * Rôle déclaré + aucun vérificateur = `503` et journal `CRITIC`, jamais une
 * porte qui laisse passer les porteurs sans les lire.
 *
-* **Mince par design** : tout le protocole vit AU CŒUR (`nodefony`, en fonctions
-* pures) ; ce controller ne fait que traduire HTTP ↔ JSON-RPC et fournir au
-* collecteur ce que lui seul connaît — le service du module, le broker
-* d'administration, la racine du projet. C'est ce qui permet à un autre module
-* d'ouvrir la même porte ailleurs (en production, sous authentification) sans
-* réécrire une ligne de protocole.
+* **Mince par design** : la porte est définie par `defineMcpGate` (`@nodefony/ai`)
+* dans `DevkitService.mcpGate()`, à partir de `devkit.mcp.*` ; ce controller
+* ne fait que la servir. Une application ouvre SA porte, en développement ou en
+* production, exactement de la même façon.
 */
 let McpController = class McpController extends Controller {
 	constructor(context) {
@@ -73,216 +64,24 @@ let McpController = class McpController extends Controller {
 		return svc;
 	}
 	/**
-	* Ce qui, dans cette application, sait valider un jeton — ou rien.
-	*
-	* Résolu par NOM dans le conteneur, et non importé : ce module est
-	* `policy: "dev"` et ne peut pas dépendre de `@nodefony/security`, qui porte
-	* la cryptographie. Une application peut donc fournir sa propre
-	* implémentation du contrat sous ce nom, sans que cette porte en sache quoi
-	* que ce soit.
-	*
-	* L'absence est un cas NORMAL (rôle éteint) ou une faute de configuration
-	* (rôle allumé) — c'est l'appelant qui tranche, pas cette méthode.
-	*/
-	#tokenVerifier() {
-		return this.get(ACCESS_TOKEN_VERIFIER) ?? void 0;
-	}
-	/**
-	* L'en-tête porte-t-il un gabarit d'interpolation jamais substitué ?
-	*
-	* Un `.mcp.json` déclare son jeton par `${NF_MCP_TOKEN}` : le client
-	* développe la variable, ou transmet la chaîne telle quelle si elle manque.
-	* Le second cas ne se distingue d'un jeton invalide par AUCUN symptôme
-	* observable de l'extérieur, et c'est pourtant le plus fréquent des deux —
-	* une session lancée depuis un terminal où la variable n'était pas posée.
-	*
-	* @param header - la valeur brute de l'en-tête `Authorization`
-	* @returns vrai si ce qui est présenté est resté un gabarit
-	*/
-	#isUnsubstitutedTemplate(header) {
-		const read = readBearerHeader(header);
-		return read.kind === "token" && read.token.startsWith("${") && read.token.endsWith("}");
-	}
-	/**
-	* Le corps reçu est-il un texte qui ne se PARSE pas en JSON ?
-	*
-	* Le parseur HTTP ignore un JSON malformé et laisse `@Body()` à `{}` : seul
-	* le brut (`request.data`) permet alors de distinguer un `{}` envoyé d'un
-	* texte illisible. Relu uniquement quand le corps n'a aucune clé.
-	*
-	* @param body - corps tel que `@Body()` le rend
-	* @returns `true` si le texte reçu n'est pas du JSON
-	*/
-	#unparsableBody(body) {
-		if (body === null || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length > 0) return false;
-		const request = this.request;
-		if (!request || !("data" in request)) return false;
-		const text = request.data.toString(request.charset).trim();
-		if (text === "") return false;
-		try {
-			JSON.parse(text);
-			return false;
-		} catch {
-			return true;
-		}
-	}
-	/**
-	* `POST /nodefony/mcp` — un message JSON-RPC entre, une réponse sort.
-	*
-	* Les trois statuts que rend cette route sont ceux que la spec impose, et pas
-	* un de plus : `202` sans corps pour une notification acceptée, `403` pour un
-	* appel dont l'origine ou l'adresse est refusée, `404` pour une méthode
-	* inconnue (afin de la distinguer d'un serveur qui n'hébergerait pas
-	* d'endpoint MCP du tout).
-	*/
-	async mcp(body, origin, protocolVersion, authorization) {
-		const settings = this.#service().mcpSettings();
-		if (!settings.enabled) return this.renderJson({ error: "MCP désactivé" }, 404);
-		const verdict = checkMcpAccess({
-			origin,
-			remoteAddress: this.context?.remoteAddress ?? void 0
-		}, {
-			allowedOrigins: settings.allowedOrigins,
-			allowRemote: settings.allowRemote
-		});
-		if (!verdict.allowed) {
-			this.log(`MCP refusé — ${verdict.why}`, "WARNING");
-			return this.renderJson(jsonRpcFailure(null, JsonRpcError.INVALID_REQUEST, "origine refusée"), 403);
-		}
-		if (this.#unparsableBody(body)) return this.renderJson(jsonRpcFailure(null, JsonRpcError.PARSE_ERROR, "corps illisible : JSON invalide"), 400);
-		if (body === null || typeof body !== "object") return this.renderJson(jsonRpcFailure(null, JsonRpcError.INVALID_REQUEST, "corps attendu : un message JSON-RPC (objet)"), 400);
-		const authz = settings.authorization;
-		const gateProtected = settings.authorization.authorizationServers.length > 0;
-		let caller = {
-			authenticated: false,
-			scopes: [],
-			roles: mcpCallerRoles({
-				protected: gateProtected,
-				authenticated: false,
-				scopes: []
-			})
-		};
-		if (gateProtected) {
-			const authVerdict = await authorizeProtectedResource(authorization, {
-				resource: authz.resource,
-				acceptedResources: authz.additionalResources,
-				metadataUrl: protectedResourceMetadataUrl(authz.resource),
-				scopes: this.#service().declaredMcpScopes(),
-				allowAnonymous: authz.anonymous
-			}, this.#tokenVerifier());
-			switch (authVerdict.outcome) {
-				case "unverifiable":
-					this.log(authVerdict.why ? `MCP — la vérification du jeton a ÉCHOUÉ, le jeton n'est donc ni accepté ni refusé : la porte refuse de servir (503). Cause — ${authVerdict.why}` : "MCP — `mcp.authorization` déclare un serveur d'autorisation, mais aucun service du conteneur ne sait vérifier un jeton (`accessTokenVerifier`). La porte refuse de servir : accepter les porteurs sans les valider serait pire que rester anonyme.", "CRITIC");
-					return this.renderJson(jsonRpcFailure(null, JsonRpcError.INTERNAL_ERROR, "autorisation indisponible"), 503);
-				case "challenge":
-					if (this.#isUnsubstitutedTemplate(authorization)) this.log("MCP — l'en-tête `Authorization` porte un GABARIT non substitué : la variable d'environnement du jeton n'est pas posée dans le process du client. Émettre le jeton (`nodefony security:token`) et le poser, ou rendre la porte anonyme pour ce client (`nodefony ai:mcp --no-auth`) — sans en-tête, les outils publics sont servis.", "WARNING");
-					return this.renderJson(jsonRpcFailure(null, JsonRpcError.INVALID_REQUEST, "autorisation requise"), authVerdict.status, { "WWW-Authenticate": authVerdict.wwwAuthenticate });
-				case "authenticated":
-					caller = {
-						authenticated: true,
-						scopes: authVerdict.principal.scopes,
-						subject: authVerdict.principal.subject,
-						roles: mcpCallerRoles({
-							protected: true,
-							authenticated: true,
-							scopes: authVerdict.principal.scopes
-						})
-					};
-					break;
-				case "anonymous":
-					if (authVerdict.rejected) this.log("MCP — jeton REJETÉ (expiré, mauvaise audience ou signature invalide) : la requête est servie en ANONYME, les outils réservés restent retenus. Renouveler le jeton (`nodefony security:token`) pour les retrouver.", "WARNING");
-					caller = {
-						authenticated: false,
-						scopes: [],
-						roles: mcpCallerRoles({
-							protected: true,
-							authenticated: false,
-							scopes: []
-						})
-					};
-			}
-		}
-		const kernel = Nodefony.getKernel();
-		let withheldCount = 0;
-		const tools = collectMcpTools({
-			builtins: settings.tools,
-			modules: kernel?.modules,
-			caller,
-			onSkip: (why) => this.log(`MCP — ${why}`, "WARNING"),
-			onWithheld: (name, why) => {
-				withheldCount += 1;
-				this.log(`MCP — outil « ${name} » retenu : ${why}`, "DEBUG");
-			},
-			deps: this.#service().mcpToolDeps()
-		});
-		const context = this.context;
-		const stream = createMcpResponseStream({
-			signal: context?.signal,
-			open: this.acceptsSse() ? () => this.renderSse({ maxEventBytes: MCP_STREAM_MAX_EVENT_BYTES }) : void 0,
-			onError: (error, final) => this.log(`MCP — ${final ? "réponse finale" : "notification"} perdue sur le flux : ${error instanceof Error ? error.message : String(error)}`, final ? "WARNING" : "DEBUG")
-		});
-		const reply = await handleMcpMessage(body, {
-			tools,
-			caller,
-			withheldCount,
-			transport: stream.transport,
-			serverInfo: {
-				name: kernel?.projectName ?? "nodefony",
-				version: Nodefony.version
-			}
-		}, { protocolVersion });
-		if (reply.failure) {
-			const { tool, error } = reply.failure;
-			this.log(`MCP — l'outil « ${tool} » a levé : ${error instanceof Error ? error.stack ?? error.message : String(error)}`, "ERROR");
-		}
-		const sse = await stream.finish(reply.body);
-		if (sse !== null) return sse.close();
-		if (reply.body === null) return this.renderResponse("", void 0, reply.status);
-		return this.renderJson(reply.body, reply.status);
-	}
-	/**
-	* `GET` et `DELETE /nodefony/mcp` — refusés en `405`, avec `Allow: POST`.
-	*
-	* Un client d'une révision antérieure du transport ouvre un flux SSE en `GET`
-	* et clôt sa session en `DELETE` ; la révision `2026-07-28` a retiré les deux
-	* et demande ce `405` (transports, « Earlier Streamable HTTP Revisions »).
-	* Sans cette route, la requête tombait dans le repli SPA du Studio
+	* `/nodefony/mcp` — `POST` sert un message JSON-RPC ; `GET` et `DELETE`
+	* rendent `405` + `Allow: POST` (verbes retirés par la révision
+	* `2026-07-28`). Sans eux, la requête tombait dans le repli SPA du Studio
 	* (`/nodefony/{page}`) : `200` + HTML, que le client prenait pour un flux
 	* rompu et rouvrait à chaque seconde, indéfiniment.
 	*/
-	unsupported() {
-		if (!this.#service().mcpSettings().enabled) return this.renderJson({ error: "MCP désactivé" }, 404);
-		return this.renderResponse("", void 0, 405, { allow: "POST" });
+	mcp(body) {
+		return this.#service().mcpGate().serve(this, body);
 	}
 };
-__decorate([
-	route("devkit-mcp", {
-		path: "/mcp",
-		requirements: { methods: ["POST"] }
-	}),
-	__decorateParam(0, Body()),
-	__decorateParam(1, Headers("origin")),
-	__decorateParam(2, Headers("mcp-protocol-version")),
-	__decorateParam(3, Headers("authorization")),
-	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", [
-		Object,
-		String,
-		String,
-		String
-	]),
-	__decorateMetadata("design:returntype", Promise)
-], McpController.prototype, "mcp", null);
-__decorate([
-	route("devkit-mcp-unsupported", {
-		path: "/mcp",
-		requirements: { methods: ["GET", "DELETE"] }
-	}),
-	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", []),
-	__decorateMetadata("design:returntype", void 0)
-], McpController.prototype, "unsupported", null);
-McpController = __decorate([controller("/nodefony"), __decorateMetadata("design:paramtypes", [Object])], McpController);
+__decorate([route("devkit-mcp", {
+	path: "/mcp",
+	requirements: { methods: [
+		"POST",
+		"GET",
+		"DELETE"
+	] }
+}), __decorateParam(0, Body())], McpController.prototype, "mcp", null);
+McpController = __decorate([controller("/nodefony")], McpController);
 var McpController_default = McpController;
-//#endregion
 export { McpController_default as default };

package/dist/nodefony/controllers/ProfileSessionController.js

@@ -0,0 +1,47 @@
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { Controller, controller, route } from "@nodefony/framework";
+// nodefony/controllers/ProfileSessionController.ts
+/**
+* Ouvre la session au nom de laquelle `nodefony_profile_route` tire ses
+* requêtes.
+*
+* **Mince par design** : la mécanique (ticket à usage unique, localité,
+* ouverture par le flux de session de l'application, verdict uniforme) est la
+* porte `defineTicketSessionGate` de `@nodefony/ai`, définie dans
+* `DevkitService.profileSessionGate()`. Ce controller ne fait que DÉCLARER la
+* route, comme le ferait une application pour ses propres outils.
+*
+* Ce qui protège cette route : le ticket (émis dans le process, valable dix
+* secondes, jamais affiché ni journalisé, identité fixée à l'émission), la
+* localité de l'appelant (défaut de la porte), et la `policy: "dev"` du module.
+*
+* Elle vit sous `/nodefony/devkit/`, hors du motif de la zone d'administration
+* (`^/nodefony/[^/]+/api`), qui exigerait une session déjà ouverte.
+*/
+let ProfileSessionController = class ProfileSessionController extends Controller {
+	constructor(context) {
+		super("devkit-profile-session", context);
+	}
+	/** Résout le service du module depuis le conteneur partagé. */
+	#service() {
+		const svc = this.get("devkit");
+		if (!svc) throw new Error("DevkitService non enregistré");
+		return svc;
+	}
+	/**
+	* `POST /nodefony/devkit/profile-session` — rachète le ticket et ouvre la
+	* session. `200` rend le compte et le pseudonyme de session ; tout refus est
+	* un `403` au message unique ; `503` quand l'application n'a pas de flux de
+	* session.
+	*/
+	async profileSession() {
+		return this.#service().profileSessionGate().serve(this);
+	}
+};
+__decorate([route("devkit-profile-session", {
+	path: "/profile-session",
+	requirements: { methods: ["POST"] }
+})], ProfileSessionController.prototype, "profileSession", null);
+ProfileSessionController = __decorate([controller("/nodefony/devkit")], ProfileSessionController);
+var ProfileSessionController_default = ProfileSessionController;
+export { ProfileSessionController_default as default };

package/dist/nodefony/mcp/observe.js

@@ -0,0 +1,235 @@
+import { progressLine, renderProfileReport } from "./profileReport.js";
+import { watchToolStop } from "./shutdown.js";
+import { ProcessProbe } from "nodefony";
+import { MCP_RESERVED_PREFIX, mcpText } from "@nodefony/ai";
+import { setTimeout } from "node:timers/promises";
+import { N_PLUS_ONE_MIN_REPEATS, createProfileAggregator, isFailedProfile } from "@nodefony/http";
+// nodefony/mcp/observe.ts
+/** Fenêtre d'observation par défaut, en secondes. */
+const OBSERVE_DEFAULT_SEC = 10;
+/**
+* Fenêtre maximale, en secondes. Sous les 60 s qu'un client MCP attend par
+* défaut avant d'abandonner une requête : au-delà, l'agent couperait l'appel
+* juste avant le rapport.
+*/
+const OBSERVE_MAX_SEC = 50;
+/** Intervalle entre deux relevés, en ms : un instantané de progression par relevé. */
+const OBSERVE_TICK_MS = 2e3;
+/**
+* Requêtes en erreur dont on lit le journal, au plus — les mêmes que les
+* exemples d'erreurs du rapport, dans le même ordre.
+*/
+const OBSERVE_ERROR_LOGS_MAX = 10;
+/**
+* Le contrat de l'outil tel que l'agent le lit dans `tools/list` — le seul
+* texte qu'il voit à coup sûr. Les seuils cités sont les constantes du code :
+* la description ne peut pas promettre autre chose que ce que l'outil fait.
+* Composée une fois, au chargement du module.
+*/
+const OBSERVE_DESCRIPTION = `Mesure l'application Nodefony qui tourne, pendant une fenêtre de quelques secondes, à partir de son profileur de développement : où part le temps de chaque route, les requêtes SQL, les erreurs et la charge du process. C'est la seule façon de SAVOIR qu'une page est lente ou interroge la base dans une boucle — ni le code ni les tests ne le montrent.
+
+QUAND : après avoir modifié un contrôleur, un service ou une requête ; face à « c'est lent », « trop de requêtes SQL », « une erreur 500 de temps en temps ».
+
+COMMENT :
+1. Appeler avec durationSec (défaut 10, max 50).\n2. PENDANT la fenêtre, solliciter le code : ouvrir la page, jouer les tests, envoyer des requêtes. L'outil n'en génère AUCUNE : sans trafic, il n'a rien à juger.
+3. Corriger la cause nommée, puis rappeler l'outil sur le même trafic et comparer le bloc « Données (JSON) » des deux rapports.
+Ne modifier AUCUN fichier pendant la fenêtre : le serveur redémarre et le rapport rendu est partiel (il le dit).
+
+LE RAPPORT, dans l'ordre : un verdict (ok, anomalies, INCOMPLÈTE avec la raison) ; les anomalies, nommées par route et contrôleur — « N+1 » (même requête SQL répétée au moins ${N_PLUS_ONE_MIN_REPEATS} fois dans une requête HTTP : charger d'un coup, \`relations\` ou \`\$in\`), « Erreurs » (5xx avec leur requestId et leurs lignes de journal WARNING/ERROR), « Lente » (p95 ≥ 500 ms, avec ce qui coûte par requête : action.self = le code de l'action et de ses services, SQL (cumul), render, firewall), « Boucle d'événements bloquée » (un traitement synchrone de 100 ms ou plus) ; puis un tableau par route, les requêtes SQL les plus coûteuses (valeurs masquées par ?), et les données JSON. Les refus 401/403 sont comptés à part, hors des durées.
+
+LIMITES : développement seulement. Le journal des erreurs exige un appel authentifié (scope admin:read) ; sans jeton le rapport le dit. Les routes /nodefony/… et les assets relayés /_vite/… (outillage) sont écartés sauf includeTooling. Un instantané est envoyé en progression à chaque relevé (toutes les ${OBSERVE_TICK_MS / 1e3} s).`;
+/**
+* Ce que rend un outil de MESURE dans un process qui ne sert aucune requête —
+* l'application démarrée en console, sous la porte stdio (`nodefony ai:stdio`).
+* Sans ce refus, `nodefony_observe` y attendrait un trafic qui n'arrive jamais
+* et rendrait « aucune requête » avec aplomb.
+*/
+const NOT_SERVING_MESSAGE = "Ce process ne sert aucune requête : l'application y est démarrée en console (porte stdio `nodefony ai:stdio`), sans serveur HTTP — rien à mesurer ici. Pour observer ou profiler le trafic réel : démarrer l'application (`nodefony dev`) et passer par sa porte HTTP (`/nodefony/mcp`, déclarée à l'agent par `nodefony ai:mcp`).";
+/**
+* Reconnaît un profileur par sa FORME : le conteneur le rend sous le nom
+* `"profiler"`, et ce module ne dépend pas de sa classe.
+*
+* @param value - ce que le conteneur a rendu.
+* @returns le lecteur, ou `undefined` s'il ne tient pas le contrat.
+*/
+function asProfilerReader(value) {
+	return isProfilerReader(value) ? value : void 0;
+}
+function isProfilerReader(value) {
+	return typeof value === "object" && value !== null && "cursor" in value && typeof value.cursor === "number" && "since" in value && typeof value.since === "function" && "get" in value && typeof value.get === "function";
+}
+/** Durée demandée, bornée — et la remarque à faire si elle a été corrigée. */
+function readDuration(raw) {
+	if (raw === void 0) return {
+		sec: 10,
+		note: null
+	};
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return {
+		sec: 10,
+		note: `durationSec illisible, fenêtre par défaut de 10 s`
+	};
+	const sec = Math.min(Math.max(Math.round(raw), 1), 50);
+	return {
+		sec,
+		note: sec === raw ? null : `durationSec ramenée à ${sec} s (bornes 1–50)`
+	};
+}
+/**
+* L'outil `nodefony_observe` : observe l'application qui tourne pendant une
+* fenêtre bornée et rend ce que le profileur de développement a mesuré —
+* routes lentes et où part leur temps, N+1, requêtes SQL coûteuses, erreurs,
+* charge du process.
+*
+* C'est un outil LONG : un relevé toutes les deux secondes, chacun envoyé à
+* l'agent en progression ; un client qui l'annule l'arrête au relevé suivant,
+* qu'il ferme le flux de la réponse ou envoie `notifications/cancelled`. Rien
+* n'est armé en dehors d'un appel : un minuteur par relevé,
+* libéré par l'annulation elle-même, et la sonde du process libérée en sortie.
+*
+* @param deps - le profileur et, pour les tests, la cadence et la sonde.
+*/
+function observeTool(deps) {
+	const tickMs = deps.tickMs ?? 2e3;
+	const createProbe = deps.createProbe ?? (() => new ProcessProbe());
+	return {
+		name: `${MCP_RESERVED_PREFIX}observe`,
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: false
+		},
+		description: OBSERVE_DESCRIPTION,
+		inputSchema: {
+			type: "object",
+			properties: {
+				durationSec: {
+					type: "integer",
+					minimum: 1,
+					maximum: 50,
+					description: `Durée de la fenêtre, en secondes (défaut 10, max 50) : assez pour solliciter le code pendant qu'elle court`
+				},
+				route: {
+					type: "string",
+					description: "Restreindre à UNE route, par son NOM — celui que rend `nodefony_inspect` sujet `routes` (ex. `blog-index`, `OrdersController::list`), jamais son chemin"
+				},
+				includeTooling: {
+					type: "boolean",
+					description: "Inclure les requêtes de l'outillage (`/nodefony/…` : console, API d'administration, porte MCP ; `/_vite/…` : assets relayés). Défaut : non"
+				}
+			}
+		},
+		handler: async (args, caller, run) => {
+			if (deps.servesTraffic?.() === false) return mcpText(NOT_SERVING_MESSAGE, true);
+			const profiler = deps.getProfiler();
+			if (profiler === void 0) return mcpText("Aucun profileur dans cette application : il n'existe qu'en développement, et seulement si `@nodefony/http` est chargé. Rien à observer.", true);
+			const { sec, note } = readDuration(args.durationSec);
+			const route = typeof args.route === "string" && args.route.length > 0 ? args.route : null;
+			return observe(profiler, {
+				windowMs: sec * 1e3,
+				route,
+				includeTooling: args.includeTooling === true,
+				tickMs,
+				createProbe,
+				run,
+				note,
+				caller,
+				readRequestLogs: deps.readRequestLogs,
+				onShutdown: deps.onShutdown
+			});
+		}
+	};
+}
+async function observe(profiler, opts) {
+	const aggregator = createProfileAggregator({ includeTooling: opts.includeTooling });
+	const read = opts.readRequestLogs;
+	const logs = /* @__PURE__ */ new Map();
+	const stop = watchToolStop(opts.run, opts.onShutdown);
+	const signal = stop.signal;
+	const windowSec = opts.windowMs / 1e3;
+	let cursor = profiler.cursor;
+	let lost = 0;
+	let filteredRoute = 0;
+	let ticks = 0;
+	let cancelled = false;
+	let loopSum = 0;
+	let loopMax = 0;
+	let loopReads = 0;
+	const drain = () => {
+		const batch = profiler.since(cursor);
+		cursor = batch.cursor;
+		lost += batch.lost;
+		for (const entry of batch.entries) {
+			if (opts.route !== null && entry.route !== opts.route) {
+				filteredRoute += 1;
+				continue;
+			}
+			if (aggregator.add(entry) && read !== void 0 && logs.size < 10 && isFailedProfile(entry)) logs.set(entry.requestId, read(entry.requestId, opts.caller).catch(() => ({
+				kind: "unavailable",
+				reason: "la lecture du journal a échoué"
+			})));
+		}
+	};
+	const probe = opts.createProbe();
+	const started = performance.now();
+	const deadline = started + opts.windowMs;
+	let heapStart = 0;
+	let heapEnd = null;
+	try {
+		heapStart = probe.read().heapUsed;
+		opts.run?.progress(0, windowSec, `observation démarrée pour ${windowSec} s` + (opts.route === null ? "" : ` sur la route ${opts.route}`));
+		for (;;) {
+			const remaining = deadline - performance.now();
+			if (remaining <= 0) break;
+			if (signal.aborted) {
+				cancelled = !stop.interrupted;
+				break;
+			}
+			try {
+				await setTimeout(Math.min(opts.tickMs, remaining), void 0, { signal });
+			} catch {
+				cancelled = !stop.interrupted;
+				break;
+			}
+			drain();
+			ticks += 1;
+			const health = probe.read();
+			heapEnd = health.heapUsed;
+			loopSum += health.eventLoopMs;
+			loopReads += 1;
+			if (health.eventLoopMaxMs > loopMax) loopMax = health.eventLoopMaxMs;
+			const elapsedSec = (performance.now() - started) / 1e3;
+			opts.run?.progress(Math.min(elapsedSec, windowSec), windowSec, progressLine(aggregator.result(), elapsedSec, windowSec, lost));
+		}
+		drain();
+	} catch (error) {
+		stop.release();
+		throw error;
+	} finally {
+		probe.dispose();
+	}
+	let errorLogs = null;
+	if (read !== void 0) {
+		errorLogs = /* @__PURE__ */ new Map();
+		for (const [requestId, pending] of logs) errorLogs.set(requestId, await pending);
+	}
+	const text = renderProfileReport(aggregator.result(), {
+		windowMs: opts.windowMs,
+		elapsedMs: performance.now() - started,
+		ticks,
+		lost,
+		cancelled,
+		interrupted: stop.interrupted,
+		errorLogs,
+		route: opts.route,
+		filteredRoute,
+		pid: process.pid,
+		uptimeSec: process.uptime(),
+		eventLoop: loopReads === 0 ? null : {
+			meanMs: loopSum / loopReads,
+			maxMs: loopMax
+		},
+		heapDeltaBytes: heapEnd === null ? null : heapEnd - heapStart
+	});
+	stop.release();
+	return mcpText(opts.note === null ? text : `ℹ️ ${opts.note}.\n${text}`);
+}
+export { NOT_SERVING_MESSAGE, OBSERVE_DEFAULT_SEC, OBSERVE_ERROR_LOGS_MAX, OBSERVE_MAX_SEC, OBSERVE_TICK_MS, asProfilerReader, observeTool };