@mostajs/wagon-engine 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -3,6 +3,54 @@
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 Format : Keep a Changelog ; versions : SemVer.
 
+## [0.9.0] — 2026-10-29
+
+### Modifié — les clés du `.env` sans préfixe `WAGON_` (demande du fondateur)
+Le préfixe `WAGON_` ne disait ni la fonction de la clé ni son sens métier, et se mêlait mal au profil `MOSTA_ENV`
+(`PROD_SGBD_URI` n'était pas lu : la base des comptes retombait sur `data/wagon.db`). Les clés portent désormais le
+nom de leur fonction ; le seul préfixe est celui du profil. **Les anciens noms ne sont plus lus** (pas de secours) :
+le démarrage avertit pour chacun qui reste (`signalerClesRetirees`).
+
+| retiré | remplacé par |
+|---|---|
+| `WAGON_SGBD`, `WAGON_DB_DIALECT` | `SGBD_URI`, `DB_DIALECT` |
+| `WAGON_BASE_URL` | `BASE_URL` |
+| `WAGON_ADMINS` | `ADMIN_EMAILS` |
+| `WAGON_EMAIL_SERVER_HOST`/`_PORT`/`_USER`/`_PASSWORD`, `WAGON_EMAIL_FROM` | `EMAIL_SERVER_HOST`/`_PORT`/`_USER`/`_PASSWORD`, `EMAIL_FROM` |
+| `WAGON_COURRIEL_FICHIER` | `EMAIL_FICHIER` |
+| `WAGON_STRIPE_RESTRICTED_KEY`, `WAGON_STRIPE_SECRET_KEY`, `WAGON_STRIPE_WEBHOOK_SECRET` | `STRIPE_RESTRICTED_KEY`, `STRIPE_SECRET_KEY`, `STRIPE_WEBHOOK_SECRET` |
+| `WAGON_GREFFE` (suite de conformité) | `GREFFE` |
+
+Toutes ces clés sont lues par `getEnv` de `@mostajs/config` (la suite de conformité aussi, qui lisait `process.env`).
+Ajouté : `adminsDeclares(config)` (la liste des administrateurs déclarés, pour les scripts d'administration des
+greffes), `signalerClesRetirees(journal)`, `CLES_RETIREES`.
+
+Essai T-ENG-17 (cascade `MOSTA_ENV=PROD` → `PROD_SGBD_URI` ; `WAGON_SGBD` ignoré et signalé) ; 53/53 ; sabotage vérifié
+(relire `WAGON_SGBD` → T-ENG-17 tombe).
+
+## [0.8.0] — 2026-10-29
+
+### Ajouté — les membres d'un compte (demandé par CaisseTrax : écart E-08 de SPEC-ECRANS-CAISSETRAX)
+- `ctx.utilisateur` (la personne de la session, sans empreinte) et `ctx.role` (son rôle dans le compte) ; `null`
+  sans session et pour une clé d'API.
+- `ctx.membres` (session seulement) : `lister()` (courriel, nom, rôle, statut `actif` | `invite` | `suspendu`),
+  `inviter({ courriel, nom, role })` → membre du MÊME compte + lien d'activation (`config.invitationJours`, défaut 7),
+  `reinviter(id)`, `changerRole(id, role)`, `retirer(id)`. Le lien part par courriel s'il y a un transport et est
+  TOUJOURS rendu à la charge (un commerce n'a pas toujours de courriel). La charge décide qui peut s'en servir.
+- `charge.vues.connexion({ lang, action, erreur, oubli })` et `charge.vues.reinitialiser({ lang, jeton, utilisateur, erreur,
+  expire, minimum })` : la greffe rend ces deux pages ENTIÈRES (l'écran de SA maquette), erreurs comprises ; le porteur
+  d'un jeton d'invitation est lu sans le consommer (« Bienvenue …, vous êtes invité comme … »).
+- `config.apresConnexion` : la page d'arrivée après connexion ou activation (défaut `/compte`).
+
+### Corrigé
+- Les jetons de réinitialisation vivaient en mémoire : un redémarrage perdait les liens en cours. Ils sont rangés en
+  base (table `wagon_jetons`, empreinte seule).
+- `/connexion/reinitialiser` est servie dès que la connexion est par mot de passe, même sans courriel : le lien d'une
+  invitation remis de la main à la main doit fonctionner. La DEMANDE (`/connexion/oubli`) exige toujours un courriel.
+
+Essais T-WAG-30 à 35 (test-scripts/unit/membres.test.mjs) ; 52/52 ; sabotage vérifié (jetons remis en mémoire →
+T-WAG-32 tombe).
+
 ## [0.7.0] — 2026-10-29
 
 ### Ajouté

package/README.md

@@ -34,17 +34,17 @@ await demarrer({ config, charge });
 | `.env` | rôle |
 |---|---|
 | `PORT`, `HOST` | écoute (4800, 127.0.0.1) |
-| `WAGON_BASE_URL` | l'adresse publique (liens des courriels, retours de paiement) |
-| `WAGON_DB_DIALECT`, `WAGON_SGBD` | la base : `sqlite` et un chemin, ou `postgres` et `postgresql://…` |
-| `WAGON_EMAIL_SERVER_HOST`, `…_PORT`, `…_USER`, `…_PASSWORD`, `WAGON_EMAIL_FROM` | le courriel (SMTP) |
-| `WAGON_STRIPE_SECRET_KEY`, `WAGON_STRIPE_WEBHOOK_SECRET` | Stripe |
+| `BASE_URL` | l'adresse publique (liens des courriels, retours de paiement) |
+| `DB_DIALECT`, `SGBD_URI` | la base : `sqlite` et un chemin, ou `postgres` et `postgresql://…` |
+| `EMAIL_SERVER_HOST`, `…_PORT`, `…_USER`, `…_PASSWORD`, `EMAIL_FROM` | le courriel (SMTP) |
+| `STRIPE_SECRET_KEY` (ou `STRIPE_RESTRICTED_KEY`), `STRIPE_WEBHOOK_SECRET` | Stripe |
 | `CHARGILY_SECRET_KEY` · `SATIM_MERCHANT_ID`, `SATIM_PASSWORD`, `SATIM_TERMINAL_ID` · `PAYPAL_…` | les banques prépayées proposées par `config.paiement.prepaye` |
 | `PAIEMENT_STRIPE=off`, `PAIEMENT_CHARGILY=off`, `PAIEMENT_SATIM=off`, `PAIEMENT_PAYPAL=off` | **coupe un moyen** sans toucher à ses clés |
-| `WAGON_ADMINS` | les courriels administrateurs (confirmés par un code reçu) |
+| `ADMIN_EMAILS` | les courriels administrateurs (confirmés par un code reçu) |
 | `PAIEMENT_VENDEUR_DZD`, `PAIEMENT_VENDEUR_EUR`… | 0.6 — **le vendeur de chaque devise** (dénomination, forme, adresse, immatriculations) ; dès qu'une est déclarée, une devise sans vendeur n'est pas vendue, et `{{VENDEUR}}` des CGV les nomme |
 | `PAIEMENT_STRIPE_DEVISES` | 0.6 — la devise de Stripe (défaut `EUR`) |
 
-**Le `.env` d'abord.** Toutes les clés passent par `getEnv` de `@mostajs/config` : cascade `MOSTA_ENV` (`PROD_CLÉ` l'emporte sur `CLÉ`), valeur vide = absente, et `loadEnv` n'écrase jamais une variable déjà posée par l'orchestrateur. Si `wagon.config.mjs` lit des variables, il appelle `loadEnv` lui-même, en tête.
+**Le `.env` d'abord.** Toutes les clés passent par `getEnv` de `@mostajs/config` : cascade `MOSTA_ENV` (`PROD_CLÉ` l'emporte sur `CLÉ`), valeur vide = absente, et `loadEnv` n'écrase jamais une variable déjà posée par l'orchestrateur. Une clé porte le nom de sa fonction ; le seul préfixe est celui du profil (`PROD_SGBD_URI`, `DEV_BASE_URL`). Depuis la 0.9, les anciens noms `WAGON_…` ne sont plus lus : le démarrage signale ceux qui restent. Si `wagon.config.mjs` lit des variables, il appelle `loadEnv` lui-même, en tête.
 
 **Un vendeur par devise (0.6).** Un SaaS qui vend en dinars par un auto-entrepreneur et en euros par une société pose `PAIEMENT_VENDEUR_DZD=…` et `PAIEMENT_VENDEUR_EUR=…`. Une devise déclarée vide (`PAIEMENT_VENDEUR_EUR=`, la société n'est pas encore immatriculée) n'est pas vendue : Stripe est écarté même avec sa clé. Sans aucune `PAIEMENT_VENDEUR_*`, rien ne change.
 
@@ -54,7 +54,7 @@ await demarrer({ config, charge });
 
 ## Juger une greffe
 
-La suite de conformité est publiée avec le moteur. Elle juge la greffe du dossier courant, ou celle que désigne `WAGON_GREFFE` :
+La suite de conformité est publiée avec le moteur. Elle juge la greffe du dossier courant, ou celle que désigne `GREFFE` :
 
 ```bash
 npx mjs-unit node_modules/@mostajs/wagon-engine/src/conformite/conformite.test.mjs

package/examples/verifier.mjs

@@ -13,7 +13,7 @@ import { demarrer } from '../src/index.js';
 const racine = mkdtempSync(join(tmpdir(), 'greffe-'));
 mkdirSync(join(racine, 'legal'));
 writeFileSync(join(racine, 'legal', 'cgu.fr.md'), '# Conditions\n\n{{SERVICE}} est édité par Exemple SARL.\n');
-writeFileSync(join(racine, '.env'), `PORT=0\nWAGON_SGBD=${join(racine, 'wagon.db')}\nWAGON_BASE_URL=http://127.0.0.1\nCHARGILY_SECRET_KEY=test_sk_exemple\nPAIEMENT_STRIPE=off\n`);
+writeFileSync(join(racine, '.env'), `PORT=0\nSGBD_URI=${join(racine, 'wagon.db')}\nBASE_URL=http://127.0.0.1\nCHARGILY_SECRET_KEY=test_sk_exemple\nPAIEMENT_STRIPE=off\n`);
 
 const config = {
   marque: { nom: 'Échos', symbole: 'É', auteur: 'Exemple SARL' }, langues: ['fr', 'en', 'ar'], connexion: 'motdepasse',

package/llms.txt

@@ -4,7 +4,7 @@
 > PayPal), espace client, administration, pages légales, robots/sitemap, sauvegarde, fr/en/ar. Une GREFFE n'apporte que
 > wagon.config.mjs, charge/, legal/ et son .env. N2 (pack). Extrait du gabarit mosta-wagon 0.11.0 le 26/10/2026.
 
-- Version: 0.6.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
+- Version: 0.8.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
 - Chemin: mostajs/mosta-platform-stack/mosta-wagon-engine · gabarit d'une greffe : Entreprise/mosta-wagon
 
 ## ⚙️ D'EMBLÉE : LE .env ET LA CASCADE @mostajs/config
@@ -17,7 +17,7 @@ Une greffe se configure par SON `.env` (dossier courant de `demarrer`, ou `racin
    conteneur) prime sur le fichier.
 3. **Cascade** (première valeur NON VIDE) : `${MOSTA_ENV}_${CLÉ}` → `${CLÉ}` → défaut. Un seul .env, des profils
    `TEST_`/`DEV_`/`PROD_`. Toutes les clés ci-dessous, et celles de `@mostajs/payment`, passent par `getEnv`.
-4. **Vide = absent** : `WAGON_STRIPE_SECRET_KEY=` ne configure rien. Exception voulue : `PAIEMENT_VENDEUR_<DEVISE>=`
+4. **Vide = absent** : `STRIPE_SECRET_KEY=` ne configure rien. Exception voulue : `PAIEMENT_VENDEUR_<DEVISE>=`
    vide DÉCLARE la devise sans la nommer (elle n'est pas vendue).
 5. Les secrets et les informations de l'entreprise sont posés par l'exploitant sur le serveur, jamais commités ;
    `.env.example` de la greffe liste chaque clé, sans valeur.
@@ -27,13 +27,13 @@ Une greffe se configure par SON `.env` (dossier courant de `demarrer`, ou `racin
 - creerWagon({ config, charge, sgbd: string|{dialect,uri}, baseUrl, stripe?, webhookSecret?, transport?, journal?,
   paiement?: { banques: { chargily:'DZD', … }, port?, deviseStripe? }, racine? }) → { moyens, handler, catalogue(), catalogueStripe(), fermer(), … }
 - schemasWagon() (sauvegarde) · sauvegarder({ cibles, driver, seau, recipients, garder }) · suivrePalette(…)
-- '@mostajs/wagon-engine/conformite' = src/conformite/conformite.test.mjs (suite mjs-unit, juge WAGON_GREFFE ou cwd)
+- '@mostajs/wagon-engine/conformite' = src/conformite/conformite.test.mjs (suite mjs-unit, juge GREFFE ou cwd)
 
 ## .env lu par demarrer
-PORT, HOST · WAGON_BASE_URL · WAGON_DB_DIALECT (sqlite|postgres…), WAGON_SGBD · WAGON_EMAIL_SERVER_HOST/PORT/USER/PASSWORD,
-WAGON_EMAIL_FROM (ou WAGON_COURRIEL_FICHIER pour les essais) · WAGON_STRIPE_SECRET_KEY|RESTRICTED_KEY, WAGON_STRIPE_WEBHOOK_SECRET ·
+PORT, HOST · BASE_URL · DB_DIALECT (sqlite|postgres…), SGBD_URI · EMAIL_SERVER_HOST/PORT/USER/PASSWORD,
+EMAIL_FROM (ou EMAIL_FICHIER pour les essais) · STRIPE_SECRET_KEY|STRIPE_RESTRICTED_KEY, STRIPE_WEBHOOK_SECRET ·
 CHARGILY_SECRET_KEY|API_KEY · SATIM_MERCHANT_ID, SATIM_PASSWORD, SATIM_TERMINAL_ID · PAYPAL_CLIENT_ID, PAYPAL_SECRET,
-PAYPAL_WEBHOOK_ID · PAIEMENT_<STRIPE|CHARGILY|SATIM|PAYPAL>=off (coupe le moyen) · WAGON_ADMINS · WAGON_INDEXER.
+PAYPAL_WEBHOOK_ID · PAIEMENT_<STRIPE|CHARGILY|SATIM|PAYPAL>=off (coupe le moyen) · ADMIN_EMAILS. Cascade MOSTA_ENV (PROD_SGBD_URI…). 0.9 : plus aucun nom WAGON_… n'est lu (signalé au démarrage).
 0.6 (@mostajs/payment ≥ 2.7) : PAIEMENT_VENDEUR_<DEVISE> (le vendeur de cette devise : dénomination, forme, adresse,
 immatriculations) · PAIEMENT_STRIPE_DEVISES (la devise de Stripe, défaut EUR).
 Moyen ACTIF = clés présentes ET commutateur ≠ off (ET, pour une banque prépayée, proposée par config.paiement.prepaye)
@@ -49,6 +49,7 @@ démarrage) · exporterCompte(id), effacerCompte(id) (RGPD) · sitemap() · sauv
 { '/page': { microphone: 'self' }, '/dossier/*': … }, garde-http ≥ 0.2).
 ctx : chemin, methode, lang, t, ui, page({ titre, contenu }), envoyer, json, rediriger, formulaire, corpsJson({ strict }),
 compte, consommer(cle), refuser(v), palier({ compte? }), plafond(cle, n, { compte? }), courriel({ to, subject, text, html? }) → bool, admin.
+  0.8 : ctx.utilisateur, ctx.role ; ctx.membres = { lister(), inviter({ courriel, nom, role }) → { utilisateurId, courriel, role, lien, expiresAt, courrielParti }, reinviter(id), changerRole(id, role), retirer(id) } (session seulement ; la charge garde l'accès) ; config.apresConnexion, config.invitationJours ; jetons en base (wagon_jetons) ; /connexion/reinitialiser servie sans courriel ; charge.vues.connexion(…) / charge.vues.reinitialiser({ jeton, utilisateur, erreur, expire }) → page entière.
   0.7 : ctx.paiement (null sans banque prépayée active) = { moyens: [{ moyen, devise }], ouvrir({ moyen, montant (unités MINEURES), description, reference, metadata, merci: '/chemin', annule: '/chemin' }) → { ok, url, commande } | { ok: false, raison } } — paiement PONCTUEL de la charge (une place de cours…). La banque confirme à /api/paiement/charge/<moyen> (webhook, signature) ou renvoie l'acheteur à /api/paiement/charge-retour/<moyen> (SATIM) ; le wagon appelle alors charge.paiementRegle({ reference, statut: paid|failed|refunded|…, commande, montant (mineures), devise, moyen, metadata }), à écrire IDEMPOTENT (une banque rejoue). merci/annule : chemins locaux seulement.
   0.4 : /inscription?suite=/chemin et /connexion?suite=/chemin — retour à une page LOCALE après inscription (si ni clé ni paiement à montrer ; sinon bouton « Continuer ») ou connexion par mot de passe ; //hôte et adresses absolues ignorés.
   0.3 : ctx.page({ disposition: 'vitrine'|'application'|'console'|'nu'|<fournie>, application: { retour, titre, avatar, onglets, langues }, console: { menu, contexte, utilisateur } }) (wagon-ui 0.10) ; config.jetons { rayon, police, policeTitres, ombre, fond } ; config.marque.logo / logoClair (SVG en ligne ou chemin /…).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/wagon-engine",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Le wagon d'un SaaS, une fois pour toutes : comptes, connexion, paliers, quotas, paiement (Stripe, Chargily, SATIM), espace client, administration, pages légales, fr/en/ar. Une greffe n'apporte que wagon.config.mjs, charge/, legal/ et son .env ; la suite de conformité publiée juge la greffe.",
   "keywords": [
     "mostajs",

package/src/conformite/conformite.test.mjs

@@ -1,5 +1,5 @@
 // @mostajs/wagon-engine — LA SUITE DE CONFORMITÉ : elle dit si une greffe tient.
-// La greffe jugée est celle de WAGON_GREFFE, sinon le dossier courant : sa configuration (wagon.config.mjs), sa
+// La greffe jugée est celle de GREFFE, sinon le dossier courant : sa configuration (wagon.config.mjs), sa
 // charge (charge/index.mjs) et ses textes légaux (legal/). Lancer depuis la greffe :
 //   mjs-unit node_modules/@mostajs/wagon-engine/src/conformite/conformite.test.mjs
 // Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
@@ -20,10 +20,11 @@ import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import Stripe from 'stripe';
 import { creerWagon } from '../wagon.mjs';
+import { getEnv } from '@mostajs/config';
 
-const GREFFE = resolve(process.env.WAGON_GREFFE || process.cwd());
+const GREFFE = resolve(getEnv('GREFFE', process.cwd()));
 if (!existsSync(join(GREFFE, 'wagon.config.mjs')) || !existsSync(join(GREFFE, 'charge', 'index.mjs'))) {
-  throw new Error(`conformité : greffe introuvable dans ${GREFFE} (wagon.config.mjs et charge/index.mjs attendus ; WAGON_GREFFE la désigne)`);
+  throw new Error(`conformité : greffe introuvable dans ${GREFFE} (wagon.config.mjs et charge/index.mjs attendus ; GREFFE la désigne)`);
 }
 const config = (await import(pathToFileURL(join(GREFFE, 'wagon.config.mjs')).href)).default;
 const charge = (await import(pathToFileURL(join(GREFFE, 'charge', 'index.mjs')).href)).default;
@@ -374,7 +375,7 @@ test('T-WAG-27 — `config.css` : la feuille de l’application est posée sur l
 });
 
 // 0.5 (audit du 09/10/2026) — la base du wagon n'est plus figée en sqlite : `sgbd: { dialect, uri }` (le .env :
-// WAGON_DB_DIALECT, WAGON_SGBD), comme la base de la charge. La chaîne seule reste un chemin sqlite.
+// DB_DIALECT, SGBD_URI), comme la base de la charge. La chaîne seule reste un chemin sqlite.
 test('T-WAG-19 — la base du wagon se choisit par { dialect, uri } ; la chaîne reste un chemin sqlite', async () => {
   const W2 = await creerWagon({ config: { ...config, dossierLegal: LEGAL_COMPLET }, charge, sgbd: { dialect: 'sqlite', uri: join(atelier, `objet${Math.random()}.db`) }, baseUrl: 'http://127.0.0.1', racine: GREFFE });
   await W2.catalogue();

package/src/demarrer.mjs

@@ -13,18 +13,19 @@ import { join } from 'node:path';
 import { loadEnv, getEnv } from '@mostajs/config';
 import { devisesDuMoyen } from '@mostajs/payment/server';
 import { creerWagon } from './wagon.mjs';
+import { signalerClesRetirees } from './env.mjs';
 
 const coupe = (moyen) => getEnv(`PAIEMENT_${moyen.toUpperCase()}`, '') === 'off';
 
 /** Les courriels : SMTP (avec DKIM si la clé est publiée), ou un fichier pour les essais. */
 async function transport() {
-  const fichier = getEnv('WAGON_COURRIEL_FICHIER', '');
+  const fichier = getEnv('EMAIL_FICHIER', '');
   if (fichier) return { envoyer: async (m) => appendFileSync(fichier, `${JSON.stringify(m)}\n`, { mode: 0o600 }) };
-  const host = getEnv('WAGON_EMAIL_SERVER_HOST', '');
+  const host = getEnv('EMAIL_SERVER_HOST', '');
   if (!host) return null;
   const { createSmtpLiteDriver } = await import('@mostajs/mailer');
-  const pilote = createSmtpLiteDriver({ host, port: Number(getEnv('WAGON_EMAIL_SERVER_PORT', '587')), user: getEnv('WAGON_EMAIL_SERVER_USER', ''), pass: getEnv('WAGON_EMAIL_SERVER_PASSWORD', '') });
-  const de = getEnv('WAGON_EMAIL_FROM', getEnv('WAGON_EMAIL_SERVER_USER', ''));
+  const pilote = createSmtpLiteDriver({ host, port: Number(getEnv('EMAIL_SERVER_PORT', '587')), user: getEnv('EMAIL_SERVER_USER', ''), pass: getEnv('EMAIL_SERVER_PASSWORD', '') });
+  const de = getEnv('EMAIL_FROM', getEnv('EMAIL_SERVER_USER', ''));
   return { envoyer: (m) => pilote.send({ from: de, ...m }) };
 }
 
@@ -45,14 +46,15 @@ const PRETES = {
  */
 export async function demarrer({ config, charge, racine = process.cwd(), journal = console }) {
   loadEnv({ path: join(racine, '.env') });
-  const cle = coupe('stripe') ? '' : (getEnv('WAGON_STRIPE_RESTRICTED_KEY', '') || getEnv('WAGON_STRIPE_SECRET_KEY', ''));
+  signalerClesRetirees(journal);
+  const cle = coupe('stripe') ? '' : (getEnv('STRIPE_RESTRICTED_KEY', '') || getEnv('STRIPE_SECRET_KEY', ''));
   const banques = Object.fromEntries(Object.entries(config.paiement?.prepaye ?? {}).filter(([b]) => PRETES[b]?.() && !coupe(b)));
   const wagon = await creerWagon({
     config, charge, racine, journal,
-    sgbd: { dialect: getEnv('WAGON_DB_DIALECT', 'sqlite'), uri: getEnv('WAGON_SGBD', join(racine, 'data', 'wagon.db')) },
-    baseUrl: getEnv('WAGON_BASE_URL', 'http://localhost:4800'),
+    sgbd: { dialect: getEnv('DB_DIALECT', 'sqlite'), uri: getEnv('SGBD_URI', join(racine, 'data', 'wagon.db')) },
+    baseUrl: getEnv('BASE_URL', 'http://localhost:4800'),
     stripe: cle ? new (await import('stripe')).default(cle) : null,
-    webhookSecret: getEnv('WAGON_STRIPE_WEBHOOK_SECRET', ''),
+    webhookSecret: getEnv('STRIPE_WEBHOOK_SECRET', ''),
     transport: await transport(),
     // 0.6 — la devise de Stripe (PAIEMENT_STRIPE_DEVISES, défaut EUR) : creerWagon écarte une devise sans vendeur.
     paiement: { banques, deviseStripe: devisesDuMoyen('stripe', ['EUR'])[0] },

package/src/env.mjs

@@ -0,0 +1,39 @@
+/**
+ * @mostajs/wagon-engine — les clés du .env, toujours lues par getEnv de @mostajs/config (cascade MOSTA_ENV :
+ * `PROD_CLÉ` l'emporte sur `CLÉ`, valeur vide = absente).
+ * @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ *
+ * 0.9 — les clés portent le nom de leur fonction (SGBD_URI, BASE_URL, ADMIN_EMAILS…) ; le seul préfixe est celui du
+ * profil MOSTA_ENV. Les anciens noms `WAGON_…` ne sont PLUS lus : s'il en reste dans le .env, le démarrage le dit.
+ */
+import { getEnv } from '@mostajs/config';
+
+/** Les noms retirés en 0.9, et leur remplaçant. */
+export const CLES_RETIREES = {
+  WAGON_SGBD: 'SGBD_URI',
+  WAGON_DB_DIALECT: 'DB_DIALECT',
+  WAGON_BASE_URL: 'BASE_URL',
+  WAGON_ADMINS: 'ADMIN_EMAILS',
+  WAGON_EMAIL_SERVER_HOST: 'EMAIL_SERVER_HOST',
+  WAGON_EMAIL_SERVER_PORT: 'EMAIL_SERVER_PORT',
+  WAGON_EMAIL_SERVER_USER: 'EMAIL_SERVER_USER',
+  WAGON_EMAIL_SERVER_PASSWORD: 'EMAIL_SERVER_PASSWORD',
+  WAGON_EMAIL_FROM: 'EMAIL_FROM',
+  WAGON_COURRIEL_FICHIER: 'EMAIL_FICHIER',
+  WAGON_STRIPE_RESTRICTED_KEY: 'STRIPE_RESTRICTED_KEY',
+  WAGON_STRIPE_SECRET_KEY: 'STRIPE_SECRET_KEY',
+  WAGON_STRIPE_WEBHOOK_SECRET: 'STRIPE_WEBHOOK_SECRET',
+};
+
+/** Signale les anciens noms encore posés : ils sont ignorés. Rend la liste. */
+export function signalerClesRetirees(journal = console) {
+  const restes = Object.keys(CLES_RETIREES).filter((k) => getEnv(k, undefined) !== undefined);
+  for (const k of restes) journal.warn(`wagon : ${k} n'est plus lue — renommez-la ${CLES_RETIREES[k]} dans le .env (même préfixe MOSTA_ENV)`);
+  return restes;
+}
+
+/** Les courriels administrateurs déclarés (config.admins + ADMIN_EMAILS), en minuscules. */
+export function adminsDeclares(config = {}) {
+  return [...new Set([...(config.admins ?? []), ...String(getEnv('ADMIN_EMAILS', '') ?? '').split(',')]
+    .map((x) => x.trim().toLowerCase()).filter(Boolean))];
+}

package/src/index.js

@@ -5,3 +5,4 @@ export { creerWagon, schemasWagon } from './wagon.mjs';
 export { demarrer } from './demarrer.mjs';
 export { sauvegarder } from './sauvegarde.mjs';
 export { suivrePalette } from './palette.mjs';
+export { adminsDeclares, signalerClesRetirees, CLES_RETIREES } from './env.mjs';

package/src/wagon.mjs

@@ -19,8 +19,10 @@
  * faux ; l'administration est invisible (404) à qui n'est pas administrateur.
  */
 import { readFileSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { openIsolatedDialect } from '@mostajs/data-plug';
+import { adminsDeclares } from './env.mjs';
 import { creerWagonUi, esc } from '@mostajs/wagon-ui';
 import { creerComptes, schemasComptes } from '@mostajs/comptes';
 import { createBilling, createStripeSale, createPrepaidSale, billingSchemas, checkLimits, assertMonotonicPlans } from '@mostajs/subscriptions-plan/server';
@@ -33,7 +35,6 @@ import { emailCodeEmailHtml, emailCodeEmailText, emailCodeForm, emailLinkConfirm
 import { magasinSessions } from '@mostajs/auth-plug';
 import { requeteLegitime, enTetesSecurite, cookieStrict } from '@mostajs/garde-http';
 import { mdToHtml } from '@mostajs/markdown-html';
-import { getEnv } from '@mostajs/config';
 import { suivrePalette } from './palette.mjs';
 
 const COURRIEL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -133,7 +134,7 @@ const CredentialSchema = {
   relations: {}, indexes: [{ fields: { user: 'asc' }, unique: true }],
 };
 /**
- * 0.4 (audit du 09/10/2026) — les administrateurs CONFIRMÉS. Un courriel déclaré (config.admins, WAGON_ADMINS) ne
+ * 0.4 (audit du 09/10/2026) — les administrateurs CONFIRMÉS. Un courriel déclaré (config.admins, ADMIN_EMAILS) ne
  * donne l'administration qu'une fois sa détention prouvée : connexion par code ou par lien reçu à ce courriel, ou
  * confirmation faite sur le serveur (scripts/admin.mjs). Sans cela, quiconque inscrivait ce courriel AVANT son
  * titulaire prenait l'administration.
@@ -143,12 +144,21 @@ const AdminSchema = {
   fields: { courriel: { type: 'string', required: true }, confirmeLe: { type: 'date' }, par: { type: 'string' } },
   relations: {}, indexes: [{ fields: { courriel: 'asc' }, unique: true }],
 };
+/**
+ * 0.8 — les JETONS à usage unique (réinitialisation, invitation), RANGÉS EN BASE : jusqu'à la 0.7 ils vivaient en
+ * mémoire, et un redémarrage perdait le lien qu'un invité n'avait pas encore ouvert. Seule l'empreinte est rangée.
+ */
+const JetonSchema = {
+  name: 'WagonJeton', collection: 'wagon_jetons', timestamps: false,
+  fields: { cle: { type: 'string', required: true }, user: { type: 'string', required: true }, expiresAt: { type: 'number', required: true } },
+  relations: {}, indexes: [{ fields: { cle: 'asc' }, unique: true }],
+};
 export const schemasWagon = () => {
   const vus = new Set();
   // `Payment` (@mostajs/payment) : une ligne par session de banque, que le webhook retrouve pour clore la vente.
   // Déclarée même sans banque prépayée — incident RestoTrax du 19/08/2026 : « no such table: payments » APRÈS
   // que le client eut engagé son paiement.
-  return [...schemasComptes(), ...billingSchemas(), PaymentSchema, SessionSchema, CredentialSchema, AdminSchema].filter((s) => (vus.has(s.name) ? false : vus.add(s.name)));
+  return [...schemasComptes(), ...billingSchemas(), PaymentSchema, SessionSchema, CredentialSchema, AdminSchema, JetonSchema].filter((s) => (vus.has(s.name) ? false : vus.add(s.name)));
 };
 
 const lireCorps = (req, max = 1_000_000) => new Promise((ok, ko) => {
@@ -185,7 +195,7 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
   const https = /^https:/.test(origine);
   const S = Object.fromEntries(schemasWagon().map((s) => [s.name, s]));
   // 0.5 (audit du 09/10/2026) — `sgbd` : un chemin sqlite (comme avant), ou { dialect, uri } d'après le .env
-  // (WAGON_DB_DIALECT, WAGON_SGBD) : la base des comptes n'est plus figée en sqlite.
+  // (DB_DIALECT, SGBD_URI) : la base des comptes n'est plus figée en sqlite.
   const base = typeof sgbd === 'string' ? { dialect: 'sqlite', uri: sgbd } : { dialect: sgbd?.dialect ?? 'sqlite', uri: sgbd?.uri };
   const d = await openIsolatedDialect({ ...base, schemaStrategy: 'update' }, schemasWagon());
   // 0.4 — la charge ouvre SA base au démarrage, pas au premier client (DEVRULES-SAAS-APP §5.2).
@@ -218,13 +228,21 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
   const purgerSessions = () => sessions.purger?.().catch((e) => journal.warn(`wagon : purge des sessions : ${e?.message ?? e}`));
   purgerSessions(); setInterval(purgerSessions, 6 * 3600 * 1000).unref?.();
   const freinInscription = memoryLimiter({ limits: { byIp: config.freinInscription ?? { capacity: 10, refillPerSec: 1 / 60 } } });
-  const motsDePasse = createPasswordAuth({
-    credentials: {
-      get: async (u) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); return r ? { hash: r.hash, updatedAt: r.updatedAt } : null; },
-      set: async (u, rec) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); if (r) await d.update(S.WagonCredential, String(r.id), rec); else await d.create(S.WagonCredential, { user: String(u), ...rec }); },
-    },
-    findUser: async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; },
-  });
+  const identifiants = {
+    get: async (u) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); return r ? { hash: r.hash, updatedAt: r.updatedAt } : null; },
+    set: async (u, rec) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); if (r) await d.update(S.WagonCredential, String(r.id), rec); else await d.create(S.WagonCredential, { user: String(u), ...rec }); },
+  };
+  const trouverUtilisateur = async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; };
+  // 0.8 — les jetons en base (voir JetonSchema), partagés par la réinitialisation et l'invitation.
+  const jetons = {
+    get: async (cle) => { const r = await d.findOne(S.WagonJeton, { cle }); return r ? { userId: String(r.user), expiresAt: Number(r.expiresAt) } : null; },
+    put: async (cle, e) => { await d.create(S.WagonJeton, { cle, user: String(e.userId), expiresAt: Number(e.expiresAt) }); },
+    delete: async (cle) => { for (const r of await d.find(S.WagonJeton, { cle })) await d.delete(S.WagonJeton, String(r.id)); },
+  };
+  const motsDePasse = createPasswordAuth({ credentials: identifiants, findUser: trouverUtilisateur, resetTokens: jetons });
+  // L'invitation : même magasin, durée plus longue (un invité n'ouvre pas son courriel dans la demi-heure).
+  const invitations = createPasswordAuth({ credentials: identifiants, findUser: trouverUtilisateur, resetTokens: jetons, limiter: false,
+    resetTtlMs: (config.invitationJours ?? 7) * 86400000 });
   const codes = createEmailCodeAuth({ findUser: async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; } });
   const vente = stripe ? createStripeSale({
     billing: facturation, stripe, webhookSecret, metadataKeys: META,
@@ -307,7 +325,7 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     } catch (e) { journal.warn(`wagon : paiementRegle de la charge : ${e?.message ?? e}`); return { status: 500, paye: false, meta }; }
     return { status: 200, paye: r.status === 'paid', meta };
   }
-  const admins = new Set([...(config.admins ?? []), ...String(getEnv('WAGON_ADMINS', '') ?? '').split(',')].map((x) => x.trim().toLowerCase()).filter(Boolean));
+  const admins = new Set(adminsDeclares(config));
   /** Un courriel est administrateur s'il est DÉCLARÉ et CONFIRMÉ. */
   const estAdministrateur = async (courriel) => {
     const c = String(courriel ?? '').toLowerCase();
@@ -494,6 +512,53 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     });
   }
 
