@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/llms.txt
ADDED
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
# @mostajs/delegation 0.9.0
|
|
2
|
+
> Déléguer des tâches typées à des machines, sous feu vert. Auteur : Dr Hamid MADANI <drmdh@msn.com>. AGPL-3.0-or-later. ESM, Node >= 20.
|
|
3
|
+
|
|
4
|
+
RÈGLE CENTRALE : les commandes vivent chez l'agent. La centrale ne connaît que des déclarations ; elle envoie { type, entrees } ; l'agent revalide avec son registre et fabrique ses étapes.
|
|
5
|
+
|
|
6
|
+
EXPORTS
|
|
7
|
+
- creerRegistre({ declarations?: false }) → { declarations, enregistrer(def), types(), type(nom), declaration(nom) (sans étapes), valider(nom, entrees) → string[] }. def = { type (/^[a-z][a-z0-9-]{1,40}$/), version, capacites: string[], entrees?: { champ: { requis?, motif? } }, etapes: (entrees) => [{ code, titre?, commande, cwd?, analyse?: 'suite'|'films', continuer? }], livrables?, dureeMinutes? }. declarations:true → etapes INTERDIT (E_TYPE) ; sinon etapes requis. E_TYPE, E_TYPE_DOUBLE.
|
|
8
|
+
- manquesPour(machine { capacites }, def) → capacités manquantes.
|
|
9
|
+
- creerFile({ registre, stockage, maintenant? }) → proposer({ type, entrees, par, titre? }) (E_ENTREES), feuVert(id, on, { par }) (E_COMMENCEE), affecter(id, machine, { par }) (E_FEU_VERT, E_CAPACITE), tirer(machine { id, capacites, types? }) → tâche|null (types : filtre), demarrer, progression(id, { progression }) (en_cours seulement, E_TRANSITION), terminer(id, { par, ok, resultat }), annuler, tache, taches({ etat? }), enCoursDe(machineId), journal(id), execution(id) → { id, titre, etapes } (E_ETAPES sur un registre de centrale).
|
|
10
|
+
- ETATS = proposee, affectee, en_cours, faite, echec, annulee. Feu vert OFF à la naissance. Tâche : { id, type, titre, entrees, etat, feuVert, machine, cree, maj, par, resultat, progression?, progressionMaj? }.
|
|
11
|
+
- creerStockageMemoire(), creerStockageFichier(chemin) — FORMAT_FILE 'mostajs-delegation-file/1'.
|
|
12
|
+
- lancerExecution(def { id, titre?, attendu?, env?, etapes }, { racine?, reprendre?, env?, surEtat?(etat, { finEtape }) }) → état ; <racine>/executions/<id>/etat.json + <code>.log. Bin delegation-lancer <execution.json> [--reprendre].
|
|
13
|
+
- creerApiAgents({ file, machines?: [{ id, jeton: empreinte }], machinesFichier?, maintenant?, absenceMs? }) → handler (req, res) ; .machines() → [{ id, roles, capacites, types, telemetrie, vu, tache, etat: libre|occupee|absente }] ; .declarer(liste) (à chaud). Routes POST /api/agent/ : annonce { capacites, roles, types, telemetrie }, tirer → 200 { tache: { id, type, titre, entrees, etat } } | 204, miennes → { taches: [{ tache }] }, taches/<id>/demarrer, taches/<id>/progression { progression } (≤ 32 Ko), taches/<id>/rendre { ok, resultat } (resultat.finJournal tronqué à 8 Ko). 401 jeton, 403 autre machine, 404, 409 transition, 413, 400.
|
|
14
|
+
- creerAgent({ url, jeton, machine: { roles?, capacites }, registre (requis, avec étapes), racine?, progressionS=15, lancer?, fetch? }) → { annoncer(), livrer() → n, tour() → tâche rendue { ...tache, resultat, enAttente? } | null, reprendre() }. Bin delegation-agent --config agent.mjs [--une-fois].
|
|
15
|
+
- releverTelemetrie(racine) ; VERSION_AGENT ; bornerJson(v, { chaine=300, liste=50, cles=40, profondeur=6 }) ; bornerTelemetrie(t) ; finDeJournal(texte, octets=8192) ; FIN_JOURNAL_OCTETS.
|
|
16
|
+
- empreinteJeton(jeton) → sha256 hex.
|
|
17
|
+
|
|
18
|
+
- creerTypeTrain({ fichier: train.json, type='train', capacites=['node@20','git','ssh','conducteur'], siInterrompue='arreter' }) → définition de type (agent). train.json : { travail (absolu), applications: { <nom>: { source, depot (clone de travail), cible='main', attenteS=30, delaiMaxMin=600, demarrageMaxS=120, executant: { hote ('local'|ssh), racine, lanceur }, suite: { etapes (gabarits : {racine} {paquet} {branche} {version} {application} {id} {suite}), rapport }, rougesConnus: [], tournage?: { etapes, captures? }, films?: { distant, index, local, indexDepot }, integration?: { autorisee, auteur: { nom, email }, d4q?: { commande, cwd }, push?: { distant } } } } }. Phases : paquet, envoi, suite, resultats, tournage, rapatriement [, index, fusion, d4q, push]. Bin delegation-train <phase> --config --application --branche --version (0 fait, 1 arrêt + rapport.json, 2 usage). phaseTrain, validerConfigTrain, lireConfigTrain, phasesDe.
|
|
19
|
+
|
|
20
|
+
- creerParc({ fichier?, maintenant?, dureeEnrolementMin=30 }) → { annoncer({ nom, roles, capacites, par }) → { machine, jetonEnrolement } (une fois), enroler(jetonEnrolement, { detecte }) → { id, jeton } (E_ENROLEMENT), accepter|refuser|suspendre|reprendre|retirer(id, { par }) (E_TRANSITION, E_INCONNUE), revoquer(id) → { jetonEnrolement }, renommer(id, nom), identifier(jeton) → machine|null, machines(), machine(id), journal(id?) }. ETATS_MACHINE : annoncee, en_attente, acceptee, suspendue, refusee, retiree. FORMAT_PARC 'mostajs-delegation-parc/1'.
|
|
21
|
+
- creerApiAgents({ parc }) : POST /api/agent/enroler { jeton, detecte } → { machine, jeton } | 401 ; en_attente : annonce seule (403) ; suspendue : tirer 403.
|
|
22
|
+
- detecterCapacites({ racine? }) → { capacites, cpus, memoireMo, disqueMo, systeme, hote } ; enrolerMachine({ url, jetonEnrolement, fichierJeton }) → { id, capacites }. Bin : delegation-agent --enroler --url U --jeton-fichier F (jeton sur stdin).
|
|
23
|
+
|
|
24
|
+
0.6.0
|
|
25
|
+
- parc.demander({ origine? }) → { code, expire } (15 min, usage unique, empreinte ; E_TROP au-delà de demandesMax / attenteMax) ; parc.enroler(code, { nom, roles, detecte }) ; origine 'inscription'|'annonce'. parc.reglageCentrale() / reglerCentrale({ executer, types, concurrence 1..8 }, { par }) (train → E_INTERDIT, E_REGLAGE) ; parc.noterMarche(id, 'hors-ligne'|'en-ligne').
|
|
26
|
+
- creerApiAgents({ ..., centrale: { jeton: empreinte }, canal: true|{...}, battementS=30, battementsManques=3, repriseApresS=900 }) → + distribuer(tache|id) → ids réveillés, demander(id, evenement, donnees, { delaiMs }), verifier() → { horsLigne, enLigne, reprises }, surveiller({ periodeS }) → arrêt, presence(), fermer(). Routes : taches/<id>/interrompue { motif } → { decision, tache } ; taches/<id>/battement (409 hors en_cours, 403 autre machine) ; rendre { interrompue: true }. CENTRALE_ID = 'centrale'.
|
|
27
|
+
- creerFile({ siInterrompue='remettre', interruptionsMax=3 }) → interrompre(id, { par, motif, politique? }) → { decision: remettre|arreter|reprendre, tache }. Type : siInterrompue.
|
|
28
|
+
- creerAgent({ ..., bailS=300 }) → + racine, ecouter({ mode, reveil?, reconnexionMinS?, reconnexionMaxS? }) → canal { etat(), arreter() } ; reprendre() déclare « interrompue » les tâches en_cours (résultat .interrompue = décision) ; tour() rend resultat.etat 'abandonnee' (reprise ailleurs) ou 'interrompue' (bail).
|
|
29
|
+
- creerAgentCentrale({ url, jeton, registre, reglage, capacites?, racine?, lancer? }) → { tick() → { actif, faites }, actif(), demarrer({ periodeS }) }.
|
|
30
|
+
- Bin installer-machine.sh --centrale U [--nom --roles --paquet --conducteur --a-la-demande --sans-service --service utilisateur|systeme --essai --verifier] ; code sur stdin, --code refusé (2).
|
|
31
|
+
|
|
32
|
+
0.7.0 (durcissement)
|
|
33
|
+
- R1 signature.js : creerCleSignature() → { publique, privee } (PEM) ; empreinteCle(pem) 'xxxx-xxxx-xxxx-xxxx' ; nouvelOrdre(tache, { dureeH=24 }) → { id, type, entrees, echeance, nonce } ; signerOrdre(o, privee) → { echeance, nonce, cle, signature } ; verifierOrdre(tache, ordre, cles, { maintenant, toleranceMs=5 min }) → { ok, motif } (non signé | clé inconnue | signature invalide | expiré) ; lireClePrivee(chemin) (E_CLE si mode & 077) ; canonique(v). creerFile({ clesPubliques }) → feuVert(id, true, { par, ordre }) (E_SIGNATURE), ordreASigner(id, { dureeH }) ; tache.ordre ; tirer renvoie tache.ordre. creerAgent({ clesPubliques }) refuse (motif « ordre refusé : … », rien exécuté) ; rejeu : <racine>/delegation/ordres-vus.json. Bin delegation-cle generer --prive --publique | empreinte <pem> | signer --prive <f> (ordre JSON sur stdin → ordre signé, une ligne).
|
|
34
|
+
- R2 parc : accepter(id, { par, empreinte?, capacites?, roles? }) fige capacitesAcceptees/rolesAcceptes (rien de connu → figées à la 1re annonce) ; noterAnnonce(id, { capacites, roles }) → { capacites, roles, refusees } ; accepterCapacites(id, { par, capacites=true, roles=true }) ; refuserCapacites(id) ; vue : capacitesEnAttente, rolesEnAttente, annonce. API annonce → { machine, refusees: { capacites, roles } }.
|
|
35
|
+
- R3 : empreinteMachine(empreinteJetonHex) 'XXXX-XXXX-XXXX' ; enrolerMachine → { id, capacites, empreinte } ; parc vue.empreinte ; creerParc({ exigerEmpreinte }) → E_EMPREINTE.
|
|
36
|
+
- R4 : type { demarrageMaxS, dureeMaxMin, silenceMaxS } (DELAIS) ; creerApiAgents({ demarrageMaxS=900, silenceMaxS=600, muetteJours=30 }) ; verifier() → + enSommeil ; parc.noterVu, parc.mettreEnSommeil ; vue.vu.
|
|
37
|
+
- R5 : lancerExecution(def, { travail: true }) → etat.travail (effacé) ; creerAgent({ travailJetable=true, uid, autoriserRoot=false }) (E_ROOT). installer : --compte <nom>, --cle-publique <pem>, DELEGATION_UID.
|
|
38
|
+
- R6 : creerApiAgents({ exigerHttps, mandataireDeConfiance(adresse) = boucle locale }) → 426 ; creerAgent refuse http hors boucle locale (E_HTTPS ; autoriserHttp).
|
|
39
|
+
|
|
40
|
+
0.8.0 (train)
|
|
41
|
+
- T1 rougesConnus: [{ essai, motif (≥ 3), echeance (date), depuis?, renvoi? }] (liste nue → E_CONFIG) ; échéance dépassée → arrêt à resultats (rapport.echus [{ ..., encoreRouge }]) ; etat-train.resultats = { essais, rougesConnus: [...], devenusVerts, instables }.
|
|
42
|
+
- T2 films.signature: { clePrivee } → <films.local>/<index>.attestation.json { format 'mostajs-delegation-attestation/1', application, version, branche, tete, index { fichier, sha256 }, films { film: { cle: sha256 } }, quand, cle, signature } ; commitée avec l'index (<indexDepot>.attestation.json). signerAttestation(sujet, privee), verifierAttestation(att, cles, { index: chemin }) → { ok, motif }.
|
|
43
|
+
- T3 paquet note st.cible ; fusion : fetch, si <distant>/<cible> ≠ st.cible et non ancêtre de la branche → arrêt { message « … a bougé … git rebase … », cibleAvant, cibleMaintenant }.
|
|
44
|
+
- T4 suite.reessai: { etapes (gabarit, {essais} = ids cités), rapport } : une exécution distante « reessai », une seule (etat-train.reessai) ; passes → instables.
|
|
45
|
+
|
|
46
|
+
0.9.0 (Windows et macOS)
|
|
47
|
+
- plateforme.js : cheminsAgent({ plateforme, env, home }) → { donnees, journaux, agent, jeton, configuration, clePublique } (Linux ~/.delegation ; macOS ~/Library/Application Support/mostajs/delegation, journaux ~/Library/Logs/mostajs-delegation ; Windows %LOCALAPPDATA%\mostajs\delegation) ; etendreTilde ; signauxArret(p) (+ SIGBREAK win32) ; estAdministrateur({ plateforme, uid, executer }) (win32 : net session) ; commandeArretArbre(pid, p) (taskkill /T /F) ; trouverProgramme(nom, { plateforme, env, existe }) (PATHEXT) ; trouverBash (Git for Windows, jamais System32) ; trouverChrome ; droitsTropOuverts(mode, p) (win32 : faux) ; restreindreAcces(f, { plateforme, utilisateur, dossier }) (600/700 ou icacls).
|
|
48
|
+
- services.js : plistLaunchd({ mode utilisateur|systeme, node, agent, configuration, journaux, donnees, home, compte }) (RunAtLoad, KeepAlive { SuccessfulExit: false }, ThrottleInterval 30 ; systeme : UserName, jamais root) ; cheminPlist ; tacheWindows({ mode, utilisateur, node, veilleur, configuration, journal, donnees }) (systeme : BootTrigger + S4U ; utilisateur : LogonTrigger + InteractiveToken ; Repetition PT5M, IgnoreNew, RestartOnFailure PT1M, PT0S, LeastPrivilege) ; ecrireConfigurationAgent (wx, 600, import file://) ; LABEL_LAUNCHD, TACHE_WINDOWS.
|
|
49
|
+
- veilleur.js : veiller({ programme, arguments, journal, delaiS=5, delaiMaxS=60, codeArret=2 }) → { fini, arreter } ; tournerJournal(f, 5 Mo). Bin delegation-veilleur --config <agent.mjs> [--journal f] [--delai s] | -- <programme> [args].
|
|
50
|
+
- Bin delegation-service plist | tache-windows | configuration | chemins.
|
|
51
|
+
- Étape { code, programme, arguments } : spawn sans shell ; { code, commande } : bash (E_ETAPES si ni l'un ni l'autre). creerAgent({ plateforme, administrateur }) → E_ADMIN (win32 élevé) ; win32 : type avec étape « commande » sans capacité 'bash' refusé. agent.executerTache(t).
|
|
52
|
+
- Bin installer-machine-macos.sh [mêmes options que Linux] --a-blanc|--imprimer --desinstaller [--purger] ; DELEGATION_UNAME, DELEGATION_LAUNCHCTL, DELEGATION_UID.
|
|
53
|
+
- Bin installer-machine.ps1 (Windows, PowerShell 5.1/7) [mêmes options] --a-blanc|--imprimer --desinstaller [--purger].
|
|
54
|
+
|
|
55
|
+
PIÈGES
|
|
56
|
+
- launchd ne sait pas « ne pas relancer sur le code 2 » : sans clé publique, l'agent macOS est relancé toutes les 30 s (son journal le dit). Sous Windows, le veilleur s'arrête sur le code 2 et la tâche le relance toutes les 5 min.
|
|
57
|
+
- LaunchAgent : seulement session ouverte (et jamais par SSH : « Could not find domain ») ; au boot sans session : --service systeme (LaunchDaemon).
|
|
58
|
+
- Windows : une tâche au démarrage (BootTrigger) ne s'enregistre qu'en administrateur ; le script l'imprime, ne s'élève jamais. S4U : pas d'accès aux partages réseau authentifiés.
|
|
59
|
+
- installer-machine.ps1 doit rester en UTF-8 avec BOM et sans guillemets typographiques (PowerShell 5.1).
|
|
60
|
+
- Train : commande contenant d4pf/deploy → E_INTERDIT ; jamais de D4PF. État entre phases : <travail>/trains/<app>-<version>/etat-train.json ; rapport court : rapport.json.
|
|
61
|
+
- 0.3.0 incompatible avec un agent 0.2.x : tirer ne renvoie plus `execution`. Mettre à jour la centrale et les agents ensemble.
|
|
62
|
+
- Une machine qui n'annonce pas `types` (agent < 0.3.0) n'est pas filtrée par type.
|
|
63
|
+
- Résultat refusé par la machine : etat 'echec', motif « refusé par la machine : … », rien n'est exécuté.
|
|
64
|
+
- Comptes rendus en attente : <racine>/delegation/comptes-rendus.json ; un 4xx à la livraison les abandonne (tâche annulée…), une liaison coupée les garde.
|
|
65
|
+
- La progression n'arrête jamais l'exécution (erreurs ignorées).
|
|
66
|
+
- Jamais délégués : déploiement en production (D4PF, D4PFQ).
|
|
67
|
+
- delegation-agent sans clé publique → code 2 (le service ne redémarre pas : RestartPreventExitStatus=2) ; « signature: false » le dit explicitement.
|
|
68
|
+
- Une tâche remise en file après l'échéance de son ordre est refusée par l'agent : il faut un nouveau feu vert signé.
|
package/package.json
CHANGED
|
@@ -1,6 +1,53 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@mostajs/delegation",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.9.0",
|
|
4
|
+
"description": "Déléguer des tâches typées à des machines, sous feu vert : registre des types de tâches (comme des dialectes), file à états journalisée (@mostajs/statemachine), machines et capacités, exécutant d'étapes avec journaux et reprise ; agent par machine qui tire ses tâches (HTTP, un jeton par machine, la console n'en garde que l'empreinte). Une tâche ne porte jamais de commande : un type et des entrées validées. Agents Linux (systemd), macOS (launchd) et Windows (tâche planifiée et veilleur).",
|
|
5
|
+
"author": "Dr Hamid MADANI <drmdh@msn.com>",
|
|
6
|
+
"license": "AGPL-3.0-or-later",
|
|
7
|
+
"type": "module",
|
|
8
|
+
"main": "src/index.js",
|
|
9
|
+
"exports": {
|
|
10
|
+
".": "./src/index.js"
|
|
11
|
+
},
|
|
12
|
+
"bin": {
|
|
13
|
+
"delegation-lancer": "bin/delegation-lancer.mjs",
|
|
14
|
+
"delegation-agent": "bin/delegation-agent.mjs",
|
|
15
|
+
"delegation-train": "bin/delegation-train.mjs",
|
|
16
|
+
"delegation-cle": "bin/delegation-cle.mjs",
|
|
17
|
+
"delegation-veilleur": "bin/delegation-veilleur.mjs",
|
|
18
|
+
"delegation-service": "bin/delegation-service.mjs"
|
|
19
|
+
},
|
|
20
|
+
"files": [
|
|
21
|
+
"src",
|
|
22
|
+
"bin",
|
|
23
|
+
"README.md",
|
|
24
|
+
"llms.txt",
|
|
25
|
+
"CHANGELOG.md",
|
|
26
|
+
"LICENSE"
|
|
27
|
+
],
|
|
28
|
+
"engines": {
|
|
29
|
+
"node": ">=20"
|
|
30
|
+
},
|
|
31
|
+
"scripts": {
|
|
32
|
+
"test": "mjs-unit test-scripts/unit/delegation.test.mjs && mjs-unit test-scripts/unit/agent.test.mjs && mjs-unit test-scripts/unit/centrale.test.mjs && mjs-unit test-scripts/unit/train.test.mjs && mjs-unit test-scripts/unit/parc.test.mjs && mjs-unit test-scripts/unit/inscription.test.mjs && mjs-unit test-scripts/unit/orphelin.test.mjs && mjs-unit test-scripts/unit/installer.test.mjs && mjs-unit test-scripts/unit/durcissement.test.mjs && mjs-unit test-scripts/unit/train-t.test.mjs && mjs-unit test-scripts/unit/plateformes.test.mjs && mjs-unit test-scripts/unit/services.test.mjs && mjs-unit test-scripts/unit/installer-macos.test.mjs && mjs-unit test-scripts/unit/installer-windows.test.mjs"
|
|
33
|
+
},
|
|
34
|
+
"keywords": [
|
|
35
|
+
"delegation",
|
|
36
|
+
"task-queue",
|
|
37
|
+
"agent",
|
|
38
|
+
"machines",
|
|
39
|
+
"capabilities",
|
|
40
|
+
"green-light",
|
|
41
|
+
"mostajs",
|
|
42
|
+
"windows",
|
|
43
|
+
"macos",
|
|
44
|
+
"launchd"
|
|
45
|
+
],
|
|
46
|
+
"dependencies": {
|
|
47
|
+
"@mostajs/canal-network": "^0.1.1",
|
|
48
|
+
"@mostajs/statemachine": "^0.0.1"
|
|
49
|
+
},
|
|
50
|
+
"devDependencies": {
|
|
51
|
+
"@mostajs/mjs-unit": "^0.16.1"
|
|
52
|
+
}
|
|
53
|
+
}
|
package/src/agent.js
ADDED
|
@@ -0,0 +1,334 @@
|
|
|
1
|
+
// @mostajs/delegation — l'agent d'une machine (lots L2, C1) : il s'annonce, tire une tâche qu'il sait faire, l'exécute
|
|
2
|
+
// avec l'exécutant de cidev et rend le résultat. Il reprend, au redémarrage, les tâches qu'il avait commencées.
|
|
3
|
+
//
|
|
4
|
+
// 0.3.0 (plan 02, §8.2-1) : les types et leurs COMMANDES vivent ici, dans le registre de l'agent. La centrale n'envoie que
|
|
5
|
+
// `{ type, entrees }` ; l'agent revalide les entrées avec SON schéma et fabrique lui-même ses étapes. Une centrale
|
|
6
|
+
// compromise ne peut que demander un type que la machine accepte déjà, avec des entrées qu'elle revalide.
|
|
7
|
+
// Il rend compte pendant l'exécution (progression, N1), s'annonce avec sa télémétrie (N2), joint la fin du journal sur
|
|
8
|
+
// échec (N3), et garde ses comptes rendus sur disque quand la centrale est injoignable (§8.2-2).
|
|
9
|
+
// Le jeton ne quitte la machine que dans l'en-tête Authorization ; il n'est jamais écrit dans un journal.
|
|
10
|
+
// @author Dr Hamid MADANI <drmdh@msn.com>
|
|
11
|
+
import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync, statSync, openSync, readSync, closeSync, statfsSync } from 'node:fs';
|
|
12
|
+
import { join, dirname } from 'node:path';
|
|
13
|
+
import { homedir, hostname, loadavg, cpus, totalmem, freemem } from 'node:os';
|
|
14
|
+
import { lancerExecution } from './lanceur.js';
|
|
15
|
+
import { finDeJournal } from './bornes.js';
|
|
16
|
+
import { creerCanal } from '@mostajs/canal-network';
|
|
17
|
+
import { verifierOrdre } from './signature.js';
|
|
18
|
+
import { empreinteJeton } from './api.js';
|
|
19
|
+
import { empreinteMachine } from './parc.js';
|
|
20
|
+
import { estAdministrateur, trouverProgramme, trouverBash, trouverChrome, restreindreAcces } from './plateforme.js';
|
|
21
|
+
|
|
22
|
+
const erreur = (code, message, plus = {}) => Object.assign(new Error(message), { code, ...plus });
|
|
23
|
+
export const VERSION_AGENT = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
|
|
24
|
+
const MO = 1024 * 1024;
|
|
25
|
+
|
|
26
|
+
/** La télémétrie de la machine (N2) : ce qu'elle dit d'elle-même à chaque annonce. */
|
|
27
|
+
export function releverTelemetrie(racine = homedir()) {
|
|
28
|
+
let disque = { totalMo: null, libreMo: null };
|
|
29
|
+
try { const s = statfsSync(existsSync(racine) ? racine : homedir()); disque = { totalMo: Math.round((s.blocks * s.bsize) / MO), libreMo: Math.round((s.bavail * s.bsize) / MO) }; } catch { /* inconnu */ }
|
|
30
|
+
return {
|
|
31
|
+
hote: hostname().replace(/[^A-Za-z0-9._-]/g, '-').slice(0, 64), charge: Math.round(loadavg()[0] * 100) / 100, cpus: cpus().length,
|
|
32
|
+
memoire: { totaleMo: Math.round(totalmem() / MO), libreMo: Math.round(freemem() / MO) }, disque,
|
|
33
|
+
version: VERSION_AGENT, node: process.versions.node, plateforme: `${process.platform}-${process.arch}`,
|
|
34
|
+
};
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/** La fin (≤ 8 Ko) du journal d'une étape, lue sans charger le fichier entier. */
|
|
38
|
+
function queueDuJournal(chemin) {
|
|
39
|
+
try {
|
|
40
|
+
const n = statSync(chemin).size; const deb = Math.max(0, n - 32 * 1024); const b = Buffer.alloc(n - deb);
|
|
41
|
+
const fd = openSync(chemin, 'r'); readSync(fd, b, 0, b.length, deb); closeSync(fd);
|
|
42
|
+
return finDeJournal(b.toString('utf8'));
|
|
43
|
+
} catch { return null; }
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
/**
|
|
47
|
+
* @param {{ url: string, jeton: string, machine: { roles?: string[], capacites: string[] },
|
|
48
|
+
* registre: ReturnType<import('./types.js').creerRegistre>, racine?: string, progressionS?: number, bailS?: number,
|
|
49
|
+
* lancer?: typeof lancerExecution, fetch?: typeof fetch }} o
|
|
50
|
+
* registre : les types que CETTE machine sait faire, avec leurs étapes (jamais un registre de centrale).
|
|
51
|
+
* bailS (0.6.0, « jamais orphelin ») : sans contact avec la centrale depuis ce délai pendant une exécution, l'agent
|
|
52
|
+
* l'arrête et garde un compte rendu « interrompue », livré au retour. Un battement part toutes les `progressionS`.
|
|
53
|
+
* clesPubliques (0.7.0, R1) : les clés publiques des ordres (PEM), LOCALES à la machine ; avec elles, toute tâche dont
|
|
54
|
+
* l'ordre est absent, d'une clé inconnue, retouché, expiré ou rejoué est refusée sans rien exécuter.
|
|
55
|
+
* travailJetable (R5, vrai par défaut) : un dossier de travail neuf par tâche, effacé à la fin. Jamais root (E_ROOT).
|
|
56
|
+
* R6 : http seulement vers la machine elle-même (un mandataire local) ; ailleurs HTTPS (E_HTTPS).
|
|
57
|
+
* 0.9.0 (R9) : `plateforme` (défaut : celle du processus). Sous Windows, jamais en session ÉLEVÉE (E_ADMIN,
|
|
58
|
+
* `administrateur` calculé par `net session`) ; un type dont une étape passe par bash (« commande ») doit déclarer
|
|
59
|
+
* la capacité « bash », sinon la machine le refuse sans rien exécuter.
|
|
60
|
+
*/
|
|
61
|
+
export function creerAgent({ url, jeton, machine, registre, racine = process.env.CIDEV_RACINE || join(homedir(), 'cidev'), progressionS = 15, bailS = 300,
|
|
62
|
+
lancer = lancerExecution, fetch: f = globalThis.fetch, clesPubliques = null, travailJetable = true, uid = process.getuid?.(), autoriserRoot = false, autoriserHttp = false, plateforme = process.platform, administrateur = null }) {
|
|
63
|
+
if (!url || !jeton || !machine?.capacites) throw erreur('E_OPTION', 'creerAgent : url, jeton et machine.capacites requis');
|
|
64
|
+
if (uid === 0 && !autoriserRoot) throw erreur('E_ROOT', 'l’agent ne tourne jamais en root : un compte dédié sans privilège');
|
|
65
|
+
if (plateforme === 'win32' && !autoriserRoot && (administrateur ?? estAdministrateur({ plateforme }))) {
|
|
66
|
+
throw erreur('E_ADMIN', 'l’agent ne tourne jamais en administrateur (session élevée) : un compte dédié sans privilège');
|
|
67
|
+
}
|
|
68
|
+
let adresse; try { adresse = new URL(url); } catch { throw erreur('E_OPTION', `adresse de centrale illisible : ${url}`); }
|
|
69
|
+
if (adresse.protocol === 'http:' && !autoriserHttp && !/^(127\.\d+\.\d+\.\d+|localhost|\[::1\])$/.test(adresse.hostname)) {
|
|
70
|
+
throw erreur('E_HTTPS', `la centrale se joint en HTTPS (port 443) : ${adresse.origin}`);
|
|
71
|
+
}
|
|
72
|
+
const verifier = Array.isArray(clesPubliques) && clesPubliques.length > 0;
|
|
73
|
+
if (!registre || registre.declarations || typeof registre.valider !== 'function') throw erreur('E_OPTION', 'creerAgent : le registre de la machine (avec ses étapes) est requis');
|
|
74
|
+
const base = url.replace(/\/+$/, '');
|
|
75
|
+
const fichierCR = join(racine, 'delegation', 'comptes-rendus.json');
|
|
76
|
+
// R1 : les ordres déjà vus (nonce → tâche, fini ?), pour refuser un rejeu ; purgés après leur échéance.
|
|
77
|
+
const fichierOrdres = join(racine, 'delegation', 'ordres-vus.json');
|
|
78
|
+
const lireOrdres = () => { try { return JSON.parse(readFileSync(fichierOrdres, 'utf8')); } catch { return {}; } };
|
|
79
|
+
const ecrireOrdres = (o) => {
|
|
80
|
+
const t = Date.now(); for (const [k, v] of Object.entries(o)) if (Date.parse(v.echeance) + 86400_000 < t) delete o[k];
|
|
81
|
+
mkdirSync(join(racine, 'delegation'), { recursive: true }); writeFileSync(`${fichierOrdres}.tmp`, JSON.stringify(o)); renameSync(`${fichierOrdres}.tmp`, fichierOrdres);
|
|
82
|
+
};
|
|
83
|
+
/** Rend le motif de refus de l'ordre d'une tâche, ou null s'il est bon (et le note comme vu). */
|
|
84
|
+
const controlerOrdre = (tache, { reprendre }) => {
|
|
85
|
+
if (!verifier) return null;
|
|
86
|
+
const vus = lireOrdres(); const deja = tache.ordre?.nonce ? vus[tache.ordre.nonce] : null;
|
|
87
|
+
// Une tâche commencée sous un ordre valide se reprend, même après l'échéance.
|
|
88
|
+
if (deja && deja.tache === tache.id && !deja.fini && (reprendre || tache.etat === 'en_cours')) return null;
|
|
89
|
+
const v = verifierOrdre(tache, tache.ordre, clesPubliques);
|
|
90
|
+
if (!v.ok) return v.motif;
|
|
91
|
+
if (deja && (deja.tache !== tache.id || deja.fini)) return 'ordre rejoué (déjà exécuté)';
|
|
92
|
+
vus[tache.ordre.nonce] = { tache: tache.id, fini: false, echeance: tache.ordre.echeance }; ecrireOrdres(vus);
|
|
93
|
+
return null;
|
|
94
|
+
};
|
|
95
|
+
const ordreFini = (tache) => {
|
|
96
|
+
if (!verifier || !tache.ordre?.nonce) return;
|
|
97
|
+
const vus = lireOrdres(); if (vus[tache.ordre.nonce]) { vus[tache.ordre.nonce].fini = true; ecrireOrdres(vus); }
|
|
98
|
+
};
|
|
99
|
+
let courante = null; // l'identifiant de la tâche en cours d'exécution (réponse « etat » du canal)
|
|
100
|
+
|
|
101
|
+
const appel = async (chemin, corps = {}) => {
|
|
102
|
+
let r;
|
|
103
|
+
try {
|
|
104
|
+
r = await f(`${base}/api/agent/${chemin}`, { method: 'POST',
|
|
105
|
+
headers: { 'content-type': 'application/json', authorization: `Bearer ${jeton}` }, body: JSON.stringify(corps) });
|
|
106
|
+
} catch (e) { throw erreur('E_LIAISON', `${chemin} : centrale injoignable (${e.cause?.code || e.message})`); }
|
|
107
|
+
if (r.status === 204) return null;
|
|
108
|
+
const d = await r.json().catch(() => ({}));
|
|
109
|
+
if (r.status >= 500) throw erreur('E_LIAISON', `${chemin} : ${r.status} ${d.erreur || ''}`.trim(), { statut: r.status });
|
|
110
|
+
if (!r.ok) throw erreur('E_CONSOLE', `${chemin} : ${r.status} ${d.erreur || ''}`.trim(), { statut: r.status });
|
|
111
|
+
return d;
|
|
112
|
+
};
|
|
113
|
+
|
|
114
|
+
// ── Les comptes rendus en attente (§8.2-2) : écrits sur disque, livrés dans l'ordre au retour de la liaison ──
|
|
115
|
+
const lireCR = () => { try { return JSON.parse(readFileSync(fichierCR, 'utf8')); } catch { return []; } };
|
|
116
|
+
const ecrireCR = (l) => { mkdirSync(join(racine, 'delegation'), { recursive: true }); writeFileSync(`${fichierCR}.tmp`, JSON.stringify(l)); renameSync(`${fichierCR}.tmp`, fichierCR); };
|
|
117
|
+
const corpsCR = (x) => ({ ok: x.ok, resultat: x.resultat, ...(x.interrompue ? { interrompue: true, motif: x.resultat?.motif } : {}) });
|
|
118
|
+
const livrer = async () => {
|
|
119
|
+
const l = lireCR();
|
|
120
|
+
let n = 0;
|
|
121
|
+
while (l.length) {
|
|
122
|
+
try { await appel(`taches/${l[0].tache}/rendre`, corpsCR(l[0])); } catch (e) {
|
|
123
|
+
if (e.code === 'E_LIAISON') break; // toujours injoignable : on garde, on réessaiera
|
|
124
|
+
// 4xx : la centrale a lu et refusé (tâche annulée, déjà rendue…) ; inutile d'insister.
|
|
125
|
+
}
|
|
126
|
+
l.shift(); n += 1; ecrireCR(l);
|
|
127
|
+
}
|
|
128
|
+
return n;
|
|
129
|
+
};
|
|
130
|
+
const rendre = async (id, ok, resultat, { interrompue = false } = {}) => {
|
|
131
|
+
const x = { tache: id, ok, resultat, ...(interrompue ? { interrompue: true } : {}) };
|
|
132
|
+
try { await appel(`taches/${id}/rendre`, corpsCR(x)); return false; } catch (e) {
|
|
133
|
+
if (e.code !== 'E_LIAISON') throw e;
|
|
134
|
+
ecrireCR([...lireCR(), x]);
|
|
135
|
+
return true;
|
|
136
|
+
}
|
|
137
|
+
};
|
|
138
|
+
|
|
139
|
+
/** Exécute une tâche tirée et rend son résultat (les journaux restent sur la machine ; un résumé remonte). */
|
|
140
|
+
const executer = async (tache, { reprendre = false } = {}) => {
|
|
141
|
+
const def = registre.type(tache.type);
|
|
142
|
+
const refusOrdre = controlerOrdre(tache, { reprendre });
|
|
143
|
+
let refus = refusOrdre ? [`ordre refusé : ${refusOrdre}`]
|
|
144
|
+
: !def ? [`type « ${tache.type} » inconnu de cette machine`] : registre.valider(tache.type, tache.entrees ?? {});
|
|
145
|
+
let lesEtapes = null;
|
|
146
|
+
if (!refus.length) {
|
|
147
|
+
try { lesEtapes = def.etapes(structuredClone(tache.entrees ?? {})); } catch (e) { refus = [`étapes : ${e.message}`]; }
|
|
148
|
+
// R9 : sous Windows, bash n'est pas un acquis — le type qui s'en sert le déclare.
|
|
149
|
+
if (lesEtapes && plateforme === 'win32' && lesEtapes.some((x) => x?.programme == null) && !(def.capacites || []).includes('bash')) {
|
|
150
|
+
refus = [`le type « ${tache.type} » passe par bash : il doit déclarer la capacité « bash » (Windows)`];
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
if (tache.etat === 'affectee') await appel(`taches/${tache.id}/demarrer`);
|
|
154
|
+
if (refus.length) {
|
|
155
|
+
const resultat = { etat: 'echec', motif: `refusé par la machine : ${refus.join(' ; ')}`, etapes: [] };
|
|
156
|
+
const enAttente = await rendre(tache.id, false, resultat);
|
|
157
|
+
return { ...tache, resultat, ...(enAttente ? { enAttente } : {}) };
|
|
158
|
+
}
|
|
159
|
+
const execution = { id: tache.id, titre: tache.titre, etapes: lesEtapes };
|
|
160
|
+
|
|
161
|
+
// La progression (N1) et le BAIL (0.6.0) : toutes les `progressionS`, la progression si elle a changé, sinon un
|
|
162
|
+
// battement. Une réponse 403/404/409 dit que la tâche n'est plus à cette machine (reprise par la centrale) : l'agent
|
|
163
|
+
// ABANDONNE son exécution (jamais deux exécutions). Sans contact depuis `bailS`, il l'arrête : « interrompue ».
|
|
164
|
+
const arret = new AbortController(); let issue = null; let contact = Date.now();
|
|
165
|
+
let dernier = null; let envoye = null; let chaine = Promise.resolve();
|
|
166
|
+
const resume = (x) => ({ etat: x.etat, debut: x.debut, etapes: x.etapes.map((e) => ({ code: e.code, titre: e.titre, etat: e.etat, debut: e.debut, fin: e.fin, sortie: e.sortie, progression: e.progression ?? null })) });
|
|
167
|
+
const stopper = (quoi) => { if (!issue) { issue = quoi; arret.abort(); } };
|
|
168
|
+
const envoyer = (force) => {
|
|
169
|
+
if (issue) return chaine;
|
|
170
|
+
const change = dernier && dernier !== envoye;
|
|
171
|
+
if (!change && !force) return chaine;
|
|
172
|
+
const x = dernier; if (change) envoye = x;
|
|
173
|
+
chaine = chaine.then(async () => {
|
|
174
|
+
try {
|
|
175
|
+
if (change) await appel(`taches/${tache.id}/progression`, { progression: resume(x) });
|
|
176
|
+
else await appel(`taches/${tache.id}/battement`);
|
|
177
|
+
contact = Date.now();
|
|
178
|
+
} catch (e) {
|
|
179
|
+
if (e.code === 'E_CONSOLE' && [403, 404, 409].includes(e.statut)) stopper('abandonnee');
|
|
180
|
+
// E_LIAISON : la progression est un plus, jamais un arrêt — le bail tranche.
|
|
181
|
+
}
|
|
182
|
+
});
|
|
183
|
+
return chaine;
|
|
184
|
+
};
|
|
185
|
+
const minuteur = setInterval(() => {
|
|
186
|
+
if (bailS && Date.now() - contact > bailS * 1000) stopper('interrompue');
|
|
187
|
+
envoyer(true);
|
|
188
|
+
}, Math.max(50, progressionS * 1000)); minuteur.unref?.();
|
|
189
|
+
let etat;
|
|
190
|
+
courante = tache.id;
|
|
191
|
+
try {
|
|
192
|
+
etat = await lancer(execution, { racine, reprendre, signal: arret.signal, plateforme, ...(travailJetable ? { travail: true } : {}), surEtat: (x, { finEtape }) => { dernier = x; if (finEtape) envoyer(false); } });
|
|
193
|
+
} catch (e) { etat = { etat: 'echec', motif: e.message, etapes: [] }; } finally { clearInterval(minuteur); courante = null; }
|
|
194
|
+
await chaine;
|
|
195
|
+
|
|
196
|
+
const etapes = (etat.etapes || []).map((e) => ({ code: e.code, etat: e.etat, sortie: e.sortie, progression: e.progression ?? null }));
|
|
197
|
+
if (issue === 'abandonnee') {
|
|
198
|
+
// La tâche n'est plus à nous : rien n'est rendu (la centrale refuserait), l'exécution locale est arrêtée.
|
|
199
|
+
return { ...tache, resultat: { etat: 'abandonnee', motif: 'reprise par la centrale : exécution abandonnée', etapes } };
|
|
200
|
+
}
|
|
201
|
+
if (issue === 'interrompue') {
|
|
202
|
+
const resultat = { etat: 'interrompue', motif: `centrale injoignable depuis plus de ${bailS} s (bail dépassé)`, etapes };
|
|
203
|
+
const enAttente = await rendre(tache.id, false, resultat, { interrompue: true });
|
|
204
|
+
return { ...tache, resultat, ...(enAttente ? { enAttente } : {}) };
|
|
205
|
+
}
|
|
206
|
+
ordreFini(tache);
|
|
207
|
+
const resultat = { etat: etat.etat, ...(etat.motif ? { motif: etat.motif } : {}), etapes };
|
|
208
|
+
if (etat.travail) resultat.travail = 'jetable';
|
|
209
|
+
if (etat.etat !== 'fait') { // N3 : la fin du journal de l'étape en échec, jamais le journal entier
|
|
210
|
+
const e = etat.etapes.find((x) => x.etat === 'echec');
|
|
211
|
+
const fin = e ? queueDuJournal(join(racine, 'executions', tache.id, `${e.code}.log`)) : null;
|
|
212
|
+
if (fin) resultat.finJournal = fin;
|
|
213
|
+
}
|
|
214
|
+
const enAttente = await rendre(tache.id, etat.etat === 'fait', resultat);
|
|
215
|
+
return { ...tache, resultat, ...(enAttente ? { enAttente } : {}) };
|
|
216
|
+
};
|
|
217
|
+
|
|
218
|
+
const typesConnus = () => registre.types().filter((n) => typeof registre.type(n)?.etapes === 'function');
|
|
219
|
+
const annoncer = () => appel('annonce', { capacites: machine.capacites, roles: machine.roles || [], types: typesConnus(), telemetrie: releverTelemetrie(racine) });
|
|
220
|
+
const tour = async () => { await livrer(); await annoncer(); const t = await appel('tirer'); return t ? executer(t.tache) : null; };
|
|
221
|
+
return {
|
|
222
|
+
racine,
|
|
223
|
+
annoncer,
|
|
224
|
+
/** Les comptes rendus restés en attente pendant une coupure, livrés maintenant ; rend leur nombre. */
|
|
225
|
+
livrer,
|
|
226
|
+
/**
|
|
227
|
+
* Un tour : livrer les comptes rendus en attente, s'annoncer, tirer, exécuter, rendre. null s'il n'y a rien à faire.
|
|
228
|
+
* L'annonce précède chaque tirage : une console qui a redémarré a oublié les annonces (T-DLG-20).
|
|
229
|
+
*/
|
|
230
|
+
tour,
|
|
231
|
+
/** Exécute une tâche déjà tirée (essais, et l'agent local de la centrale) ; rend la tâche et son résultat. */
|
|
232
|
+
executerTache: (t, o) => executer(t, o),
|
|
233
|
+
/**
|
|
234
|
+
* Au redémarrage : les tâches qui étaient à cette machine. Une tâche COMMENCÉE a été coupée : elle est déclarée
|
|
235
|
+
* « interrompue » et la centrale décide (politique du type) : remettre en file, arrêter, ou la laisser reprendre ici
|
|
236
|
+
* sans rejouer les étapes faites. Une tâche affectée mais non commencée est exécutée.
|
|
237
|
+
*/
|
|
238
|
+
async reprendre() {
|
|
239
|
+
await livrer();
|
|
240
|
+
await annoncer();
|
|
241
|
+
const { taches } = await appel('miennes');
|
|
242
|
+
const faites = [];
|
|
243
|
+
for (const { tache: t } of taches) {
|
|
244
|
+
if (t.etat !== 'en_cours') { faites.push(await executer(t, { reprendre: true })); continue; }
|
|
245
|
+
const d = await appel(`taches/${t.id}/interrompue`, { motif: 'machine redémarrée pendant la tâche' });
|
|
246
|
+
if (d.decision === 'reprendre') { faites.push({ ...(await executer(t, { reprendre: true })), interrompue: 'reprendre' }); continue; }
|
|
247
|
+
faites.push({ ...t, interrompue: d.decision,
|
|
248
|
+
resultat: { etat: d.decision === 'arreter' ? 'echec' : 'remise-en-file', motif: `interrompue : ${d.decision}`, etapes: [] } });
|
|
249
|
+
}
|
|
250
|
+
return faites;
|
|
251
|
+
},
|
|
252
|
+
/**
|
|
253
|
+
* Le canal direct (0.6.0) : la centrale réveille (« tache »), interroge (« etat ») et invite à se réannoncer
|
|
254
|
+
* (« annoncer », à chaque reconnexion). Le canal accélère, il ne remplace rien : le tirage reste un POST revalidé.
|
|
255
|
+
* Rend le canal ({ etat(), arreter() }).
|
|
256
|
+
*/
|
|
257
|
+
ecouter({ mode = 'auto', reveil = null, tampon, ...o } = {}) {
|
|
258
|
+
const canal = creerCanal({ mode, url: `${base}/canal`, jeton, fetch: f, ...(tampon ? { tampon } : {}), ...o });
|
|
259
|
+
canal.sur('tache', (d) => { try { (reveil || (() => tour().catch(() => {})))({ id: d?.id, type: d?.type }); } catch { /* un réveil n'arrête rien */ } return { recu: true }; });
|
|
260
|
+
canal.sur('etat', () => ({ telemetrie: releverTelemetrie(racine), types: typesConnus(), capacites: [...machine.capacites], tache: courante }));
|
|
261
|
+
canal.sur('annoncer', async () => { await annoncer(); return { annonce: true }; });
|
|
262
|
+
canal.demarrer();
|
|
263
|
+
return canal;
|
|
264
|
+
},
|
|
265
|
+
};
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
/**
|
|
269
|
+
* L'agent LOCAL de la centrale (maestro, décision du 20/11/2026) : il ne fait rien tant que le réglage « la centrale
|
|
270
|
+
* exécute » est désactivé (le défaut) ; activé, il tire seulement les types permis, dans la limite de concurrence que
|
|
271
|
+
* l'API applique, et jamais le train (la capacité « conducteur » ne lui est jamais donnée).
|
|
272
|
+
* @param {{ url: string, jeton: string, registre: object, reglage: () => Promise<{ executer: boolean }>, capacites?: string[],
|
|
273
|
+
* racine?: string, lancer?: typeof lancerExecution, fetch?: typeof fetch, toursMax?: number }} o
|
|
274
|
+
*/
|
|
275
|
+
export function creerAgentCentrale({ url, jeton, registre, reglage, capacites = null, racine, lancer, fetch: f, toursMax = 8, ...plus }) {
|
|
276
|
+
if (typeof reglage !== 'function') throw erreur('E_OPTION', 'creerAgentCentrale : reglage() requis');
|
|
277
|
+
let actif = false; let agent = null; let minuteur = null;
|
|
278
|
+
const caps = () => (capacites || detecterCapacites().capacites).filter((c) => c !== 'conducteur');
|
|
279
|
+
const tick = async () => {
|
|
280
|
+
const r = await reglage();
|
|
281
|
+
actif = r?.executer === true;
|
|
282
|
+
if (!actif) return { actif: false, faites: 0 };
|
|
283
|
+
agent ||= creerAgent({ url, jeton, machine: { roles: ['centrale'], capacites: caps() }, registre, ...(racine ? { racine } : {}), ...(lancer ? { lancer } : {}), ...(f ? { fetch: f } : {}), ...plus });
|
|
284
|
+
let faites = 0;
|
|
285
|
+
try {
|
|
286
|
+
for (let i = 0; i < toursMax; i++) { const t = await agent.tour(); if (!t) break; faites += 1; }
|
|
287
|
+
} catch (e) { if (e.statut === 403) { actif = false; return { actif: false, faites }; } throw e; }
|
|
288
|
+
return { actif: true, faites };
|
|
289
|
+
};
|
|
290
|
+
return {
|
|
291
|
+
tick,
|
|
292
|
+
actif: () => actif,
|
|
293
|
+
/** Un tick toutes les `periodeS` secondes ; rend la fonction d'arrêt. */
|
|
294
|
+
demarrer({ periodeS = 30 } = {}) {
|
|
295
|
+
let enCours = false;
|
|
296
|
+
minuteur = setInterval(async () => { if (enCours) return; enCours = true; try { await tick(); } catch { /* prochain tick */ } finally { enCours = false; } }, Math.max(1, periodeS) * 1000);
|
|
297
|
+
return () => { clearInterval(minuteur); minuteur = null; };
|
|
298
|
+
},
|
|
299
|
+
};
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
/**
|
|
303
|
+
* Ce que la machine sait faire, relevé sur place (enrôlement, lot C5) : node@<majeure>, chrome, ffmpeg, piper, git, ssh,
|
|
304
|
+
* rsync, bash ; cœurs, mémoire, disque, système. Rien n'est déclaré à la main : la centrale voit ce qui est vraiment là.
|
|
305
|
+
* 0.9.0 (R9) : recherche dans le PATH sans shell (PATHEXT sous Windows), Chrome dans /Applications ou Program Files,
|
|
306
|
+
* bash de Git for Windows ; `plateforme`, `env`, `existe` simulent un autre système (essais).
|
|
307
|
+
*/
|
|
308
|
+
export function detecterCapacites({ racine = homedir(), plateforme = process.platform, env = process.env, existe } = {}) {
|
|
309
|
+
const o = { plateforme, env, ...(existe ? { existe } : {}) };
|
|
310
|
+
const capacites = [`node@${process.versions.node.split('.')[0]}`];
|
|
311
|
+
if (trouverChrome(o)) capacites.push('chrome');
|
|
312
|
+
for (const c of ['ffmpeg', 'piper', 'git', 'ssh', 'rsync']) if (trouverProgramme(c, o)) capacites.push(c);
|
|
313
|
+
if (trouverBash(o)) capacites.push('bash');
|
|
314
|
+
const t = releverTelemetrie(racine);
|
|
315
|
+
return { capacites, cpus: t.cpus, memoireMo: t.memoire.totaleMo, disqueMo: t.disque.totalMo, systeme: t.plateforme, hote: t.hote };
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
/**
|
|
319
|
+
* Enrôle CETTE machine auprès de la centrale avec le jeton d'enrôlement (usage unique) ; pose le jeton durable dans
|
|
320
|
+
* `fichierJeton` (600) et ne le rend jamais. Rend { id, capacites }. Le même appel sert le CODE DE DEMANDE de
|
|
321
|
+
* l'inscription depuis le PC (0.6.0), avec `nom` et `roles`.
|
|
322
|
+
*/
|
|
323
|
+
export async function enrolerMachine({ url, jetonEnrolement, fichierJeton, nom, roles, detecte = detecterCapacites(), fetch: f = globalThis.fetch }) {
|
|
324
|
+
if (!url || !jetonEnrolement || !fichierJeton) throw erreur('E_OPTION', 'enrolerMachine : url, jetonEnrolement et fichierJeton requis');
|
|
325
|
+
if (existsSync(fichierJeton)) throw erreur('E_EXISTE', `${fichierJeton} existe déjà : on ne remplace pas un jeton sans le vouloir`);
|
|
326
|
+
const r = await f(`${url.replace(/\/+$/, '')}/api/agent/enroler`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jeton: jetonEnrolement, detecte, ...(nom ? { nom } : {}), ...(Array.isArray(roles) && roles.length ? { roles } : {}) }) });
|
|
327
|
+
const d = await r.json().catch(() => ({}));
|
|
328
|
+
if (!r.ok) throw erreur('E_ENROLEMENT', `enrôlement refusé : ${r.status} ${d.erreur || ''}`.trim());
|
|
329
|
+
mkdirSync(dirname(fichierJeton), { recursive: true, mode: 0o700 });
|
|
330
|
+
writeFileSync(fichierJeton, `${d.jeton}\n`, { mode: 0o600 });
|
|
331
|
+
if (process.platform === 'win32') restreindreAcces(fichierJeton); // le mode 600 n'existe pas sous Windows : l'ACL
|
|
332
|
+
// R3 : l'empreinte que la console affiche aussi, à comparer avant d'accepter.
|
|
333
|
+
return { id: d.machine, capacites: detecte.capacites, empreinte: empreinteMachine(empreinteJeton(d.jeton)) };
|
|
334
|
+
}
|