nodefony 7.0.2 → 10.0.0-alpha.2

package/templates/app/frontend/vue/frontend/src/App.vue.tpl

@@ -0,0 +1,367 @@
+<script setup lang="ts">
+import { onMounted, onUnmounted, ref, version as vueVersion } from "vue";
+<% if (it.complete) { %>// FAÇADE temps réel isomorphe du framework — reconnexion, re-subscribe, état :
+// gérés par le client. Aucun `new WebSocket` à la main. Subpath `nodefony/vue` :
+// les COMPOSABLES du framework, de minces enveloppes sur le socle agnostique
+// que React, Angular et Svelte consomment aussi. Le plugin s'installe dans
+// `main.ts` — c'est là, et là seulement, que l'adresse du serveur est écrite.
+import {
+  useNodefony,
+  useNodefonyChannelData,
+  useNodefonyState,
+} from "nodefony/vue";
+<% } %>import { NODEFONY_LOGO } from "./brand";
+// Mise en page et palette de la démonstration — feuille PARTAGÉE par les trois
+// vitrines ; `accent.css` n'y ajoute que la couleur du framework.
+import "./showcase.css";
+import "./accent.css";
+
+interface ApiData {
+  hello: string;
+  pid: number;
+  /** Identité résolue par la zone firewall `main` (^/api) — « anonyme » sinon. */
+  who?: string;
+}
+<% if (it.complete) { %>
+/** Réponse de la route PROTÉGÉE /api/secure/hello (zone `secure`, 401 sans session). */
+interface SecureData {
+  message: string;
+  zone: string;
+  pid: number;
+}
+<% } %>
+/**
+ * Page d'accueil de l'app — vitrine AUTONOME (zéro dépendance UI) :
+ *  - panneau de marque (même design que le login de Studio : dégradé, glow,
+ *    logo, slogan, 3 piliers du framework) ;
+ *  - preuves INTERACTIVES : fetch HTTP, echo WebSocket live sur le MÊME
+ *    controller (le différenciateur Nodefony), compteur HMR.
+ * Édite ce fichier : Vite recompile à la volée.
+ */
+
+const data = ref<ApiData | null>(null);
+const error = ref<string | null>(null);
+const count = ref(0);
+<% if (it.complete) { %>
+/** Un message du canal `live:events` (cf `nodefony/controllers/LiveController.ts`). */
+interface LiveEvent {
+  text: string;
+  ts: number;
+  pid: number;
+}
+
+// La socket de la page, fournie par le plugin — UNE seule pour tout le monde.
+// Les deux composables ci-dessous s'abonnent au montage et RENDENT l'abonnement
+// au démontage, sans une ligne à écrire : c'est la portée du composant qui
+// libère. L'abonnement serveur est ref-compté et rejoué à chaque reconnexion.
+const live = useNodefony();
+const liveState = useNodefonyState();
+const last = useNodefonyChannelData<LiveEvent>("live:events");
+const pingMs = ref<number | null>(null);
+<% } else { %>const wsInput = ref("ping");
+const wsLog = ref<string[]>([]);
+let ws: WebSocket | null = null;
+<% } %>
+<% if (it.complete) { %>const username = ref("admin");
+const password = ref("admin");
+const authMsg = ref<string | null>(null);
+const secureData = ref<SecureData | null>(null);
+<% } %>
+// Rappelé après login/logout : la zone firewall `main` (^/api) résout
+// l'identité par requête → `who` change sans recharger la page.
+const refreshHello = () =>
+  fetch("/api/hello")
+    .then((r) => r.json())
+    .then((j) => {
+      const d = (j.result ?? j) as ApiData; // Nodefony wrappe `{ result }`
+      data.value = d;
+<% if (it.complete) { %>      // Connecté → la route PROTÉGÉE prend le relais (zone `secure`,
+      // ^/api/secure : sans session le firewall répond 401 avant le controller).
+      if (d.who && d.who !== "anonyme") {
+        fetch("/api/secure/hello", { credentials: "same-origin" })
+          .then((r) => (r.ok ? r.json() : null))
+          // Le corps d'un `then` REND une valeur : un bloc muet est signalé par
+          // le lint (`promise/always-return`) — dans l'application générée, donc
+          // chez l'utilisateur, dont la passe naît rouge.
+          .then((s) => (secureData.value = s ? ((s.result ?? s) as SecureData) : null))
+          .catch(() => (secureData.value = null));
+      } else {
+        secureData.value = null;
+      }
+<% } %>      // Un `then` REND une valeur — sinon le lint de l'application
+      // GÉNÉRÉE la refuse (`promise/always-return`), et sa passe naît rouge.
+      return d;
+    })
+    .catch((e) => {
+      error.value = e instanceof Error ? e.message : String(e);
+    });
+<% if (it.complete) { %>
+// Flux session BFF du framework (cookie opaque HttpOnly — le front ne voit
+// jamais de token) : mêmes endpoints que le login de la console /nodefony.
+const doLogin = async () => {
+  authMsg.value = null;
+  const r = await fetch("/nodefony/security/api/auth/login", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    credentials: "same-origin",
+    body: JSON.stringify({ username: username.value, password: password.value }),
+  });
+  const j = (await r.json()) as {
+    result?: { user?: { username?: string } };
+    user?: { username?: string };
+  };
+  if (!r.ok) {
+    authMsg.value = "identifiants invalides";
+    return;
+  }
+  const u = j.result?.user ?? j.user;
+  authMsg.value = `session ouverte — ${u?.username ?? username.value}`;
+  refreshHello();
+};
+
+const doLogout = async () => {
+  await fetch("/nodefony/security/api/auth/logout", {
+    method: "POST",
+    credentials: "same-origin",
+  });
+  authMsg.value = "session fermée";
+  refreshHello();
+};
+<% } %>
+onMounted(() => {
+  refreshHello();
+<% if (it.complete) { %>
+  // Rien à brancher ici pour le temps réel : les composables l'ont fait au
+  // `setup`, et le défont à la mort du composant. Ce qui reste dans ce hook
+  // n'est que du HTTP.
+<% } else { %>
+  // WS même origine que la page (ws en http, wss en https).
+  // ⚠ Echo BRUT = démo du pipeline HTTP/WS partagé, pas un modèle : pour du WS
+  // métier, génère la bonne couche (`nodefony create controller <nom> --kind
+  // realtime`) et consomme-la par la FAÇADE client (`RealtimeClient`) au lieu
+  // d'un `new WebSocket` à la main.
+  const scheme = location.protocol === "https:" ? "wss" : "ws";
+  const socket = new WebSocket(`${scheme}://${location.host}/api/echo`);
+  socket.addEventListener("message", (ev) => {
+    wsLog.value = [...wsLog.value.slice(-4), `← ${String(ev.data)}`];
+  });
+  socket.addEventListener("error", () => {
+    wsLog.value = [...wsLog.value, "⚠ connexion WS impossible"];
+  });
+  ws = socket;
+<% } %>});
+
+onUnmounted(() => {
+<% if (it.complete) { %>  // Rien à libérer : le rechargement à chaud remonte le composant, et sa portée
+  // a déjà rendu les abonnements. La socket PARTAGÉE, elle, reste ouverte pour
+  // la page — la couper ici trancherait les requêtes en vol des autres.
+<% } else { %>  // HMR remonte le composant : fermer une socket encore en CONNECTING lève un
+  // warning navigateur (« closed before the connection is established ») —
+  // on attend l'open pour fermer proprement.
+  const socket = ws;
+  ws = null;
+  if (!socket) return;
+  if (socket.readyState === WebSocket.CONNECTING) {
+    socket.addEventListener("open", () => socket.close());
+  } else {
+    socket.close();
+  }
+<% } %>});
+
+<% if (it.complete) { %>const doPing = async () => {
+  const t0 = performance.now();
+  await live.request("live:ping", {});
+  pingMs.value = Math.round(performance.now() - t0);
+};
+
+// Ce que CETTE page envoie, TOUTES les pages abonnées le reçoivent : ouvrir un
+// second onglet et cliquer suffit à le voir. C'est ce partage qui fait l'intérêt
+// d'une socket — pas un battement qui parlerait pour ne rien dire.
+const doSay = () =>
+  live.emit("live:say", {
+    text: `bonjour de la page (${Date.now() % 1000})`,
+  });
+<% } else { %>const sendWs = () => {
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(wsInput.value);
+    wsLog.value = [...wsLog.value.slice(-4), `→ ${wsInput.value}`];
+  }
+};
+<% } %>
+</script>
+
+<template>
+  <div class="nf-split">
+    <!-- ── Panneau de marque (même design que le login Studio) ─────────── -->
+    <aside class="nf-hero">
+      <div class="nf-glow" aria-hidden="true"></div>
+      <div style="display: flex; gap: 14px; align-items: center; position: relative">
+        <img :src="NODEFONY_LOGO" alt="Nodefony" height="42" draggable="false" />
+        <span style="font-weight: 700; font-size: 26px"><%= it.appName %></span>
+      </div>
+
+      <div style="max-width: 480px; position: relative">
+        <h2>Le temps réel, nativement.</h2>
+        <p class="nf-sub">
+          Observez, comprenez et contrôlez chaque sous-système de Nodefony —
+          en direct.
+        </p>
+        <div class="nf-feature">
+          <div class="nf-ficon">
+            <!-- éclair (bolt) -->
+            <svg viewBox="0 0 24 24"><path d="M13 2 4.5 12.5H11L9.5 22 18 11.5h-6.5L13 2z" /></svg>
+          </div>
+          <div>
+            <div style="font-weight: 600">Temps réel natif</div>
+            <div class="nf-fdesc">HTTP et WebSocket, co-citoyens dans le même contexte.</div>
+          </div>
+        </div>
+        <div class="nf-feature">
+          <div class="nf-ficon">
+            <!-- pulse (activity) -->
+            <svg viewBox="0 0 24 24"><path d="M3 12h4l2.5-7 5 14 2.5-7h4" fill="none" stroke-width="2" /></svg>
+          </div>
+          <div>
+            <div style="font-weight: 600">Observabilité totale</div>
+            <div class="nf-fdesc">Métriques, logs et traces — en direct.</div>
+          </div>
+        </div>
+        <div class="nf-feature">
+          <div class="nf-ficon">
+            <!-- bouclier -->
+            <svg viewBox="0 0 24 24"><path d="M12 2 5 5v6c0 5 3.5 8.5 7 11 3.5-2.5 7-6 7-11V5l-7-3z" /></svg>
+          </div>
+          <div>
+            <div style="font-weight: 600">Zero Trust</div>
+            <div class="nf-fdesc">Sécurité par défaut, vos données protégées.</div>
+          </div>
+        </div>
+      </div>
+
+      <div style="display: flex; justify-content: space-between; position: relative">
+        <span style="font-size: 12px; color: rgba(255, 255, 255, 0.65)">
+          Nodefony 10 · licence CeCILL-B
+        </span>
+        <a
+          href="https://github.com/nodefony/nodefony-core"
+          target="_blank"
+          rel="noreferrer noopener"
+          style="font-size: 12px; color: rgba(255, 255, 255, 0.7)"
+        >
+          GitHub
+        </a>
+      </div>
+    </aside>
+
+    <!-- ── Preuves interactives — TON app tourne ────────────────────────── -->
+    <main class="nf-main">
+      <header class="nf-fwhead">
+        <!-- Logo officiel Vue — SVG inline (aucun asset externe). -->
+        <svg
+          class="nf-fwlogo"
+          viewBox="0 0 256 221"
+          xmlns="http://www.w3.org/2000/svg"
+          aria-label="Vue"
+        >
+          <path d="M204.8 0H256L128 220.8 0 0h97.92L128 51.2 157.44 0z" fill="#41B883" />
+          <path d="m0 0 128 220.8L256 0h-51.2L128 132.48 50.56 0z" fill="#41B883" />
+          <path d="M50.56 0 128 133.12 204.8 0h-47.36L128 51.2 97.92 0z" fill="#35495E" />
+        </svg>
+        <div>
+          <h1>Votre app est en ligne.</h1>
+          <span class="nf-fwbadge">Vue v{{ vueVersion }} · Vite HMR</span>
+        </div>
+<% if (it.complete) { %>        <!-- Réponse de la route PROTÉGÉE — visible uniquement session ouverte. -->
+        <span v-if="secureData" class="nf-hello">👋 {{ secureData.message }}</span>
+<% } %>      </header>
+      <p class="nf-dim">
+        <%= it.complete ? "Quatre" : "Trois" %> preuves interactives — édite <code>frontend/src/App.vue</code>,
+        Vite recompile la page à la volée.
+      </p>
+
+      <div class="nf-card">
+<% if (it.complete) { %>        <h2>1. Backend HTTP — <code>GET {{ secureData ? "/api/secure/hello" : "/api/hello" }}</code></h2>
+<% } else { %>        <h2>1. Backend HTTP — <code>GET /api/hello</code></h2>
+<% } %>        <pre v-if="error" style="color: crimson">{{ error }}</pre>
+        <pre v-else-if="data">{{ JSON.stringify(<%= it.complete ? "secureData ?? data" : "data" %>, null, 2) }}</pre>
+        <p v-else>loading…</p>
+      </div>
+<% if (it.complete) { %>
+      <div class="nf-card">
+        <h2>2. Firewall — l'identité vit dans la zone <code>^/api</code></h2>
+        <p class="nf-dim">
+          Deux zones dans <code>nodefony.config.ts</code> : <code>main</code>
+          (<code>^/api</code>, session → anonymous, jamais bloquante) et
+          <code>secure</code> (<code>^/api/secure</code>, session SEULE —
+          pattern plus spécifique, il gagne le match ; sans session le
+          firewall répond 401). Connecte-toi (compte dev seedé
+          <code>admin / admin</code>) : la carte 1 bascule sur
+          <code>GET /api/secure/hello</code> → « Bonjour admin ».
+        </p>
+        <template v-if="data?.who && data.who !== 'anonyme'">
+          <span style="margin-right: 8px">connecté — <strong>{{ data.who }}</strong></span>
+          <button @click="doLogout">Se déconnecter</button>
+        </template>
+        <template v-else>
+          <input v-model="username" autocomplete="username" aria-label="utilisateur" />
+          <input
+            v-model="password"
+            type="password"
+            autocomplete="current-password"
+            aria-label="mot de passe"
+            @keydown.enter="doLogin"
+          />
+          <button @click="doLogin">Se connecter</button>
+        </template>
+        <p v-if="authMsg" class="nf-dim">{{ authMsg }}</p>
+      </div>
+<% } %>
+<% if (it.complete) { %>      <div class="nf-card">
+        <h2>3. Temps réel — la socket Nodefony</h2>
+        <p class="nf-dim">
+          <code>LiveController</code> (<code>--kind realtime</code>) publie le
+          canal <code>live:events</code> quand il se passe quelque chose —
+          jamais sur une horloge ; la page le consomme par la façade
+          <code>RealtimeClient</code> — zéro <code>WebSocket</code> à la main.
+          Ouvrez un second onglet pour voir arriver ce que celui-ci envoie.
+        </p>
+        <p>
+          état : <strong>{{ liveState }}</strong>
+          <template v-if="last"> · reçu <strong>{{ last.text }}</strong> (pid {{ last.pid }})</template>
+        </p>
+        <button @click="doPing">RPC live:ping</button>
+        <button @click="doSay">envoyer sur le canal</button>
+        <span v-if="pingMs !== null" class="nf-dim"> pong en {{ pingMs }} ms</span>
+      </div>
+<% } else { %>      <div class="nf-card">
+        <h2>2. WebSocket — MÊME controller que le HTTP</h2>
+        <p class="nf-dim">
+          <code>HelloController</code> porte la route GET <em>et</em> la route
+          WEBSOCKET : un seul pipeline (firewall, audit, logs).
+        </p>
+        <input
+          v-model="wsInput"
+          @keydown.enter="sendWs"
+          aria-label="message à envoyer"
+        />
+        <button @click="sendWs">Envoyer en WS</button>
+        <pre>{{ wsLog.join("\n") || "(envoie un message)" }}</pre>
+      </div>
+<% } %>
+
+      <div class="nf-card">
+        <h2><%= it.complete ? 4 : 3 %>. ♻️ HMR check — état Vue préservé</h2>
+        <button @click="count++">count is {{ count }}</button>
+        <p class="nf-dim">
+          Édite le <code>&lt;template&gt;</code> de <code>frontend/src/App.vue</code> —
+          Vite recompile à la volée, la page se met à jour <em>sans recharger</em>
+          et le compteur est conservé.
+        </p>
+      </div>
+
+<% if (it.complete) { %>      <p class="nf-dim">
+        Console d'administration : <a href="/nodefony">/nodefony</a> (Studio, en dev)
+      </p>
+<% } %>    </main>
+  </div>
+</template>