+  /**
+   * 0.8 — les MEMBRES du compte d'une session : la charge décide QUI peut s'en servir (le wagon ne connaît pas ses
+   * rôles). Inviter crée un membre du MÊME compte, au mot de passe impossible, et rend un lien d'activation (sept
+   * jours, `config.invitationJours`) : envoyé par courriel s'il y a un transport, toujours rendu à la charge, pour
+   * qu'elle le montre (un commerce n'a pas toujours de courriel).
+   */
+  const membresDe = (compteSession) => {
+    const cid = String(compteSession.id);
+    const lienDe = (token) => `${origine}/connexion/reinitialiser?t=${encodeURIComponent(token)}`;
+    const envoyerInvitation = async (courriel, nom, lien) => {
+      if (!transport) return false;
+      try {
+        await transport.envoyer({ to: courriel, subject: `${config.marque.nom} — invitation`,
+          text: [config.marque.nom, '', `${nom ? `${nom}, v` : 'V'}ous êtes invité(e). Choisissez votre mot de passe :`, lien, '', `Ce lien vaut ${config.invitationJours ?? 7} jours.`, ''].join('\n') });
+        return true;
+      } catch (e) { journal.warn(`wagon : invitation non partie : ${e?.message ?? e}`); return false; }
+    };
+    return {
+      async lister() {
+        const out = [];
+        for (const m of await comptes.membres.lister(cid)) {
+          const u = await d.findById(S.User, m.utilisateurId).catch(() => null);
+          out.push({ ...m, nom: u?.firstName ?? null, statut: u?.status !== 'active' ? 'suspendu' : (await motsDePasse.hasPassword(m.utilisateurId)) ? 'actif' : 'invite' });
+        }
+        return out;
+      },
+      async inviter({ courriel, nom = null, role = 'membre' } = {}) {
+        const r = await comptes.membres.ajouter(cid, courriel, String(role || 'membre'));
+        const n = String(nom ?? '').trim();
+        if (n) await d.update(S.User, r.utilisateurId, { firstName: n });
+        const { token, expiresAt } = await invitations.issueToken(r.utilisateurId);
+        const lien = lienDe(token);
+        return { ...r, nom: n || null, lien, expiresAt: new Date(expiresAt).toISOString(), courrielParti: await envoyerInvitation(r.courriel, n, lien) };
+      },
+      async reinviter(utilisateurId) {
+        const m = (await comptes.membres.lister(cid)).find((x) => x.utilisateurId === String(utilisateurId));
+        if (!m) throw Object.assign(new Error('Cet utilisateur n’est pas membre de ce compte.'), { code: 'NON_MEMBRE' });
+        const u = await d.findById(S.User, m.utilisateurId).catch(() => null);
+        const { token, expiresAt } = await invitations.issueToken(m.utilisateurId);
+        const lien = lienDe(token);
+        return { ...m, lien, expiresAt: new Date(expiresAt).toISOString(), courrielParti: await envoyerInvitation(m.courriel, u?.firstName, lien) };
+      },
+      changerRole: (utilisateurId, role) => comptes.membres.changerRole(cid, String(utilisateurId), String(role)),
+      retirer: (utilisateurId) => comptes.membres.retirer(cid, String(utilisateurId)),
+    };
+  };
+
   async function handler(req, res) {
     const url = new URL(req.url, 'http://wagon.local');
     const chemin = url.pathname;
@@ -684,7 +749,7 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       if (v.allowed) anonymes.set(k, (anonymes.get(k) ?? 0) + 1);
       return v;
     };
