@mostajs/enrollment 0.2.0 → 0.2.1

package/dist/cjs/agent.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * @mostajs/enrollment — L'agent MACHINE : se présente, insiste, se rattache tout seul.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIdentity = generateIdentity;
+exports.createEnrollmentAgent = createEnrollmentAgent;
+const crypto_box_1 = require("@mostajs/crypto-box");
+/** Génère l'identité de la machine (au premier démarrage). La PRIVÉE ne quitte jamais le poste. */
+function generateIdentity() {
+    return (0, crypto_box_1.generateSigningKeyPair)();
+}
+/**
+ * Crée l'agent d'enrôlement.
+ *
+ * ─── LA RE-TENTATIVE EST LE CŒUR ─────────────────────────────────────────────
+ * Sans elle, l'approbation manuelle est un piège : le client installe un dimanche à 8 h, voit
+ * « en attente »… et devrait tout recommencer lundi ? Absurde.
+ *
+ * L'agent RE-SONDE en boucle (`@mostajs/scheduler`). Le client installe et part travailler ;
+ * vous approuvez quand vous voulez ; la machine se rattache TOUTE SEULE et la bannière
+ * disparaît. **Personne ne refait rien.**
+ *
+ * L'appel est SORTANT : aucun certificat, aucun port ouvert, aucun reverse proxy chez le client.
+ * Fonctionne derrière une box, un NAT, un pare-feu d'entreprise.
+ */
+function createEnrollmentAgent(opts) {
+    const http = opts.fetchImpl ?? fetch;
+    let etat = { state: 'non_enrole' };
+    const poser = async (s) => {
+        etat = s;
+        await opts.persist(s);
+        opts.onState?.(s);
+    };
+    async function cycle() {
+        if (etat.state === 'enrole' || etat.state === 'refuse')
+            return; // terminal
+        try {
+            // 1. Se présenter (une fois), puis 2. sonder jusqu'à décision.
+            if (etat.state !== 'en_attente') {
+                const r = await http(`${opts.consoleUrl}/enroll/request`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({
+                        code: opts.code,
+                        machineId: opts.machineId,
+                        hostname: opts.hostname,
+                        app: opts.app,
+                        version: opts.version,
+                        publicKey: Buffer.from(opts.identity.publicKey).toString('hex'),
+                    }),
+                }).then((x) => x.json());
+                if (!r.ok) {
+                    await poser({ state: 'erreur', message: r.error ?? 'refus' });
+                    return;
+                }
+                await poser({ state: 'en_attente', requestId: r.requestId, depuis: new Date().toISOString() });
+                return;
+            }
+            const s = await http(`${opts.consoleUrl}/enroll/status/${etat.requestId}`).then((x) => x.json());
+            if (s.state === 'rejected') {
+                await poser({ state: 'refuse' });
+                return;
+            }
+            if (s.state !== 'approved')
+                return; // toujours en attente — on repassera
+            // ── VÉRIFIER LA SIGNATURE avant de croire quoi que ce soit.
+            const approval = s.approval;
+            const valide = (0, crypto_box_1.verifySignature)(opts.consolePublicKey, JSON.stringify(approval), Buffer.from(s.signature, 'hex'));
+            if (!valide) {
+                // Une réponse non signée par NOTRE console est une réponse d'imposteur. On ne l'applique
+                // pas, et on ne se tait pas.
+                await poser({ state: 'erreur', message: 'approbation NON SIGNÉE par la console attendue — réponse ignorée' });
+                return;
+            }
+            // La console doit aussi présenter LA clé publique qu'on connaît.
+            if (!(0, crypto_box_1.equalsConstantTime)(approval.consolePublicKey, Buffer.from(opts.consolePublicKey).toString('hex'))) {
+                await poser({ state: 'erreur', message: 'la console renvoie une clé publique INATTENDUE' });
+                return;
+            }
+            await poser({ state: 'enrole', siteId: approval.siteId, name: approval.name, token: approval.token });
+        }
+        catch (e) {
+            // Console injoignable : ce n'est PAS une erreur fatale. La machine continue de servir en
+            // local, et réessaiera au prochain tour. Les tickets doivent continuer à sortir.
+            opts.onState?.({ state: 'erreur', message: e.message });
+        }
+    }
+    // ─── POURQUOI PAS `@mostajs/scheduler` ? ──────────────────────────────────
+    // La tentation était forte : il y a une boucle, une cadence. Mais son CONTRAT est celui d'un
+    // déclencheur à FRONTIÈRES : il adopte la période courante au démarrage SANS rien lancer, et
+    // ne déclenche qu'une fois par frontière franchie. C'est exactement ce qu'il faut pour une
+    // sauvegarde nocturne — et exactement ce qu'il NE faut PAS ici : l'agent doit sonder à CHAQUE
+    // tour, dès le premier, jusqu'à obtenir une réponse.
+    //
+    // Le détourner (mode `count` avec un compteur artificiel) « marcherait »… puis casserait au
+    // premier changement de sémantique du planificateur. Une boucle de re-tentative n'est pas un
+    // planificateur : on ne force pas l'un dans l'autre. Douze lignes ici valent mieux qu'une
+    // dépendance mal utilisée.
+    let timer = null;
+    return {
+        start() {
+            if (timer)
+                return;
+            void cycle(); // on sonde IMMÉDIATEMENT — le client ne doit pas attendre une minute pour rien
+            timer = setInterval(() => { void cycle(); }, opts.intervalMs ?? 60_000);
+            // Le processus ne doit pas être maintenu en vie par cette boucle.
+            if (typeof timer?.unref === 'function') {
+                timer.unref();
+            }
+        },
+        stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+        tick: cycle,
+        state: () => etat,
+    };
+}