package/templates/app/frontend/vue/frontend/src/accent.css.tpl

@@ -0,0 +1,34 @@
+/*
+ * Accent Vue — sa couleur et l'animation de son logo.
+ *
+ * La mise en page et la palette de la démonstration vivent dans
+ * `showcase.css`, PARTAGÉE par les trois vitrines : seules ces variables
+ * changent d'un framework à l'autre.
+ *
+ * Pourquoi un fichier CSS et non le bloc de styles du composant : Angular
+ * renomme les `@keyframes` déclarés dans `styles: [...]` (encapsulation de
+ * vue) — l'animation nommée par la variable ne serait alors plus trouvée.
+ * Les trois vitrines utilisent donc le même mécanisme, un import CSS que
+ * Vite injecte globalement.
+ */
+
+:root {
+  --nf-accent: #41b883;
+  /* Encre : la MÊME teinte, assez foncée pour être lue SUR le lavis.
+     La couleur de marque ne se négocie pas ; sa luminosité, si — écrire
+     `--nf-accent` sur `--nf-accent-wash` donnait 2,78:1, sous le seuil AA. */
+  --nf-accent-ink: #17714b;
+  --nf-accent-glow: rgba(66, 184, 131, 0.35);
+  --nf-accent-wash: rgba(66, 184, 131, 0.14);
+  --nf-accent-line: rgba(66, 184, 131, 0.35);
+  --nf-logo-anim: nf-float 4s ease-in-out infinite;
+}
+@keyframes nf-float {
+  0%,
+  100% {
+    transform: translateY(0);
+  }
+  50% {
+    transform: translateY(-6px);
+  }
+}

