nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/kernel/CliKernel.js

@@ -0,0 +1,630 @@
+import { version } from "../package.js";
+import Syslog from "../syslog/Syslog.js";
+import "../cli/sysexits.js";
+import { toImportSpecifier } from "./resolveModuleEntry.js";
+import Cli from "../Cli.js";
+import { shouldColorize, usableWidth } from "./checks/report.js";
+import { renderHelp } from "../cli/helpReport.js";
+import { buildCliManifest, runCompleteQuery, runCompletionCommand, writeCliManifest } from "../cli/completion.js";
+import Menu from "./commands/MenuCommand.js";
+import { isStandaloneDevCommand, runStandaloneDevCommand } from "../service/dev/devStatusReport.js";
+import Dev from "./commands/DevCommand.js";
+import Build from "./commands/BuildCommand.js";
+import Prod from "./commands/ProdCommand.js";
+import Cluster from "./commands/ClusterCommand.js";
+import Install from "./commands/InstallCommand.js";
+import Outdated from "./commands/OutdatedCommand.js";
+import Status from "./commands/StatusCommand.js";
+import { runEnvCommand } from "../cli/env.js";
+import { isDoctorCommand, runDoctorCommand, runDoctorWithoutLive, wantsLiveDoctor } from "./checks/runDoctor.js";
+import Check from "./commands/DoctorCommand.js";
+import Inspect from "./commands/InspectCommand.js";
+import Stop from "./commands/StopCommand.js";
+import { runAiSyncCommand } from "../cli/aiSync.js";
+import AiSync from "./commands/AiSyncCommand.js";
+import { runAiMcpCommand } from "../cli/aiMcp.js";
+import AiMcp from "./commands/AiMcpCommand.js";
+import { runGitHooksCommand } from "../cli/gitHooks.js";
+import GitHooks from "./commands/GitHooksCommand.js";
+import { isDetachRequested, runDetachedStart } from "../service/dev/detachedStart.js";
+import Completion from "./commands/CompletionCommand.js";
+import { runCreateCommand } from "../cli/create.js";
+import Create from "./commands/CreateCommand.js";
+import Env from "./commands/EnvCommand.js";
+import { runCardCommand } from "../cli/card.js";
+import Card from "./commands/CardCommand.js";
+import { runSymbolsCommand } from "../cli/symbols.js";
+import Symbols from "./commands/SymbolsCommand.js";
+import Kernel, { CONSOLE_RUN_PROFILE } from "./Kernel.js";
+import path from "node:path";
+//#region src/kernel/CliKernel.ts
+const cliOptions = {
+	autoLogger: false,
+	asciify: false,
+	version,
+	warning: true,
+	pid: true
+};
+/**
+* Kernel spécialisé pour les invocations CLI (`npx nodefony <command>`).
+*
+* **N'étend PAS {@link Kernel}** mais {@link Cli} (Commander wrapper). Le `Kernel` applicatif
+* est instancié séparément par {@link start} et linké à `this.kernel`. Sa raison d'être :
+* parser argv via Commander, sélectionner une commande, configurer l'environnement
+* (`SERVER` vs `CONSOLE`), puis déléguer au `Kernel` pour le boot.
+*
+* **Piège lifecycle connu** : `environment` peut être `undefined` au constructor — les
+* sous-commandes le set dans leur hook `onKernelStart()`. Ne jamais conditionner du code
+* sur `this.environment` dans le constructor.
+*
+* @example
+* ```ts
+* // bin/nodefony.ts
+* import { CliKernel } from "nodefony";
+* const cli = new CliKernel();
+* await cli.start();   // boote le Kernel + parse argv + exécute la command
+* ```
+*/
+var CliKernel = class CliKernel extends Cli {
+	runProfile = { ...CONSOLE_RUN_PROFILE };
+	app = null;
+	packageManager = this.pnpm;
+	/**
+	* Boot SILENCIEUX : pour les commandes CLI utilitaires (help global, commandes
+	* de module type `frontend:status`) dont la sortie doit être propre — les logs
+	* de cycle de vie (NOTICE/INFO/DEBUG) sont coupés, seuls EMERGENCY..ERROR
+	* surfacent (cf {@link initSyslog}). Mis à `true` par {@link dispatchGlobalHelp}
+	* et {@link dispatchModuleCommand}. `-d/--debug` rétablit le détail.
+	*/
+	quietBoot = false;
+	/**
+	* @param environment - environnement initial (`"development"` / `"production"` / `"test"`).
+	*   Peut être `undefined` — sera set par la sous-commande dans `onKernelStart()`.
+	*/
+	constructor(environment) {
+		super("NODEFONY", cliOptions);
+		if (environment) this.environment = environment;
+		this.initSyslog();
+	}
+	/**
+	* Sélectionne le package manager pour les commandes `install`/`outdated`.
+	*
+	* @param manager - `"npm"` / `"yarn"` / `"pnpm"`. Défaut = `this.options.packageManager` (pnpm).
+	* @returns la fonction package manager liée à `this`.
+	*/
+	setPackageManager(manager = this.options?.packageManager) {
+		switch (manager) {
+			case "yarn":
+				this.packageManager = this.yarn;
+				break;
+			case "pnpm":
+				this.packageManager = this.pnpm;
+				break;
+			default: this.packageManager = this.npm;
+		}
+		return this.packageManager;
+	}
+	showHelp(quit, context) {
+		super.showHelp(quit, context);
+	}
+	/**
+	* Parse argv synchroniquement via Commander (cf {@link parseCommandAsync} pour async).
+	*
+	* @param argv - args (défaut `process.argv`).
+	* @returns instance Commander après parse.
+	*/
+	parseCommand(argv) {
+		return this.parse(argv || process.argv);
+	}
+	/**
+	* Parse argv et exécute la commande matched (peut être async — `.action(async () => ...)`).
+	*
+	* @param argv - args (défaut `process.argv`).
+	* @returns Promise résolue avec l'instance Commander après exécution.
+	*/
+	parseCommandAsync(argv) {
+		return this.parseAsync(argv || process.argv);
+	}
+	/**
+	* Boot complet : instancie le Kernel, enregistre les commandes built-in, parse argv,
+	* lance `kernel.start()`.
+	*
+	* Comportement Commander :
+	* - `--help` / `--version` → terminate(0) propre
+	* - Erreur Commander (option/commande inconnue) → terminate(1) + re-throw —
+	*   **JAMAIS de fallback serveur** (legacy supprimé : une erreur de parse ne doit
+	*   pas démarrer un runtime).
+	* - Exception kernel → terminate(1) puis re-throw
+	*
+	* @param options - options surchargées pour le `new Kernel(env, this, options)`.
+	* @returns le Kernel booté.
+	* @throws Si Commander absent OR si kernel.start() crash.
+	*/
+	async start(options) {
+		const requested = this.getRequestedCommandName();
+		if (requested !== null && isStandaloneDevCommand(requested)) return process.exit(await runStandaloneDevCommand(requested));
+		if (this.isVersionRequested()) {
+			process.stdout.write(`${version}\n`);
+			return process.exit(0);
+		}
+		if (requested === "completion") return process.exit(runCompletionCommand(process.argv));
+		if (requested === "__complete") return process.exit(runCompleteQuery(process.argv, () => this.buildBuiltinManifest()));
+		if (requested === "create") return process.exit(await runCreateCommand(process.argv));
+		if (isDoctorCommand(requested) && !wantsLiveDoctor(requested, process.argv)) return process.exit(await runDoctorCommand(process.argv));
+		if (requested === "env") return process.exit(await runEnvCommand(process.argv));
+		if (requested === "card" || requested === "devkit:card") return process.exit(runCardCommand(process.argv, version));
+		if (requested === "symbols") return process.exit(runSymbolsCommand(process.argv));
+		if (requested === "ai:sync") return process.exit(runAiSyncCommand(process.argv));
+		if (requested === "ai:mcp") return process.exit(await runAiMcpCommand(process.argv));
+		if (requested === "git:hooks") return process.exit(runGitHooksCommand(process.argv));
+		if (requested !== null && (/* @__PURE__ */ new Set([
+			"development",
+			"dev",
+			"production",
+			"prod",
+			"cluster"
+		])).has(requested) && isDetachRequested(process.argv.slice(2))) {
+			const code = await runDetachedStart(process.argv);
+			return process.exit(code);
+		}
+		this.kernel = new Kernel(this.environment, this, options);
+		try {
+			if (this.commander) {
+				this.registerBuiltinCommands();
+				if (requested !== null && this.getCommand(requested)?.quietBoot) this.quietBoot = true;
+				this.commander.exitOverride();
+				this.commander.name("nodefony");
+				this.commander.showHelpAfterError(false);
+				this.commander.showSuggestionAfterError(true);
+				this.commander.configureHelp({
+					sortOptions: true,
+					showGlobalOptions: true,
+					subcommandTerm: (cmd) => {
+						const aliases = cmd.aliases?.() ?? [];
+						return aliases.length ? `${cmd.name()}|${aliases.join("|")}` : cmd.name();
+					}
+				});
+				if (process.argv.slice(2).length === 0 && this.kernel?.isTTY) process.argv.push("menu");
+				if (this.isGlobalHelpRequested()) return this.dispatchGlobalHelp();
+				if (requested !== null && !this.getBuiltinCommandNames().has(requested)) return this.dispatchModuleCommand(requested);
+				let booting = false;
+				return this.commander?.parseAsync().then(async () => {
+					if (!this.kernel) throw new Error(`Kernel not found`);
+					booting = true;
+					return this.kernel.start();
+				}).catch(async (e) => {
+					const code = e?.code;
+					if (code === "commander.help" || code === "commander.helpDisplayed" || code === "commander.version") return this.kernel?.terminate(0);
+					const err = e;
+					if (booting && wantsLiveDoctor(requested, process.argv)) {
+						const cause = e instanceof Error ? e.message : String(e ?? "cause inconnue");
+						const reportCode = await runDoctorWithoutLive(process.argv, `l'application n'a pas démarré — ${cause}`, "corrige la cause ci-dessus, puis relance `nodefony doctor --live`");
+						return this.kernel?.terminate(reportCode);
+					}
+					if (!err.presented) this.log(e, "ERROR");
+					await this.kernel?.terminate(err.exitCode ?? 1);
+					throw e;
+				});
+			}
+			throw new Error(`Commander not found`);
+		} catch (e) {
+			if (!e.presented) this.log(e, "ERROR");
+			throw e;
+		}
+	}
+	/**
+	* Enregistre les commandes built-in dans commander (idempotent : skip si déjà
+	* fait). Ordre = ordre des groupes dans le help (Commander rend les groupes dans
+	* l'ordre de 1ʳᵉ rencontre) : Serveur → Build → Projet → Console/jobs.
+	* Partagé entre `start()` et le fallback de complétion (built-ins sans boot).
+	*/
+	registerBuiltinCommands() {
+		if (this.commands["development"]) return;
+		this.addCommand(Dev);
+		this.addCommand(Prod);
+		this.addCommand(Cluster);
+		this.addCommand(Build);
+		this.addCommand(Install);
+		this.addCommand(Outdated);
+		this.addCommand(Menu);
+		this.addCommand(Status);
+		this.addCommand(Stop);
+		this.addCommand(Completion);
+		this.addCommand(Create);
+		this.addCommand(Check);
+		this.addCommand(Env);
+		this.addCommand(Card);
+		this.addCommand(Symbols);
+		this.addCommand(Inspect);
+		this.addCommand(AiSync);
+		this.addCommand(AiMcp);
+		this.addCommand(GitHooks);
+	}
+	/**
+	* Écrit le manifest de complétion shell (cache par projet) depuis l'état COURANT
+	* de commander — appelé par le Kernel à `onPreRegister` en dev, une fois les
+	* commandes de module posées. Best-effort côté appelant (fire-and-forget).
+	*/
+	async writeCompletionManifest(cwd = process.cwd()) {
+		if (!this.commander) return;
+		await writeCliManifest(this.commander, cwd, version);
+	}
+	/**
+	* Manifest de complétion construit en MÉMOIRE depuis commander (sans cache) —
+	* fallback du fast-path `__complete` hors projet.
+	*/
+	buildBuiltinManifest() {
+		this.registerBuiltinCommands();
+		return buildCliManifest(this.commander, version);
+	}
+	/**
+	* Nom de la commande demandée = premier token non-option de `process.argv`.
+	*
+	* `null` si aucun (invocation nue, `--help`, `--version`) → on retombe sur le
+	* flow built-in inchangé.
+	*
+	* @returns nom de commande demandé ou `null`.
+	*/
+	getRequestedCommandName() {
+		for (const arg of process.argv.slice(2)) if (!arg.startsWith("-")) return arg;
+		return null;
+	}
+	/**
+	* `true` si l'invocation demande la **version globale** : `nodefony -v` ou
+	* `nodefony --version` (que des options, aucun positionnel).
+	*
+	* Un positionnel présent → la commande décide (`nodefony dev --version` n'est pas
+	* une demande de version du CLI) : on laisse commander trancher.
+	*
+	* @returns `true` si la version du CLI est demandée.
+	*/
+	isVersionRequested() {
+		const args = process.argv.slice(2);
+		for (const arg of args) if (!arg.startsWith("-")) return false;
+		return args.includes("-v") || args.includes("--version");
+	}
+	/**
+	* `true` si l'invocation demande le **help global** : `nodefony` nu,
+	* `nodefony --help` ou `nodefony -h` (que des options, aucun positionnel).
+	*
+	* Exclut volontairement `--version` (fast-path standalone, cf `isVersionRequested`)
+	* et `nodefony <cmd> --help` (help d'une sous-commande, laissé à commander / au
+	* dispatch de module — il y a un positionnel).
+	*
+	* @returns `true` si le help global est demandé.
+	*/
+	isGlobalHelpRequested() {
+		const args = process.argv.slice(2);
+		if (args.length === 0) return true;
+		for (const arg of args) if (!arg.startsWith("-")) return false;
+		return args.includes("-h") || args.includes("--help");
+	}
+	/**
+	* Noms + alias des commandes built-in déjà enregistrées dans commander.
+	*
+	* Dérivé de commander (pas de liste en dur → suit l'ajout/retrait de built-ins).
+	* À appeler APRÈS `addCommand(...)` des built-ins et AVANT que les modules
+	* n'enregistrent les leurs.
+	*
+	* @returns set des noms et alias built-in.
+	*/
+	getBuiltinCommandNames() {
+		const names = /* @__PURE__ */ new Set();
+		for (const cmd of this.commander?.commands ?? []) {
+			names.add(cmd.name());
+			for (const alias of cmd.aliases?.() ?? []) names.add(alias);
+		}
+		return names;
+	}
+	/**
+	* Dispatch DIFFÉRÉ d'une commande de module.
+	*
+	* commander ignore la commande au boot (posée par le module à `onPreRegister`,
+	* chargé depuis `config.modules`). On parse donc argv depuis un listener
+	* `onPreRegister` lui-même posé via `onStart` : `loadApp()` (qui pose le listener
+	* `loadModulesFromManifest`) précède `onStart`, et `emitAsync` est séquentiel →
+	* notre listener tourne APRÈS le chargement des modules, donc quand toutes les
+	* commandes de module sont connues, mais
+	* AVANT les phases qu'elles ciblent (`onRegister`/`onReady`/…) → leur
+	* `kernel.once(kernelEvent)` fire normalement. Le kernel reste en mode CONSOLE
+	* (aucune commande serveur ne fixe `type=SERVER`) → 0 serveur démarré. Commande
+	* réellement introuvable (typo) → `terminate(1)`, jamais de fallback serveur.
+	*
+	* @param requested - nom de commande demandé (pour le message d'erreur).
+	* @returns le Kernel booté (terminé après exécution de la commande).
+	*/
+	dispatchModuleCommand(requested) {
+		const kernel = this.kernel;
+		this.quietBoot = true;
+		kernel.once("onStart", () => {
+			kernel.once("onPreRegister", async () => {
+				try {
+					await this.commander?.parseAsync();
+				} catch (e) {
+					const code = e?.code;
+					if (code === "commander.helpDisplayed" || code === "commander.version") {
+						await this.kernel?.terminate(0);
+						return;
+					}
+					this.log(`command not found: ${requested}`, "ERROR");
+					await this.kernel?.terminate(64);
+				}
+			});
+		});
+		return kernel.start().catch(async (e) => {
+			const code = e.exitCode ?? 70;
+			await this.kernel?.terminate(code);
+			throw e;
+		});
+	}
+	/**
+	* Boote le kernel jusqu'à `onPreRegister` (modules instanciés → leurs commandes
+	* sont posées dans commander), affiche le help COMPLET puis `terminate(0)`.
+	*
+	* Même mécanique de timing que {@link dispatchModuleCommand} : le listener
+	* `onPreRegister` est posé depuis `onStart` pour passer APRÈS le chargement des modules
+	* (`emitAsync` séquentiel). Le kernel reste CONSOLE (aucune commande → 0 serveur)
+	* et `terminate(0)` stoppe le boot avant `onRegister` (process.exit au nextTick).
+	*
+	* Boot KO (hors d'une app, config invalide) → fallback : help built-in seul
+	* (déjà enregistré dans commander) + `terminate(0)`. L'utilisateur a toujours un help.
+	*
+	* @returns le Kernel (terminé après affichage du help).
+	*/
+	async dispatchGlobalHelp() {
+		const kernel = this.kernel;
+		this.quietBoot = true;
+		if (await kernel.isTrunk() === null) return this.renderStandaloneHelp(kernel);
+		let shown = false;
+		const render = async () => {
+			if (!shown) {
+				shown = true;
+				await this.writeCompletionManifest().catch(() => {});
+				this.writeHelp();
+			}
+			await this.kernel?.terminate(0);
+		};
+		kernel.once("onStart", () => {
+			kernel.once("onPreRegister", render);
+		});
+		return kernel.start().catch(async () => {
+			await render();
+			return kernel;
+		});
+	}
+	/**
+	* L'aide des commandes INTÉGRÉES, sans démarrer quoi que ce soit.
+	*
+	* Le repli de {@link dispatchGlobalHelp} quand il n'y a pas d'application à
+	* interroger : hors de tout projet, ou dans une application qui n'est pas
+	* encore installée ni construite. Les commandes de module manqueront —
+	* personne ne peut les connaître sans charger les modules — et c'est dit.
+	*
+	* Sort en **0** : demander de l'aide n'est pas une erreur, et un code 1
+	* casse un `nodefony --help | less` autant qu'un script d'installation.
+	*
+	* @param kernel - le kernel, terminé après l'affichage.
+	* @returns le kernel.
+	*/
+	async renderStandaloneHelp(kernel) {
+		const hint = kernel.diagnoseUnbootableProject();
+		this.writeHelp(hint ? { note: hint.split("\n").join(" ") } : {
+			note: "hors d'une application Nodefony : seules les commandes intégrées sont listées.",
+			noteAction: "nodefony create app <nom>"
+		});
+		return await kernel.terminate(0, true);
+	}
+	/**
+	* Les commandes qui répondent en JSON — la seule chose qu'un agent cherche
+	* d'abord, et que rien n'affichait.
+	*
+	* Écrite ici plutôt que dérivée d'un `--json` cherché dans les options : la
+	* moitié des commandes en portent un pour un usage local (un fragment, un
+	* fichier), et les lister toutes noierait celles qui rendent un DOCUMENT
+	* exploitable. La liste est courte et se relit d'un coup d'œil.
+	*/
+	static JSON_COMMANDS = [
+		"doctor --json",
+		"inspect <sujet> --json",
+		"env --json",
+		"card --json"
+	];
+	/**
+	* Compose le modèle d'aide depuis commander, et l'écrit.
+	*
+	* 🔴 Le modèle se lit sur COMMANDER, jamais sur `cli.commands` : les
+	* commandes de module ne sont pas dans ce registre (elles s'enregistrent
+	* directement dans commander depuis `Module`), et c'est ce trou qui faisait
+	* déjà perdre des commandes au menu. Le groupe voyage donc avec la commande,
+	* posé par son constructeur (`OptionsCommandInterface.helpGroup`).
+	*
+	* @param extra - une note de situation, quand l'aide est rendue hors d'une
+	*   application ou dans une application non installée.
+	*/
+	writeHelp(extra) {
+		const c = this.commander;
+		let shownVersion = "";
+		try {
+			const v = c?.version();
+			if (typeof v === "string") shownVersion = v;
+		} catch {}
+		const owner = {};
+		const modules = this.kernel?.getModules?.() ?? {};
+		for (const name in modules) {
+			const cmds = modules[name].commands;
+			for (const cn in cmds ?? {}) owner[cn] = name;
+		}
+		const commands = (c?.commands ?? []).filter((cmd) => cmd.name() !== "help").map((cmd) => {
+			const group = cmd.helpGroup?.();
+			const arg = cmd.registeredArguments?.[0];
+			const values = arg?.argChoices ?? [];
+			const entry = {
+				name: cmd.name(),
+				aliases: cmd.aliases?.() ?? [],
+				description: cmd.description() || ""
+			};
+			if (typeof group === "string" && group) entry.group = group;
+			const module = owner[cmd.name()];
+			if (module) entry.module = module;
+			if (values.length) entry.accepts = {
+				label: arg?.name() ?? "valeurs",
+				values
+			};
+			return entry;
+		});
+		const globalOptions = (c?.options ?? []).map((o) => ({
+			flags: o.flags,
+			description: o.description
+		})).concat([{
+			flags: "-h, --help",
+			description: "affiche cette aide"
+		}]).sort((a, b) => a.flags.localeCompare(b.flags));
+		const loaded = Object.keys(modules).filter((m) => m !== "app");
+		const out = process.stdout;
+		const lines = renderHelp({
+			version: shownVersion,
+			commands,
+			globalOptions,
+			...loaded.length ? { modules: loaded } : {},
+			jsonCommands: CliKernel.JSON_COMMANDS,
+			...extra?.note ? { note: extra.note } : {},
+			...extra?.noteAction ? { noteAction: extra.noteAction } : {}
+		}, {
+			width: usableWidth(out.columns),
+			color: shouldColorize(process.env, Boolean(this.kernel?.isTTY))
+		});
+		out.write(`${lines.join("\n")}\n`);
+	}
+	/**
+	* Définit le profil d'exécution du run (cf {@link IRunProfile}) — déclaré par les
+	* commandes serveur/daemon. Le Kernel le recopie depuis `cli.runProfile` à `onStart`.
+	*
+	* @param profile - profil à appliquer (`servers`/`lifetime`/`interactive`).
+	* @returns le profil appliqué.
+	*/
+	setRunProfile(profile) {
+		this.runProfile = profile;
+		if (this.kernel) this.kernel.runProfile = profile;
+		return this.runProfile;
+	}
+	/**
+	* Point UNIQUE de résolution d'une commande matchée — appelé par le callback
+	* commander de {@link Command} (parse pur : le match ne fait que signaler) et par
+	* `StartCommand` (sélection interactive).
+	*
+	* Fait, dans l'ordre :
+	* 1. lie la commande au Kernel (`kernel.command` / `kernel.commandArgs`) ;
+	* 2. applique le **profil déclaré** (`command.runProfile`) s'il existe —
+	*    `setRunProfile` resynchronise AUSSI `kernel.runProfile`, donc une commande
+	*    résolue APRÈS `onStart` (commande de module, posée à `onPreRegister`) peut
+	*    être serveur : la décision de monter les serveurs se joue plus tard
+	*    (`onReady → initServers`) ;
+	* 3. câble les hooks lifecycle + l'exécution à `kernelEvent` (`setEvents`).
+	*
+	* @param command - commande matchée.
+	* @param args - arguments produits par le parse commander.
+	*/
+	resolveCommand(command, args) {
+		const kernel = this.kernel;
+		kernel.command = command;
+		kernel.commandArgs = args;
+		if (command.runProfile) this.setRunProfile({ ...command.runProfile });
+		command.setEvents(...args);
+	}
+	/**
+	* Enregistre une commande CLI dans le registre du CliKernel + Commander.
+	*
+	* @param cliCommand - constructeur de la commande (signature `new (cli: CliKernel) => Command`).
+	* @returns instance de la commande créée.
+	*/
+	addCommand(cliCommand) {
+		const command = new cliCommand(this);
+		this.commands[command.name] = command;
+		return command;
+	}
+	/**
+	* Charge dynamiquement un module ES depuis le filesystem local.
+	*
+	* Résout les chemins relatifs par rapport à `cwd`. Capture les erreurs d'import et les log
+	* en ERROR avant de les re-throw.
+	*
+	* @param moduleName - chemin absolu OR relatif vers le module à importer.
+	* @param cwd - racine pour résoudre `moduleName` (défaut `process.cwd()`).
+	* @returns export default du module ou `null`.
+	* @throws L'erreur d'import est re-throw après log.
+	*/
+	async loadLocalModule(moduleName, cwd = process.cwd()) {
+		try {
+			const detectpath = path.isAbsolute(moduleName) ? moduleName : path.resolve(cwd, moduleName);
+			return (await import(toImportSpecifier(detectpath))).default;
+		} catch (error) {
+			this.log(error, "ERROR");
+			throw error;
+		}
+	}
+	/**
+	* Configure le pipeline Syslog selon environnement et mode debug.
+	*
+	* Sans kernel attaché → délègue à {@link Cli.initSyslog} parent. Avec kernel :
+	* - Sévérités `[0..6]` (EMERGENCY..INFO) toujours
+	* - `+7` (DEBUG) si `debug === true` OR `this.debug`
+	* - `+4, +5` (WARNING, NOTICE) si type === SERVER et env === development
+	* - mode MACHINE (`--json`) ou {@link quietBoot} → `[0..3]` seulement, que
+	*   `Syslog.rawLog` dirige vers la sortie d'erreur : le flux de données reste
+	*   pur, et un échec reste lisible.
+	*
+	* Le `pid` est ajouté en préfixe de chaque ligne SAUF en dev mono-process.
+	*
+	* @param environment - environnement (override de `this.environment`).
+	* @param debug - active sévérité DEBUG (override de `this.debug`).
+	* @param options - conditions de filtrage Syslog custom.
+	*/
+	initSyslog(environment, debug, options) {
+		if (!this.kernel) return super.initSyslog(environment, debug, options);
+		const { syslog } = this;
+		const argvDebug = process.argv.includes("-d") || process.argv.includes("--debug");
+		const argvMachine = process.argv.includes("--json") || process.argv.includes("-j");
+		const data = (this.quietBoot || argvMachine) && !(debug || this.debug || argvDebug) ? [
+			0,
+			1,
+			2,
+			3
+		] : [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		];
+		if (debug || this.debug) data.push(7);
+		if (this.kernel.runProfile?.servers && this.kernel.environment === "development") {
+			data.push(4);
+			data.push(5);
+		}
+		const conditions = { severity: { data } };
+		const format = Syslog.formatDebug(debug || this.debug);
+		if (typeof format === "object") conditions.msgid = { data: format };
+		syslog?.removeAllListeners("onLog");
+		return syslog?.listenWithConditions(conditions, (pdu) => {
+			const pid = this.environment === "development" ? "" : this.pid?.toString();
+			Syslog.rawLog(pdu, pid);
+		});
+	}
+	/**
+	* Arrêt propre — délègue à `kernel.terminate()` si kernel présent, sinon `super.terminate()`.
+	*
+	* @param code - exit code Unix (0 = succès, 1+ = erreur). Défaut `0`.
+	* @param quiet - supprime les messages de terminaison si `true`.
+	*/
+	async terminate(code = 0, quiet) {
+		if (this.kernel) {
+			await this.kernel.terminate(code, quiet);
+			return;
+		}
+		return Promise.resolve(super.terminate(code, quiet));
+	}
+};
+//#endregion
+export { CliKernel as default };