@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 +224 -0
- package/LICENSE +15 -0
- package/README.md +226 -2
- package/bin/delegation-agent.mjs +98 -0
- package/bin/delegation-cle.mjs +44 -0
- package/bin/delegation-lancer.mjs +17 -0
- package/bin/delegation-service.mjs +38 -0
- package/bin/delegation-train.mjs +16 -0
- package/bin/delegation-veilleur.mjs +24 -0
- package/bin/installer-machine-macos.sh +270 -0
- package/bin/installer-machine.ps1 +330 -0
- package/bin/installer-machine.sh +266 -0
- package/llms.txt +68 -0
- package/package.json +51 -4
- package/src/agent.js +334 -0
- package/src/api.js +368 -0
- package/src/bornes.js +72 -0
- package/src/file.js +175 -0
- package/src/index.js +17 -0
- package/src/lanceur.js +164 -0
- package/src/parc.js +282 -0
- package/src/plateforme.js +134 -0
- package/src/services.js +154 -0
- package/src/signature.js +116 -0
- package/src/stockage.js +30 -0
- package/src/train.js +370 -0
- package/src/types.js +98 -0
- package/src/veilleur.js +80 -0
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
|
-
#
|
|
1
|
+
# @mostajs/delegation
|
|
2
2
|
|
|
3
|
-
|
|
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); }
|