package/dist/cjs/code.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * @mostajs/enrollment — Le code d'enrôlement : dictable au téléphone.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._internal = void 0;
+exports.generateCode = generateCode;
+exports.normalizeCode = normalizeCode;
+exports.parseCode = parseCode;
+exports.hashCode = hashCode;
+exports.verifyCode = verifyCode;
+const crypto_box_1 = require("@mostajs/crypto-box");
+/**
+ * Alphabet **Crockford Base32** : ni `I`, ni `L`, ni `O`, ni `U`.
+ *
+ * Ce n'est pas un détail esthétique. Un code se dicte au téléphone, et « c'est un zéro ou un
+ * O ? », « un 1 ou un I ? » sont les deux questions qui font échouer une installation à
+ * distance. `U` est retiré pour ne pas former de mot grossier par accident.
+ */
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+/** Confusions courantes, corrigées SILENCIEUSEMENT à la lecture (Crockford). */
+const CORRECTIONS = { O: '0', I: '1', L: '1', U: 'V' };
+const PREFIX = 'MJSE';
+const RANDOM_LEN = 10;
+const CHECK_LEN = 2;
+/** Somme de contrôle : 2 caractères dérivés du corps du code. */
+function checksum(body) {
+    const digest = (0, crypto_box_1.sha256)(`mostajs-enrollment-code/v1:${body}`); // hex
+    const n = parseInt(digest.slice(0, 4), 16); // 16 bits
+    return ALPHABET[(n >> 5) & 31] + ALPHABET[n & 31];
+}
+/** Met en forme : `MJSE-XXXX-XXXX-XXXX`. */
+function format(body12) {
+    return `${PREFIX}-${body12.slice(0, 4)}-${body12.slice(4, 8)}-${body12.slice(8, 12)}`;
+}
+/**
+ * Génère un code d'enrôlement.
+ *
+ * 10 caractères aléatoires (50 bits) + 2 de contrôle. 50 bits ne résistent PAS à une attaque
+ * en ligne illimitée — c'est pourquoi le service verrouille après quelques échecs (voir
+ * `service.ts`). Un code n'est pas un mot de passe : il est à usage unique et expire en 7 jours.
+ */
+function generateCode(secret) {
+    const bytes = (0, crypto_box_1.randomKey)(16);
+    let body = '';
+    for (let i = 0; i < RANDOM_LEN; i++)
+        body += ALPHABET[bytes[i] & 31];
+    body += checksum(body);
+    return { display: format(body), canonical: body, hash: hashCode(body, secret) };
+}
+/**
+ * Normalise une saisie humaine : majuscules, tirets et espaces retirés, préfixe optionnel,
+ * confusions Crockford corrigées (`O`→`0`, `I`/`L`→`1`, `U`→`V`).
+ *
+ * On accepte donc `mjse 7k4p-2xq9 m3ta`, `7K4P2XQ9M3TA`, ou une saisie où le client a tapé `O`
+ * au lieu de zéro. Refuser un code correct pour une virgule de forme serait absurde : c'est
+ * l'ENTROPIE qui protège, pas la ponctuation.
+ */
+function normalizeCode(input) {
+    let s = String(input ?? '').toUpperCase().replace(/[\s-]/g, '');
+    if (s.startsWith(PREFIX))
+        s = s.slice(PREFIX.length);
+    return [...s].map((c) => CORRECTIONS[c] ?? c).join('');
+}
+/**
+ * Valide la FORME d'un code, **hors ligne**.
+ *
+ * C'est tout l'intérêt de la somme de contrôle : une faute de frappe est rejetée **avant le
+ * moindre appel réseau**. Le client voit « code invalide » immédiatement, au lieu d'attendre
+ * trente secondes pour un « refusé » qui ne lui dit pas si c'est lui ou le serveur.
+ *
+ * Elle ne prouve RIEN sur la validité du code — seulement qu'il a été correctement recopié.
+ */
+function parseCode(input) {
+    const c = normalizeCode(input);
+    if (c.length !== RANDOM_LEN + CHECK_LEN)
+        return { ok: false, error: 'longueur' };
+    if ([...c].some((ch) => !ALPHABET.includes(ch)))
+        return { ok: false, error: 'caractere_invalide' };
+    const body = c.slice(0, RANDOM_LEN);
+    const check = c.slice(RANDOM_LEN);
+    if (check !== checksum(body))
+        return { ok: false, error: 'somme_de_controle' };
+    return { ok: true, canonical: c };
+}
+/**
+ * Empreinte du code, pour la console.
+ *
+ * Le code n'est **jamais** stocké en clair : une fuite de la base ne doit donner **aucun** code
+ * utilisable. C'est un secret d'authentification — on le traite comme un mot de passe.
+ * HMAC (et non simple SHA) : sans le `secret` de la console, on ne peut pas pré-calculer un
+ * dictionnaire de 2⁵⁰ empreintes.
+ */
+function hashCode(canonical, secret) {
+    return (0, crypto_box_1.hmacSha256)(secret, `mostajs-enrollment-code/v1:${normalizeCode(canonical)}`);
+}
+/** Compare un code saisi à une empreinte — en TEMPS CONSTANT. */
+function verifyCode(input, hash, secret) {
+    const p = parseCode(input);
+    if (!p.ok)
+        return false;
+    return (0, crypto_box_1.equalsConstantTime)(hashCode(p.canonical, secret), hash);
+}
+exports._internal = { ALPHABET, checksum, format, PREFIX, RANDOM_LEN, CHECK_LEN };