-    // 0.3.1 — `admin` : la session est celle d'un administrateur (config.admins + WAGON_ADMINS) — pour qu'une
+    // 0.3.1 — `admin` : la session est celle d'un administrateur (config.admins + ADMIN_EMAILS) — pour qu'une
     // charge réserve ses outils (ex. l'outil de l'agence de travel) sans recalculer la liste.
     /** 0.2 (wagon-engine) — un courriel de la charge, par le transport du wagon (SMTP du .env). Rend true s'il est parti,
      *  false s'il n'y a pas de transport ou s'il a échoué (journalisé) : jamais une exception dans la route. */
@@ -693,7 +758,10 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       try { await transport.envoyer(m); return true; } catch (e) { journal.warn(`wagon : courriel de la charge non parti : ${e?.message ?? e}`); return false; }
     };
     const ctx = { chemin, methode, lang, t, ui, page, envoyer, json, rediriger, formulaire, corpsJson, compte, consommer, refuser, palier, plafond, courriel, admin: estAdmin && !compteCle,
-      paiement: paiementCharge };   // 0.7 — null sans banque prépayée active
+      paiement: paiementCharge,   // 0.7 — null sans banque prépayée active
+      // 0.8 — la PERSONNE de la session (sans empreinte) et son rôle dans le compte ; les membres du compte.
+      utilisateur: compteCle ? null : (qui?.utilisateur ?? null), role: compteCle ? null : (qui?.role ?? null),
+      membres: qui && !compteCle ? membresDe(qui.compte) : null };
     if (charge.routes && (await charge.routes(req, res, ctx))) return true;
     if (chemin.startsWith('/api/')) return json(404, { ok: false, error: 'introuvable' });
 
