nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/service/dev/devProjects.js

@@ -0,0 +1,138 @@
+import { foreignProjectRoots, readRuntimeState } from "./devProcess.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+//#region src/service/dev/devProjects.ts
+/**
+* Lit le nom d'un projet dans son `package.json`.
+*
+* Repli sur le nom du DOSSIER, jamais sur une chaîne inventée : un projet sans
+* `package.json` lisible reste désignable, et l'appelant sait par `nameSource`
+* que le nom n'a pas été déclaré.
+*
+* @param root - racine du projet.
+* @returns le nom déclaré, ou `null` si aucun n'est lisible.
+*/
+function readProjectName(root) {
+	try {
+		const raw = readFileSync(path.join(root, "package.json"), "utf8");
+		const name = JSON.parse(raw).name;
+		return typeof name === "string" && name.length > 0 ? name : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Compose la table des projets Nodefony vivants — fonction PURE (toute lecture
+* disque passe par {@link IProjectTableDeps}), donc éprouvable sans process ni
+* fichier.
+*
+* Le projet courant figure toujours en tête et n'est OMIS que s'il ne tourne pas :
+* une table qui listerait le voisin sans dire lequel est le nôtre obligerait à
+* comparer des chemins à l'œil.
+*
+* @param cwd - racine du projet courant.
+* @param mine - runtimes du projet courant.
+* @param foreign - runtimes des autres projets (sortie `splitByProject().foreign`).
+* @param myPorts - ports à l'écoute du projet courant.
+* @param deps - lectures injectables (nom, ports).
+* @returns la table, projet courant d'abord puis les autres par nom.
+*/
+function buildProjectTable(cwd, mine, foreign, myPorts = [], deps = {}) {
+	const readName = deps.readName ?? readProjectName;
+	const readPorts = deps.readPorts ?? ((root) => readRuntimeState(root, { purgeStale: false })?.ports ?? []);
+	const entry = (root, procs, ports, current) => {
+		const declared = readName(root);
+		return {
+			name: declared ?? path.basename(root),
+			nameSource: declared ? "package" : "dossier",
+			root,
+			current,
+			procs,
+			ports: [...ports].sort((a, b) => a - b)
+		};
+	};
+	const table = [];
+	if (mine.length > 0) table.push(entry(cwd, mine, myPorts, true));
+	const others = foreignProjectRoots(foreign).map((root) => {
+		const procs = foreign.filter((p) => p.cwd === root || p.cwd?.startsWith(root + path.sep));
+		return entry(root, procs, readPorts(root), false);
+	});
+	others.sort((a, b) => a.name.localeCompare(b.name));
+	return [...table, ...others];
+}
+/**
+* Met en forme la table des projets — lignes SANS couleur (l'appelant colore et
+* indente), colonnes alignées sur le contenu réel.
+*
+* Le nom du projet courant porte un repère : c'est lui qu'on cherche d'abord, et
+* comparer des racines à l'œil est précisément ce que cette table supprime. Un nom
+* qui vient du dossier plutôt que du `package.json` est marqué `~` — l'utilisateur
+* peut le viser tout autant, mais il sait que le projet ne s'est pas nommé.
+*
+* @param projects - table produite par {@link buildProjectTable}.
+* @returns lignes prêtes à afficher (vide si aucun projet).
+*/
+function formatProjectTable(projects) {
+	if (projects.length === 0) return [];
+	const rows = projects.map((p) => ({
+		name: `${p.name}${p.nameSource === "dossier" ? "~" : ""}${p.current ? " ▸" : ""}`,
+		proc: String(p.procs.length),
+		ports: p.ports.length > 0 ? p.ports.join(" ") : "—",
+		root: p.root
+	}));
+	const w = (key, head) => Math.max(head.length, ...rows.map((r) => r[key].length));
+	const wName = w("name", "NOM");
+	const wProc = w("proc", "PROC");
+	const wPorts = w("ports", "PORTS");
+	const line = (name, proc, ports, root) => `  ${name.padEnd(wName)}  ${proc.padEnd(wProc)}  ${ports.padEnd(wPorts)}  ${root}`;
+	const lines = [
+		"",
+		"  Projets Nodefony sur ce poste",
+		line("NOM", "PROC", "PORTS", "RACINE"),
+		...rows.map((r) => line(r.name, r.proc, r.ports, r.root))
+	];
+	if (projects.some((p) => p.current)) lines.push("  ▸ projet courant");
+	if (projects.some((p) => p.nameSource === "dossier")) lines.push("  ~ nom du dossier (aucun nom déclaré dans package.json)");
+	lines.push("  arrêter un projet : nodefony stop <nom|chemin>");
+	return lines;
+}
+/**
+* Résout une cible `nodefony stop <projet>` — par NOM ou par CHEMIN.
+*
+* Le refus est la règle dès que la désignation n'est pas certaine : arrêter des
+* process est irréversible, et deviner « le plus proche » ferait tomber le mauvais
+* serveur sur une faute de frappe. Zéro correspondance et deux correspondances
+* sont donc deux refus distincts, chacun avec de quoi corriger.
+*
+* Un argument contenant un séparateur, ou absolu, est traité comme un CHEMIN
+* (résolu contre le répertoire courant) ; sinon il est comparé au nom déclaré ET
+* au nom du dossier — un projet se désigne comme on le nomme, pas comme son
+* `package.json` l'a nommé.
+*
+* ⚠️ La comparaison de chemins est exacte, casse comprise. Sur un système de
+* fichiers insensible à la casse, une casse différente rend donc « inconnu »
+* plutôt qu'une correspondance : un refus, jamais un mauvais arrêt.
+*
+* @param arg - ce que l'utilisateur a tapé.
+* @param projects - table produite par {@link buildProjectTable}.
+* @returns le projet visé, ou le motif du refus avec ses candidats.
+*/
+function resolveProjectTarget(arg, projects, grammar = path) {
+	const matches = grammar.isAbsolute(arg) || arg.includes("/") || arg.includes(grammar.sep) ? projects.filter((p) => grammar.resolve(p.root) === grammar.resolve(arg)) : projects.filter((p) => p.name === arg || grammar.basename(p.root) === arg);
+	if (matches.length === 1) return {
+		ok: true,
+		project: matches[0]
+	};
+	if (matches.length === 0) return {
+		ok: false,
+		reason: "inconnu",
+		candidates: projects
+	};
+	return {
+		ok: false,
+		reason: "ambigu",
+		candidates: matches
+	};
+}
+//#endregion
+export { buildProjectTable, formatProjectTable, readProjectName, resolveProjectTarget };

package/dist/node/service/dev/devStatusReport.js

@@ -0,0 +1,395 @@
+import Cli from "../../Cli.js";
+import { printUsage } from "../../cli/usageReport.js";
+import { defaultDevPorts, detectRuntimeMode, devSupervisorPidFile, discoverDevProcessesDetailed, discoverFromRuntimeState, foreignPortOwners, formatForeignRuntimes, formatUptime, isNodefonyProjectDir, isPidAlive, portOwnership, probePorts, readReadinessState, readSupervisorPid, runtimeModes, splitByProject } from "./devProcess.js";
+import { buildProjectTable } from "./devProjects.js";
+import { probeReadiness } from "./bootVerdict.js";
+import { runStopReport } from "./devStop.js";
+import { writeSync } from "node:fs";
+import path from "node:path";
+//#region src/service/dev/devStatusReport.ts
+/**
+* Rapport `nodefony status` — composition + exécution DÉCOUPLÉES de la classe Command.
+*
+* Pur outillage de process (ps + sonde ports + pidfile) : aucun boot kernel, aucune
+* trunk requise → exécutable depuis N'IMPORTE OÙ (cf le fast-path « standalone » de
+* `CliKernel.start`). Cohérent avec le choix no-IPC du superviseur (observation externe).
+*/
+const ANSI = {
+	dim: "\x1B[90m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	red: "\x1B[31m",
+	yellow: "\x1B[33m",
+	bold: "\x1B[1m",
+	reset: "\x1B[0m"
+};
+/** Commandes « système » exécutables SANS boot kernel ni trunk (outillage process). */
+const STANDALONE_DEV_COMMANDS = /* @__PURE__ */ new Set(["status", "stop"]);
+/** La page d'aide de `nodefony status`. */
+const STATUS_PAGE = {
+	command: "nodefony status",
+	tagline: "dit quels processus Nodefony de ce projet tournent, dans quel mode, et sur quels ports",
+	synopsis: ["nodefony status"],
+	sections: [{
+		title: "CE QU'ELLE OBSERVE",
+		paragraph: "Le fichier de pid du superviseur, le fichier d'état du runtime, les ports du poste, et — quand la machine l'offre — la table des processus. Aucune de ces sources n'est déduite de la plateforme : ce que `ps` ne peut pas donner ici est ANNONCÉ dans le rapport, jamais remplacé par un silence. Elle ne démarre ni n'arrête rien."
+	}],
+	options: [],
+	examples: [{
+		term: "nodefony status",
+		text: "l'état des processus de ce projet"
+	}]
+};
+/** La page d'aide de `nodefony stop`. */
+const STOP_PAGE = {
+	command: "nodefony stop",
+	tagline: "arrête proprement les processus Nodefony de ce projet",
+	synopsis: ["nodefony stop [projet] [--all]"],
+	sections: [{
+		title: "CE QU'ELLE ARRÊTE",
+		paragraph: "Le projet du répertoire courant, et lui seul. Un autre projet se désigne par son nom ou son chemin ; `--all` étend le geste à TOUS les projets Nodefony de cette machine, ce qui se demande explicitement parce que personne ne veut l'obtenir par défaut."
+	}],
+	options: [{
+		term: "--all",
+		text: "arrête les processus Nodefony de TOUS les projets de cette machine (défaut : le projet courant seulement)"
+	}],
+	examples: [
+		{
+			term: "nodefony stop",
+			text: "arrête le projet d'ici"
+		},
+		{
+			term: "nodefony stop mon-app",
+			text: "arrête un projet nommé"
+		},
+		{
+			term: "nodefony stop --all",
+			text: "arrête tout, sur cette machine"
+		}
+	],
+	exitCodes: [{
+		term: "1",
+		text: "la cible n'a pas pu être désignée — rien n'a été arrêté"
+	}]
+};
+/**
+* `true` si l'invocation demande l'aide de la commande, et non son exécution.
+*
+* 🔴 Ces commandes analysent `process.argv` elles-mêmes — le fast-path court
+* AVANT commander. Sans ce contrôle, `nodefony stop --help` ARRÊTAIT le serveur :
+* le drapeau était simplement ignoré, et un lecteur qui cherchait la
+* documentation obtenait l'effet.
+*
+* @param name - le nom de la commande, pour ne lire que ce qui la suit.
+* @param argv - la ligne de commande.
+* @returns `true` si `--help` ou `-h` a été demandé.
+*/
+function wantsHelp(name, argv) {
+	const at = argv.indexOf(name);
+	if (at === -1) return false;
+	return argv.slice(at + 1).some((a) => a === "--help" || a === "-h");
+}
+/** `true` si `name` est une commande système standalone (status/stop). */
+function isStandaloneDevCommand(name) {
+	return STANDALONE_DEV_COMMANDS.has(name);
+}
+/**
+* Exécute une commande système standalone par son nom — point d'entrée du fast-path
+* `CliKernel.start` (avant tout boot). N'écrit jamais via le syslog (kernel non booté).
+* `stop --all` = trans-projets explicite (défaut : scope au projet du cwd).
+*/
+async function runStandaloneDevCommand(name) {
+	const cwd = process.cwd();
+	if (wantsHelp(name, process.argv)) return printUsage(name === "stop" ? STOP_PAGE : STATUS_PAGE);
+	if (name === "status") {
+		await runStatusReport(cwd);
+		return 0;
+	}
+	if (name === "stop") return runStopReport(cwd, {
+		all: process.argv.includes("--all"),
+		target: standaloneTarget("stop")
+	});
+	return 0;
+}
+/**
+* Argument positionnel d'une commande standalone, lu sur `process.argv` — le
+* fast-path court AVANT commander, il n'a donc personne pour l'analyser.
+*
+* Seul le premier mot qui suit le nom de la commande et ne commence pas par `-`
+* est retenu ; tout le reste appartient aux options. Rendre `undefined` plutôt
+* qu'une chaîne vide garde la distinction « pas de cible » / « cible vide ».
+*
+* @param name - nom de la commande (`stop`).
+* @returns la cible tapée, ou `undefined`.
+*/
+function standaloneTarget(name) {
+	const argv = process.argv;
+	const at = argv.indexOf(name);
+	if (at === -1) return void 0;
+	for (const arg of argv.slice(at + 1)) if (!arg.startsWith("-")) return arg;
+}
+/**
+* Compose le {@link DevStatusReport} (décompte + incohérences) — fonction PURE :
+* `pidAlive` est fourni par l'appelant (aucun syscall ici → testable sans `ps`/process).
+* Centralise la synthèse + les warnings consommés AUSSI BIEN par le rendu ANSI CLI
+* ({@link renderStatus}) que par le data plane Studio ({@link collectDevStatus}).
+*/
+function buildDevStatus(cwd, pid, pidAlive, procs, ports, inProject = true, discoverySupported = true, foreign = [], projectScopeBlind = false, readiness = null) {
+	const nSup = procs.filter((p) => p.role === "supervisor").length;
+	const nSrv = procs.filter((p) => p.role === "server").length;
+	const nVite = procs.filter((p) => p.role === "vite").length;
+	const nMaster = procs.filter((p) => p.role === "master").length;
+	const nWorker = procs.filter((p) => p.role === "worker").length;
+	const portsUp = ports.filter((p) => p.listening).length;
+	const mode = detectRuntimeMode(procs);
+	const warnings = [];
+	const modes = runtimeModes(procs);
+	if (modes.size > 1) warnings.push(`${modes.size} runtimes Nodefony cohabitent sur CE projet (${[...modes].join(" + ")}) — anormal : \`nodefony stop\` pour tout arrêter`);
+	const supPids = procs.filter((p) => p.role === "supervisor").map((p) => p.pid);
+	if (pid !== null && !supPids.includes(pid)) warnings.push(pidAlive ? `pidfile pointe pid ${pid} (vivant) qui n'est pas le superviseur réel — pidfile incohérent` : `pidfile pointe pid ${pid} mort — pidfile périmé`);
+	const devSrv = procs.filter((p) => p.mode === "dev" && p.role === "server").length;
+	if (nSup === 0 && (devSrv > 0 || nVite > 0)) warnings.push("process dev orphelins (serveur/Vite sans superviseur) — `nodefony stop` les nettoiera");
+	if (nSup > 1) warnings.push(`${nSup} superviseurs simultanés sur CE projet — empilement anormal`);
+	if (nMaster > 1) warnings.push(`${nMaster} masters cluster simultanés sur CE projet — empilement anormal`);
+	if (nSrv > 1) warnings.push(`${nSrv} serveurs simultanés sur CE projet — empilement anormal`);
+	if (!discoverySupported && procs.length > 0) warnings.push("process non observables ici (`ps` indisponible) — topologie lue dans le pidfile et le fichier d'état (ni RSS, ni %CPU, ni Vite)");
+	if (projectScopeBlind) warnings.push("appartenance au projet indéterminable (répertoire courant des process illisible — `lsof` absent ?) — liste GLOBALE du poste, `nodefony stop` n'agira que sur ce projet");
+	return {
+		supported: discoverySupported,
+		running: procs.length > 0,
+		mode,
+		processes: procs,
+		ports,
+		summary: {
+			supervisors: nSup,
+			servers: nSrv,
+			vites: nVite,
+			masters: nMaster,
+			workers: nWorker,
+			portsUp,
+			portsTotal: ports.length
+		},
+		warnings,
+		pidfile: {
+			path: path.relative(cwd, devSupervisorPidFile(cwd)),
+			pid,
+			alive: pidAlive
+		},
+		inProject,
+		foreign,
+		portOwners: foreignPortOwners(foreign),
+		readiness
+	};
+}
+/**
+* Collecte l'état dev (ps + sonde ports + pidfile) → {@link DevStatusReport} JSON.
+* Best-effort : Windows (pas de `ps` POSIX) → `supported:false`. `opts.includeSelf`
+* (data plane = le serveur DOIT se compter). AUCUN boot kernel requis (observation
+* externe pure) → utilisable depuis le fast-path standalone ET depuis le data plane.
+*/
+async function collectDevStatus(cwd, opts = {}) {
+	const pid = readSupervisorPid(cwd);
+	const observed = (opts.discover ?? discoverDevProcessesDetailed)(opts);
+	const scoped = observed.supported ? splitByProject(observed.procs, cwd, opts.getCwd) : {
+		mine: discoverFromRuntimeState(cwd),
+		foreign: []
+	};
+	const cwdBlind = observed.procs.length > 0 && scoped.mine.length === 0 && scoped.foreign.every((p) => p.cwd === null);
+	const ports = await (opts.probe ?? probePorts)(defaultDevPorts(cwd));
+	const owners = foreignPortOwners(cwdBlind ? [] : scoped.foreign);
+	const listening = ports.find((p) => p.listening && owners[p.port] === void 0);
+	const readiness = withBlockedBy(listening ? await (opts.probeReadiness ?? probeReadiness)(listening.port) : null, cwd);
+	return buildDevStatus(cwd, pid, pid !== null && isPidAlive(pid), cwdBlind ? observed.procs : scoped.mine, ports, isNodefonyProjectDir(cwd), observed.supported, cwdBlind ? [] : scoped.foreign, cwdBlind, readiness);
+}
+/** Collecte (ps + ports + pidfile) puis écrit le rapport status sur stdout. */
+async function runStatusReport(cwd, deps = {}) {
+	const report = await collectDevStatus(cwd, deps);
+	const lines = [];
+	const projects = report.foreign.length > 0 ? buildProjectTable(cwd, report.processes, report.foreign, report.ports.filter((p) => p.listening).map((p) => p.port)) : [];
+	const portsVoisins = [...new Set(projects.filter((p) => !p.current).flatMap((p) => p.ports))].filter((port) => !report.ports.some((p) => p.port === port));
+	renderStatus(lines, report, projects, portsVoisins.length > 0 ? await (deps.probe ?? probePorts)(portsVoisins) : []);
+	(deps.write ?? ((chunk) => writeSync(1, chunk)))(lines.join("\n") + "\n");
+}
+/**
+* Tableau ANSI des process dev (RÔLE/PID/PPID/UPTIME/RSS/%CPU + `↳ bundles`) —
+* LE gabarit partagé `nodefony status` ⇄ bilan de fin de boot (même topologie,
+* même sérieux). `indent` décale toute la grille (le bilan l'aligne sous ses
+* lignes `➜`).
+*
+* Largeur de la colonne RÔLE = plus long label réel (labels courts : supervisor /
+* server / vite) → alignement stable. Le détail des bundles Vite passe sur une 2ᵉ
+* ligne indentée (hors colonne) au lieu de faire déborder la grille.
+*/
+function renderProcessTable(lines, procs, indent = "  ") {
+	const roleW = Math.max(4, ...procs.map((p) => p.label.length));
+	lines.push(`${ANSI.dim}${indent}${"RÔLE".padEnd(roleW)}  ${"PID".padEnd(7)}  ${"PPID".padEnd(7)}  ${"UPTIME".padEnd(9)}  ${"RSS".padEnd(9)}  %CPU${ANSI.reset}`, `${ANSI.dim}${indent}${"─".repeat(roleW + 46)}${ANSI.reset}`);
+	for (const p of procs) {
+		const color = p.role === "supervisor" || p.role === "master" ? ANSI.cyan : p.role === "server" || p.role === "worker" ? ANSI.green : ANSI.dim;
+		lines.push(`${indent}${color}${p.label.padEnd(roleW)}${ANSI.reset}  ${String(p.pid).padEnd(7)}  ${String(p.ppid).padEnd(7)}  ${formatUptime(p.uptimeSec).padEnd(9)}  ${Cli.niceBytes(p.rssKb * 1024).padEnd(9)}  ${p.cpu.toFixed(1)}`);
+		if (p.detail) lines.push(`${indent}  ${ANSI.dim}↳ ${p.detail.replace(/\+/g, ", ")}${ANSI.reset}`);
+	}
+}
+/**
+* Bloc des runtimes ÉTRANGERS — même mise en forme que `nodefony stop` (une seule
+* implémentation, `formatForeignRuntimes`), y compris les commandes exactes pour
+* aller les arrêter. `status` les taisait tout en les COMPTANT comme les siens : le
+* dev voyait « 4 process » sans savoir qu'aucun n'était à lui.
+*/
+function renderForeign(lines, report, projects = [], neighborProbes = []) {
+	if (report.foreign.length === 0) return;
+	const voisins = projects.filter((p) => !p.current);
+	if (voisins.length === 0) {
+		lines.push(`  ${ANSI.dim}${report.foreign.length} runtime(s) d'un AUTRE projet sur ce poste (non comptés ci-dessus) :${ANSI.reset}`, ...formatForeignRuntimes(report.foreign).map((l) => `${ANSI.dim}${l}${ANSI.reset}`));
+		return;
+	}
+	for (const project of voisins) renderProjectBlock(lines, project, [...report.ports, ...neighborProbes], report.portOwners);
+}
+/**
+* Bloc d'UN projet : son nom, sa racine, ses process, ses ports.
+*
+* Le projet courant et un voisin s'affichent pareil — la seule différence est le
+* repère `▸` et le fait que NOS ports sont sondés quand ceux d'un voisin sont
+* seulement DÉCLARÉS (il publie son état, on ne va pas frapper à sa porte). Cette
+* nuance est écrite plutôt que gommée : un port « déclaré » n'est pas un port
+* vérifié, et laisser croire l'inverse est le genre de raccourci qui fait
+* chercher une panne au mauvais endroit.
+*/
+function renderProjectBlock(lines, project, probes = [], owners = {}) {
+	const label = project.current ? `${ANSI.cyan}▸ ${ANSI.bold}${project.name}${ANSI.reset} ${ANSI.dim}— ce projet${ANSI.reset}` : `  ${ANSI.bold}${project.name}${ANSI.reset}`;
+	const source = project.nameSource === "dossier" ? ` ${ANSI.dim}(nom du dossier — aucun nom dans package.json)${ANSI.reset}` : "";
+	lines.push("", `  ${label}${source}`, `    ${ANSI.dim}${project.root}${ANSI.reset}`);
+	if (project.procs.length > 0) renderProcessTable(lines, project.procs, "    ");
+	const rendered = project.ports.map((port) => {
+		const probe = probes.find((s) => s.port === port);
+		const heldBy = owners[port];
+		if (heldBy !== void 0 && heldBy !== project.root) return `${port} ${ANSI.yellow}tenu par ${heldBy}${ANSI.reset}`;
+		if (probe) return probe.listening ? `${port} ${ANSI.green}✓ écoute${ANSI.reset}` : `${port} ${ANSI.red}✗ silencieux${ANSI.reset}`;
+		return `${port} ${ANSI.dim}déclaré${ANSI.reset}`;
+	});
+	if (rendered.length > 0) lines.push(`    ${ANSI.dim}ports${ANSI.reset}   ${rendered.join("   ")}`);
+	if (rendered.some((r) => r.includes("déclaré"))) lines.push(`    ${ANSI.dim}        « déclaré » = publié par le projet, pas sondé par cette commande${ANSI.reset}`);
+}
+/**
+* Résumé de fin — ce que le lecteur doit retenir, et le geste qui suit.
+*
+* Il n'est écrit QUE si un voisin existe : dans le cas nominal (une seule
+* application), expliquer le cloisonnement serait du bruit. C'est l'inverse qui
+* a coûté cher — voir « aucune instance » avec un serveur qui répond, sans que
+* rien ne dise que les deux phrases parlent de projets différents.
+*/
+function renderSummary(lines, report, projects) {
+	const voisins = projects.filter((p) => !p.current);
+	if (voisins.length === 0) return;
+	const nVoisinProcs = voisins.reduce((n, p) => n + p.procs.length, 0);
+	const aMoi = report.processes.length;
+	const portsUp = report.ports.filter((p) => p.listening).length;
+	const pluriel = voisins.length > 1 ? "s" : "";
+	lines.push("", `  ${ANSI.bold}Résumé${ANSI.reset}`, report.inProject ? `    ce projet : ${aMoi === 0 ? `${ANSI.yellow}rien ne tourne${ANSI.reset}` : `${aMoi} process · ${portsUp}/${report.ports.length} ports en écoute`}` : `    ici       : ${ANSI.dim}aucun projet Nodefony${ANSI.reset}`, report.inProject ? `    voisin${pluriel}   : ${voisins.length} projet${pluriel} · ${nVoisinProcs} process` : `    ailleurs  : ${voisins.length} projet${pluriel} · ${nVoisinProcs} process`, ...!report.inProject ? [`    ${ANSI.dim}place-toi dans un projet pour le piloter, ou vise-le par son nom${ANSI.reset}`, `    ${ANSI.dim}depuis ici — status et stop n'agissent jamais que sur UN projet.${ANSI.reset}`] : aMoi === 0 ? [`    ${ANSI.dim}status et stop ne voient QUE ce projet : « aucune instance » signifie${ANSI.reset}`, `    ${ANSI.dim}« aucune à MOI », jamais « rien ne tourne sur ce poste ».${ANSI.reset}`] : [`    ${ANSI.dim}les process du haut sont ceux de CE projet ; le${pluriel} voisin${pluriel} n'${voisins.length > 1 ? "en font" : "en fait"} pas partie${ANSI.reset}`, `    ${ANSI.dim}et ${voisins.length > 1 ? "ne sont" : "n'est"} ni compté${pluriel} dans la synthèse, ni arrêté${pluriel} par ${ANSI.reset}${ANSI.cyan}nodefony stop${ANSI.reset}${ANSI.dim}.${ANSI.reset}`], `    ${ANSI.dim}arrêter ${report.inProject ? "un voisin" : "l'un d'eux"}, sans changer de dossier : ${ANSI.reset}${ANSI.cyan}nodefony stop ${voisins[0].name}${ANSI.reset}`);
+}
+/**
+* Ligne d'état des ports. `listening` seul ne dit pas à QUI : un port tenu par le
+* projet voisin s'affichait `✓ UP` sous le titre de notre application. Le
+* propriétaire connu est donc nommé, et un port étranger n'est jamais un verdict
+* sur notre runtime.
+*/
+function portsLine(ports, owners, upLabel, freeLabel) {
+	return ports.map((p) => {
+		switch (portOwnership(p, owners)) {
+			case "free": return `${p.port} ${freeLabel}`;
+			case "foreign": return `${p.port} ${ANSI.yellow}occupé par ${owners[p.port]}${ANSI.reset}`;
+			default: return `${p.port} ${upLabel}`;
+		}
+	}).join("   ");
+}
+/**
+* Rend le {@link DevStatusReport} en ANSI (tableau + ports + synthèse + warnings)
+* dans `lines`.
+*
+* `projects` est FACULTATIF : omis, le rendu est identique à celui d'avant. Il
+* n'entre pas dans {@link DevStatusReport} parce que le rapport est aussi le
+* contrat du data plane — nommer les projets exige de lire un `package.json` par
+* projet voisin, un coût que la console d'administration n'a pas demandé.
+*/
+function renderStatus(lines, report, projects = [], neighborProbes = []) {
+	const tag = `${ANSI.dim}[status]${ANSI.reset}`;
+	const { processes: procs } = report;
+	if (!report.running) {
+		const { pid, alive } = report.pidfile;
+		const pidNote = pid === null ? `${ANSI.dim}absent${ANSI.reset}` : alive ? `${ANSI.yellow}périmé (pid ${pid} vivant mais non-superviseur)${ANSI.reset}` : `${ANSI.yellow}périmé (pid ${pid} mort)${ANSI.reset}`;
+		const detaille = projects.some((p) => !p.current);
+		lines.push("", report.inProject ? `${tag} ${ANSI.bold}Nodefony dev — aucune instance de ce projet en cours${ANSI.reset}` : `${tag} ${ANSI.bold}Nodefony — ce dossier n'est pas un projet Nodefony${ANSI.reset}`, ...report.inProject ? [`  ${ANSI.dim}pidfile${ANSI.reset}  ${report.pidfile.path} — ${pidNote}`] : [], ...detaille || !report.inProject ? [] : [`  ${ANSI.dim}ports${ANSI.reset}    ${portsLine(report.ports, report.portOwners, `${ANSI.yellow}occupé${ANSI.reset}`, `${ANSI.dim}libre${ANSI.reset}`)}`], report.inProject ? `  ${ANSI.dim}→ lance ${ANSI.reset}${ANSI.cyan}nodefony dev${ANSI.reset}${ANSI.dim} pour démarrer${ANSI.reset}` : `  ${ANSI.dim}aucun package.json qui dépende de « nodefony » ici${ANSI.reset}\n  ${ANSI.dim}→ place-toi à la racine d'une app, ou crée-en une : ${ANSI.reset}${ANSI.cyan}nodefony create app${ANSI.reset}`);
+		renderForeign(lines, report, projects, neighborProbes);
+		renderSummary(lines, report, projects);
+		lines.push("");
+		return;
+	}
+	lines.push("", `${tag} ${ANSI.bold}Nodefony ${runtimeLabel(report.mode)} — ${procs.length} process${ANSI.reset}`);
+	if (!report.inProject) lines.push(`  ${ANSI.yellow}⚠ ce dossier n'est pas un projet Nodefony${ANSI.reset}${ANSI.dim} — vue globale du poste ; stop/dev se lancent depuis la racine d'une app (ou nodefony stop --all)${ANSI.reset}`);
+	lines.push("");
+	renderProcessTable(lines, procs);
+	lines.push("", `  ${ANSI.dim}ports serveur${ANSI.reset} : ${portsLine(report.ports, report.portOwners, `${ANSI.green}✓ UP${ANSI.reset}`, `${ANSI.red}✗ DOWN${ANSI.reset}`)}`, `  ${ANSI.dim}synthèse${ANSI.reset}      : ${summaryLine(report)}`);
+	if (report.readiness !== null) lines.push(`  ${ANSI.dim}disponibilité${ANSI.reset} : ${readinessLine(report.readiness)}`);
+	for (const w of report.warnings) lines.push(`  ${ANSI.yellow}⚠ ${w}${ANSI.reset}`);
+	renderForeign(lines, report, projects, neighborProbes);
+	renderSummary(lines, report, projects);
+	lines.push("");
+}
+/** Libellé du mode runtime pour le titre du rapport (`dev`/`production`/`cluster`). */
+function runtimeLabel(mode) {
+	if (mode === "prod") return "production";
+	if (mode === "cluster") return "cluster";
+	if (mode === "dev") return "dev";
+	return "runtime";
+}
+/**
+* Ajoute au verdict de la sonde le DÉTAIL que le serveur publie sur le disque.
+*
+* Deux sources, une règle : **le compte fait foi, le détail ne fait qu'illustrer.**
+* Le compte vient du runtime interrogé à l'instant ; le détail vient d'un fichier
+* qui peut avoir un cycle de retard. S'ils ne concordent pas — un contributeur
+* libéré entre-temps, un fichier d'un process mort, aucun fichier —, on garde le
+* compte seul. Un nom faux coûte plus cher qu'une absence de nom : il envoie
+* chercher une cause qui n'existe plus.
+*
+* @param probe - verdict rendu par le runtime, ou `null` s'il n'a rien dit.
+* @param cwd - racine du projet, où le serveur publie son détail.
+* @returns le verdict, enrichi seulement si les deux sources s'accordent.
+*/
+function withBlockedBy(probe, cwd) {
+	if (probe === null || probe.blocked === 0) return probe;
+	const publies = readReadinessState(cwd);
+	if (publies === null) return probe;
+	const retenant = publies.filter((c) => !c.ready);
+	if (retenant.length !== probe.blocked) return probe;
+	return {
+		...probe,
+		blockedBy: retenant.map((c) => c.reason === void 0 ? { name: c.name } : {
+			name: c.name,
+			reason: c.reason
+		})
+	};
+}
+/**
+* Ligne de disponibilité — ce que l'orchestrateur ferait de ce pod. Retenu, elle
+* NOMME la conséquence (aucun trafic) : « 503 » seul n'apprend rien à qui n'a pas
+* la doctrine k8s en tête, et c'est précisément le moment où l'on cherche.
+*/
+function readinessLine(probe) {
+	if (probe.ready) return `${ANSI.green}✓ prête${ANSI.reset} ${ANSI.dim}— /readyz rend 200${ANSI.reset}`;
+	const qui = probe.blockedBy !== void 0 && probe.blockedBy.length > 0 ? probe.blockedBy.map((c) => c.reason ? `${c.name} (${c.reason})` : c.name).join(", ") : probe.blocked > 0 ? `${probe.blocked} composant${probe.blocked > 1 ? "s" : ""} retien${probe.blocked > 1 ? "nent" : "t"} la mise en service` : "boot pas terminé";
+	return `${ANSI.yellow}⚠ RETENUE${ANSI.reset} ${ANSI.dim}— ${qui} ; /readyz rend 503, l'orchestrateur n'envoie AUCUN trafic${ANSI.reset}`;
+}
+/** Ligne de synthèse : segments non-nuls seulement (s'adapte à dev / prod / cluster). */
+function summaryLine(report) {
+	const s = report.summary;
+	const seg = [];
+	if (s.supervisors) seg.push(`${s.supervisors} superviseur`);
+	if (s.masters) seg.push(`${s.masters} master`);
+	if (s.workers) seg.push(`${s.workers} worker`);
+	if (s.servers) seg.push(`${s.servers} serveur`);
+	if (s.vites) seg.push(`${s.vites} Vite`);
+	seg.push(`${s.portsUp}/${s.portsTotal} ports UP`);
+	return seg.join(" · ");
+}
+//#endregion
+export { buildDevStatus, collectDevStatus, isStandaloneDevCommand, renderProcessTable, runStandaloneDevCommand, runStatusReport };