package/dist/cjs/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @mostajs/enrollment — Enrôler une machine chez un client distant, sans configuration.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N1 · Compose : crypto-box (Ed25519, HMAC) · scheduler (re-tentative)
+ *
+ * ─── LE PROBLÈME ─────────────────────────────────────────────────────────────
+ * Un `.exe` identique pour tous, installé chez N clients, doit s'IDENTIFIER auprès d'une console
+ * centrale — sans que le client configure quoi que ce soit.
+ *
+ * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
+ * Ce n'est PAS de la licence. Deux questions distinctes, qu'il ne faut jamais fusionner :
+ *   « Ce client a-t-il le DROIT d'utiliser le logiciel ? »  → @mostajs/licensing
+ *   « Cette machine EST-ELLE bien la sienne ? »             → ce module
+ * Les mélanger interdirait de révoquer un enrôlement (machine volée) sans couper la licence.
+ *
+ * ─── LES TROIS VERROUS ───────────────────────────────────────────────────────
+ * 1. **Pas de jeton générique dans le binaire.** Quiconque possède le `.exe` pourrait s'enrôler.
+ *    → Un code PAR CLIENT, dictable au téléphone, à usage unique, 7 jours.
+ * 2. **`machineId` n'authentifie pas** — il identifie. Il est public et falsifiable.
+ *    → Une paire Ed25519 générée sur la machine ; la clé PRIVÉE ne sort jamais. Un jeton volé est
+ *      rejouable ; une clé qui ne bouge pas, non.
+ * 3. **La console peut être usurpée** (DNS détourné, certificat frauduleux).
+ *    → Chaque approbation est SIGNÉE, et vérifiée avec la clé publique EMBARQUÉE dans le binaire.
+ *
+ * ─── ET LE CLIENT NE REFAIT JAMAIS RIEN ──────────────────────────────────────
+ * L'approbation est un CLIC humain — mais l'agent RE-SONDE en boucle. Le client installe et part
+ * travailler ; vous approuvez quand vous voulez ; la machine se rattache toute seule.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMachineId = exports.generateIdentity = exports.createEnrollmentAgent = exports.createEnrollmentService = exports.verifyCode = exports.hashCode = exports.normalizeCode = exports.parseCode = exports.generateCode = exports.moduleInfo = void 0;
+exports.moduleInfo = { name: '@mostajs/enrollment', version: '0.2.1', level: 'N1' };
+var code_js_1 = require("./code.js");
+Object.defineProperty(exports, "generateCode", { enumerable: true, get: function () { return code_js_1.generateCode; } });
+Object.defineProperty(exports, "parseCode", { enumerable: true, get: function () { return code_js_1.parseCode; } });
+Object.defineProperty(exports, "normalizeCode", { enumerable: true, get: function () { return code_js_1.normalizeCode; } });
+Object.defineProperty(exports, "hashCode", { enumerable: true, get: function () { return code_js_1.hashCode; } });
+Object.defineProperty(exports, "verifyCode", { enumerable: true, get: function () { return code_js_1.verifyCode; } });
+var service_js_1 = require("./service.js");
+Object.defineProperty(exports, "createEnrollmentService", { enumerable: true, get: function () { return service_js_1.createEnrollmentService; } });
+var agent_js_1 = require("./agent.js");
+Object.defineProperty(exports, "createEnrollmentAgent", { enumerable: true, get: function () { return agent_js_1.createEnrollmentAgent; } });
+Object.defineProperty(exports, "generateIdentity", { enumerable: true, get: function () { return agent_js_1.generateIdentity; } });
+var machine_js_1 = require("./machine.js");
+Object.defineProperty(exports, "readMachineId", { enumerable: true, get: function () { return machine_js_1.readMachineId; } });