@@ -729,6 +797,10 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     // 0.5 — « mot de passe oublié » n'existe que si un courriel peut partir : un accusé de réception d'un message que
     // personne n'enverra serait pire qu'une page absente (auth-plug T-KIT-5).
     const oubliPossible = methodeConnexion === 'motdepasse' && !!transport;
+    // 0.8 — la page qui consomme un jeton est servie dès que l'on se connecte par mot de passe : le lien d'une
+    // INVITATION remis de la main à la main (sans courriel) doit fonctionner. Seule la DEMANDE (/connexion/oubli)
+    // exige un courriel possible.
+    const reinitPossible = methodeConnexion === 'motdepasse';
     if (chemin === '/inscription') {
       const tous = await paliersEnBase();
       const palierDe = (slug) => tous.find((p) => p.slug === slug && p.active !== false) ?? tous.find((p) => p.slug === (config.planGratuit ?? 'gratuit'));
@@ -775,11 +847,18 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     if (chemin === '/connexion') {
       const suite = suiteSure(url.searchParams.get('suite'));
       const action = avecSuite('/connexion', suite);
-      if (methode === 'GET') return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion, action }) + (oubliPossible ? `<p class="hint"><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` : '') }));
+      // 0.8 — `charge.vues.connexion({ lang, action, erreur, oubli })` rend la page ENTIÈRE à la place de wagon-ui
+      // (champs « courriel » et « motdepasse », POST vers `action`) : l'écran de la maquette de la greffe.
+      const vueConnexion = methodeConnexion === 'motdepasse' && typeof charge.vues?.connexion === 'function' ? charge.vues.connexion : null;
+      if (methode === 'GET') {
+        if (vueConnexion) return envoyer(200, await vueConnexion({ lang, action, erreur: null, oubli: oubliPossible ? '/connexion/oubli' : null }));
+        return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion, action }) + (oubliPossible ? `<p class="hint"><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` : '') }));
+      }
       const f = await formulaire();
       if (methodeConnexion === 'motdepasse') {
         const r = await motsDePasse.login(String(f.courriel ?? ''), String(f.motdepasse ?? ''), { ip: ipClient(req) });
-        if (r.ok) return ouvrirSession(r.userId, suite ?? '/compte');
+        if (r.ok) return ouvrirSession(r.userId, suite ?? config.apresConnexion ?? '/compte');
+        if (vueConnexion) return envoyer(r.reason === 'throttled' ? 429 : 200, await vueConnexion({ lang, action, erreur: t('espace.identifiantsFaux'), oubli: oubliPossible ? '/connexion/oubli' : null }));
         return envoyer(r.reason === 'throttled' ? 429 : 200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, erreur: t('espace.identifiantsFaux'), action }) }));
       }
       const courriel = String(f.courriel ?? '').trim().toLowerCase();