package/templates/app/home/nodefony/controllers/HomeController.ts.tpl

@@ -0,0 +1,38 @@
+import { route, controller, Controller } from "@nodefony/framework";
+import type { ContextType } from "@nodefony/http";
+
+/**
+ * Accueil `GET /` — la racine de TON application.
+ *
+ * Sans frontend, une racine muette répond 404 : la première URL qu'on ouvre
+ * après `npm run dev` dirait « rien ici ». Cette route dit QUI répond, et rien
+ * de plus. Elle n'est générée que pour une app SANS frontend — avec un front,
+ * c'est `AppController` qui tient `/`.
+ *
+ * ⚠️ **Volontairement sobre, et c'est une décision de sécurité.** Ce que cette
+ * réponse contient part en PRODUCTION, vers n'importe qui. Énumérer les routes
+ * internes, la console d'administration ou les chemins de documentation
+ * décrirait ton architecture à qui la demande : c'est une divulgation, pas une
+ * fonctionnalité. Ces informations se demandent au TERMINAL, où seul celui qui
+ * a déjà la main les obtient : `npx nodefony card` (et sa porte HTTP de
+ * développement, `@nodefony/devkit`, `policy: "dev"`, absente de la production).
+ *
+ * Tu ajoutes un frontend plus tard (`nodefony create front`) ? Sa page vivra
+ * sous sa propre route ; garde cet accueil JSON ou remplace-le, c'est TA racine.
+ */
+@controller("")
+class HomeController extends Controller {
+  constructor(context: ContextType) {
+    super("home", context);
+  }
+
+  @route("app-home", { path: "/", method: "GET" })
+  async home() {
+    return this.renderJson({
+      app: "<%= it.appName %>",
+      nodefony: "<%= it.nodefonyVersion %>",
+    });
+  }
+}
+
+export default HomeController;