package/dist/cjs/machine.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * @mostajs/enrollment — Lire l'identifiant de la MACHINE, sans dépendance native.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ *
+ * ─── POURQUOI ICI ────────────────────────────────────────────────────────────
+ * L'agent exige un `machineId`, et TOUTE machine qui s'enrôle doit savoir le produire. Le laisser
+ * à la charge de chaque application, c'est garantir N implémentations divergentes — et une
+ * dépendance à `node-machine-id` (binaire natif) qui interdirait un `.exe` PUR-JS.
+ *
+ * ─── CE QUE CET IDENTIFIANT EST, ET N'EST PAS ────────────────────────────────
+ * Il **identifie**, il n'**authentifie** pas. Il est lisible par n'importe qui sur le poste et
+ * falsifiable par quiconque contrôle la machine. C'est la clé Ed25519 — privée, jamais transmise —
+ * qui authentifie. Le `machineId` sert à une seule chose : reconnaître « c'est le même poste » afin
+ * de LEVER L'ALERTE de ré-enrôlement quand la clé, elle, a changé.
+ *
+ * ─── ET IL EST HACHÉ ─────────────────────────────────────────────────────────
+ * On ne transmet JAMAIS le GUID brut de l'OS. Il est haché avec un `salt` propre à l'application :
+ *   - la console n'apprend pas l'identifiant système du client (elle n'en a aucun besoin) ;
+ *   - le même poste enrôlé dans deux applications donne deux identifiants DIFFÉRENTS — impossible
+ *     de recouper les parcs de deux clients.
+ * Le hachage est stable : même poste + même salt ⇒ même identifiant, indéfiniment.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMachineId = readMachineId;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const crypto_box_1 = require("@mostajs/crypto-box");
+const run = (cmd, args) => new Promise((resolve, reject) => {
+    // execFile, PAS exec : aucun shell, donc aucune injection possible même si un jour un
+    // paramètre venait de l'extérieur.
+    (0, node_child_process_1.execFile)(cmd, args, { timeout: 5_000, windowsHide: true }, (err, stdout) => {
+        if (err)
+            reject(err);
+        else
+            resolve(String(stdout));
+    });
+});
+/** Le GUID BRUT de l'OS. Interne : il ne doit jamais sortir d'ici sans être haché. */
+async function guidNatif() {
+    try {
+        if (process.platform === 'win32') {
+            // MachineGuid : posé par Windows à l'installation, stable, lisible sans privilège.
+            const out = await run(`${process.env.SystemRoot ?? 'C:\\Windows'}\\System32\\reg.exe`, [
+                'QUERY', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid',
+            ]);
+            const m = /MachineGuid\s+REG_SZ\s+(\S+)/i.exec(out);
+            if (m)
+                return { brut: m[1], source: 'windows-registry' };
+            return null;
+        }
+        if (process.platform === 'darwin') {
+            const out = await run('/usr/sbin/ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice']);
+            const m = /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out);
+            if (m)
+                return { brut: m[1], source: 'macos-ioplatform' };
+            return null;
+        }
+        if (process.platform === 'linux') {
+            // /etc/machine-id (systemd) ; le repli D-Bus couvre les distributions qui ne l'ont pas.
+            for (const f of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+                try {
+                    const brut = (await (0, promises_1.readFile)(f, 'utf8')).trim();
+                    if (brut)
+                        return { brut, source: 'linux-machine-id' };
+                }
+                catch { /* fichier absent : on essaie le suivant */ }
+            }
+        }
+        // Tout autre OS (AIX, BSD, SunOS…) : on ne devine PAS. Étiqueter `linux-machine-id` un
+        // identifiant qui ne vient pas de Linux serait un mensonge dans les journaux — et le jour où
+        // il faudra diagnostiquer une machine qui se ré-enrôle sans cesse, ce mensonge coûtera cher.
+        return null;
+    }
+    catch {
+        // Registre verrouillé par une GPO, conteneur sans /etc/machine-id, binaire absent… On ne
+        // fait pas échouer l'application pour ça : l'appelant recevra `aleatoire` et saura quoi dire.
+        return null;
+    }
+}
+/**
+ * Lit l'identifiant de la machine, haché avec le sel de l'application.
+ *
+ * ─── LE REPLI ALÉATOIRE EST UN PIÈGE — LISEZ CECI ────────────────────────────
+ * Quand l'OS ne fournit rien (conteneur nu, registre verrouillé), on renvoie `source: 'aleatoire'`
+ * et un identifiant tiré au sort. **L'hôte DOIT le persister** et le repasser en `fallback` aux
+ * démarrages suivants. Sinon l'identifiant change à chaque lancement — et la machine, déjà
+ * enrôlée, se présente à chaque fois comme un poste inconnu.
+ *
+ * On ne le persiste pas nous-mêmes : ce module ne choisit pas votre stockage (fichier ? base ?
+ * `userData` d'Electron ?). Mais on vous DIT, par `source`, que la persistance est obligatoire.
+ */
+async function readMachineId(opts) {
+    const natif = await guidNatif();
+    if (natif) {
+        // HMAC et pas SHA-256 nu : sans clé, un GUID Windows (espace connu et énumérable) se
+        // retrouverait par force brute à partir du haché. Le sel, secret ou non, coupe le dictionnaire.
+        return { id: (0, crypto_box_1.hmacSha256)(opts.salt, natif.brut), source: natif.source };
+    }
+    const repli = opts.fallback?.trim();
+    if (repli)
+        return { id: (0, crypto_box_1.hmacSha256)(opts.salt, repli), source: 'aleatoire' };
+    // Aucune graine fournie : on en tire une — et on la REND, pour que l'hôte la persiste. La
+    // garder pour nous produirait un identifiant neuf à chaque démarrage : le pire des deux mondes.
+    const graine = (0, crypto_box_1.randomKey)(32).toString('hex');
+    return { id: (0, crypto_box_1.hmacSha256)(opts.salt, graine), source: 'aleatoire', seedToPersist: graine };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/service.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * @mostajs/enrollment — Le service CONSOLE : reçoit, approuve, révoque.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnrollmentService = createEnrollmentService;
+const crypto_box_1 = require("@mostajs/crypto-box");
+const code_js_1 = require("./code.js");
+/**
+ * Le service d'enrôlement, côté console.
+ *
+ * ─── CE QU'IL PROTÈGE ────────────────────────────────────────────────────────
+ * 1. **La force brute.** 50 bits d'entropie ne résistent PAS à une attaque en ligne illimitée.
+ *    Le service VERROUILLE après quelques échecs — par code ET par origine. Sans ce verrou, le
+ *    code dictable serait une fausse sécurité.
+ * 2. **Le ré-enrôlement usurpé.** Une machine déjà enrôlée qui revient avec une clé publique
+ *    DIFFÉRENTE : disque remplacé, ou usurpation ? On ne peut pas deviner — donc on ne décide
+ *    PAS. On lève un drapeau et on exige un clic conscient.
+ * 3. **La console usurpée.** Chaque approbation est SIGNÉE (Ed25519). La machine vérifie avec la
+ *    clé publique embarquée dans son binaire : même si TLS tombait (DNS détourné, certificat
+ *    frauduleux), un faux jeton ne pourrait pas être forgé.
+ */
+function createEnrollmentService(opts) {
+    const clock = opts.now ?? (() => new Date());
+    const maxAttempts = opts.maxAttempts ?? 5;
+    const lockoutMs = opts.lockoutMs ?? 15 * 60_000;
+    /** Compteurs d'échec, par origine (IP) ET par code présenté. */
+    const echecs = new Map();
+    function verrouille(cle) {
+        const e = echecs.get(cle);
+        if (!e)
+            return false;
+        // Aucun verrou POSÉ (jusqua = 0) : on est encore en phase de comptage. Surtout NE PAS
+        // purger l'entrée ici — une première version le faisait, et remettait donc le compteur à
+        // zéro à chaque appel : il ne dépassait jamais 1, et le verrou ne se déclenchait JAMAIS.
+        // Un anti-force-brute qui ne bloque rien est pire que pas d'anti-force-brute : on se croit
+        // protégé.
+        if (e.jusqua === 0)
+            return false;
+        if (clock().getTime() < e.jusqua)
+            return true;
+        echecs.delete(cle); // le verrou a expiré : on repart à zéro
+        return false;
+    }
+    function echec(cle) {
+        const e = echecs.get(cle) ?? { n: 0, jusqua: 0 };
+        e.n += 1;
+        if (e.n >= maxAttempts)
+            e.jusqua = clock().getTime() + lockoutMs;
+        echecs.set(cle, e);
+    }
+    return {
+        /**
+         * Une machine se présente. Elle ne reçoit RIEN d'utile ici : seulement un `requestId` pour
+         * sonder. Le jeton n'existe qu'après approbation humaine.
+         */
+        async request(input) {
+            const origine = input.origin ?? 'inconnue';
+            if (verrouille(origine))
+                return { ok: false, error: 'verrouille' };
+            // Forme d'abord : rejeter une faute de frappe ne doit RIEN coûter, ni compter comme un
+            // échec de sécurité — sinon un client maladroit se verrouille tout seul.
+            const forme = (0, code_js_1.parseCode)(input.code);
+            if (!forme.ok)
+                return { ok: false, error: 'code_malforme' };
+            const invitation = await opts.store.findInvitationByCode((h) => (0, code_js_1.verifyCode)(input.code, h, opts.codeSecret));
+            if (!invitation) {
+                echec(origine);
+                return { ok: false, error: 'code_invalide' };
+            }
+            if (invitation.usedAt)
+                return { ok: false, error: 'code_deja_utilise' };
+            if (new Date(invitation.expiresAt) < clock())
+                return { ok: false, error: 'code_expire' };
+            // ── Le drapeau du ré-enrôlement. On NE tranche PAS : on alerte.
+            const existant = await opts.store.findSiteByMachineId(input.machineId);
+            const cleChangee = !!existant && !(0, crypto_box_1.equalsConstantTime)(existant.publicKey, input.publicKey);
+            const req = {
+                id: `req-${Date.now()}-${(0, crypto_box_1.randomKey)(6).toString('hex')}`,
+                invitationId: invitation.id,
+                machineId: input.machineId,
+                hostname: input.hostname,
+                publicKey: input.publicKey,
+                app: input.app,
+                version: input.version,
+                origin: origine,
+                state: 'pending',
+                createdAt: clock().toISOString(),
+                /**
+                 * Machine connue, clé DIFFÉRENTE. C'est soit un disque remplacé chez le client, soit
+                 * quelqu'un qui usurpe son identité — et rien dans la requête ne permet de distinguer
+                 * les deux. L'accepter en silence serait le piège classique de ce protocole.
+                 */
+                reenrollmentAlert: cleChangee
+                    ? { previousSiteId: existant.siteId, previousPublicKey: existant.publicKey }
+                    : undefined,
+            };
+            await opts.store.saveRequest(req);
+            echecs.delete(origine); // code valide → on remet le compteur à zéro
+            return { ok: true, requestId: req.id, state: 'pending' };
+        },
+        /** La machine sonde. Tant qu'aucun humain n'a cliqué, elle n'obtient rien. */
+        async status(requestId) {
+            const req = await opts.store.findRequest(requestId);
+            if (!req)
+                return { state: 'unknown' };
+            if (req.state !== 'approved' || !req.approval) {
+                return { state: req.state };
+            }
+            // L'approbation est SIGNÉE : la machine la vérifie avec la clé publique embarquée dans son
+            // binaire. Un imposteur ne peut pas forger de jeton, même en cassant TLS.
+            const payload = JSON.stringify(req.approval);
+            return { state: 'approved', approval: req.approval, signature: (0, crypto_box_1.sign)(opts.signingKey, payload).toString('hex') };
+        },
+        /**
+         * Le clic. `acceptReenrollment` DOIT être explicite quand un drapeau est levé : on refuse de
+         * laisser approuver une usurpation par inadvertance.
+         */
+        async approve(input) {
+            const req = await opts.store.findRequest(input.requestId);
+            if (!req)
+                return { ok: false, error: 'inconnue' };
+            if (req.state !== 'pending')
+                return { ok: false, error: 'deja_traitee' };
+            if (req.reenrollmentAlert && !input.acceptReenrollment) {
+                // Refus DÉLIBÉRÉ : l'approbateur doit avoir vu l'alerte et l'avoir acceptée sciemment.
+                return { ok: false, error: 'reenrolement_non_confirme' };
+            }
+            const token = (0, crypto_box_1.randomKey)(32).toString('hex');
+            const site = {
+                siteId: input.siteId,
+                name: input.name,
+                machineId: req.machineId,
+                publicKey: req.publicKey,
+                app: req.app,
+                token,
+                enrolledAt: clock().toISOString(),
+                revokedAt: null,
+            };
+            req.state = 'approved';
+            req.approval = { siteId: site.siteId, name: site.name, token, consolePublicKey: Buffer.from(opts.signingPublicKey).toString('hex') };
+            req.decidedAt = clock().toISOString();
+            req.decidedBy = input.approvedBy;
+            await opts.store.saveSite(site);
+            await opts.store.saveRequest(req);
+            // Le code est CONSOMMÉ. Un secret qui traîne est une porte ouverte pour rien.
+            await opts.store.markInvitationUsed(req.invitationId, clock().toISOString());
+            return { ok: true, site };
+        },
+        async reject(requestId, by) {
+            const req = await opts.store.findRequest(requestId);
+            if (!req || req.state !== 'pending')
+                return { ok: false };
+            req.state = 'rejected';
+            req.decidedAt = clock().toISOString();
+            req.decidedBy = by;
+            await opts.store.saveRequest(req);
+            return { ok: true };
+        },
+        /** Révoque un site — machine volée, client parti. La licence, elle, n'est PAS touchée. */
+        async revoke(siteId) {
+            const site = await opts.store.findSite(siteId);
+            if (!site || site.revokedAt)
+                return { ok: false };
+            site.revokedAt = clock().toISOString();
+            await opts.store.saveSite(site);
+            return { ok: true };
+        },
+        /** Le jeton présenté est-il celui d'un site enrôlé et NON révoqué ? */
+        async authenticate(siteId, token) {
+            const site = await opts.store.findSite(siteId);
+            if (!site || site.revokedAt)
+                return null;
+            return (0, crypto_box_1.equalsConstantTime)(site.token, token) ? site : null;
+        },
+    };
+}

package/dist/cjs/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @mostajs/enrollment — types partagés.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -29,7 +29,7 @@
  */
 export declare const moduleInfo: {
     readonly name: "@mostajs/enrollment";
-    readonly version: "0.2.0";
+    readonly version: "0.2.1";
     readonly level: "N1";
 };
 export { generateCode, parseCode, normalizeCode, hashCode, verifyCode } from './code.js';

package/dist/index.js

@@ -27,7 +27,7 @@
  * L'approbation est un CLIC humain — mais l'agent RE-SONDE en boucle. Le client installe et part
  * travailler ; vous approuvez quand vous voulez ; la machine se rattache toute seule.
  */
-export const moduleInfo = { name: '@mostajs/enrollment', version: '0.2.0', level: 'N1' };
+export const moduleInfo = { name: '@mostajs/enrollment', version: '0.2.1', level: 'N1' };
 export { generateCode, parseCode, normalizeCode, hashCode, verifyCode } from './code.js';
 export { createEnrollmentService } from './service.js';
 export { createEnrollmentAgent, generateIdentity } from './agent.js';

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "@mostajs/enrollment",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Enrôler une machine chez un client distant, sans configuration : code dictable au téléphone (usage unique, 7 jours), identité Ed25519 générée sur la machine, approbation par un clic dans la console, re-tentative automatique. Compose crypto-box et scheduler.",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/index.d.ts",
   "license": "AGPL-3.0-or-later",
   "author": "Dr Hamid MADANI <drmdh@msn.com>",
-  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
+      "require": "./dist/cjs/index.js",
       "default": "./dist/index.js"
     }
   },
@@ -19,7 +22,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.cjs.json && node -e \"require('fs').writeFileSync('dist/cjs/package.json', JSON.stringify({type:'commonjs'}))\"",
     "test": "bash test-scripts/run-tests.sh",
     "example": "node examples/demo.mjs",
     "prepublishOnly": "npm run build"
@@ -34,11 +37,11 @@
     "mostajs"
   ],
   "dependencies": {
-    "@mostajs/crypto-box": "^0.2.0"
+    "@mostajs/crypto-box": "^0.2.1"
   },
   "devDependencies": {
     "@mostajs/mjs-unit": "^0.4.1",
     "@types/node": "^20",
     "typescript": "^5.6.0"
   }
-}
+}