@@ -826,15 +905,36 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       }
       return true;
     }
-    if (oubliPossible && chemin === '/connexion/reinitialiser') {
+    if (reinitPossible && chemin === '/connexion/reinitialiser') {
       const formulaireReinit = (tk, erreur = '') => `<h1>${esc(TC.reinit)}</h1>${erreur ? `<p class="msg">${esc(erreur)}</p>` : ''}<form method="post" action="/connexion/reinitialiser"><input type="hidden" name="t" value="${esc(tk)}"><p><label>${esc(TC.nouveau)} <input type="password" name="nouveau" required autocomplete="new-password"></label></p><p><label>${esc(TC.confirmer)} <input type="password" name="confirmer" required autocomplete="new-password"></label></p><button class="bouton">${esc(TC.enregistrer)}</button></form>`;
-      if (methode === 'GET') return envoyer(200, page({ titre: TC.reinit, contenu: formulaireReinit(url.searchParams.get('t') ?? '') }));
+      // 0.8 — `charge.vues.reinitialiser({ lang, jeton, utilisateur, erreur, expire })` rend la page ENTIÈRE (champs
+      // « t », « nouveau », « confirmer ») : une invitation s'y présente (« Bienvenue …, vous êtes invité comme … »).
+      // `utilisateur` (id, courriel, prenom) est lu sur le jeton SANS le consommer ; null si le lien ne vaut plus.
+      const vueReinit = typeof charge.vues?.reinitialiser === 'function' ? charge.vues.reinitialiser : null;
+      const porteurDe = async (tk) => {
+        const e = tk ? await jetons.get(createHash('sha256').update(String(tk)).digest('base64url')) : null;
+        if (!e || e.expiresAt < Date.now()) return null;
+        const u = await d.findById(S.User, e.userId).catch(() => null);
+        return u ? { id: String(u.id), courriel: u.email, prenom: u.firstName ?? null } : null;
+      };
+      const vueR = async (code, tk, erreur) => {
+        const u = await porteurDe(tk);
+        return envoyer(code, await vueReinit({ lang, jeton: tk, utilisateur: u, erreur, expire: !u, minimum: motsDePasse.policy.minLength }));
+      };
+      if (methode === 'GET') {
+        if (vueReinit) return vueR(200, url.searchParams.get('t') ?? '', null);
+        return envoyer(200, page({ titre: TC.reinit, contenu: formulaireReinit(url.searchParams.get('t') ?? '') }));
+      }
       const f = await formulaire();
-      if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) return envoyer(400, page({ titre: TC.reinit, contenu: formulaireReinit(String(f.t ?? ''), TC.differents) }));
+      if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) {
+        if (vueReinit) return vueR(400, String(f.t ?? ''), TC.differents);
+        return envoyer(400, page({ titre: TC.reinit, contenu: formulaireReinit(String(f.t ?? ''), TC.differents) }));
+      }
       const r = await motsDePasse.consumeReset(String(f.t ?? ''), String(f.nouveau ?? ''));
+      if (!r.ok && vueReinit) return vueR(400, String(f.t ?? ''), r.reason === 'policy' ? t('espace.faible', { motifs: (r.issues ?? []).join(', ') }) : TC.lienMort);
       if (!r.ok) return envoyer(400, page({ titre: TC.reinit, contenu: r.reason === 'policy' ? formulaireReinit(String(f.t ?? ''), t('espace.faible', { motifs: (r.issues ?? []).join(', ') })) : `<h1>${esc(TC.reinit)}</h1><p class="msg">${esc(TC.lienMort)}</p><p><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` }));
       await sessions.fermerToutes(String(r.userId));
-      return ouvrirSession(r.userId);
+      return ouvrirSession(r.userId, config.apresConnexion ?? '/compte');
     }
 
     // L'espace du client.