package/templates/command/nodefony/command/__NAME__.ts.tpl

@@ -0,0 +1,132 @@
+import { Command, CliKernel, type OptionsCommandInterface } from "nodefony";
+<% if (it.service) { %>import type <%= it.service.pascal %> from "../service/<%= it.service.pascal %>";
+<% } %>
+/**
+ * `kernelEvent` = point d'ARRÊT du boot : le kernel s'arrête à cette phase, et
+ * c'est là que la commande s'exécute.
+ *
+ * - `onReady` (défaut) — services prêts, AUCUN serveur en écoute : une commande
+ *   qui lit ou écrit des données n'a pas à ouvrir un port.
+ * - `onRegister` — modules enregistrés, services pas encore construits (léger).
+ * - `onPostReady` — serveurs HTTP/WS en écoute. Seulement si la commande doit
+ *   parler à ses propres serveurs.
+ */
+const options: OptionsCommandInterface = {
+  showBanner: false,
+  kernelEvent: "<%= it.phase %>",
+  // Le journal de cycle de vie n'est PAS la sortie d'une commande. Sans ceci,
+  // ta commande rend d'abord trente lignes de boot (`MODULE ADD`, stores
+  // résolus, certificats) et sa réponse arrive en dernier, sous un mur que
+  // personne n'a demandé. Seuls NOTICE et INFO tombent : `EMERGENCY..ERROR`
+  // restent visibles, et `-d/--debug` rétablit tout.
+  // À RETIRER si ta commande LANCE quelque chose dont le journal EST la sortie
+  // (un serveur, une migration qu'on regarde se dérouler).
+  quietBoot: true,
+};
+
+/**
+ * <%= it.description %> — `nodefony <%= it.commandName %> [who]`.
+ *
+ * Convention Nodefony : `<module>:<action>`. La commande vit AVEC le module qui
+ * la porte (elle disparaît si le module n'est pas chargé) et parle au même
+ * service que les controllers — une seule logique, deux portes d'entrée.
+<% if (!it.service) { %> *
+ * Pour atteindre un service depuis ici : `this.kernel?.container?.get("<clé>")`,
+ * où la clé est celle du `super("<clé>", …)` du service — jamais le nom de sa
+ * classe.
+<% } %> */
+class <%= it.nameClass %> extends Command {
+  constructor(cli: CliKernel) {
+    super("<%= it.commandName %>", "<%= it.description %>", cli, options);
+    // Argument POSITIONNEL optionnel : sans déclaration, Commander refuse le mot
+    // (« too many arguments ») — un argument non déclaré n'existe pas.
+    //
+    // 🔴 Garde les crochets `[…]`, même pour un argument INDISPENSABLE. Déclaré
+    // `<obligatoire>`, Commander refuse la commande AVANT qu'elle existe
+    // (« error: missing required argument ») — y compris quand l'utilisateur
+    // l'a CHOISIE dans `nodefony menu`, où l'on ne peut taper aucun argument.
+    // Réclame-le plutôt avec `askArgument` (voir `generate` ci-dessous) : il
+    // demande en terminal, et hors terminal il échoue en montrant la ligne à
+    // taper — jamais une question qui pend dans un pipeline.
+    this.addArgument("[who]", "qui saluer (défaut : monde)");
+    this.addOption("-j, --json", "sortie JSON (scriptable)");
+  }
+
+  override async generate(
+    who: string | undefined,
+    opts: { json?: boolean },
+  ): Promise<this> {
+<% if (it.service) { %>    // On demande le service par sa CLÉ de conteneur — celle du `super("<%= it.service.key %>", …)`
+    // du service, pas le nom de sa classe. (Depuis le DI, `@inject("<%= it.service.pascal %>")`
+    // mènerait à la même instance ; mais hors injection, c'est la clé qui sert.)
+    const svc = this.kernel?.container?.get("<%= it.service.key %>") as <%= it.service.pascal %> | undefined;
+    if (!svc) {
+      // Absent = le module n'est pas chargé, ou son service a échoué au boot (le
+      // kernel l'aura annoncé : « boot DÉGRADÉ »). On le dit, on ne devine pas.
+      this.log("service « <%= it.service.key %> » non enregistré", "ERROR");
+      return this;
+    }
+    // Remplace cet appel par le tien : ce que ces lignes MONTRENT, c'est comment
+    // on obtient le service — le reste est de la mise en forme.
+    const result = await svc.<%= it.service.method %>();
+    const message =
+      typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    if (who) {
+      this.log(`argument reçu : ${who}`, "DEBUG");
+    }
+<% } else { %>    // Un argument dont tu ne peux pas te passer se DEMANDE, il ne se refuse pas :
+    //   const cible = await this.askArgument(who, {
+    //     name: "who",
+    //     message: "Qui saluer ?",
+    //     // choices: ["monde", "toi"],  // → une liste plutôt qu'une saisie
+    //   });
+    // En terminal il pose la question ; sans terminal (CI, script) il échoue
+    // avec la ligne exacte à taper. Ici l'argument a un défaut, donc rien à
+    // demander.
+    const message = `Bonjour, ${who ?? "monde"} !`;
+<% } %>    // 🔴 La SORTIE va sur la sortie standard, JAMAIS dans le journal.
+    // `this.log(message, "INFO")` semble marcher — jusqu'au jour où un filtre
+    // de journal (`quietBoot` ci-dessus, `--json`, une commande lancée depuis
+    // le menu) coupe INFO : la réponse disparaît avec lui. Le journal RACONTE
+    // l'exécution, la sortie EST le résultat ; `this.log` reste pour ce qui
+    // relève du récit (avertissements, erreurs, détail sous `--debug`).
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify({ message })}\n`);
+    } else {
+      process.stdout.write(`${message}\n`);
+    }
+
+    // ── ENCHAÎNER sur une autre commande ────────────────────────────────────
+    //
+    // Quand le geste suivant appartient à une AUTRE commande (souvent d'un
+    // autre module), ne le réimplémente pas : APPELLE-la. Un process neuf,
+    // comme le fait le menu — commander ne connaît pas toujours la cible au
+    // moment où l'on décide.
+    //
+    //   const { spawnSync } = await import("node:child_process");
+    //   spawnSync(process.execPath, [process.argv[1]!, "autre:commande", "--write"], {
+    //     stdio: "inherit",                                   // (3)
+    //     cwd: this.kernel?.path ?? process.cwd(),             // (2)
+    //     env: { ...process.env, NODE_ENV: "development" },    // (1)
+    //   });
+    //
+    // 🔴 TROIS choses ne suivent PAS toutes seules d'un process à l'autre, et
+    // chacune a déjà produit un échec quand elle manquait :
+    //   (1) l'ENVIRONNEMENT — un enfant ne reçoit QUE ce qu'on lui donne.
+    //       Sans le report, il part sans PATH ; et si la cible n'existe qu'en
+    //       développement (module `policy: "dev"`), pose `NODE_ENV`, sinon
+    //       elle échouera sur une ressource que l'application ne sert pas ;
+    //   (2) le RÉPERTOIRE — ce qui s'écrit doit l'être dans le PROJET, pas là
+    //       où la commande a été tapée ;
+    //   (3) le TERMINAL — `stdio: "inherit"` le transmet. Sans lui, l'enfant
+    //       voit `isTTY` faux, ne peut poser aucune question, et échoue.
+    //
+    // Et n'enchaîne PAS sous `--json` ni `--dry-run` : le premier part vers un
+    // script qu'une question romprait, le second ne doit rien produire. Isole
+    // cette décision dans une fonction PURE — le `spawn` est de la plomberie,
+    // la décision est ce qui peut être faux, et c'est elle qui se teste.
+    return this;
+  }
+}
+
+export default <%= it.nameClass %>;