@imenam/mcp-dependabot-tracker 1.0.6 → 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 +14 -6
- 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 +3 -0
- package/dist/shared/schemas/model.schema.d.ts +40 -2
- package/dist/shared/schemas/model.schema.js +13 -2
- package/dist/src/core/audit-all.d.ts +24 -0
- package/dist/src/core/audit-all.js +62 -0
- package/dist/src/core/github.d.ts +14 -2
- package/dist/src/core/github.js +19 -1
- package/dist/src/core/operations.d.ts +8 -0
- package/dist/src/core/operations.js +30 -1
- package/dist/src/core/repos.d.ts +27 -6
- package/dist/src/core/repos.js +53 -12
- package/dist/src/core/store.js +14 -2
- package/dist/src/gui-worker.js +3 -0
- package/dist/src/index.js +16 -4
- package/dist/src/tools/format.js +7 -0
- package/gui/dist/assets/index-D_wlwOtv.js +64 -0
- package/gui/dist/assets/{index-DYqEypkM.css → index-U8DEkNi4.css} +1 -1
- package/gui/dist/index.html +2 -2
- package/package.json +1 -1
- package/gui/dist/assets/index-CzKoNRZJ.js +0 -63
package/README.md
CHANGED
|
@@ -63,7 +63,7 @@ Un token à grain fin, limité aux dépôts suivis, avec les permissions :
|
|
|
63
63
|
|---|---|---|
|
|
64
64
|
| Dependabot alerts | lecture | lire les alertes |
|
|
65
65
|
| Contents | lecture et écriture | cloner, pousser la branche de correction |
|
|
66
|
-
| Pull requests | lecture et écriture | ouvrir la pull request |
|
|
66
|
+
| Pull requests | lecture et écriture | ouvrir la pull request, suivre celles qui attendent d'être mergées |
|
|
67
67
|
| Metadata | lecture | imposée par GitHub ; liste les dépôts proposés à l'ajout |
|
|
68
68
|
|
|
69
69
|
Un token classique convient aussi, avec les scopes `repo` et `security_events`. Les commits sont signés du compte du token, avec son adresse `noreply` GitHub. Le token est transmis à `git` par un en-tête HTTP (`http.<serveur>/.extraheader`, dans l'environnement de la commande) : il n'est écrit ni dans le clone ni dans la ligne de commande. Les commandes `git` et `npm` ne reçoivent pas `GITHUB_TOKEN` dans leur environnement.
|
|
@@ -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, 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. |
|
|
@@ -143,6 +143,10 @@ La **branche analysée** se choisit par dépôt dans la GUI ; c'est la branche p
|
|
|
143
143
|
4. **npm audit fix --force** — proposé quand des vulnérabilités restantes ne se corrigent que par une version majeure (`fixAvailable.isSemVerMajor` du rapport npm). L'écran liste les paquets concernés, leur version installée et la version cible, et le nombre de vulnérabilités en jeu.
|
|
144
144
|
5. **Commit et push** — commit des fichiers modifiés sur la branche `fix/npm-audit-<AAAA-MM-JJ>-<HHMMSS>` (heure locale du serveur, fixée quand la correction est prête), push, puis pull request vers la branche analysée. Son corps donne les vulnérabilités avant et après, l'application de `--force` et les paquets mis à jour.
|
|
145
145
|
|
|
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
|
+
|
|
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
|
+
|
|
146
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.
|
|
147
151
|
|
|
148
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.
|
|
@@ -155,9 +159,11 @@ Depuis la GUI, l'opération s'arrête aux étapes 4 et 5 pour la décision de l'
|
|
|
155
159
|
|
|
156
160
|
Thème sombre, une information par ligne, une action principale par écran.
|
|
157
161
|
|
|
158
|
-
- **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). « 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.
|
|
159
|
-
À droite, les dépôts de la catégorie choisie, du plus exposé au moins exposé (gravité la plus haute, puis nombre
|
|
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.
|
|
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.
|
|
160
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.
|
|
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.
|
|
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).
|
|
161
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).
|
|
162
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.
|
|
163
169
|
|
|
@@ -169,13 +175,15 @@ Les écrans se relisent par polling : toutes les 3 s pour les listes, toutes les
|
|
|
169
175
|
|
|
170
176
|
Deux processus, selon le standard de l'écosystème (`@imenam/mcp-gui-interface`) :
|
|
171
177
|
|
|
172
|
-
- **Maître MCP** (`src/index.ts`) — JSON-RPC sur stdio, outils (`src/tools/`), logique (`src/core/`), relecture des alertes toutes les 10 minutes, cycle de vie du worker via `GuiLauncher`.
|
|
178
|
+
- **Maître MCP** (`src/index.ts`) — JSON-RPC sur stdio, outils (`src/tools/`), logique (`src/core/`), relecture des alertes et des pull requests toutes les 10 minutes, cycle de vie du worker via `GuiLauncher`.
|
|
173
179
|
- **Worker GUI** (`src/gui-worker.ts`) — Hono, enregistrement auprès du proxy ou écoute sur `APP_PORT`, API REST transmise au maître par IPC, fichiers de la SPA avec la balise `<base>` du chemin de montage. Il écoute sur `127.0.0.1` derrière `honoGuiGuard`.
|
|
174
180
|
|
|
175
181
|
| Route | Effet |
|
|
176
182
|
|---|---|
|
|
177
183
|
| `GET /api/config` | Version, répertoire des données, présence du token. |
|
|
178
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? }`). |
|
|
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). |
|
|
179
187
|
| `GET /api/github/repos` | Dépôts accessibles au token (`/user/repos`) et pas encore suivis, pour les suggestions d'ajout. |
|
|
180
188
|
| `GET` / `DELETE /api/repos/:propriétaire/:nom` | Dépôt ; retrait. |
|
|
181
189
|
| `PUT /api/repos/:propriétaire/:nom/rights` | Droits de l'agent. |
|
|
@@ -216,4 +224,4 @@ cd gui && npm run lint # oxlint
|
|
|
216
224
|
| `gui/` | Vite + React 19 + zustand, CSS écrit à la main. |
|
|
217
225
|
| `test/` | Tests `node --test`. |
|
|
218
226
|
|
|
219
|
-
Les tests utilisent une fausse API GitHub (dépôts, alertes paginées, utilisateur, pull requests) et des dépôts nus locaux servis par `file://` (`GITHUB_API_URL`, `GITHUB_SERVER_URL`). `test/operations.test.ts` et `test/server.test.ts` lancent un vrai `npm audit` sur un petit projet vulnérable (`test/fixtures/vulnerable` : `lodash`, corrigé par `audit fix`, et `nth-check`, corrigé seulement par `--force`) : ils ont besoin du registre npm et sont ignorés, avec la raison, s'il est injoignable. `test/server.test.ts` lance le serveur sur stdio avec sa GUI sur un port libre et parcourt les outils, les droits et la correction complète depuis l'API de la GUI.
|
|
227
|
+
Les tests utilisent une fausse API GitHub (dépôts, alertes paginées, utilisateur, création et liste des pull requests) et des dépôts nus locaux servis par `file://` (`GITHUB_API_URL`, `GITHUB_SERVER_URL`). `test/operations.test.ts` et `test/server.test.ts` lancent un vrai `npm audit` sur un petit projet vulnérable (`test/fixtures/vulnerable` : `lodash`, corrigé par `audit fix`, et `nth-check`, corrigé seulement par `--force`) : ils ont besoin du registre npm et sont ignorés, avec la raison, s'il est injoignable. `test/server.test.ts` lance le serveur sur stdio avec sa GUI sur un port libre et parcourt les outils, les droits et la correction complète depuis l'API de la GUI.
|
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", "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];
|
|
@@ -45,6 +45,14 @@ export declare const HandledAlertSchema: z.ZodObject<{
|
|
|
45
45
|
markedAt: z.ZodString;
|
|
46
46
|
}, z.core.$strip>;
|
|
47
47
|
export type HandledAlert = z.infer<typeof HandledAlertSchema>;
|
|
48
|
+
/** Pull request ouverte par le tracker, ni mergée ni fermée ; `branch` est sa branche `fix/npm-audit-…`. */
|
|
49
|
+
export declare const PullRequestSchema: z.ZodObject<{
|
|
50
|
+
number: z.ZodNumber;
|
|
51
|
+
url: z.ZodString;
|
|
52
|
+
branch: z.ZodString;
|
|
53
|
+
createdAt: z.ZodString;
|
|
54
|
+
}, z.core.$strip>;
|
|
55
|
+
export type PullRequest = z.infer<typeof PullRequestSchema>;
|
|
48
56
|
/** Catégorie de dépôts, choisie par l'utilisateur ; un dépôt appartient à une catégorie au plus. */
|
|
49
57
|
export declare const CategorySchema: z.ZodObject<{
|
|
50
58
|
id: z.ZodString;
|
|
@@ -55,7 +63,8 @@ export type Category = z.infer<typeof CategorySchema>;
|
|
|
55
63
|
* Dépôt suivi. `id` est le nom complet GitHub, `propriétaire/nom` ; `branch` est
|
|
56
64
|
* la branche que les opérations clonent et vers laquelle la pull request est ouverte ;
|
|
57
65
|
* `categoryId` est sa catégorie, null s'il n'est rangé dans aucune ;
|
|
58
|
-
* `handledAlerts` les alertes qu'il a marquées corrigées à la main
|
|
66
|
+
* `handledAlerts` les alertes qu'il a marquées corrigées à la main ;
|
|
67
|
+
* `pullRequests` les pull requests du tracker encore ouvertes à la dernière lecture.
|
|
59
68
|
*/
|
|
60
69
|
export declare const RepoSchema: z.ZodObject<{
|
|
61
70
|
id: z.ZodString;
|
|
@@ -92,6 +101,12 @@ export declare const RepoSchema: z.ZodObject<{
|
|
|
92
101
|
package: z.ZodString;
|
|
93
102
|
markedAt: z.ZodString;
|
|
94
103
|
}, z.core.$strip>>;
|
|
104
|
+
pullRequests: z.ZodArray<z.ZodObject<{
|
|
105
|
+
number: z.ZodNumber;
|
|
106
|
+
url: z.ZodString;
|
|
107
|
+
branch: z.ZodString;
|
|
108
|
+
createdAt: z.ZodString;
|
|
109
|
+
}, z.core.$strip>>;
|
|
95
110
|
syncedAt: z.ZodNullable<z.ZodString>;
|
|
96
111
|
syncError: z.ZodNullable<z.ZodString>;
|
|
97
112
|
}, z.core.$strip>;
|
|
@@ -136,6 +151,12 @@ export declare const ReposFileSchema: z.ZodObject<{
|
|
|
136
151
|
package: z.ZodString;
|
|
137
152
|
markedAt: z.ZodString;
|
|
138
153
|
}, z.core.$strip>>;
|
|
154
|
+
pullRequests: z.ZodArray<z.ZodObject<{
|
|
155
|
+
number: z.ZodNumber;
|
|
156
|
+
url: z.ZodString;
|
|
157
|
+
branch: z.ZodString;
|
|
158
|
+
createdAt: z.ZodString;
|
|
159
|
+
}, z.core.$strip>>;
|
|
139
160
|
syncedAt: z.ZodNullable<z.ZodString>;
|
|
140
161
|
syncError: z.ZodNullable<z.ZodString>;
|
|
141
162
|
}, z.core.$strip>>;
|
|
@@ -204,7 +225,8 @@ export type LogEntry = z.infer<typeof LogEntrySchema>;
|
|
|
204
225
|
/**
|
|
205
226
|
* Opération d'audit ou de correction sur un clone temporaire. `workDir` est le
|
|
206
227
|
* clone, présent tant que l'opération n'est pas terminée ; `pid` est le processus
|
|
207
|
-
* 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.
|
|
208
230
|
*/
|
|
209
231
|
export declare const OperationSchema: z.ZodObject<{
|
|
210
232
|
id: z.ZodString;
|
|
@@ -274,6 +296,22 @@ export declare const OperationSchema: z.ZodObject<{
|
|
|
274
296
|
afterFix: z.ZodNullable<z.ZodNumber>;
|
|
275
297
|
afterForce: z.ZodNullable<z.ZodNumber>;
|
|
276
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>>;
|
|
277
315
|
remaining: z.ZodArray<z.ZodObject<{
|
|
278
316
|
project: z.ZodString;
|
|
279
317
|
name: z.ZodString;
|
|
@@ -34,6 +34,13 @@ export const HandledAlertSchema = z.object({
|
|
|
34
34
|
package: z.string(),
|
|
35
35
|
markedAt: z.string(),
|
|
36
36
|
});
|
|
37
|
+
/** Pull request ouverte par le tracker, ni mergée ni fermée ; `branch` est sa branche `fix/npm-audit-…`. */
|
|
38
|
+
export const PullRequestSchema = z.object({
|
|
39
|
+
number: z.number().int(),
|
|
40
|
+
url: z.string(),
|
|
41
|
+
branch: z.string(),
|
|
42
|
+
createdAt: z.string(),
|
|
43
|
+
});
|
|
37
44
|
/** Catégorie de dépôts, choisie par l'utilisateur ; un dépôt appartient à une catégorie au plus. */
|
|
38
45
|
export const CategorySchema = z.object({
|
|
39
46
|
id: z.string(),
|
|
@@ -43,7 +50,8 @@ export const CategorySchema = z.object({
|
|
|
43
50
|
* Dépôt suivi. `id` est le nom complet GitHub, `propriétaire/nom` ; `branch` est
|
|
44
51
|
* la branche que les opérations clonent et vers laquelle la pull request est ouverte ;
|
|
45
52
|
* `categoryId` est sa catégorie, null s'il n'est rangé dans aucune ;
|
|
46
|
-
* `handledAlerts` les alertes qu'il a marquées corrigées à la main
|
|
53
|
+
* `handledAlerts` les alertes qu'il a marquées corrigées à la main ;
|
|
54
|
+
* `pullRequests` les pull requests du tracker encore ouvertes à la dernière lecture.
|
|
47
55
|
*/
|
|
48
56
|
export const RepoSchema = z.object({
|
|
49
57
|
id: z.string(),
|
|
@@ -56,6 +64,7 @@ export const RepoSchema = z.object({
|
|
|
56
64
|
rights: RightsSchema,
|
|
57
65
|
alerts: z.array(AlertSchema),
|
|
58
66
|
handledAlerts: z.array(HandledAlertSchema),
|
|
67
|
+
pullRequests: z.array(PullRequestSchema),
|
|
59
68
|
syncedAt: z.string().nullable(),
|
|
60
69
|
syncError: z.string().nullable(),
|
|
61
70
|
});
|
|
@@ -100,7 +109,8 @@ export const LogEntrySchema = z.object({ at: z.string(), text: z.string() });
|
|
|
100
109
|
/**
|
|
101
110
|
* Opération d'audit ou de correction sur un clone temporaire. `workDir` est le
|
|
102
111
|
* clone, présent tant que l'opération n'est pas terminée ; `pid` est le processus
|
|
103
|
-
* 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.
|
|
104
114
|
*/
|
|
105
115
|
export const OperationSchema = z.object({
|
|
106
116
|
id: z.string(),
|
|
@@ -127,6 +137,7 @@ export const OperationSchema = z.object({
|
|
|
127
137
|
afterFix: z.number().int().nullable(),
|
|
128
138
|
afterForce: z.number().int().nullable(),
|
|
129
139
|
}),
|
|
140
|
+
found: z.array(VulnerabilitySchema),
|
|
130
141
|
remaining: z.array(VulnerabilitySchema),
|
|
131
142
|
forceCandidates: z.array(ForceCandidateSchema),
|
|
132
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
|
+
}
|
|
@@ -14,9 +14,19 @@ export interface GitHubUser {
|
|
|
14
14
|
id: number;
|
|
15
15
|
name: string | null;
|
|
16
16
|
}
|
|
17
|
-
|
|
17
|
+
/** Pull request créée ; `createdAt` est sa date d'ouverture. */
|
|
18
|
+
export interface CreatedPullRequest {
|
|
18
19
|
number: number;
|
|
19
20
|
url: string;
|
|
21
|
+
createdAt: string;
|
|
22
|
+
}
|
|
23
|
+
/** Pull request ouverte ; `headRepo` est le dépôt de sa branche, null si ce dépôt a été supprimé. */
|
|
24
|
+
export interface OpenPullRequest {
|
|
25
|
+
number: number;
|
|
26
|
+
url: string;
|
|
27
|
+
branch: string;
|
|
28
|
+
headRepo: string | null;
|
|
29
|
+
createdAt: string;
|
|
20
30
|
}
|
|
21
31
|
/** URL de la page suivante dans un en-tête `Link` de pagination, ou null. */
|
|
22
32
|
export declare function nextPageUrl(link: string | null): string | null;
|
|
@@ -33,12 +43,14 @@ export declare class GitHubClient {
|
|
|
33
43
|
/** Noms des branches du dépôt, toutes pages comprises. */
|
|
34
44
|
listBranches(owner: string, name: string): Promise<string[]>;
|
|
35
45
|
getAuthenticatedUser(): Promise<GitHubUser>;
|
|
46
|
+
/** Pull requests ouvertes du dépôt, toutes pages comprises. */
|
|
47
|
+
listOpenPullRequests(owner: string, name: string): Promise<OpenPullRequest[]>;
|
|
36
48
|
createPullRequest(owner: string, name: string, pr: {
|
|
37
49
|
title: string;
|
|
38
50
|
head: string;
|
|
39
51
|
base: string;
|
|
40
52
|
body: string;
|
|
41
|
-
}): Promise<
|
|
53
|
+
}): Promise<CreatedPullRequest>;
|
|
42
54
|
}
|
|
43
55
|
/** Échec HTTP de l'API GitHub, avec son code. */
|
|
44
56
|
export declare class GitHubApiError extends TrackerError {
|
package/dist/src/core/github.js
CHANGED
|
@@ -126,9 +126,27 @@ export class GitHubClient {
|
|
|
126
126
|
const { json } = await this.request("GET", "/user");
|
|
127
127
|
return { login: json.login, id: json.id, name: json.name ?? null };
|
|
128
128
|
}
|
|
129
|
+
/** Pull requests ouvertes du dépôt, toutes pages comprises. */
|
|
130
|
+
async listOpenPullRequests(owner, name) {
|
|
131
|
+
const pulls = [];
|
|
132
|
+
let url = `/repos/${owner}/${name}/pulls?state=open&per_page=100`;
|
|
133
|
+
for (let page = 0; url !== null; page += 1) {
|
|
134
|
+
if (page === MAX_REPOSITORY_PAGES) {
|
|
135
|
+
throw new TrackerError(`${owner}/${name} has more than ${MAX_REPOSITORY_PAGES * 100} open pull requests; the tracker reads at most that many.`);
|
|
136
|
+
}
|
|
137
|
+
const { json, link } = await this.request("GET", url);
|
|
138
|
+
if (!Array.isArray(json))
|
|
139
|
+
throw new TrackerError(`GitHub API returned an unexpected list of pull requests for ${owner}/${name}.`);
|
|
140
|
+
for (const raw of json) {
|
|
141
|
+
pulls.push({ number: raw.number, url: raw.html_url, branch: raw.head?.ref ?? "", headRepo: raw.head?.repo?.full_name ?? null, createdAt: raw.created_at });
|
|
142
|
+
}
|
|
143
|
+
url = nextPageUrl(link);
|
|
144
|
+
}
|
|
145
|
+
return pulls;
|
|
146
|
+
}
|
|
129
147
|
async createPullRequest(owner, name, pr) {
|
|
130
148
|
const { json } = await this.request("POST", `/repos/${owner}/${name}/pulls`, pr);
|
|
131
|
-
return { number: json.number, url: json.html_url };
|
|
149
|
+
return { number: json.number, url: json.html_url, createdAt: json.created_at };
|
|
132
150
|
}
|
|
133
151
|
}
|
|
134
152
|
/** Échec HTTP de l'API GitHub, avec son code. */
|
|
@@ -19,11 +19,19 @@ export interface AgentPlan {
|
|
|
19
19
|
}
|
|
20
20
|
/** `fix/npm-audit-2026-10-28-143205`, à l'heure locale du serveur. */
|
|
21
21
|
export declare function branchName(date: Date): string;
|
|
22
|
+
/** Vrai pour une branche nommée par `branchName`. */
|
|
23
|
+
export declare function isTrackerBranch(branch: string): boolean;
|
|
22
24
|
/**
|
|
23
25
|
* Lance une correction depuis la GUI : clone, audit et `npm audit fix` s'exécutent
|
|
24
26
|
* en arrière-plan, puis l'opération attend la décision sur `--force` ou le push.
|
|
25
27
|
*/
|
|
26
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>;
|
|
27
35
|
/** Applique ou passe `npm audit fix --force` sur une opération qui attend cette décision. */
|
|
28
36
|
export declare function decideForce(ctx: OperationContext, id: string, apply: boolean): Operation;
|
|
29
37
|
/** Commit, push et pull request d'une opération qui attend le push. */
|
|
@@ -24,6 +24,10 @@ export function branchName(date) {
|
|
|
24
24
|
const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
|
|
25
25
|
return `fix/npm-audit-${day}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
|
|
26
26
|
}
|
|
27
|
+
/** Vrai pour une branche nommée par `branchName`. */
|
|
28
|
+
export function isTrackerBranch(branch) {
|
|
29
|
+
return /^fix\/npm-audit-\d{4}-\d{2}-\d{2}-\d{6}$/.test(branch);
|
|
30
|
+
}
|
|
27
31
|
/** Variables qui authentifient git auprès de GitHub par un en-tête HTTP, sans écrire le token dans le clone. */
|
|
28
32
|
function gitAuthEnv(config) {
|
|
29
33
|
const basic = Buffer.from(`x-access-token:${config.token}`).toString("base64");
|
|
@@ -60,6 +64,7 @@ function newOperation(repo, kind, origin) {
|
|
|
60
64
|
steps: { clone: "pending", audit: "pending", fix: "pending", force: "pending", push: "pending" },
|
|
61
65
|
projects: [],
|
|
62
66
|
counts: { initial: null, afterFix: null, afterForce: null },
|
|
67
|
+
found: [],
|
|
63
68
|
remaining: [],
|
|
64
69
|
forceCandidates: [],
|
|
65
70
|
changes: [],
|
|
@@ -90,6 +95,13 @@ class Runner {
|
|
|
90
95
|
update(fn) {
|
|
91
96
|
return this.ctx.store.updateOperation(this.id, fn);
|
|
92
97
|
}
|
|
98
|
+
/** Ajoute une pull request ouverte à celles en attente du dépôt. */
|
|
99
|
+
addPullRequest(pullRequest) {
|
|
100
|
+
this.ctx.store.updateRepo(this.operation.repoId, (repo) => ({
|
|
101
|
+
...repo,
|
|
102
|
+
pullRequests: [...repo.pullRequests.filter((candidate) => candidate.number !== pullRequest.number), pullRequest],
|
|
103
|
+
}));
|
|
104
|
+
}
|
|
93
105
|
setStep(step, state) {
|
|
94
106
|
this.update((operation) => ({ ...operation, steps: { ...operation.steps, [step]: state } }));
|
|
95
107
|
}
|
|
@@ -182,6 +194,7 @@ async function refreshChanges(runner) {
|
|
|
182
194
|
async function auditStep(runner) {
|
|
183
195
|
runner.setStep("audit", "running");
|
|
184
196
|
const vulnerabilities = await auditAll(runner, "initial");
|
|
197
|
+
runner.update((operation) => ({ ...operation, found: operation.remaining }));
|
|
185
198
|
runner.setStep("audit", "done");
|
|
186
199
|
return vulnerabilities;
|
|
187
200
|
}
|
|
@@ -262,7 +275,8 @@ async function pushStep(runner) {
|
|
|
262
275
|
throw new TrackerError(`Branch ${branch} was pushed, but the pull request could not be opened: ${err?.message ?? err}`);
|
|
263
276
|
}
|
|
264
277
|
runner.log(`Pull request #${pullRequest.number}: ${pullRequest.url}`);
|
|
265
|
-
runner.update((current) => ({ ...current, pullRequest }));
|
|
278
|
+
runner.update((current) => ({ ...current, pullRequest: { number: pullRequest.number, url: pullRequest.url } }));
|
|
279
|
+
runner.addPullRequest({ number: pullRequest.number, url: pullRequest.url, branch, createdAt: pullRequest.createdAt });
|
|
266
280
|
runner.setStep("push", "done");
|
|
267
281
|
}
|
|
268
282
|
// --- Enchaînement ------------------------------------------------------------
|
|
@@ -367,6 +381,21 @@ export function startUserFix(ctx, repoId) {
|
|
|
367
381
|
}));
|
|
368
382
|
return operation;
|
|
369
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
|
+
}
|
|
370
399
|
/** Applique ou passe `npm audit fix --force` sur une opération qui attend cette décision. */
|
|
371
400
|
export function decideForce(ctx, id, apply) {
|
|
372
401
|
const operation = resume(ctx, id, "waiting_force", (current) => current);
|