@imenam/mcp-dependabot-tracker 1.0.7 → 1.0.8
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/README.md +6 -3
- package/dist/shared/alerts.d.ts +5 -1
- package/dist/shared/alerts.js +13 -0
- package/dist/shared/schemas/api.schema.d.ts +33 -4
- package/dist/shared/schemas/ipc.schema.d.ts +1 -1
- package/dist/shared/schemas/ipc.schema.js +2 -0
- package/dist/shared/schemas/model.schema.d.ts +18 -1
- package/dist/shared/schemas/model.schema.js +3 -1
- package/dist/src/core/audit-all.d.ts +24 -0
- package/dist/src/core/audit-all.js +62 -0
- package/dist/src/core/operations.d.ts +6 -0
- package/dist/src/core/operations.js +17 -0
- package/dist/src/core/repos.d.ts +12 -4
- package/dist/src/core/repos.js +29 -10
- package/dist/src/core/store.js +11 -1
- package/dist/src/gui-worker.js +2 -0
- package/dist/src/index.js +10 -1
- package/dist/src/tools/format.js +4 -0
- package/gui/dist/assets/index-D_wlwOtv.js +64 -0
- package/gui/dist/index.html +1 -1
- package/package.json +1 -1
- package/gui/dist/assets/index-D1XdEio2.js +0 -64
package/README.md
CHANGED
|
@@ -121,7 +121,7 @@ Cinq outils, en anglais. Le résultat d'une opération se termine par le lien ve
|
|
|
121
121
|
|
|
122
122
|
| Outil | Droit | Effet |
|
|
123
123
|
|---|---|---|
|
|
124
|
-
| `list_repositories` | — | Dépôts suivis, tous ou ceux d'une catégorie (`category`, son nom) : catégorie, alertes Dependabot ouvertes par gravité (hors celles que l'utilisateur a corrigées à la main, comptées à part), paquets sans version corrigée au dernier audit, dernier audit sans vulnérabilité qui contredit les alertes, date de la dernière lecture (et son erreur), droits de l'agent, pull requests du tracker pas encore mergées, opération en cours. |
|
|
124
|
+
| `list_repositories` | — | Dépôts suivis, tous ou ceux d'une catégorie (`category`, son nom) : catégorie, alertes Dependabot ouvertes par gravité (hors celles que l'utilisateur a corrigées à la main, comptées à part), paquets sans version corrigée au dernier audit, dernier audit sans vulnérabilité qui contredit les alertes, vulnérabilités trouvées par le dernier audit de la branche par défaut quand Dependabot ne signale rien, date de la dernière lecture (et son erreur), droits de l'agent, pull requests du tracker pas encore mergées, opération en cours. |
|
|
125
125
|
| `get_alerts` | — | Relit sur GitHub les alertes ouvertes d'un dépôt (`repository`) et les liste de la plus grave à la moins grave : numéro, gravité, paquet, écosystème, manifeste, résumé, version corrigée, marque « corrigée à la main » de l'utilisateur, lien. |
|
|
126
126
|
| `run_audit` | audit | `npm audit` dans un clone temporaire : vulnérabilités par projet npm, avec la correction proposée (aucune, dans les plages déclarées, ou montée majeure qui demande `--force`). Rien n'est modifié. |
|
|
127
127
|
| `fix_vulnerabilities` | fix (+ force, + push) | Clone, `npm audit`, `npm audit fix` ; avec `force: true`, `npm audit fix --force` s'il reste des vulnérabilités qu'une montée majeure corrige ; avec `push: true`, commit (`commit_message`, défaut `fix(deps): resolve npm audit vulnerabilities`), push d'une nouvelle branche et pull request vers la branche analysée. Sans `push`, rien ne sort du clone : le résultat décrit ce que les corrections changent. |
|
|
@@ -145,6 +145,8 @@ La **branche analysée** se choisit par dépôt dans la GUI ; c'est la branche p
|
|
|
145
145
|
|
|
146
146
|
**Pull requests en attente** — à chaque lecture d'un dépôt (toutes les 10 minutes, ou « Synchroniser maintenant »), le tracker lit ses pull requests ouvertes sur GitHub et garde celles dont la branche suit le nommage `fix/npm-audit-<AAAA-MM-JJ>-<HHMMSS>` et appartient au dépôt lui-même (pas à une fourche). Les pull requests ouvertes avant cette fonction sont donc reconnues, même quand l'historique des opérations ne les contient plus. Une pull request mergée ou fermée disparaît à la lecture suivante ; une pull request que le tracker vient d'ouvrir apparaît aussitôt.
|
|
147
147
|
|
|
148
|
+
**Auditer tout** — depuis l'accueil, un audit seul (clone et `npm audit`, sans correction) de la **branche par défaut** de chaque dépôt suivi, quelle que soit sa branche analysée : c'est la branche que Dependabot analyse, et la seule sur laquelle les deux se comparent. Trois audits tournent à la fois. Un dépôt où une opération est déjà en cours est laissé de côté ; un audit qui échoue (dépôt sans `package-lock.json`, clone impossible) n'arrête pas les autres. La série vit dans le processus qui sert la GUI ; une seule à la fois.
|
|
149
|
+
|
|
148
150
|
Les paquets mis à jour sont lus en comparant chaque lockfile à celui du commit cloné : version changée, paquet ajouté ou retiré. S'il n'y a rien à corriger, ou si les corrections ne changent rien, l'opération se termine sans push.
|
|
149
151
|
|
|
150
152
|
Depuis la GUI, l'opération s'arrête aux étapes 4 et 5 pour la décision de l'utilisateur. Menée par l'agent, elle va d'un bout à l'autre selon `force` et `push`. Une seule opération à la fois par dépôt.
|
|
@@ -158,10 +160,10 @@ Depuis la GUI, l'opération s'arrête aux étapes 4 et 5 pour la décision de l'
|
|
|
158
160
|
Thème sombre, une information par ligne, une action principale par écran.
|
|
159
161
|
|
|
160
162
|
- **Accueil (`#/`, `#/c/<catégorie>`)** — à gauche, la barre des catégories : « Tous mes projets », puis chaque catégorie, chacune avec le nombre d'alertes ouvertes de ses dépôts, coloré selon la plus grave (aucune pastille sans alerte), précédé du nombre de pull requests du tracker en attente (aucune pastille sans pull request). « Nouvelle catégorie » ouvre un champ en place (Entrée crée, Échap annule) ; au survol d'une catégorie, « … » propose de la renommer ou de la supprimer (un second clic confirme ; ses dépôts restent suivis, sans catégorie). Un dépôt appartient à une catégorie au plus.
|
|
161
|
-
À droite, les dépôts de la catégorie choisie, du plus exposé au moins exposé (gravité la plus haute, puis nombre
|
|
163
|
+
À droite, les dépôts de la catégorie choisie, du plus exposé au moins exposé (gravité la plus haute, puis nombre de vulnérabilités). L'interrupteur « Vulnérables seulement » ne garde que les dépôts réellement vulnérables : des paquets sans version corrigée au dernier audit, des alertes non corrigées à la main que le dernier audit ne contredit pas (« Audit OK » et « Corrigé à la main » sont donc cachés), ou des vulnérabilités trouvées par l'audit alors que Dependabot ne signale rien ; le navigateur retient sa position. En bout de ligne, une seule information : le nombre d'alertes coloré selon la gravité la plus haute, « Correction en cours », « Audit en cours », « Synchronisation impossible » (l'erreur en infobulle) ou « À jour ». Quand le dernier audit (de l'utilisateur ou de l'agent) n'a trouvé aucune vulnérabilité alors que Dependabot signale encore des alertes, la ligne affiche « Audit OK le <jour> à <heure> » et estompe la pastille des alertes : Dependabot n'a pas encore repassé. La mention ne vaut que pour un audit de la branche par défaut, la seule que Dependabot analyse ; elle disparaît dès qu'un audit plus récent trouve une vulnérabilité, que Dependabot n'a plus d'alerte, ou qu'il en émet une après l'audit. À l'inverse, quand Dependabot ne signale aucune alerte mais que le dernier audit de la branche par défaut a trouvé des vulnérabilités, la ligne affiche « ⚠ Audit du <jour> à <heure> » et une pastille « N vulnérabilités » colorée selon la plus grave : Dependabot n'a pas encore repassé. Ces vulnérabilités comptent dans la barre des catégories comme les alertes. « ⚠ N sans correctif », devant la pastille, compte les paquets pour lesquels le dernier audit n'a trouvé aucune version corrigée publiée : ils sont à mettre à jour à la main. Les alertes marquées corrigées à la main ne comptent plus, ni dans la pastille, ni dans la barre des catégories ; quand elles le sont toutes, la ligne affiche « Corrigé à la main » et estompe la pastille.
|
|
162
164
|
« Ajouter un dépôt » ouvre une fenêtre avec un champ de recherche et la catégorie. Dès la première lettre, jusqu'à dix dépôts accessibles au token et pas encore suivis sont proposés (ceux dont le nom commence par la saisie d'abord) ; ↑ et ↓ parcourent, Entrée ou un clic reportent le dépôt dans le champ, Échap referme la liste, puis la fenêtre. La catégorie part de celle affichée. « Ajouter » valide ; sans suggestion, Entrée aussi. La saisie peut être `propriétaire/dépôt` ou un lien GitHub. Un nouveau dépôt n'accorde que l'audit à l'agent.
|
|
163
165
|
« PR en attente » ne garde que les dépôts où une pull request du tracker attend d'être mergée ; combiné à « Vulnérables seulement », les deux conditions s'appliquent. Le navigateur retient sa position. Sur la ligne, « PR #42 en attente » ouvre la pull request sur GitHub, « 3 PR en attente » la liste des pull requests du dépôt.
|
|
164
|
-
« Synchroniser maintenant », à côté, relit tout de suite les alertes et les pull requests de tous les dépôts, sans attendre la relecture des 10 minutes ; l'icône tourne jusqu'à la fin.
|
|
166
|
+
« Synchroniser maintenant », à côté, relit tout de suite les alertes et les pull requests de tous les dépôts, sans attendre la relecture des 10 minutes ; l'icône tourne jusqu'à la fin. « Auditer tout » audite la branche par défaut de tous les dépôts (voir plus haut) : le bouton affiche la progression (« Audit 4/12… »), chaque dépôt audité affiche « Audit en cours », et un message final donne le nombre de dépôts audités, laissés de côté et en échec (avec leurs noms).
|
|
165
167
|
- **Dépôt (`#/r/<propriétaire>/<nom>`)** — sélecteur de la branche analysée (un clic ouvre la liste des branches avec un champ de recherche, la branche par défaut en tête ; ↑ ↓ et Entrée ou un clic choisissent, Échap ferme), sélecteur de la catégorie (« Sans catégorie » ou l'une des catégories), date de la dernière lecture des alertes et lien vers la dernière correction ; les alertes ouvertes (gravité, paquet, résumé), chacune ouvrant l'alerte sur GitHub. Une alerte dont le paquet n'a aucune version corrigée publiée porte « ⚠ sans correctif ». Au survol d'une alerte, « Corrigée à la main » la range dans la section « Corrigées à la main », avec la date du marquage ; « Rétablir » la remet à traiter. Dependabot continue souvent de signaler une alerte corrigée à la main (un paquet installé hors du registre npm, par exemple) : la marque tient tant que l'alerte reste ouverte, et tombe à la lecture suivante si Dependabot émet une nouvelle alerte sur le même paquet. « Corriger » lance une correction, ou « Reprendre la correction » rouvre celle en cours. « Agent » ouvre le volet des droits : quatre interrupteurs, enregistrés aussitôt, et « Retirer le dépôt » (un second clic confirme dans les 4 secondes ; refusé pendant une opération).
|
|
166
168
|
- **Correction (`#/r/<propriétaire>/<nom>/op/<id>`)** — qui l'a lancée (vous ou l'agent), la branche clonée, puis les étapes : celles qui sont faites tiennent sur une ligne avec leur résultat (« 4 vulnérabilités », « 3 corrigées », lien vers la pull request), seule l'étape qui attend une décision est dépliée. Une étape passée en donne la raison : « aucune correction possible » pour `--force` quand npm ne propose aucune montée majeure, « rien à corriger » quand `npm audit fix` a tout corrigé, « rien à pousser » quand les corrections n'ont rien changé, « ignorée » sinon. Les vulnérabilités sans aucune version corrigée publiée sur le registre npm (`fixAvailable: false`, par exemple `xlsx`, que SheetJS ne publie plus sur npm) sont comptées sur la ligne du dernier audit (« 1 sans correctif ») ; un clic les liste avec leur gravité : leur mise à jour est à faire à la main. L'étape `--force` liste les montées majeures avec « Appliquer --force » et « Passer » ; l'étape du push montre le message de commit modifiable, le nom de la branche, « voir les changements » (paquets mis à jour, replié) et « Pousser et ouvrir la PR ». Une erreur s'affiche sous l'étape qui a échoué. « Journal » déplie les commandes lancées et leurs résultats ; « Annuler » arrête l'opération.
|
|
167
169
|
|
|
@@ -181,6 +183,7 @@ Deux processus, selon le standard de l'écosystème (`@imenam/mcp-gui-interface`
|
|
|
181
183
|
| `GET /api/config` | Version, répertoire des données, présence du token. |
|
|
182
184
|
| `GET /api/repos`, `POST /api/repos` | Dépôts suivis (avec catégorie, opération en cours et dernière opération) et catégories ; ajout d'un dépôt (`{ repository, categoryId? }`). |
|
|
183
185
|
| `POST /api/sync` | Relit tout de suite les alertes et les pull requests de chaque dépôt suivi, en parallèle ; renvoie les dépôts et les catégories. |
|
|
186
|
+
| `GET /api/audit-all`, `POST /api/audit-all` | État de la dernière série « Auditer tout » (`null` si aucune depuis le démarrage) : en cours ou non, dépôts traités sur le total, laissés de côté, en échec avec la raison ; lancement d'une série (`409` si une série est en cours). |
|
|
184
187
|
| `GET /api/github/repos` | Dépôts accessibles au token (`/user/repos`) et pas encore suivis, pour les suggestions d'ajout. |
|
|
185
188
|
| `GET` / `DELETE /api/repos/:propriétaire/:nom` | Dépôt ; retrait. |
|
|
186
189
|
| `PUT /api/repos/:propriétaire/:nom/rights` | Droits de l'agent. |
|
package/dist/shared/alerts.d.ts
CHANGED
|
@@ -1,5 +1,9 @@
|
|
|
1
|
-
import type
|
|
1
|
+
import { type Alert, type AlertSeverity, type NpmSeverity, type Repo } from "./schemas/model.schema.js";
|
|
2
2
|
/** Alertes ouvertes que l'utilisateur n'a pas marquées corrigées à la main. */
|
|
3
3
|
export declare function pendingAlerts(repo: Repo): Alert[];
|
|
4
4
|
/** Alertes ouvertes marquées corrigées à la main. */
|
|
5
5
|
export declare function handledAlerts(repo: Repo): Alert[];
|
|
6
|
+
/** Gravité d'alerte correspondant à une gravité npm (`moderate` → `medium`, `info` → `low`). */
|
|
7
|
+
export declare function fromNpmSeverity(severity: NpmSeverity): AlertSeverity;
|
|
8
|
+
/** Gravité la plus haute d'une liste, ou null si elle est vide. */
|
|
9
|
+
export declare function worstOf(severities: AlertSeverity[]): AlertSeverity | null;
|
package/dist/shared/alerts.js
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { ALERT_SEVERITIES } from "./schemas/model.schema.js";
|
|
1
2
|
/** Alertes ouvertes que l'utilisateur n'a pas marquées corrigées à la main. */
|
|
2
3
|
export function pendingAlerts(repo) {
|
|
3
4
|
const handled = new Set(repo.handledAlerts.map((mark) => mark.number));
|
|
@@ -8,3 +9,15 @@ export function handledAlerts(repo) {
|
|
|
8
9
|
const handled = new Set(repo.handledAlerts.map((mark) => mark.number));
|
|
9
10
|
return repo.alerts.filter((alert) => handled.has(alert.number));
|
|
10
11
|
}
|
|
12
|
+
/** Gravité d'alerte correspondant à une gravité npm (`moderate` → `medium`, `info` → `low`). */
|
|
13
|
+
export function fromNpmSeverity(severity) {
|
|
14
|
+
if (severity === "moderate")
|
|
15
|
+
return "medium";
|
|
16
|
+
if (severity === "info")
|
|
17
|
+
return "low";
|
|
18
|
+
return severity;
|
|
19
|
+
}
|
|
20
|
+
/** Gravité la plus haute d'une liste, ou null si elle est vide. */
|
|
21
|
+
export function worstOf(severities) {
|
|
22
|
+
return ALERT_SEVERITIES.find((severity) => severities.includes(severity)) ?? null;
|
|
23
|
+
}
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
|
-
import { type Category, type Operation, type Repo } from "./model.schema.js";
|
|
2
|
+
import { type AlertSeverity, type Category, type Operation, type Repo } from "./model.schema.js";
|
|
3
3
|
/** Corps de `POST /api/repos` : `propriétaire/nom` ou lien GitHub, et la catégorie où le ranger (aucune par défaut). */
|
|
4
4
|
export declare const AddRepoBodySchema: z.ZodObject<{
|
|
5
5
|
repository: z.ZodString;
|
|
@@ -61,13 +61,20 @@ export declare const AlertRequestSchema: z.ZodObject<{
|
|
|
61
61
|
export declare const OperationRequestSchema: z.ZodObject<{
|
|
62
62
|
operationId: z.ZodString;
|
|
63
63
|
}, z.core.$strip>;
|
|
64
|
+
/** Vulnérabilités trouvées par un audit : leur nombre, la plus haute gravité, et la date de l'audit. */
|
|
65
|
+
export interface AuditFindings {
|
|
66
|
+
at: string;
|
|
67
|
+
count: number;
|
|
68
|
+
severity: AlertSeverity;
|
|
69
|
+
}
|
|
64
70
|
/**
|
|
65
71
|
* Dépôt, sa catégorie, et l'état de son opération en cours et de la dernière
|
|
66
72
|
* opération, pour la liste et l'écran du dépôt. `cleanAuditAt` est la date du
|
|
67
73
|
* dernier audit quand il n'a trouvé aucune vulnérabilité alors que Dependabot
|
|
68
|
-
* signale encore des alertes émises avant lui ; `
|
|
69
|
-
*
|
|
70
|
-
*
|
|
74
|
+
* signale encore des alertes émises avant lui ; `auditFindings` ce qu'a trouvé
|
|
75
|
+
* le dernier audit de la branche par défaut alors que Dependabot ne signale
|
|
76
|
+
* aucune alerte ; `unfixable` les paquets pour lesquels le dernier audit n'a
|
|
77
|
+
* trouvé aucune version corrigée, hors ceux marqués corrigés à la main.
|
|
71
78
|
*/
|
|
72
79
|
export interface RepoView {
|
|
73
80
|
repo: Repo;
|
|
@@ -75,8 +82,30 @@ export interface RepoView {
|
|
|
75
82
|
activeOperation: Operation | null;
|
|
76
83
|
latestOperation: Operation | null;
|
|
77
84
|
cleanAuditAt: string | null;
|
|
85
|
+
auditFindings: AuditFindings | null;
|
|
78
86
|
unfixable: string[];
|
|
79
87
|
}
|
|
88
|
+
/**
|
|
89
|
+
* Série « Auditer tout » : `done` dépôts traités sur `total`, dont ceux laissés
|
|
90
|
+
* de côté parce qu'une opération y était en cours (`skipped`) et ceux dont
|
|
91
|
+
* l'audit a échoué, avec la raison (`failed`).
|
|
92
|
+
*/
|
|
93
|
+
export interface AuditAllState {
|
|
94
|
+
running: boolean;
|
|
95
|
+
startedAt: string;
|
|
96
|
+
finishedAt: string | null;
|
|
97
|
+
total: number;
|
|
98
|
+
done: number;
|
|
99
|
+
skipped: string[];
|
|
100
|
+
failed: {
|
|
101
|
+
repoId: string;
|
|
102
|
+
error: string;
|
|
103
|
+
}[];
|
|
104
|
+
}
|
|
105
|
+
/** Dernière série « Auditer tout », null si aucune n'a été lancée depuis le démarrage du serveur. */
|
|
106
|
+
export interface AuditAllResponse {
|
|
107
|
+
auditAll: AuditAllState | null;
|
|
108
|
+
}
|
|
80
109
|
/** Dépôts suivis et catégories, pour l'accueil et sa barre latérale. */
|
|
81
110
|
export interface ReposResponse {
|
|
82
111
|
repos: RepoView[];
|
|
@@ -22,5 +22,5 @@ export declare const IPCMessageSchema: z.ZodObject<{
|
|
|
22
22
|
}, z.core.$strip>;
|
|
23
23
|
export type IPCMessage = z.infer<typeof IPCMessageSchema>;
|
|
24
24
|
/** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
|
|
25
|
-
export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_REPOS", "SYNC_REPOS", "LIST_ADDABLE_REPOS", "GET_REPO", "ADD_REPO", "REMOVE_REPO", "SET_RIGHTS", "LIST_BRANCHES", "SET_BRANCH", "SET_CATEGORY", "MARK_ALERT_HANDLED", "UNMARK_ALERT_HANDLED", "LIST_CATEGORIES", "CREATE_CATEGORY", "RENAME_CATEGORY", "DELETE_CATEGORY", "START_FIX", "GET_OPERATION", "DECIDE_FORCE", "PUSH_OPERATION", "CANCEL_OPERATION"];
|
|
25
|
+
export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_REPOS", "SYNC_REPOS", "GET_AUDIT_ALL", "START_AUDIT_ALL", "LIST_ADDABLE_REPOS", "GET_REPO", "ADD_REPO", "REMOVE_REPO", "SET_RIGHTS", "LIST_BRANCHES", "SET_BRANCH", "SET_CATEGORY", "MARK_ALERT_HANDLED", "UNMARK_ALERT_HANDLED", "LIST_CATEGORIES", "CREATE_CATEGORY", "RENAME_CATEGORY", "DELETE_CATEGORY", "START_FIX", "GET_OPERATION", "DECIDE_FORCE", "PUSH_OPERATION", "CANCEL_OPERATION"];
|
|
26
26
|
export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];
|
|
@@ -225,7 +225,8 @@ export type LogEntry = z.infer<typeof LogEntrySchema>;
|
|
|
225
225
|
/**
|
|
226
226
|
* Opération d'audit ou de correction sur un clone temporaire. `workDir` est le
|
|
227
227
|
* clone, présent tant que l'opération n'est pas terminée ; `pid` est le processus
|
|
228
|
-
* qui exécute l'étape en cours.
|
|
228
|
+
* qui exécute l'étape en cours. `found` liste les vulnérabilités du premier
|
|
229
|
+
* audit, `remaining` celles qui restent après la dernière étape.
|
|
229
230
|
*/
|
|
230
231
|
export declare const OperationSchema: z.ZodObject<{
|
|
231
232
|
id: z.ZodString;
|
|
@@ -295,6 +296,22 @@ export declare const OperationSchema: z.ZodObject<{
|
|
|
295
296
|
afterFix: z.ZodNullable<z.ZodNumber>;
|
|
296
297
|
afterForce: z.ZodNullable<z.ZodNumber>;
|
|
297
298
|
}, z.core.$strip>;
|
|
299
|
+
found: z.ZodArray<z.ZodObject<{
|
|
300
|
+
project: z.ZodString;
|
|
301
|
+
name: z.ZodString;
|
|
302
|
+
severity: z.ZodEnum<{
|
|
303
|
+
critical: "critical";
|
|
304
|
+
high: "high";
|
|
305
|
+
info: "info";
|
|
306
|
+
low: "low";
|
|
307
|
+
moderate: "moderate";
|
|
308
|
+
}>;
|
|
309
|
+
fix: z.ZodEnum<{
|
|
310
|
+
available: "available";
|
|
311
|
+
major: "major";
|
|
312
|
+
none: "none";
|
|
313
|
+
}>;
|
|
314
|
+
}, z.core.$strip>>;
|
|
298
315
|
remaining: z.ZodArray<z.ZodObject<{
|
|
299
316
|
project: z.ZodString;
|
|
300
317
|
name: z.ZodString;
|
|
@@ -109,7 +109,8 @@ export const LogEntrySchema = z.object({ at: z.string(), text: z.string() });
|
|
|
109
109
|
/**
|
|
110
110
|
* Opération d'audit ou de correction sur un clone temporaire. `workDir` est le
|
|
111
111
|
* clone, présent tant que l'opération n'est pas terminée ; `pid` est le processus
|
|
112
|
-
* qui exécute l'étape en cours.
|
|
112
|
+
* qui exécute l'étape en cours. `found` liste les vulnérabilités du premier
|
|
113
|
+
* audit, `remaining` celles qui restent après la dernière étape.
|
|
113
114
|
*/
|
|
114
115
|
export const OperationSchema = z.object({
|
|
115
116
|
id: z.string(),
|
|
@@ -136,6 +137,7 @@ export const OperationSchema = z.object({
|
|
|
136
137
|
afterFix: z.number().int().nullable(),
|
|
137
138
|
afterForce: z.number().int().nullable(),
|
|
138
139
|
}),
|
|
140
|
+
found: z.array(VulnerabilitySchema),
|
|
139
141
|
remaining: z.array(VulnerabilitySchema),
|
|
140
142
|
forceCandidates: z.array(ForceCandidateSchema),
|
|
141
143
|
changes: z.array(ChangeSchema),
|
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
import type { AuditAllState } from "../../shared/schemas/api.schema.js";
|
|
2
|
+
import type { Operation } from "../../shared/schemas/model.schema.js";
|
|
3
|
+
/** Audits menés en même temps par « Auditer tout ». */
|
|
4
|
+
export declare const AUDIT_ALL_CONCURRENCY = 3;
|
|
5
|
+
/**
|
|
6
|
+
* Audit de tous les dépôts suivis, lancé depuis la GUI : `AUDIT_ALL_CONCURRENCY`
|
|
7
|
+
* audits à la fois. Un dépôt dont une opération est déjà en cours est laissé de
|
|
8
|
+
* côté. Une seule série à la fois dans ce processus.
|
|
9
|
+
*/
|
|
10
|
+
export declare class AuditAll {
|
|
11
|
+
private readonly audit;
|
|
12
|
+
private readonly logError;
|
|
13
|
+
private state;
|
|
14
|
+
private run;
|
|
15
|
+
constructor(audit: (repoId: string) => Promise<Operation>, logError: (message: string) => void);
|
|
16
|
+
/** État de la dernière série, null si aucune n'a été lancée. */
|
|
17
|
+
status(): AuditAllState | null;
|
|
18
|
+
/** Lance la série sur `repoIds` et rend aussitôt son état ; refusé si une série est en cours. */
|
|
19
|
+
start(repoIds: string[]): AuditAllState;
|
|
20
|
+
/** Attend la fin de la série en cours. */
|
|
21
|
+
finished(): Promise<void>;
|
|
22
|
+
private auditAll;
|
|
23
|
+
private auditOne;
|
|
24
|
+
}
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
import { ConflictError } from "./errors.js";
|
|
2
|
+
/** Audits menés en même temps par « Auditer tout ». */
|
|
3
|
+
export const AUDIT_ALL_CONCURRENCY = 3;
|
|
4
|
+
/**
|
|
5
|
+
* Audit de tous les dépôts suivis, lancé depuis la GUI : `AUDIT_ALL_CONCURRENCY`
|
|
6
|
+
* audits à la fois. Un dépôt dont une opération est déjà en cours est laissé de
|
|
7
|
+
* côté. Une seule série à la fois dans ce processus.
|
|
8
|
+
*/
|
|
9
|
+
export class AuditAll {
|
|
10
|
+
audit;
|
|
11
|
+
logError;
|
|
12
|
+
state = null;
|
|
13
|
+
run = Promise.resolve();
|
|
14
|
+
constructor(audit, logError) {
|
|
15
|
+
this.audit = audit;
|
|
16
|
+
this.logError = logError;
|
|
17
|
+
}
|
|
18
|
+
/** État de la dernière série, null si aucune n'a été lancée. */
|
|
19
|
+
status() {
|
|
20
|
+
return this.state && { ...this.state, skipped: [...this.state.skipped], failed: [...this.state.failed] };
|
|
21
|
+
}
|
|
22
|
+
/** Lance la série sur `repoIds` et rend aussitôt son état ; refusé si une série est en cours. */
|
|
23
|
+
start(repoIds) {
|
|
24
|
+
if (this.state?.running)
|
|
25
|
+
throw new ConflictError("An audit of every repository is already running.");
|
|
26
|
+
this.state = { running: true, startedAt: new Date().toISOString(), finishedAt: null, total: repoIds.length, done: 0, skipped: [], failed: [] };
|
|
27
|
+
this.run = this.auditAll(this.state, [...repoIds]);
|
|
28
|
+
return this.status();
|
|
29
|
+
}
|
|
30
|
+
/** Attend la fin de la série en cours. */
|
|
31
|
+
finished() {
|
|
32
|
+
return this.run;
|
|
33
|
+
}
|
|
34
|
+
async auditAll(state, queue) {
|
|
35
|
+
const worker = async () => {
|
|
36
|
+
for (let repoId = queue.shift(); repoId !== undefined; repoId = queue.shift())
|
|
37
|
+
await this.auditOne(state, repoId);
|
|
38
|
+
};
|
|
39
|
+
await Promise.all(Array.from({ length: Math.min(AUDIT_ALL_CONCURRENCY, queue.length) }, worker));
|
|
40
|
+
state.running = false;
|
|
41
|
+
state.finishedAt = new Date().toISOString();
|
|
42
|
+
}
|
|
43
|
+
async auditOne(state, repoId) {
|
|
44
|
+
try {
|
|
45
|
+
const operation = await this.audit(repoId);
|
|
46
|
+
if (operation.status !== "done")
|
|
47
|
+
state.failed.push({ repoId, error: operation.error ?? operation.status });
|
|
48
|
+
}
|
|
49
|
+
catch (err) {
|
|
50
|
+
if (err instanceof ConflictError) {
|
|
51
|
+
state.skipped.push(repoId);
|
|
52
|
+
}
|
|
53
|
+
else {
|
|
54
|
+
state.failed.push({ repoId, error: err?.message ?? String(err) });
|
|
55
|
+
this.logError(`Audit of ${repoId} could not run: ${err?.stack ?? err}`);
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
finally {
|
|
59
|
+
state.done += 1;
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
}
|
|
@@ -26,6 +26,12 @@ export declare function isTrackerBranch(branch: string): boolean;
|
|
|
26
26
|
* en arrière-plan, puis l'opération attend la décision sur `--force` ou le push.
|
|
27
27
|
*/
|
|
28
28
|
export declare function startUserFix(ctx: OperationContext, repoId: string): Operation;
|
|
29
|
+
/**
|
|
30
|
+
* Audit de la branche par défaut, celle que Dependabot analyse, lancé par
|
|
31
|
+
* l'utilisateur et attendu jusqu'à sa fin. Refusé si une opération est en
|
|
32
|
+
* cours sur le dépôt.
|
|
33
|
+
*/
|
|
34
|
+
export declare function runDefaultBranchAudit(ctx: OperationContext, repoId: string): Promise<Operation>;
|
|
29
35
|
/** Applique ou passe `npm audit fix --force` sur une opération qui attend cette décision. */
|
|
30
36
|
export declare function decideForce(ctx: OperationContext, id: string, apply: boolean): Operation;
|
|
31
37
|
/** Commit, push et pull request d'une opération qui attend le push. */
|
|
@@ -64,6 +64,7 @@ function newOperation(repo, kind, origin) {
|
|
|
64
64
|
steps: { clone: "pending", audit: "pending", fix: "pending", force: "pending", push: "pending" },
|
|
65
65
|
projects: [],
|
|
66
66
|
counts: { initial: null, afterFix: null, afterForce: null },
|
|
67
|
+
found: [],
|
|
67
68
|
remaining: [],
|
|
68
69
|
forceCandidates: [],
|
|
69
70
|
changes: [],
|
|
@@ -193,6 +194,7 @@ async function refreshChanges(runner) {
|
|
|
193
194
|
async function auditStep(runner) {
|
|
194
195
|
runner.setStep("audit", "running");
|
|
195
196
|
const vulnerabilities = await auditAll(runner, "initial");
|
|
197
|
+
runner.update((operation) => ({ ...operation, found: operation.remaining }));
|
|
196
198
|
runner.setStep("audit", "done");
|
|
197
199
|
return vulnerabilities;
|
|
198
200
|
}
|
|
@@ -379,6 +381,21 @@ export function startUserFix(ctx, repoId) {
|
|
|
379
381
|
}));
|
|
380
382
|
return operation;
|
|
381
383
|
}
|
|
384
|
+
/**
|
|
385
|
+
* Audit de la branche par défaut, celle que Dependabot analyse, lancé par
|
|
386
|
+
* l'utilisateur et attendu jusqu'à sa fin. Refusé si une opération est en
|
|
387
|
+
* cours sur le dépôt.
|
|
388
|
+
*/
|
|
389
|
+
export async function runDefaultBranchAudit(ctx, repoId) {
|
|
390
|
+
ctx.githubConfig();
|
|
391
|
+
const repo = ctx.store.getRepo(repoId);
|
|
392
|
+
const operation = ctx.store.createOperation({ ...newOperation(repo, "audit", "user"), baseBranch: repo.defaultBranch });
|
|
393
|
+
return execute(ctx, operation.id, async (runner) => {
|
|
394
|
+
await cloneStep(runner);
|
|
395
|
+
await auditStep(runner);
|
|
396
|
+
finish(runner);
|
|
397
|
+
});
|
|
398
|
+
}
|
|
382
399
|
/** Applique ou passe `npm audit fix --force` sur une opération qui attend cette décision. */
|
|
383
400
|
export function decideForce(ctx, id, apply) {
|
|
384
401
|
const operation = resume(ctx, id, "waiting_force", (current) => current);
|
package/dist/src/core/repos.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { type Alert, type AlertSeverity, type HandledAlert, type Operation, type PullRequest, type Repo, type Rights } from "../../shared/schemas/model.schema.js";
|
|
2
|
-
import type { RepoView } from "../../shared/schemas/api.schema.js";
|
|
2
|
+
import type { AuditFindings, RepoView } from "../../shared/schemas/api.schema.js";
|
|
3
3
|
import type { GitHubConfig } from "./config.js";
|
|
4
4
|
import { type OpenPullRequest } from "./github.js";
|
|
5
5
|
import { type Store } from "./store.js";
|
|
@@ -10,12 +10,14 @@ export declare function sortAlerts(alerts: Alert[]): Alert[];
|
|
|
10
10
|
/** Nombre d'alertes ouvertes par gravité. */
|
|
11
11
|
export declare function countBySeverity(alerts: Alert[]): Record<AlertSeverity, number>;
|
|
12
12
|
/**
|
|
13
|
-
* Dépôts triés par gravité la plus haute, puis par nombre
|
|
14
|
-
* nom
|
|
15
|
-
*
|
|
13
|
+
* Dépôts triés par gravité la plus haute, puis par nombre de vulnérabilités,
|
|
14
|
+
* puis par nom. Comptent les alertes non corrigées à la main et, sans alerte,
|
|
15
|
+
* les vulnérabilités du dernier audit ; un dépôt sans rien de tout cela vient
|
|
16
|
+
* en dernier.
|
|
16
17
|
*/
|
|
17
18
|
export declare function sortRepos<T extends {
|
|
18
19
|
repo: Repo;
|
|
20
|
+
auditFindings?: AuditFindings | null;
|
|
19
21
|
}>(views: T[]): T[];
|
|
20
22
|
/**
|
|
21
23
|
* Date du dernier audit, quand il n'a trouvé aucune vulnérabilité alors que
|
|
@@ -24,6 +26,12 @@ export declare function sortRepos<T extends {
|
|
|
24
26
|
* alertes. Null sinon. `operations` va de la plus récente à la plus ancienne.
|
|
25
27
|
*/
|
|
26
28
|
export declare function cleanAuditAt(repo: Repo, operations: Operation[]): string | null;
|
|
29
|
+
/**
|
|
30
|
+
* Vulnérabilités trouvées par le dernier audit de la branche par défaut, la
|
|
31
|
+
* seule que Dependabot analyse, quand Dependabot ne signale aucune alerte.
|
|
32
|
+
* Null sinon. `operations` va de la plus récente à la plus ancienne.
|
|
33
|
+
*/
|
|
34
|
+
export declare function auditFindings(repo: Repo, operations: Operation[]): AuditFindings | null;
|
|
27
35
|
/**
|
|
28
36
|
* Paquets pour lesquels le dernier audit n'a trouvé aucune version corrigée,
|
|
29
37
|
* hors ceux dont une alerte est marquée corrigée à la main. `operations` va de
|
package/dist/src/core/repos.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { pendingAlerts } from "../../shared/alerts.js";
|
|
1
|
+
import { fromNpmSeverity, pendingAlerts, worstOf } from "../../shared/alerts.js";
|
|
2
2
|
import { ALERT_SEVERITIES, DEFAULT_RIGHTS } from "../../shared/schemas/model.schema.js";
|
|
3
3
|
import { ConflictError, NotFoundError } from "./errors.js";
|
|
4
4
|
import { GitHubClient } from "./github.js";
|
|
@@ -22,19 +22,23 @@ export function countBySeverity(alerts) {
|
|
|
22
22
|
return counts;
|
|
23
23
|
}
|
|
24
24
|
/**
|
|
25
|
-
* Dépôts triés par gravité la plus haute, puis par nombre
|
|
26
|
-
* nom
|
|
27
|
-
*
|
|
25
|
+
* Dépôts triés par gravité la plus haute, puis par nombre de vulnérabilités,
|
|
26
|
+
* puis par nom. Comptent les alertes non corrigées à la main et, sans alerte,
|
|
27
|
+
* les vulnérabilités du dernier audit ; un dépôt sans rien de tout cela vient
|
|
28
|
+
* en dernier.
|
|
28
29
|
*/
|
|
29
30
|
export function sortRepos(views) {
|
|
30
|
-
const key = (
|
|
31
|
-
const pending = pendingAlerts(repo);
|
|
32
|
-
const
|
|
33
|
-
|
|
31
|
+
const key = (view) => {
|
|
32
|
+
const pending = pendingAlerts(view.repo);
|
|
33
|
+
const severities = pending.map((alert) => alert.severity);
|
|
34
|
+
if (view.auditFindings)
|
|
35
|
+
severities.push(view.auditFindings.severity);
|
|
36
|
+
const worst = severities.reduce((best, severity) => Math.min(best, severityRank(severity)), ALERT_SEVERITIES.length);
|
|
37
|
+
return { worst, count: pending.length + (view.auditFindings?.count ?? 0) };
|
|
34
38
|
};
|
|
35
39
|
return [...views].sort((a, b) => {
|
|
36
|
-
const ka = key(a
|
|
37
|
-
const kb = key(b
|
|
40
|
+
const ka = key(a);
|
|
41
|
+
const kb = key(b);
|
|
38
42
|
return ka.worst - kb.worst || kb.count - ka.count || a.repo.id.localeCompare(b.repo.id);
|
|
39
43
|
});
|
|
40
44
|
}
|
|
@@ -53,6 +57,20 @@ export function cleanAuditAt(repo, operations) {
|
|
|
53
57
|
const auditedAt = Date.parse(audited.createdAt);
|
|
54
58
|
return repo.alerts.every((alert) => Date.parse(alert.createdAt) <= auditedAt) ? audited.createdAt : null;
|
|
55
59
|
}
|
|
60
|
+
/**
|
|
61
|
+
* Vulnérabilités trouvées par le dernier audit de la branche par défaut, la
|
|
62
|
+
* seule que Dependabot analyse, quand Dependabot ne signale aucune alerte.
|
|
63
|
+
* Null sinon. `operations` va de la plus récente à la plus ancienne.
|
|
64
|
+
*/
|
|
65
|
+
export function auditFindings(repo, operations) {
|
|
66
|
+
if (repo.alerts.length > 0)
|
|
67
|
+
return null;
|
|
68
|
+
const audited = operations.find((operation) => operation.steps.audit === "done" && operation.baseBranch === repo.defaultBranch);
|
|
69
|
+
const severity = audited ? worstOf(audited.found.map((vulnerability) => fromNpmSeverity(vulnerability.severity))) : null;
|
|
70
|
+
if (!audited || severity === null)
|
|
71
|
+
return null;
|
|
72
|
+
return { at: audited.createdAt, count: audited.found.length, severity };
|
|
73
|
+
}
|
|
56
74
|
/**
|
|
57
75
|
* Paquets pour lesquels le dernier audit n'a trouvé aucune version corrigée,
|
|
58
76
|
* hors ceux dont une alerte est marquée corrigée à la main. `operations` va de
|
|
@@ -94,6 +112,7 @@ export function repoView(store, repo) {
|
|
|
94
112
|
activeOperation: operations.find(isActive) ?? null,
|
|
95
113
|
latestOperation: operations[0] ?? null,
|
|
96
114
|
cleanAuditAt: cleanAuditAt(repo, operations),
|
|
115
|
+
auditFindings: auditFindings(repo, operations),
|
|
97
116
|
unfixable: unfixablePackages(repo, operations),
|
|
98
117
|
};
|
|
99
118
|
}
|
package/dist/src/core/store.js
CHANGED
|
@@ -62,6 +62,16 @@ function normalizeReposFile(file) {
|
|
|
62
62
|
})),
|
|
63
63
|
};
|
|
64
64
|
}
|
|
65
|
+
/**
|
|
66
|
+
* Complète une opération écrite par une version antérieure : sans `found`, les
|
|
67
|
+
* vulnérabilités du premier audit sont `remaining` tant qu'aucune correction
|
|
68
|
+
* n'a suivi, et inconnues sinon.
|
|
69
|
+
*/
|
|
70
|
+
function normalizeOperation(operation) {
|
|
71
|
+
if (operation === null || typeof operation !== "object" || operation.found !== undefined)
|
|
72
|
+
return operation;
|
|
73
|
+
return { ...operation, found: operation.counts?.afterFix === null ? operation.remaining : [] };
|
|
74
|
+
}
|
|
65
75
|
function sameName(a, b) {
|
|
66
76
|
return a.trim().toLowerCase() === b.trim().toLowerCase();
|
|
67
77
|
}
|
|
@@ -267,7 +277,7 @@ export class Store {
|
|
|
267
277
|
return null;
|
|
268
278
|
throw err;
|
|
269
279
|
}
|
|
270
|
-
const parsed = OperationSchema.safeParse(JSON.parse(raw));
|
|
280
|
+
const parsed = OperationSchema.safeParse(normalizeOperation(JSON.parse(raw)));
|
|
271
281
|
if (!parsed.success)
|
|
272
282
|
throw new TrackerError(`${file} is invalid: ${parsed.error.message}`);
|
|
273
283
|
return parsed.data;
|
package/dist/src/gui-worker.js
CHANGED
|
@@ -196,6 +196,8 @@ app.post("/api/repos", async (c) => {
|
|
|
196
196
|
return forward(c, "ADD_REPO", { body: read.body });
|
|
197
197
|
});
|
|
198
198
|
app.post("/api/sync", (c) => forward(c, "SYNC_REPOS"));
|
|
199
|
+
app.get("/api/audit-all", (c) => forward(c, "GET_AUDIT_ALL"));
|
|
200
|
+
app.post("/api/audit-all", (c) => forward(c, "START_AUDIT_ALL"));
|
|
199
201
|
app.get("/api/github/repos", (c) => forward(c, "LIST_ADDABLE_REPOS"));
|
|
200
202
|
app.get("/api/repos/:owner/:name", (c) => forward(c, "GET_REPO", { repoId: repoId(c) }));
|
|
201
203
|
app.delete("/api/repos/:owner/:name", (c) => forward(c, "REMOVE_REPO", { repoId: repoId(c) }));
|
package/dist/src/index.js
CHANGED
|
@@ -13,7 +13,8 @@ import { resolveLogDir } from "./core/log-dir.js";
|
|
|
13
13
|
import { githubConfigured, readGitHubConfig } from "./core/config.js";
|
|
14
14
|
import { ConflictError, NotFoundError, TrackerError } from "./core/errors.js";
|
|
15
15
|
import { Store } from "./core/store.js";
|
|
16
|
-
import { cancelOperation, decideForce, pushOperation, startUserFix } from "./core/operations.js";
|
|
16
|
+
import { cancelOperation, decideForce, pushOperation, runDefaultBranchAudit, startUserFix } from "./core/operations.js";
|
|
17
|
+
import { AuditAll } from "./core/audit-all.js";
|
|
17
18
|
import { SYNC_INTERVAL_MS, addRepository, listAddableRepositories, listRepoBranches, listRepoViews, markAlertHandled, setBranch, setCategory, repoView, setRights, staleRepos, syncAllRepositories, syncRepository, unmarkAlertHandled } from "./core/repos.js";
|
|
18
19
|
import { GUI_REQUEST_TYPES, IPCMessageSchema } from "../shared/schemas/ipc.schema.js";
|
|
19
20
|
import { AddRepoBodySchema, AlertRequestSchema, CategoryBodySchema, CategoryRequestSchema, ForceBodySchema, OperationRequestSchema, PushBodySchema, RepoRequestSchema, SetBranchBodySchema, SetCategoryBodySchema, SetRightsBodySchema, } from "../shared/schemas/api.schema.js";
|
|
@@ -71,6 +72,8 @@ const operations = {
|
|
|
71
72
|
cloneDir: resolveCloneDir,
|
|
72
73
|
logError: (message) => logger.error(message),
|
|
73
74
|
};
|
|
75
|
+
/** Série « Auditer tout » de la GUI servie par ce processus. */
|
|
76
|
+
const auditAll = new AuditAll((repoId) => runDefaultBranchAudit(operations, repoId), (message) => logger.error(message));
|
|
74
77
|
/** Présentation du serveur transmise au client MCP : concepts, déroulé et règles. */
|
|
75
78
|
const INSTRUCTIONS = `mcp-dependabot-tracker follows the Dependabot alerts of GitHub repositories and fixes their npm vulnerabilities. The user tracks repositories and decides what you may do on each of them in a web GUI; you act only through these tools, never with git or npm yourself.
|
|
76
79
|
|
|
@@ -135,6 +138,12 @@ async function handleGuiRequest(msg) {
|
|
|
135
138
|
case "SYNC_REPOS":
|
|
136
139
|
await syncAllRepositories(store, readGitHubConfig());
|
|
137
140
|
return { repos: listRepoViews(store), categories: store.listCategories() };
|
|
141
|
+
case "GET_AUDIT_ALL":
|
|
142
|
+
return { auditAll: auditAll.status() };
|
|
143
|
+
case "START_AUDIT_ALL":
|
|
144
|
+
readGitHubConfig();
|
|
145
|
+
store.failOrphanedOperations();
|
|
146
|
+
return { auditAll: auditAll.start(store.listRepos().map((repo) => repo.id)) };
|
|
138
147
|
case "LIST_ADDABLE_REPOS":
|
|
139
148
|
return { repositories: await listAddableRepositories(store, readGitHubConfig()) };
|
|
140
149
|
case "GET_REPO": {
|
package/dist/src/tools/format.js
CHANGED
|
@@ -37,6 +37,10 @@ export function describeRepo(view, category) {
|
|
|
37
37
|
if (view.cleanAuditAt) {
|
|
38
38
|
lines.push(` npm audit of ${view.cleanAuditAt} found no vulnerability on the default branch: these Dependabot alerts are probably not refreshed yet.`);
|
|
39
39
|
}
|
|
40
|
+
if (view.auditFindings) {
|
|
41
|
+
const { at, count, severity } = view.auditFindings;
|
|
42
|
+
lines.push(` npm audit of ${at} found ${count} vulnerabilit${count === 1 ? "y" : "ies"} (worst: ${severity}) on the default branch although Dependabot reports none: Dependabot has probably not caught up yet.`);
|
|
43
|
+
}
|
|
40
44
|
lines.push(` Agent rights: ${rightsLabel(repo)}`);
|
|
41
45
|
if (activeOperation)
|
|
42
46
|
lines.push(` Operation in progress: ${activeOperation.id} (${activeOperation.status})`);
|