@mostajs/delegation 0.0.0-stage → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md ADDED
@@ -0,0 +1,224 @@
1
+ # Changelog — @mostajs/delegation
2
+
3
+ **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
4
+ Format [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/) · [SemVer](https://semver.org/lang/fr/).
5
+
6
+ ## [0.9.0] — 2026-11-21 — agents Windows et macOS
7
+
8
+ ### Ajouté
9
+ - **macOS** : `bin/installer-machine-macos.sh` (bash 3.2, relancé sous bash s'il est lancé par zsh) — détection
10
+ (`sysctl`, `/Applications`), Node darwin dans `~/.local`, inscription (code sur l'entrée standard), empreinte de la
11
+ clé publique, configuration écrite une fois, service launchd `dev.mostajs.delegation-agent` (`RunAtLoad`,
12
+ `KeepAlive { SuccessfulExit: false }`, `ThrottleInterval 30`, journaux `~/Library/Logs/mostajs-delegation`) :
13
+ LaunchAgent chargé sans sudo, ou LaunchDaemon (`UserName`) préparé avec ses commandes `sudo` imprimées ; `--compte`,
14
+ `--a-blanc` / `--imprimer`, `--desinstaller [--purger]` ; jamais root ; idempotent.
15
+ - **Windows** : `bin/installer-machine.ps1` (PowerShell 5.1 et 7, UTF-8 avec BOM) — mêmes options ; jamais en session
16
+ élevée ; Node par l'archive zip ; ACL du dossier de données et du jeton par `icacls` ; tâche planifiée
17
+ `\mostajs\delegation-agent` (au démarrage en S4U sous un compte dédié, ou à l'ouverture de session), répétée toutes
18
+ les 5 min sans doublon, relancée après un échec ; `--desinstaller [--purger]`.
19
+ - `bin/delegation-veilleur.mjs`, `src/veilleur.js` (`veiller`, `tournerJournal`) : relance l'agent après une panne,
20
+ s'arrête sur le code 2, journal tourné, arrêt transmis ; l'agent s'arrête quand le veilleur disparaît (IPC).
21
+ - `bin/delegation-service.mjs`, `src/services.js` : `plistLaunchd`, `cheminPlist`, `tacheWindows`,
22
+ `ecrireConfigurationAgent` (import par URL `file://`), `LABEL_LAUNCHD`, `TACHE_WINDOWS`.
23
+ - `src/plateforme.js` : `cheminsAgent`, `etendreTilde`, `signauxArret`, `estAdministrateur`, `commandeArretArbre`,
24
+ `trouverProgramme`, `trouverBash`, `trouverChrome`, `droitsTropOuverts`, `restreindreAcces`.
25
+ - Étapes `{ programme, arguments }` : lancées par `spawn` sans shell, sur tous les systèmes.
26
+ - Essais T-DLG-71 à 85 (T-DLG-84, l'analyse par pwsh, est sauté et signalé quand pwsh manque).
27
+
28
+ ### Changé
29
+ - `creerAgent({ plateforme, administrateur })` : sous Windows, refus en session élevée (`E_ADMIN`) ; un type dont une
30
+ étape passe par bash doit déclarer la capacité `bash`. `executerTache(tache)` exposé.
31
+ - `lancerExecution` refuse une étape sans `commande` ni `programme` (`E_ETAPES`) ; sous Windows, bash est celui de Git
32
+ for Windows (jamais le lanceur WSL de System32), et l'arrêt passe par `taskkill /T`.
33
+ - `detecterCapacites` cherche dans le `PATH` sans shell (PATHEXT sous Windows) et relève la capacité `bash`.
34
+ - `delegation-agent` : signaux par système (SIGBREAK sous Windows), droits du jeton lus seulement hors Windows.
35
+
36
+ ## [0.8.1] — 2026-11-21
37
+
38
+ ### Ajouté
39
+ - `delegation-cle signer --prive <fichier>` : l'ordre à signer lu sur l'entrée standard, l'ordre signé rendu en une
40
+ ligne JSON (pour une console qui ne tourne pas sur le poste : on y colle l'ordre signé). Essai T-DLG-70.
41
+
42
+ ## [0.8.0] — 2026-11-21 — le train durci (T1 à T4)
43
+
44
+ ### Ajouté
45
+ - **T1, rouges connus datés** : chaque entrée de `rougesConnus` est `{ essai, motif, echeance, depuis?, renvoi? }` ;
46
+ une liste nue est refusée (`E_CONFIG`). Une échéance dépassée fait **échouer** le train (rapport `echus`, encore rouge
47
+ ou redevenu vert) ; les rouges connus devenus verts sont signalés, à retirer ; le verdict garde les motifs.
48
+ - **T2, index des films attesté** : `films.signature.clePrivee` (fichier local en 600) → attestation Ed25519
49
+ `mostajs-delegation-attestation/1` (application, version, branche, tête, empreinte de l'index, empreintes des films),
50
+ écrite à côté de l'index et commitée avec lui ; `signerAttestation`, `verifierAttestation(att, cles, { index })` ;
51
+ clé absente ou lisible par d'autres → arrêt au rapatriement.
52
+ - **T3, la cible a bougé** : la tête de la cible est notée au paquet ; avant la fusion, si elle a bougé et que la
53
+ branche ne la contient pas, arrêt avec un message clair (avant → maintenant, `git rebase`) ; rien n'est fusionné.
54
+ - **T4, un seul nouvel essai** : `suite.reessai { etapes (gabarit {essais}), rapport }` ; les rouges nouveaux sont
55
+ rejoués une fois ; ceux qui passent sont **instables** (journal, `resultats.instables`) et le train continue ; les
56
+ autres l'arrêtent (`reessai: true` au rapport).
57
+ - Essais T-DLG-66 à 69.
58
+
59
+ ### Changé (incompatible)
60
+ - `rougesConnus` : liste d'objets datés et motivés (T1) ; une configuration à liste de noms est refusée.
61
+
62
+ ## [0.7.0] — 2026-11-21 — durcissement avant la mise en ligne (R1 à R6)
63
+
64
+ ### Ajouté
65
+ - **R1, ordres signés** (`src/signature.js`, `node:crypto` seul) : `creerCleSignature()`, `empreinteCle(pem)`,
66
+ `nouvelOrdre(tache, { dureeH })`, `signerOrdre(ordre, clePrivee)` → `{ echeance, nonce, cle, signature }`,
67
+ `verifierOrdre(tache, ordre, clesPubliques)`, `lireClePrivee(chemin)` (refuse un fichier lisible par d'autres).
68
+ `creerFile({ clesPubliques })` : le feu vert exige un ordre valide (`E_SIGNATURE`) ; `file.ordreASigner(id)` ;
69
+ l'ordre est gardé, journalisé avec l'empreinte de la clé, et part avec la tâche. `creerAgent({ clesPubliques })` :
70
+ ordre absent, clé inconnue, retouché, expiré ou **rejoué** (`<racine>/delegation/ordres-vus.json`) → refusé sans rien
71
+ exécuter. Bin **`delegation-cle`** (`generer`, `empreinte`) : clé privée en 600, jamais écrasée ni imprimée.
72
+ - **R2, capacités figées** : `parc.accepter` fige `capacitesAcceptees` et `rolesAcceptes` ; une annonce qui en ajoute
73
+ ne les obtient pas (`refusees` dans la réponse, `capacitesEnAttente`, journal « capacites-demandees ») ;
74
+ `parc.accepterCapacites`, `parc.refuserCapacites`.
75
+ - **R3, empreinte du PC** : `empreinteMachine(empreinteJeton)` (XXXX-XXXX-XXXX), rendue par `enrolerMachine`, imprimée
76
+ par le bin et l'installateur, affichée par `parc.machine()` ; `parc.accepter(id, { empreinte })` (`E_EMPREINTE`),
77
+ exigée avec `creerParc({ exigerEmpreinte: true })`.
78
+ - **R4, jamais orphelin (suite)** : délais par type `demarrageMaxS`, `dureeMaxMin`, `silenceMaxS` (et défauts de l'API) ;
79
+ battements par tâche ; `api.verifier()` remet, arrête ou interrompt selon le cas ; machines muettes depuis
80
+ `muetteJours` mises en sommeil (suspendues, journal « muette »), jamais effacées ; dernier signe de vie gardé dans le
81
+ parc.
82
+ - **R5, compte dédié et dossier jetable** : `lancerExecution(def, { travail: true })` (dossier neuf par tâche,
83
+ `DELEGATION_TRAVAIL`, effacé à la fin) ; l'agent le fait par défaut (`travailJetable`) et refuse root (`E_ROOT`).
84
+ `installer-machine.sh` : jamais root ; `--compte <nom>` imprime la création du compte et la relance sous ce compte ;
85
+ `--cle-publique` ; `RestartPreventExitStatus=2`.
86
+ - **R6, tout sur 443** : `creerApiAgents({ exigerHttps: true })` (426 sans HTTPS ; `X-Forwarded-Proto` cru d'un
87
+ mandataire local seulement) ; l'agent refuse une centrale en http hors de la machine (`E_HTTPS`). Le flux SSE passe
88
+ un mandataire (`X-Accel-Buffering: no`).
89
+ - Essais T-DLG-56 à 65.
90
+
91
+ ### Changé
92
+ - `bin/delegation-agent` refuse de démarrer sans clé publique des ordres (code 2), sauf `signature: false` explicite.
93
+ - Les étapes sans `cwd` travaillent dans le dossier jetable de leur tâche (et non plus dans le dossier personnel).
94
+
95
+ ## [0.6.0] — 2026-11-21 — la centrale maestro, l'inscription depuis le PC, « jamais orphelin »
96
+
97
+ ### Ajouté
98
+ - **Inscription depuis le PC** : `parc.demander()` rend un **code de demande** à usage unique, valable 15 minutes,
99
+ gardé en empreinte, qui ne révèle rien du parc ; `POST /api/agent/enroler { code, nom, roles, detecte }` ; la machine
100
+ naît « en attente », origine « inscription ». Plafonds des demandes vivantes et des machines en attente (`E_TROP`).
101
+ - **La centrale maestro** : son agent (`creerApiAgents({ centrale: { jeton: <empreinte> } })`, id `CENTRALE_ID`)
102
+ ne tire **rien par défaut** ; `parc.reglerCentrale({ executer, types, concurrence })` (1 à 8, au journal) ;
103
+ `creerAgentCentrale({ url, jeton, registre, reglage })` ne démarre que si le réglage est activé.
104
+ - **Le train jamais à la centrale** : `creerTypeTrain` exige `node@20`, `git`, `ssh`, `conducteur` ; le réglage refuse
105
+ `train` (`E_INTERDIT`), l'API retire `conducteur` des capacités de la centrale, la file ne lui donne jamais un type qui
106
+ l'exige.
107
+ - **Canal direct** (`@mostajs/canal-network`) : `creerApiAgents({ canal: true })` monte le canal sous `/canal` ;
108
+ `api.distribuer(tache)` réveille les machines **acceptées** qui savent faire ; `api.demander(id, 'etat')` ;
109
+ `agent.ecouter({ mode, reveil })` (réveil, état, réannonce à chaque reconnexion). Admis au canal relus chaque seconde.
110
+ - **Jamais orphelin** : au retour d'un redémarrage, l'agent déclare sa tâche commencée « interrompue »
111
+ (`POST taches/<id>/interrompue`) ; la politique du type décide (`siInterrompue` : `remettre` par défaut, `arreter`,
112
+ `reprendre`) ; au-delà de 3 interruptions, arrêtée. Hors ligne après N battements manqués, en ligne au retour
113
+ (journal du parc) ; `api.verifier()` / `api.surveiller()` reprennent la tâche d'une machine hors ligne depuis
114
+ `repriseApresS`. **Bail** : un battement (`POST taches/<id>/battement`) part toutes les `progressionS` ; une tâche
115
+ reprise ailleurs est **abandonnée** par l'agent (processus arrêté) ; sans centrale au-delà de `bailS`, l'exécution est
116
+ arrêtée et le compte rendu « interrompue » gardé, livré au retour. `lancerExecution(def, { signal })`.
117
+ - `bin/delegation-agent` : `--enroler --nom … --roles …` (code sur l'entrée standard) ; `canal` dans la configuration ;
118
+ attente croissante bornée quand la centrale est injoignable ; reprise après une coupure.
119
+ - **`bin/installer-machine.sh`** (Linux) : détection, Node 20 dans `~/.local` si absent, agent installé
120
+ (paquet local, archive ou npm), inscription par le code lu sur l'entrée standard (jamais en argument), configuration
121
+ écrite une fois (600), service systemd utilisateur (`After=network-online.target`, `Restart=always`) ou unité système
122
+ préparée (`--service systeme`) ; `--essai`, `--verifier`, `--a-la-demande`, `--sans-service`, `--conducteur` ;
123
+ sans sudo, idempotent.
124
+ - Essais T-DLG-43 à 55.
125
+
126
+ ### Changé
127
+ - La politique par défaut d'une tâche interrompue est « remettre en file » ; un type déclare `siInterrompue: 'reprendre'`
128
+ pour être repris par la même machine sans rejouer les étapes faites.
129
+ - Nouvelle dépendance : `@mostajs/canal-network` ^0.1.1.
130
+
131
+ ## [0.5.0] — 2026-11-20 — le parc : des machines annoncées depuis la centrale
132
+
133
+ ### Ajouté
134
+ - **`creerParc({ fichier })`** (exigence du fondateur, 20/11/2026) : annoncer une machine (nom, rôles, capacités
135
+ attendues) rend un **jeton d'enrôlement** à usage unique, valable 30 minutes, montré une seule fois et gardé en
136
+ empreinte ; la machine s'enrôle (`POST /api/agent/enroler`), reçoit son **jeton durable** (empreinte seule) et passe
137
+ **en attente** avec ses capacités détectées ; `accepter`, `refuser`, `suspendre`, `reprendre`, `renommer`,
138
+ `retirer`, `revoquer` (nouveau jeton d'enrôlement, nouvelle acceptation). Chaque geste au journal, sans jeton.
139
+ - `creerApiAgents({ parc })` : une machine en attente ne peut que s'annoncer (403 sinon) ; suspendue, elle ne tire plus
140
+ rien de nouveau ; refusée, retirée ou révoquée : 401.
141
+ - Côté machine : `detecterCapacites()` (node@<majeure>, chrome, ffmpeg, piper, git, ssh, rsync ; cœurs, mémoire,
142
+ disque, système) et `enrolerMachine({ url, jetonEnrolement, fichierJeton })` (jeton durable en 600, jamais rendu) ;
143
+ `delegation-agent --enroler --url … --jeton-fichier …` (jeton d'enrôlement sur l'entrée standard).
144
+ - Essais T-DLG-37 à 42.
145
+
146
+ ## [0.4.0] — 2026-11-20 — le type de tâche « train »
147
+
148
+ ### Ajouté
149
+ - **`creerTypeTrain({ fichier })`** : le conducteur de train comme type de tâche, pour le registre d'un agent. Entrées
150
+ `application` (celles de la configuration), `branche` (`lot/…`), `version` (`x.y.z`). Phases, chacune une étape de
151
+ l'exécutant (`delegation-train <phase>`) : `paquet` (fetch de la branche dans le clone de travail, `git bundle`),
152
+ `envoi`, `suite` (exécution distante détachée, attendue), `resultats` (rapport mjs-unit, rouges connus, exécutés =
153
+ déclarés), `tournage`, `rapatriement` (films, contrôle SHA-256 contre l'index `geste-film-index/1`) ; puis, seulement
154
+ si `integration.autorisee`, `index` (commit signé de l'index), `fusion` (`--ff-only`), `d4q`, `push`.
155
+ - Arrêt avec un **rapport court** (`rapport.json` du dossier du train, imprimé en fin de journal) : essais nouveaux en
156
+ rouge et leur message, film en échec et sa capture, fichiers refusés au contrôle SHA-256, étape cassée.
157
+ - **Jamais D4PF, D4PFQ ni déploiement** : une configuration qui en contient une commande est refusée (`E_INTERDIT`) ;
158
+ le train le dit en s'arrêtant.
159
+ - Transport ssh/scp/rsync (`BatchMode`), ou `hote: "local"`. Une exécution distante déjà lancée n'est pas relancée à la
160
+ reprise ; une exécution jamais démarrée ou interrompue arrête le train.
161
+ - Bin `delegation-train`. Essais T-DLG-31 à 36.
162
+
163
+ ## [0.3.0] — 2026-11-20 — lot C1 du plan 02 (centrale)
164
+
165
+ ### Changé (incompatible)
166
+ - **Les commandes vivent chez l'agent** (plan 02, §8.2-1, défaut critique). `tirer` et `miennes` ne renvoient plus
167
+ `execution` (des étapes fabriquées par la console) mais `{ tache: { id, type, titre, entrees, etat } }`. L'agent
168
+ revalide les entrées avec SON registre et fabrique lui-même ses étapes ; des entrées qu'il refuse, ou un type qu'il ne
169
+ connaît pas, finissent en échec motivé sans rien exécuter. `creerAgent` exige `registre`.
170
+ - `creerRegistre({ declarations: true })` : le registre d'une centrale, sans étapes ; une définition qui en porte y est
171
+ refusée. `registre.declaration(nom)` : tout d'un type sauf ses étapes.
172
+ - Une machine annonce ses `types` ; elle ne reçoit que ceux-là (`file.tirer` filtre sur `machine.types`).
173
+ - `bin/delegation-agent` lit une configuration `.mjs` (types avec leurs étapes) ; une `.json` peut nommer `typesModule`.
174
+
175
+ ### Ajouté
176
+ - **Progression** (N1) : `POST /api/agent/taches/<id>/progression`, envoyée à chaque fin d'étape et toutes les
177
+ `progressionS` secondes (15) ; 403 pour la tâche d'une autre machine, 409 pour une tâche non démarrée ; bornée
178
+ (32 Ko). `file.progression(id, { progression })`, `tache.progression`, `tache.progressionMaj`.
179
+ `lancerExecution(def, { surEtat })` rend chaque état écrit.
180
+ - **Télémétrie** (N2) dans l'annonce : hôte, charge, processeurs, mémoire, disque, versions ; bornée par la centrale
181
+ (`bornerTelemetrie`), clés inconnues ignorées ; `api.machines()[].telemetrie`, `.types`.
182
+ - **Fin du journal sur échec** (N3) : `resultat.finJournal`, ≤ 8 Ko, sans codes couleur, jetons et mots de passe
183
+ masqués (`finDeJournal`) ; rien sur succès. La centrale tronque aussi ce qu'on lui envoie.
184
+ - **Machines déclarées à chaud** (N4) : `creerApiAgents({ machinesFichier })`, relu dès qu'il change ; `api.declarer(liste)`.
185
+ - **Comptes rendus gardés pendant une coupure** (§8.2-2) : `<racine>/delegation/comptes-rendus.json`, livrés au tour
186
+ suivant (`agent.livrer()`) ; une tâche en cours se termine sans la centrale.
187
+ - `bornerJson` : ce que la centrale garde d'une machine est borné (profondeur, chaînes, listes, nombres finis).
188
+ - Essais T-DLG-21 à 30.
189
+
190
+ ## [0.2.1] — 2026-11-17
191
+
192
+ ### Corrigé
193
+ - L'agent s'annonce avant chaque tirage. Une console redémarrée oublie les annonces : l'agent recevait « annoncez
194
+ d'abord vos capacités » à chaque tour, sans jamais se réannoncer, et la machine restait « absente » (constaté sur la
195
+ .12). T-DLG-20.
196
+
197
+ ## [0.2.0] — 2026-11-17 — lot L2 du plan 01
198
+
199
+ ### Ajouté
200
+ - **L'API des agents** (`creerApiAgents`), côté console : annonce, tirage, tâches de la machine (reprise), démarrer,
201
+ rendre. C'est l'agent qui tire : la console ne pousse rien. Un jeton par machine ; la console n'en garde que
202
+ l'empreinte SHA-256 (`empreinteJeton`), comparée à temps constant. Une machine n'agit que sur ses tâches (403).
203
+ Corps JSON borné à 256 Ko (413), JSON illisible (400). État des machines : `libre`, `occupee`, `absente`.
204
+ - **L'agent** (`creerAgent`, bin `delegation-agent --config agent.json`) : s'annonce, reprend ses tâches en cours
205
+ sans rejouer les étapes faites, tire, exécute avec l'exécutant de cidev et rend l'état ; les journaux restent sur
206
+ la machine. Le jeton est lu dans un fichier, jamais affiché.
207
+ - Essais T-DLG-14 à 19.
208
+
209
+ ## [0.1.0] — 2026-11-17 — lot L1 du plan 01
210
+
211
+ ### Ajouté
212
+ - **Registre des types de tâches** (`creerRegistre`), sur le patron des dialectes : `type`, `version`, `capacites`,
213
+ schéma des `entrees` (`requis`, `motif`), `etapes(entrees)`, `livrables`, `dureeMinutes`. `valider(type, entrees)`
214
+ refuse une clé hors schéma : une tâche ne porte jamais de commande.
215
+ - **Machines et capacités** : `manquesPour(machine, type)` nomme ce qui manque.
216
+ - **La file** (`creerFile`) : états `proposee → affectee → en_cours → faite | echec | annulee` portés par
217
+ `@mostajs/statemachine` ; **feu vert OFF à la naissance** (D-4), ON rend affectable, OFF retire une tâche affectée non
218
+ commencée ; chaque transition et chaque bascule est journalisée (qui, quand). `tirer(machine)` : la plus ancienne
219
+ tâche au feu vert que la machine sait faire. `execution(id)` : les étapes viennent du type.
220
+ - **Stockage** en mémoire ou fichier JSON (`mostajs-delegation-file/1`), écriture atomique ; la file se reprend après
221
+ redémarrage, et une machine retrouve ses tâches en cours (`enCoursDe`).
222
+ - **L'exécutant** (`lancerExecution`, bin `delegation-lancer`), repris du lanceur de cidev : même format d'exécution,
223
+ même `etat.json`, mêmes analyses `suite` et `films` ; ajout de la **reprise** (`--reprendre`).
224
+ - Essais T-DLG-1 à 13.
package/LICENSE ADDED
@@ -0,0 +1,15 @@
1
+ @mostajs/delegation
2
+ Copyright (C) 2026 Dr Hamid MADANI <drmdh@msn.com>
3
+
4
+ This program is free software: you can redistribute it and/or modify it under
5
+ the terms of the GNU Affero General Public License as published by the Free
6
+ Software Foundation, either version 3 of the License, or (at your option) any
7
+ later version.
8
+
9
+ This program is distributed in the hope that it will be useful, but WITHOUT
10
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
+ FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
12
+ details.
13
+
14
+ You should have received a copy of the GNU Affero General Public License
15
+ along with this program. If not, see <https://www.gnu.org/licenses/agpl-3.0.html>.
package/README.md CHANGED
@@ -1,3 +1,227 @@
1
- # Temporary Holding Version
1
+ # @mostajs/delegation
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ > Déléguer des tâches **typées** à des **machines**, sous **feu vert**. Une tâche ne porte jamais de commande : un type
4
+ > et des entrées validées. Les commandes vivent **chez la machine** : la centrale n'envoie que `{ type, entrees }`, que
5
+ > l'agent revalide avant de fabriquer lui-même ses étapes.
6
+
7
+ **Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later · **Node** ≥ 20 · ESM · **Version** 0.9.0
8
+
9
+ ## Installation
10
+
11
+ ```bash
12
+ npm i @mostajs/delegation
13
+ ```
14
+
15
+ ## Exemple
16
+
17
+ ```js
18
+ // La CENTRALE : des déclarations (nom, capacités, schéma des entrées), jamais d'étapes.
19
+ import { createServer } from 'node:http';
20
+ import { creerRegistre, creerFile, creerStockageFichier, creerApiAgents } from '@mostajs/delegation';
21
+
22
+ const declarations = creerRegistre({ declarations: true })
23
+ .enregistrer({ type: 'suite', version: '1', capacites: ['node@20'], entrees: { projet: { requis: true, motif: '^[a-z0-9-]{2,40}$' } } });
24
+ const file = creerFile({ registre: declarations, stockage: creerStockageFichier('file.json') });
25
+ const api = creerApiAgents({ file, machinesFichier: 'machines.json' }); // [{ id, jeton: <empreinte> }], relu à chaud
26
+ createServer(api).listen(8790);
27
+
28
+ const t = await file.proposer({ type: 'suite', entrees: { projet: 'mon-projet' }, par: 'mo' }); // feu vert OFF
29
+ await file.feuVert(t.id, true, { par: 'mo' }); // ON : affectable
30
+ ```
31
+
32
+ ```js
33
+ // La MACHINE : son registre, avec SES commandes.
34
+ import { creerRegistre, creerAgent } from '@mostajs/delegation';
35
+
36
+ const registre = creerRegistre().enregistrer({
37
+ type: 'suite', version: '1', capacites: ['node@20'], entrees: { projet: { requis: true, motif: '^(mon-projet)$' } },
38
+ etapes: ({ projet }) => [{ code: 'suite', commande: 'npm test', cwd: `~/depots/${projet}`, analyse: 'suite' }],
39
+ });
40
+ const agent = creerAgent({ url: 'https://centrale.exemple', jeton, machine: { capacites: ['node@20'] }, registre });
41
+ await agent.tour(); // livre les comptes rendus en attente, s'annonce, tire, exécute, rend compte
42
+ ```
43
+
44
+ ## Ce que garantit le module
45
+
46
+ | Garantie | Essai |
47
+ |---|---|
48
+ | un type incomplet est refusé, en nommant ce qui manque | T-DLG-1 |
49
+ | une entrée hors schéma (une commande) est refusée | T-DLG-2 |
50
+ | une machine sans la capacité ne reçoit pas la tâche | T-DLG-3, 6, 8 |
51
+ | rien ne part sans feu vert ; OFF retire une tâche non commencée | T-DLG-4, 7 |
52
+ | un saut d'état est refusé, un état terminal ne bouge plus | T-DLG-5 |
53
+ | la file et son journal (qui, quand) survivent à un redémarrage | T-DLG-9 |
54
+ | l'exécutant de cidev, avec reprise | T-DLG-11 à 13 |
55
+ | un jeton par machine, dont la centrale ne garde que l'empreinte | T-DLG-14 |
56
+ | deux machines tirent chacune ce qu'elles savent faire, sur HTTP | T-DLG-15, 16 |
57
+ | une machine n'agit que sur ses tâches ; l'agent reprend au redémarrage | T-DLG-17, 18 |
58
+ | **la centrale ne connaît aucune commande ; l'agent revalide ; une machine ne reçoit que ses types** | T-DLG-21, 22, 23 |
59
+ | progression visible pendant l'exécution, bornée, refusée hors de sa tâche | T-DLG-24, 25 |
60
+ | télémétrie bornée dans l'annonce | T-DLG-26 |
61
+ | fin du journal sur échec (≤ 8 Ko, sans couleurs, jetons masqués) | T-DLG-27 |
62
+ | machines ajoutées ou retirées sans redémarrage | T-DLG-28 |
63
+ | compte rendu gardé sur disque pendant une coupure, livré au retour | T-DLG-29 |
64
+ | l'agent en ligne de commande, configuré en `.mjs` | T-DLG-30 |
65
+ | type « train » : jamais D4PF ni déploiement ; phases dans l'ordre | T-DLG-31 |
66
+ | train vert : index signé, avance rapide, D4Q, push ; arrêts motivés (rouge nouveau, film, SHA-256) | T-DLG-32 à 35 |
67
+ | intégration seulement si la machine l'autorise | T-DLG-36 |
68
+ | machine annoncée : jeton d'enrôlement unique, court, gardé en empreinte | T-DLG-37 |
69
+ | machine enrôlée en attente : elle s'annonce, ne tire rien avant l'acceptation | T-DLG-38, 39 |
70
+ | refuser, retirer, révoquer, renommer ; journal sans jeton | T-DLG-40 |
71
+ | capacités détectées sur la machine ; jeton durable en 600 | T-DLG-41, 42 |
72
+ | inscription depuis le PC : code de demande unique, court, en empreinte ; plafonds | T-DLG-43 à 45 |
73
+ | la centrale n'exécute rien par défaut ; le train jamais à la centrale | T-DLG-46, 47 |
74
+ | canal direct : réveil des seules machines acceptées, demande « état » | T-DLG-48 |
75
+ | `installer-machine.sh` : détection, code sur l'entrée standard, service au boot, sans sudo, idempotent | T-DLG-49 à 51 |
76
+ | jamais orphelin : tâche interrompue déclarée, hors ligne / en ligne, bail, centrale redémarrée | T-DLG-52 à 55 |
77
+ | ordres signés Ed25519 : la file exige un feu vert signé, l'agent refuse ordre absent, retouché, expiré, rejoué | T-DLG-56 à 58, 70 |
78
+ | capacités figées à l'acceptation ; un ajout attend une nouvelle acceptation | T-DLG-59 |
79
+ | empreinte du PC comparée à l'acceptation | T-DLG-60 |
80
+ | délais par type ; machines muettes mises en sommeil | T-DLG-61, 62 |
81
+ | dossier jetable par tâche ; jamais root ; compte dédié | T-DLG-63, 64 |
82
+ | derrière un mandataire HTTPS : API et flux SSE ; 426 sans HTTPS | T-DLG-65 |
83
+ | train : rouges connus datés (échéance dépassée → échec) ; index des films attesté ; cible qui a bougé ; un seul nouvel essai | T-DLG-66 à 69 |
84
+ | agent portable : chemins par système, jamais administrateur, signaux (SIGBREAK), étapes sans shell, bash déclaré, détection, droits (ACL) | T-DLG-71 à 77 |
85
+ | plist launchd et tâche planifiée Windows générés et validés en XML ; veilleur qui relance l'agent | T-DLG-78 à 80 |
86
+ | `installer-machine-macos.sh` : à blanc, pour de vrai (launchctl témoin), idempotent, LaunchDaemon, désinstallation | T-DLG-81, 82 |
87
+ | `installer-machine.ps1` : source contrôlée (PowerShell 5.1) ; analyse par pwsh s'il est installé (sinon sauté et dit) ; paquet | T-DLG-83 à 85 |
88
+
89
+ ```bash
90
+ npm test # 85 essais (dont 1 sauté sans pwsh), sur 127.0.0.1
91
+ ```
92
+
93
+ ## Une machine
94
+
95
+ ```bash
96
+ umask 077; mkdir -p ~/.delegation; head -c 32 /dev/urandom | base64 > ~/.delegation/jeton
97
+ delegation-agent --config ~/.delegation/agent.mjs # { url, jetonFichier, roles, capacites, racine, types: [...] }
98
+ ```
99
+
100
+ La centrale déclare la machine par l'**empreinte** du jeton (`empreinteJeton`), jamais par le jeton.
101
+
102
+ ## Annoncer une machine (le parc)
103
+
104
+ ```js
105
+ const parc = creerParc({ fichier: 'parc.json' });
106
+ const api = creerApiAgents({ file, parc });
107
+ const { jetonEnrolement } = await parc.annoncer({ nom: 'Poste 2', roles: ['poste'], par: 'mo' }); // montré une fois
108
+ // sur la machine : echo "$JETON" | delegation-agent --enroler --url https://centrale.exemple --jeton-fichier ~/.delegation/jeton
109
+ await parc.accepter('poste-2', { par: 'mo' }); // rien n'est tiré avant
110
+ ```
111
+
112
+ ## Inscrire un PC (depuis le PC)
113
+
114
+ La centrale sert une page publique qui rend un **code de demande** (`parc.demander()`), à usage unique, 15 minutes.
115
+ Sur le PC :
116
+
117
+ ```bash
118
+ bash installer-machine.sh --centrale https://centrale.exemple --nom "PC Accueil" --roles poste
119
+ # le code est DEMANDÉ (saisie masquée) ; jamais en argument
120
+ ```
121
+
122
+ Le script installe l'agent, l'inscrit (« en attente »), écrit `~/.delegation/agent.mjs` une fois et pose le service
123
+ systemd utilisateur. Le fondateur accepte la machine ; rien ne lui est confié avant.
124
+
125
+ ### Sur un Mac (macOS)
126
+
127
+ ```bash
128
+ bash installer-machine-macos.sh --centrale https://centrale.exemple --nom "Mac Films" --roles films --cle-publique cle-ordres.pem
129
+ bash installer-machine-macos.sh --a-blanc --centrale https://centrale.exemple # ce qui serait fait, et le plist ; rien d'écrit
130
+ bash installer-machine-macos.sh --desinstaller [--purger]
131
+ ```
132
+
133
+ - Données : `~/Library/Application Support/mostajs/delegation` (jeton 600, dossier 700) ; journaux :
134
+ `~/Library/Logs/mostajs-delegation/agent.log`.
135
+ - Service launchd `dev.mostajs.delegation-agent` : `RunAtLoad`, `KeepAlive { SuccessfulExit: false }` (relancé après une
136
+ panne, pas après un arrêt propre), `ThrottleInterval 30`.
137
+ - `--service utilisateur` (défaut) : LaunchAgent dans `~/Library/LaunchAgents`, chargé sans sudo
138
+ (`launchctl bootstrap gui/<uid>`) ; il tourne quand la session est ouverte.
139
+ - `--service systeme` : LaunchDaemon (`UserName` = le compte) pour démarrer au boot sans session ; le plist est préparé
140
+ et les deux commandes `sudo` sont imprimées, jamais lancées. `--compte <nom>` imprime la création du compte dédié
141
+ (`sysadminctl`) et la relance du script sous lui.
142
+ - Bash 3.2 (celui de macOS) ; lancé par zsh, le script se relance sous `/bin/bash`. Jamais root.
143
+
144
+ ### Sur un PC Windows
145
+
146
+ ```powershell
147
+ powershell -NoProfile -ExecutionPolicy Bypass -File installer-machine.ps1 --centrale https://centrale.exemple --nom "PC Accueil" --roles poste --cle-publique cle-ordres.pem
148
+ powershell -NoProfile -ExecutionPolicy Bypass -File installer-machine.ps1 --a-blanc --centrale https://centrale.exemple --service systeme
149
+ powershell -NoProfile -ExecutionPolicy Bypass -File installer-machine.ps1 --desinstaller [--purger]
150
+ ```
151
+
152
+ - PowerShell 5.1 (Windows 10 et 11) et 7 ; mêmes options que sous Linux et macOS ; jamais dans une session élevée.
153
+ - Données : `%LOCALAPPDATA%\mostajs\delegation`, réservées au compte par ACL (`icacls`, l'utilisateur et SYSTEM) ;
154
+ journaux : `…\delegation\journaux\agent.log` (tourné au-delà de 5 Mo).
155
+ - Tâche planifiée `\mostajs\delegation-agent` (aucun binaire tiers) qui lance **`delegation-veilleur`** : il relance
156
+ l'agent après une panne (5 s, attente croissante bornée), s'arrête sur le code 2 (configuration refusée), et l'agent
157
+ s'arrête si le veilleur disparaît (jamais deux agents). La tâche se relance toutes les 5 minutes si le veilleur ne
158
+ tourne plus (`IgnoreNew` : jamais deux), et après un échec.
159
+ - `--service utilisateur` (défaut) : à l'ouverture de votre session, enregistrée sans droits d'administrateur.
160
+ - `--service systeme` : au démarrage, sans session, sous le compte en S4U (aucun mot de passe conservé) ; la
161
+ définition est préparée et la commande `Register-ScheduledTask` imprimée pour un administrateur. `--compte <nom>`
162
+ imprime la création du compte local dédié (`New-LocalUser`) et la relance sous lui (`runas`).
163
+ - Les étapes `{ programme, arguments }` partent sans shell ; un type dont une étape est une `commande` passe par bash
164
+ (Git for Windows) et doit déclarer la capacité `bash`, sinon la machine le refuse.
165
+
166
+ ### Générer sans installer
167
+
168
+ ```bash
169
+ delegation-service plist --mode utilisateur --node … --agent … --configuration … --journaux … --donnees … --home …
170
+ delegation-service tache-windows --mode systeme --utilisateur 'PC\agent' --node … --veilleur … --configuration … --journal … --donnees …
171
+ delegation-veilleur --config agent.mjs --journal agent.log
172
+ ```
173
+
174
+ ## Jamais orphelin
175
+
176
+ - L'agent est un service qui redémarre toujours ; il se reconnecte avec une attente croissante bornée.
177
+ - Au retour, une tâche commencée est déclarée « interrompue » ; le type décide : `remettre` (défaut), `arreter`, `reprendre`.
178
+ - Pendant une exécution, un battement part régulièrement : une tâche reprise ailleurs est abandonnée par l'agent ;
179
+ sans centrale au-delà du bail (`bailS`), l'exécution est arrêtée et le compte rendu livré au retour.
180
+
181
+ ## Le type « train »
182
+
183
+ ```js
184
+ import { creerRegistre, creerTypeTrain } from '@mostajs/delegation';
185
+ const registre = creerRegistre().enregistrer(creerTypeTrain({ fichier: '/chemin/train.json' }));
186
+ // tâche : { type: 'train', entrees: { application: 'mon-appli', branche: 'lot/L1-1.2.0', version: '1.2.0' } }
187
+ ```
188
+
189
+ Paquet de la branche → suite sur la machine d'essai → verdict (rouges connus) → tournage → rapatriement des films
190
+ vérifiés en SHA-256 → (si la machine l'autorise) commit de l'index, fusion en avance rapide, D4Q, push. Arrêt avec un
191
+ rapport court sinon. **Jamais D4PF ni déploiement.** Toute la configuration de l'application est chez l'agent.
192
+
193
+ - Rouges connus : `{ essai, motif, echeance }` ; à l'échéance, le rouge redevient bloquant.
194
+ - `films.signature.clePrivee` : l'index des films part avec une attestation signée (Ed25519), vérifiable par
195
+ `verifierAttestation`.
196
+ - Si la cible a bougé depuis le paquet, le train s'arrête avant la fusion et dit quoi faire.
197
+ - `suite.reessai` : un rouge nouveau est rejoué une fois ; vert, il est marqué instable.
198
+
199
+ ## Ordres signés
200
+
201
+ ```bash
202
+ delegation-cle generer --prive ~/.config/delegation/ordres.cle --publique ordres.pub # sur le poste du fondateur
203
+ ```
204
+
205
+ ```js
206
+ const file = creerFile({ registre, stockage, clesPubliques: [publique] }); // la centrale : clés publiques seules
207
+ const ordre = signerOrdre(await file.ordreASigner(id), lireClePrivee(process.env.CHEMIN_CLE)); // sur le poste
208
+ await file.feuVert(id, true, { par: 'mo', ordre });
209
+ const agent = creerAgent({ url, jeton, machine, registre, clesPubliques: [publique] }); // la machine vérifie
210
+ ```
211
+
212
+ La clé privée reste sur le poste (fichier en 600, chemin donné par une variable d'environnement, jamais dans un dépôt).
213
+ Une console qui tourne ailleurs montre l'ordre à signer : `delegation-cle signer --prive <clé> < ordre.json` rend l'ordre
214
+ signé, à coller dans la console.
215
+
216
+ ## Sécurité
217
+
218
+ - C'est l'agent qui tire ; la centrale n'ouvre aucune connexion vers une machine.
219
+ - Une centrale compromise ne peut que demander un type que la machine accepte déjà, avec des entrées qu'elle revalide.
220
+ - Ce que la centrale garde d'une machine est borné (`bornerJson`, `bornerTelemetrie`, `finDeJournal`).
221
+ - Un jeton volé permet de se faire passer pour sa machine (tirer ses tâches, rendre de faux résultats), jamais de donner
222
+ un feu vert ni de s'attribuer une capacité (elles sont figées à l'acceptation) ; on le retire en ôtant son empreinte
223
+ du fichier des machines, ou en révoquant la machine, sans redémarrage.
224
+ - Avec les ordres signés, une centrale compromise ne peut ni fabriquer un feu vert, ni retoucher des entrées, ni rejouer
225
+ un ordre : l'agent vérifie avec sa clé publique locale.
226
+ - Derrière un mandataire, la centrale n'écoute que sur 127.0.0.1 et exige HTTPS (`exigerHttps`) ; le flux SSE demande
227
+ à ne pas être gardé en tampon (`X-Accel-Buffering: no`) : le mandataire doit relayer sans tampon.
@@ -0,0 +1,98 @@
1
+ #!/usr/bin/env node
2
+ // delegation-agent — l'agent d'une machine : s'annonce, livre ses comptes rendus en attente, reprend ses tâches en cours,
3
+ // puis tire et exécute en boucle.
4
+ // delegation-agent --config <agent.mjs> [--une-fois]
5
+ // delegation-agent --enroler --url <centrale> --jeton-fichier <f> [--nom <nom>] [--roles a,b] (code sur l'entrée standard)
6
+ // agent.mjs (export default) : { url, jetonFichier: "~/.delegation/jeton", roles: [...], capacites: [...],
7
+ // racine: "~/cidev", intervalleS: 30, progressionS: 15, bailS: 300, canal: { mode: 'auto' },
8
+ // types: [ { type, version, capacites, entrees, etapes(entrees) } ] }
9
+ // canal (0.6.0) : le canal direct avec la centrale ; un réveil (« tache ») interrompt l'attente entre deux tours.
10
+ // Le service ne s'arrête jamais sur une erreur : il réessaie avec une attente croissante bornée (jamais orphelin).
11
+ // Les TYPES et leurs COMMANDES vivent ici, chez la machine (plan 02, §8.2-1) : la centrale n'envoie que { type, entrees }.
12
+ // Une configuration .json reste lue (sans fonctions) : ses types viennent alors du module nommé par "typesModule".
13
+ // Le jeton est LU dans son fichier (droits 600 recommandés) ; il n'est jamais affiché ni écrit dans un journal.
14
+ // 0.9.0 (R9) : Linux, macOS, Windows — signaux d'arrêt par plateforme (SIGBREAK sous Windows) ; lancé par le veilleur
15
+ // (Windows), il s'arrête quand le canal IPC se ferme (veilleur disparu) ou sur sa demande ; droits du jeton : mode
16
+ // POSIX, l'ACL sous Windows (posée par l'installateur).
17
+ // @author Dr Hamid MADANI <drmdh@msn.com>
18
+ import { readFileSync, statSync } from 'node:fs';
19
+ import { resolve, dirname } from 'node:path';
20
+ import { pathToFileURL } from 'node:url';
21
+ import { creerAgent, creerRegistre } from '../src/index.js';
22
+ import { etendreTilde, droitsTropOuverts, signauxArret } from '../src/plateforme.js';
23
+
24
+ const args = process.argv.slice(2);
25
+ // Enrôlement (une fois, à l'installation) : le jeton d'enrôlement est lu sur l'ENTRÉE STANDARD (jamais en argument, que
26
+ // `ps` montrerait) ; le jeton durable est posé dans --jeton-fichier (600) et n'est jamais affiché.
27
+ // echo "<jeton d'enrôlement ou code de demande>" | delegation-agent --enroler --url https://delegate.mostajs.dev --jeton-fichier ~/.delegation/jeton
28
+ if (args.includes('--enroler')) {
29
+ const { enrolerMachine } = await import('../src/index.js');
30
+ const val = (n) => { const k = args.indexOf(n); return k >= 0 ? args[k + 1] : undefined; };
31
+ const url = val('--url'); const fichier = val('--jeton-fichier');
32
+ const nom = val('--nom'); const roles = String(val('--roles') || '').split(',').map((x) => x.trim()).filter(Boolean);
33
+ if (!url || !fichier) { console.error('usage : delegation-agent --enroler --url <centrale> --jeton-fichier <fichier> (jeton d’enrôlement sur l’entrée standard)'); process.exit(2); }
34
+ let lu = ''; for await (const b of process.stdin) lu += b;
35
+ try {
36
+ const r = await enrolerMachine({ url, jetonEnrolement: lu.trim(), fichierJeton: etendreTilde(fichier), ...(nom ? { nom } : {}), ...(roles.length ? { roles } : {}) });
37
+ console.log(`✓ machine enrôlée : ${r.id} (capacités détectées : ${r.capacites.join(', ')}) — en attente d'acceptation à la centrale`);
38
+ console.log(` empreinte de ce poste : ${r.empreinte} — la console affiche la même ; comparez-la avant d'accepter`);
39
+ process.exit(0);
40
+ } catch (e) { console.error(`✗ ${e.message}`); process.exit(1); }
41
+ }
42
+ const i = args.indexOf('--config');
43
+ if (i < 0 || !args[i + 1]) { console.error('usage : delegation-agent --config <agent.mjs|agent.json> [--une-fois]'); process.exit(2); }
44
+ const tilde = (p) => etendreTilde(p || '');
45
+ const chemin = resolve(args[i + 1]);
46
+ const conf = /\.m?js$/.test(chemin) ? (await import(pathToFileURL(chemin).href)).default : JSON.parse(readFileSync(chemin, 'utf8'));
47
+ const types = conf.types || (conf.typesModule ? (await import(pathToFileURL(resolve(dirname(chemin), tilde(conf.typesModule))).href)).default : []);
48
+ const registre = creerRegistre();
49
+ for (const t of types) registre.enregistrer(t);
50
+ const fichierJeton = tilde(conf.jetonFichier);
51
+ if (droitsTropOuverts(statSync(fichierJeton).mode)) console.error(`⚠ ${fichierJeton} est lisible par d'autres comptes : chmod 600`);
52
+ const jeton = readFileSync(fichierJeton, 'utf8').trim();
53
+ // R1 : les clés publiques des ordres, LOCALES (clesPubliques : PEM ; clesFichiers : chemins). Sans clé, l'agent ne
54
+ // démarre pas (code 2 : le service ne s'emballe pas), sauf refus explicite « signature: false ».
55
+ const clesPubliques = [...(conf.clesPubliques || []), ...(conf.clesFichiers || []).map((p) => { try { return readFileSync(tilde(p), 'utf8'); } catch { return null; } }).filter(Boolean)];
56
+ if (!clesPubliques.length && conf.signature !== false) {
57
+ console.error('✗ aucune clé publique des ordres (clesFichiers dans la configuration) : l’agent refuse de démarrer. Posez la clé, puis relancez le service.');
58
+ process.exit(2);
59
+ }
60
+ if (conf.signature === false) console.error('⚠ signature: false — les ordres ne sont pas vérifiés sur cette machine');
61
+ const agent = creerAgent({ url: conf.url, jeton, machine: { roles: conf.roles || [], capacites: conf.capacites || [] }, registre,
62
+ racine: tilde(conf.racine || '~/cidev'), progressionS: conf.progressionS || 15, ...(conf.bailS ? { bailS: conf.bailS } : {}),
63
+ ...(clesPubliques.length ? { clesPubliques } : {}), travailJetable: conf.travailJetable !== false });
64
+ // Une attente que le canal peut écourter (réveil au feu vert).
65
+ let reveiller = null;
66
+ const pause = (s) => new Promise((ok) => { const t = setTimeout(ok, s * 1000); reveiller = () => { clearTimeout(t); ok(); }; });
67
+ let canal = null;
68
+ if (conf.canal && !args.includes('--une-fois')) {
69
+ try { canal = agent.ecouter({ ...conf.canal, reveil: () => reveiller?.() }); } catch (e) { console.error(`✗ canal : ${e.message}`); }
70
+ }
71
+ const arreter = () => { canal?.arreter(); process.exit(0); };
72
+ for (const s of signauxArret()) process.on(s, arreter);
73
+ // Lancé par le veilleur (canal IPC) : il s'arrête s'il disparaît (jamais deux agents) ou s'il le demande.
74
+ if (process.send) { process.on('disconnect', arreter); process.on('message', (m) => { if (m?.arreter) arreter(); }); }
75
+ const dire = (t) => console.log(`${new Date().toISOString()} ${t}`);
76
+ dire(`types de cette machine : ${registre.types().join(', ') || 'aucun'}`);
77
+
78
+ try {
79
+ const repris = await agent.reprendre();
80
+ for (const t of repris) dire(`↻ ${t.id} (${t.type}) : ${t.resultat.etat}`);
81
+ } catch (e) { dire(`✗ reprise : ${e.message}`); }
82
+ let echecs = 0; // attente croissante bornée quand la centrale est injoignable (jamais orphelin, jamais d'arrêt)
83
+ const base = conf.intervalleS || 30;
84
+ for (;;) {
85
+ try {
86
+ if (echecs) { const r = await agent.reprendre().catch(() => null); if (r) for (const x of r) dire(`↻ ${x.id} (${x.type}) : ${x.resultat?.etat}`); }
87
+ const t = await agent.tour();
88
+ echecs = 0;
89
+ if (t) dire(`${t.resultat.etat === 'fait' ? '✓' : '✗'} ${t.id} (${t.type}) : ${t.resultat.etat}${t.enAttente ? ' — compte rendu en attente (centrale injoignable)' : ''}`);
90
+ if (args.includes('--une-fois')) break;
91
+ if (!t) await pause(conf.intervalleS || 30);
92
+ } catch (e) {
93
+ dire(`✗ ${e.message}`);
94
+ if (args.includes('--une-fois')) process.exit(1);
95
+ echecs += 1;
96
+ await pause(Math.min(base * 4, 2 ** Math.min(echecs, 8))); // 2, 4, 8… s, au plus 4 intervalles
97
+ }
98
+ }
@@ -0,0 +1,44 @@
1
+ #!/usr/bin/env node
2
+ // delegation-cle — la clé de signature des ordres (R1), sur le POSTE du fondateur seulement.
3
+ // delegation-cle generer --prive <fichier> --publique <fichier> clé Ed25519 ; privée en 600 (dossier 700), jamais
4
+ // écrasée ni imprimée ; l'empreinte est imprimée
5
+ // delegation-cle empreinte <clé.pem> l'empreinte courte d'une clé (publique ou privée)
6
+ // delegation-cle signer --prive <fichier> < ordre.json l'ordre { id, type, entrees, echeance, nonce } lu sur
7
+ // l'entrée standard ; rend l'ordre signé (une ligne JSON)
8
+ // La clé PUBLIQUE se copie sur la centrale et sur chaque machine (installer-machine.sh --cle-publique) ; la PRIVÉE ne
9
+ // quitte jamais le poste et n'entre dans aucun dépôt.
10
+ // @author Dr Hamid MADANI <drmdh@msn.com>
11
+ import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
12
+ import { dirname, resolve } from 'node:path';
13
+ import { creerCleSignature, empreinteCle, lireClePrivee, signerOrdre } from '../src/signature.js';
14
+
15
+ const [cmd, ...args] = process.argv.slice(2);
16
+ const val = (n) => { const k = args.indexOf(n); return k >= 0 ? args[k + 1] : undefined; };
17
+ if (cmd === 'generer') {
18
+ const prive = val('--prive'); const publique = val('--publique');
19
+ if (!prive || !publique) { console.error('usage : delegation-cle generer --prive <fichier> --publique <fichier>'); process.exit(2); }
20
+ if (existsSync(prive)) { console.error(`✗ ${prive} existe déjà : une clé ne s'écrase jamais`); process.exit(1); }
21
+ const { publique: pub, privee } = creerCleSignature();
22
+ mkdirSync(dirname(resolve(prive)), { recursive: true, mode: 0o700 }); chmodSync(dirname(resolve(prive)), 0o700);
23
+ writeFileSync(prive, privee, { mode: 0o600, flag: 'wx' });
24
+ mkdirSync(dirname(resolve(publique)), { recursive: true });
25
+ writeFileSync(publique, pub, { mode: 0o644 });
26
+ console.log(`✓ clé privée : ${prive} (600 — ne la copiez nulle part)`);
27
+ console.log(`✓ clé publique : ${publique}`);
28
+ console.log(` empreinte : ${empreinteCle(pub)}`);
29
+ process.exit(0);
30
+ }
31
+ if (cmd === 'signer') {
32
+ const prive = val('--prive');
33
+ if (!prive) { console.error('usage : delegation-cle signer --prive <fichier> < ordre.json'); process.exit(2); }
34
+ let lu = ''; for await (const b of process.stdin) lu += b;
35
+ try {
36
+ const o = JSON.parse(lu);
37
+ if (!o || typeof o.id !== 'string' || typeof o.type !== 'string' || typeof o.echeance !== 'string' || !/^[0-9a-f]{32}$/.test(String(o.nonce))) throw new Error('ordre incomplet : { id, type, entrees, echeance, nonce } attendu');
38
+ console.log(JSON.stringify(signerOrdre({ id: o.id, type: o.type, entrees: o.entrees ?? {}, echeance: o.echeance, nonce: o.nonce }, lireClePrivee(prive))));
39
+ process.exit(0);
40
+ } catch (e) { console.error(`✗ ${e.message}`); process.exit(1); }
41
+ }
42
+ if (cmd === 'empreinte' && args[0]) { console.log(empreinteCle(readFileSync(args[0], 'utf8'))); process.exit(0); }
43
+ console.error('usage : delegation-cle generer --prive <f> --publique <f> | empreinte <clé.pem> | signer --prive <f> < ordre.json');
44
+ process.exit(2);
@@ -0,0 +1,17 @@
1
+ #!/usr/bin/env node
2
+ // delegation-lancer — exécute une exécution JSON (format du lanceur de cidev), comme `node lancer.mjs <execution.json>`.
3
+ // delegation-lancer <execution.json> [--reprendre]
4
+ // Sortie : $CIDEV_RACINE (défaut ~/cidev)/executions/<id>/etat.json et un journal par étape. Code 0 si tout est fait.
5
+ // @author Dr Hamid MADANI <drmdh@msn.com>
6
+ import { readFileSync } from 'node:fs';
7
+ import { resolve } from 'node:path';
8
+ import { lancerExecution } from '../src/index.js';
9
+
10
+ const args = process.argv.slice(2);
11
+ const fichier = args.find((a) => !a.startsWith('--'));
12
+ if (!fichier) { console.error('usage : delegation-lancer <execution.json> [--reprendre]'); process.exit(2); }
13
+ try {
14
+ const etat = await lancerExecution(JSON.parse(readFileSync(resolve(fichier), 'utf8')), { reprendre: args.includes('--reprendre') });
15
+ for (const e of etat.etapes) console.log(`${e.etat === 'fait' ? '✓' : e.etat === 'saute' ? '·' : '✗'} ${e.code} (${e.etat}${e.sortie != null ? `, code ${e.sortie}` : ''})`);
16
+ process.exit(etat.etat === 'fait' ? 0 : 1);
17
+ } catch (e) { console.error(`✗ ${e.code || 'E'} : ${e.message}`); process.exit(2); }