@imenam/mcp-dependabot-tracker 1.0.3 → 1.0.5
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 +13 -7
- package/dist/shared/alerts.d.ts +5 -0
- package/dist/shared/alerts.js +10 -0
- package/dist/shared/schemas/api.schema.d.ts +38 -3
- package/dist/shared/schemas/api.schema.js +12 -2
- package/dist/shared/schemas/ipc.schema.d.ts +1 -1
- package/dist/shared/schemas/ipc.schema.js +7 -0
- package/dist/shared/schemas/model.schema.d.ts +40 -2
- package/dist/shared/schemas/model.schema.js +22 -3
- package/dist/src/core/github.js +4 -0
- package/dist/src/core/repos.d.ts +33 -4
- package/dist/src/core/repos.js +81 -6
- package/dist/src/core/store.d.ts +13 -3
- package/dist/src/core/store.js +100 -22
- package/dist/src/gui-worker.js +23 -1
- package/dist/src/index.js +33 -6
- package/dist/src/tools/format.d.ts +3 -2
- package/dist/src/tools/format.js +20 -6
- package/dist/src/tools/tools.d.ts +1 -0
- package/dist/src/tools/tools.js +20 -5
- package/gui/dist/assets/index-CrklzpzY.js +63 -0
- package/gui/dist/assets/index-DYqEypkM.css +1 -0
- package/gui/dist/index.html +2 -2
- package/package.json +1 -1
- package/gui/dist/assets/index-DFY8u9sj.js +0 -63
- package/gui/dist/assets/index-Djyhcaqb.css +0 -1
package/README.md
CHANGED
|
@@ -121,8 +121,8 @@ 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 : alertes Dependabot ouvertes par
|
|
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, lien. |
|
|
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. |
|
|
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. |
|
|
128
128
|
| `reconnect_gui` | — | Relance le worker GUI et le réenregistre auprès du proxy. |
|
|
@@ -155,9 +155,11 @@ Depuis la GUI, l'opération s'arrête aux étapes 4 et 5 pour la décision de l'
|
|
|
155
155
|
|
|
156
156
|
Thème sombre, une information par ligne, une action principale par écran.
|
|
157
157
|
|
|
158
|
-
- **Accueil (
|
|
159
|
-
|
|
160
|
-
|
|
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 d'alertes). L'interrupteur « Vulnérables seulement » cache les dépôts sans alerte ouverte ; 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 », « 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. « ⚠ 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, ni pour « Vulnérables seulement » ; quand elles le sont toutes, la ligne affiche « Corrigé à la main » et estompe la pastille.
|
|
160
|
+
« 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.
|
|
161
|
+
- **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
|
+
- **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.
|
|
161
163
|
|
|
162
164
|
Les écrans se relisent par polling : toutes les 3 s pour les listes, toutes les secondes pendant une opération.
|
|
163
165
|
|
|
@@ -173,11 +175,15 @@ Deux processus, selon le standard de l'écosystème (`@imenam/mcp-gui-interface`
|
|
|
173
175
|
| Route | Effet |
|
|
174
176
|
|---|---|
|
|
175
177
|
| `GET /api/config` | Version, répertoire des données, présence du token. |
|
|
176
|
-
| `GET /api/repos`, `POST /api/repos` | Dépôts suivis (avec opération en cours et dernière opération) ; ajout d'un dépôt. |
|
|
178
|
+
| `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? }`). |
|
|
177
179
|
| `GET /api/github/repos` | Dépôts accessibles au token (`/user/repos`) et pas encore suivis, pour les suggestions d'ajout. |
|
|
178
180
|
| `GET` / `DELETE /api/repos/:propriétaire/:nom` | Dépôt ; retrait. |
|
|
179
181
|
| `PUT /api/repos/:propriétaire/:nom/rights` | Droits de l'agent. |
|
|
180
182
|
| `GET /api/repos/:propriétaire/:nom/branches`, `PUT …/branch` | Branches du dépôt, la branche par défaut en tête ; choix de la branche analysée (`{ branch }`, qui doit exister). |
|
|
183
|
+
| `PUT` / `DELETE /api/repos/:propriétaire/:nom/alerts/:numéro/handled` | Marque une alerte ouverte corrigée à la main ; retire la marque. |
|
|
184
|
+
| `PUT /api/repos/:propriétaire/:nom/category` | Catégorie du dépôt (`{ categoryId }`, null pour aucune). |
|
|
185
|
+
| `GET /api/categories`, `POST /api/categories` | Catégories dans l'ordre alphabétique ; création (`{ name }`, unique sans tenir compte de la casse). |
|
|
186
|
+
| `PUT` / `DELETE /api/categories/:id` | Renommage (`{ name }`) ; suppression, ses dépôts restant sans catégorie. |
|
|
181
187
|
| `POST /api/repos/:propriétaire/:nom/operations` | Lance une correction. |
|
|
182
188
|
| `GET /api/operations/:id` | Opération. |
|
|
183
189
|
| `POST /api/operations/:id/force`, `/push`, `/cancel` | Décision `--force` (`{ apply }`), push (`{ commitMessage }`), annulation. |
|
|
@@ -186,7 +192,7 @@ Erreurs : `400` requête invalide, `404` introuvable, `409` conflit (opération
|
|
|
186
192
|
|
|
187
193
|
### Persistance
|
|
188
194
|
|
|
189
|
-
`<données>/repos.json` pour les dépôts (droits, alertes, dernière lecture) et `<données>/operations/<id>.json` pour chaque opération ; les 20 plus récentes sont conservées par dépôt. Plusieurs instances du serveur (une par session d'agent) partagent le répertoire : les écritures sont atomiques et passent par le verrou `<données>/data.lock`. Une opération lancée par une instance se poursuit, s'annule ou se décide depuis la GUI d'une autre.
|
|
195
|
+
`<données>/repos.json` pour les catégories et les dépôts (catégorie, droits, alertes, alertes corrigées à la main, dernière lecture) et `<données>/operations/<id>.json` pour chaque opération ; les 20 plus récentes sont conservées par dépôt. Plusieurs instances du serveur (une par session d'agent) partagent le répertoire : les écritures sont atomiques et passent par le verrou `<données>/data.lock`. Une opération lancée par une instance se poursuit, s'annule ou se décide depuis la GUI d'une autre.
|
|
190
196
|
|
|
191
197
|
---
|
|
192
198
|
|
|
@@ -0,0 +1,5 @@
|
|
|
1
|
+
import type { Alert, Repo } from "./schemas/model.schema.js";
|
|
2
|
+
/** Alertes ouvertes que l'utilisateur n'a pas marquées corrigées à la main. */
|
|
3
|
+
export declare function pendingAlerts(repo: Repo): Alert[];
|
|
4
|
+
/** Alertes ouvertes marquées corrigées à la main. */
|
|
5
|
+
export declare function handledAlerts(repo: Repo): Alert[];
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
/** Alertes ouvertes que l'utilisateur n'a pas marquées corrigées à la main. */
|
|
2
|
+
export function pendingAlerts(repo) {
|
|
3
|
+
const handled = new Set(repo.handledAlerts.map((mark) => mark.number));
|
|
4
|
+
return repo.alerts.filter((alert) => !handled.has(alert.number));
|
|
5
|
+
}
|
|
6
|
+
/** Alertes ouvertes marquées corrigées à la main. */
|
|
7
|
+
export function handledAlerts(repo) {
|
|
8
|
+
const handled = new Set(repo.handledAlerts.map((mark) => mark.number));
|
|
9
|
+
return repo.alerts.filter((alert) => handled.has(alert.number));
|
|
10
|
+
}
|
|
@@ -1,8 +1,9 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
|
-
import { type Operation, type Repo } from "./model.schema.js";
|
|
3
|
-
/** Corps de `POST /api/repos` : `propriétaire/nom` ou lien GitHub. */
|
|
2
|
+
import { type Category, type Operation, type Repo } from "./model.schema.js";
|
|
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;
|
|
6
|
+
categoryId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
6
7
|
}, z.core.$strip>;
|
|
7
8
|
export type AddRepoBody = z.infer<typeof AddRepoBodySchema>;
|
|
8
9
|
export declare const SetRightsBodySchema: z.ZodObject<{
|
|
@@ -18,6 +19,23 @@ export declare const SetBranchBodySchema: z.ZodObject<{
|
|
|
18
19
|
branch: z.ZodString;
|
|
19
20
|
}, z.core.$strip>;
|
|
20
21
|
export type SetBranchBody = z.infer<typeof SetBranchBodySchema>;
|
|
22
|
+
/** Catégorie du dépôt ; null le sort de toute catégorie. */
|
|
23
|
+
export declare const SetCategoryBodySchema: z.ZodObject<{
|
|
24
|
+
categoryId: z.ZodNullable<z.ZodString>;
|
|
25
|
+
}, z.core.$strip>;
|
|
26
|
+
export type SetCategoryBody = z.infer<typeof SetCategoryBodySchema>;
|
|
27
|
+
/** Corps de `POST /api/categories` et de `PUT /api/categories/:id`. */
|
|
28
|
+
export declare const CategoryBodySchema: z.ZodObject<{
|
|
29
|
+
name: z.ZodString;
|
|
30
|
+
}, z.core.$strip>;
|
|
31
|
+
export type CategoryBody = z.infer<typeof CategoryBodySchema>;
|
|
32
|
+
export declare const CategoryRequestSchema: z.ZodObject<{
|
|
33
|
+
categoryId: z.ZodString;
|
|
34
|
+
}, z.core.$strip>;
|
|
35
|
+
/** Catégories dans l'ordre alphabétique. */
|
|
36
|
+
export interface CategoriesResponse {
|
|
37
|
+
categories: Category[];
|
|
38
|
+
}
|
|
21
39
|
/** Branches du dépôt, la branche par défaut en tête. */
|
|
22
40
|
export interface BranchesResponse {
|
|
23
41
|
branches: string[];
|
|
@@ -35,17 +53,34 @@ export type PushBody = z.infer<typeof PushBodySchema>;
|
|
|
35
53
|
export declare const RepoRequestSchema: z.ZodObject<{
|
|
36
54
|
repoId: z.ZodString;
|
|
37
55
|
}, z.core.$strip>;
|
|
56
|
+
/** Alerte d'un dépôt, par son numéro GitHub. */
|
|
57
|
+
export declare const AlertRequestSchema: z.ZodObject<{
|
|
58
|
+
repoId: z.ZodString;
|
|
59
|
+
number: z.ZodCoercedNumber<unknown>;
|
|
60
|
+
}, z.core.$strip>;
|
|
38
61
|
export declare const OperationRequestSchema: z.ZodObject<{
|
|
39
62
|
operationId: z.ZodString;
|
|
40
63
|
}, z.core.$strip>;
|
|
41
|
-
/**
|
|
64
|
+
/**
|
|
65
|
+
* Dépôt, sa catégorie, et l'état de son opération en cours et de la dernière
|
|
66
|
+
* opération, pour la liste et l'écran du dépôt. `cleanAuditAt` est la date du
|
|
67
|
+
* dernier audit quand il n'a trouvé aucune vulnérabilité alors que Dependabot
|
|
68
|
+
* signale encore des alertes émises avant lui ; `unfixable` les paquets pour
|
|
69
|
+
* lesquels le dernier audit n'a trouvé aucune version corrigée, hors ceux
|
|
70
|
+
* marqués corrigés à la main.
|
|
71
|
+
*/
|
|
42
72
|
export interface RepoView {
|
|
43
73
|
repo: Repo;
|
|
74
|
+
category: Category | null;
|
|
44
75
|
activeOperation: Operation | null;
|
|
45
76
|
latestOperation: Operation | null;
|
|
77
|
+
cleanAuditAt: string | null;
|
|
78
|
+
unfixable: string[];
|
|
46
79
|
}
|
|
80
|
+
/** Dépôts suivis et catégories, pour l'accueil et sa barre latérale. */
|
|
47
81
|
export interface ReposResponse {
|
|
48
82
|
repos: RepoView[];
|
|
83
|
+
categories: Category[];
|
|
49
84
|
}
|
|
50
85
|
/** Dépôts accessibles au token GitHub et pas encore suivis, `propriétaire/nom`. */
|
|
51
86
|
export interface AddableReposResponse {
|
|
@@ -1,12 +1,22 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
2
|
import { RightsSchema } from "./model.schema.js";
|
|
3
|
-
/** Corps de `POST /api/repos` : `propriétaire/nom` ou lien GitHub. */
|
|
4
|
-
export const AddRepoBodySchema = z.object({
|
|
3
|
+
/** Corps de `POST /api/repos` : `propriétaire/nom` ou lien GitHub, et la catégorie où le ranger (aucune par défaut). */
|
|
4
|
+
export const AddRepoBodySchema = z.object({
|
|
5
|
+
repository: z.string().trim().min(1),
|
|
6
|
+
categoryId: z.string().min(1).nullable().default(null),
|
|
7
|
+
});
|
|
5
8
|
export const SetRightsBodySchema = z.object({ rights: RightsSchema });
|
|
6
9
|
export const SetBranchBodySchema = z.object({ branch: z.string().trim().min(1) });
|
|
10
|
+
/** Catégorie du dépôt ; null le sort de toute catégorie. */
|
|
11
|
+
export const SetCategoryBodySchema = z.object({ categoryId: z.string().min(1).nullable() });
|
|
12
|
+
/** Corps de `POST /api/categories` et de `PUT /api/categories/:id`. */
|
|
13
|
+
export const CategoryBodySchema = z.object({ name: z.string().trim().min(1).max(60) });
|
|
14
|
+
export const CategoryRequestSchema = z.object({ categoryId: z.string().min(1) });
|
|
7
15
|
/** `apply` : lancer `npm audit fix --force` ; sinon l'étape est passée. */
|
|
8
16
|
export const ForceBodySchema = z.object({ apply: z.boolean() });
|
|
9
17
|
export const PushBodySchema = z.object({ commitMessage: z.string().trim().min(1) });
|
|
10
18
|
/** Identifiant d'un dépôt dans une requête IPC. */
|
|
11
19
|
export const RepoRequestSchema = z.object({ repoId: z.string().min(1) });
|
|
20
|
+
/** Alerte d'un dépôt, par son numéro GitHub. */
|
|
21
|
+
export const AlertRequestSchema = z.object({ repoId: z.string().min(1), number: z.coerce.number().int().positive() });
|
|
12
22
|
export const OperationRequestSchema = z.object({ operationId: z.string().min(1) });
|
|
@@ -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", "START_FIX", "GET_OPERATION", "DECIDE_FORCE", "PUSH_OPERATION", "CANCEL_OPERATION"];
|
|
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"];
|
|
26
26
|
export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];
|
|
@@ -25,6 +25,13 @@ export const GUI_REQUEST_TYPES = [
|
|
|
25
25
|
"SET_RIGHTS",
|
|
26
26
|
"LIST_BRANCHES",
|
|
27
27
|
"SET_BRANCH",
|
|
28
|
+
"SET_CATEGORY",
|
|
29
|
+
"MARK_ALERT_HANDLED",
|
|
30
|
+
"UNMARK_ALERT_HANDLED",
|
|
31
|
+
"LIST_CATEGORIES",
|
|
32
|
+
"CREATE_CATEGORY",
|
|
33
|
+
"RENAME_CATEGORY",
|
|
34
|
+
"DELETE_CATEGORY",
|
|
28
35
|
"START_FIX",
|
|
29
36
|
"GET_OPERATION",
|
|
30
37
|
"DECIDE_FORCE",
|
|
@@ -17,7 +17,7 @@ export declare const RightsSchema: z.ZodObject<{
|
|
|
17
17
|
export type Rights = z.infer<typeof RightsSchema>;
|
|
18
18
|
/** Droits d'un dépôt qui vient d'être ajouté : l'audit seul. */
|
|
19
19
|
export declare const DEFAULT_RIGHTS: Rights;
|
|
20
|
-
/** Alerte Dependabot ouverte, telle que la renvoie l'API GitHub, réduite à ce qui s'affiche. */
|
|
20
|
+
/** Alerte Dependabot ouverte, telle que la renvoie l'API GitHub, réduite à ce qui s'affiche ; `createdAt` est sa date d'émission. */
|
|
21
21
|
export declare const AlertSchema: z.ZodObject<{
|
|
22
22
|
number: z.ZodNumber;
|
|
23
23
|
severity: z.ZodEnum<{
|
|
@@ -32,11 +32,30 @@ export declare const AlertSchema: z.ZodObject<{
|
|
|
32
32
|
summary: z.ZodString;
|
|
33
33
|
url: z.ZodString;
|
|
34
34
|
patchedVersion: z.ZodNullable<z.ZodString>;
|
|
35
|
+
createdAt: z.ZodString;
|
|
35
36
|
}, z.core.$strip>;
|
|
36
37
|
export type Alert = z.infer<typeof AlertSchema>;
|
|
38
|
+
/**
|
|
39
|
+
* Alerte que l'utilisateur a corrigée à la main alors que Dependabot la signale
|
|
40
|
+
* encore. `package` est son paquet, `markedAt` la date du marquage.
|
|
41
|
+
*/
|
|
42
|
+
export declare const HandledAlertSchema: z.ZodObject<{
|
|
43
|
+
number: z.ZodNumber;
|
|
44
|
+
package: z.ZodString;
|
|
45
|
+
markedAt: z.ZodString;
|
|
46
|
+
}, z.core.$strip>;
|
|
47
|
+
export type HandledAlert = z.infer<typeof HandledAlertSchema>;
|
|
48
|
+
/** Catégorie de dépôts, choisie par l'utilisateur ; un dépôt appartient à une catégorie au plus. */
|
|
49
|
+
export declare const CategorySchema: z.ZodObject<{
|
|
50
|
+
id: z.ZodString;
|
|
51
|
+
name: z.ZodString;
|
|
52
|
+
}, z.core.$strip>;
|
|
53
|
+
export type Category = z.infer<typeof CategorySchema>;
|
|
37
54
|
/**
|
|
38
55
|
* Dépôt suivi. `id` est le nom complet GitHub, `propriétaire/nom` ; `branch` est
|
|
39
|
-
* la branche que les opérations clonent et vers laquelle la pull request est ouverte
|
|
56
|
+
* la branche que les opérations clonent et vers laquelle la pull request est ouverte ;
|
|
57
|
+
* `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.
|
|
40
59
|
*/
|
|
41
60
|
export declare const RepoSchema: z.ZodObject<{
|
|
42
61
|
id: z.ZodString;
|
|
@@ -44,6 +63,7 @@ export declare const RepoSchema: z.ZodObject<{
|
|
|
44
63
|
name: z.ZodString;
|
|
45
64
|
defaultBranch: z.ZodString;
|
|
46
65
|
branch: z.ZodString;
|
|
66
|
+
categoryId: z.ZodNullable<z.ZodString>;
|
|
47
67
|
addedAt: z.ZodString;
|
|
48
68
|
rights: z.ZodObject<{
|
|
49
69
|
audit: z.ZodBoolean;
|
|
@@ -65,18 +85,29 @@ export declare const RepoSchema: z.ZodObject<{
|
|
|
65
85
|
summary: z.ZodString;
|
|
66
86
|
url: z.ZodString;
|
|
67
87
|
patchedVersion: z.ZodNullable<z.ZodString>;
|
|
88
|
+
createdAt: z.ZodString;
|
|
89
|
+
}, z.core.$strip>>;
|
|
90
|
+
handledAlerts: z.ZodArray<z.ZodObject<{
|
|
91
|
+
number: z.ZodNumber;
|
|
92
|
+
package: z.ZodString;
|
|
93
|
+
markedAt: z.ZodString;
|
|
68
94
|
}, z.core.$strip>>;
|
|
69
95
|
syncedAt: z.ZodNullable<z.ZodString>;
|
|
70
96
|
syncError: z.ZodNullable<z.ZodString>;
|
|
71
97
|
}, z.core.$strip>;
|
|
72
98
|
export type Repo = z.infer<typeof RepoSchema>;
|
|
73
99
|
export declare const ReposFileSchema: z.ZodObject<{
|
|
100
|
+
categories: z.ZodArray<z.ZodObject<{
|
|
101
|
+
id: z.ZodString;
|
|
102
|
+
name: z.ZodString;
|
|
103
|
+
}, z.core.$strip>>;
|
|
74
104
|
repos: z.ZodArray<z.ZodObject<{
|
|
75
105
|
id: z.ZodString;
|
|
76
106
|
owner: z.ZodString;
|
|
77
107
|
name: z.ZodString;
|
|
78
108
|
defaultBranch: z.ZodString;
|
|
79
109
|
branch: z.ZodString;
|
|
110
|
+
categoryId: z.ZodNullable<z.ZodString>;
|
|
80
111
|
addedAt: z.ZodString;
|
|
81
112
|
rights: z.ZodObject<{
|
|
82
113
|
audit: z.ZodBoolean;
|
|
@@ -98,11 +129,18 @@ export declare const ReposFileSchema: z.ZodObject<{
|
|
|
98
129
|
summary: z.ZodString;
|
|
99
130
|
url: z.ZodString;
|
|
100
131
|
patchedVersion: z.ZodNullable<z.ZodString>;
|
|
132
|
+
createdAt: z.ZodString;
|
|
133
|
+
}, z.core.$strip>>;
|
|
134
|
+
handledAlerts: z.ZodArray<z.ZodObject<{
|
|
135
|
+
number: z.ZodNumber;
|
|
136
|
+
package: z.ZodString;
|
|
137
|
+
markedAt: z.ZodString;
|
|
101
138
|
}, z.core.$strip>>;
|
|
102
139
|
syncedAt: z.ZodNullable<z.ZodString>;
|
|
103
140
|
syncError: z.ZodNullable<z.ZodString>;
|
|
104
141
|
}, z.core.$strip>>;
|
|
105
142
|
}, z.core.$strip>;
|
|
143
|
+
export type ReposFile = z.infer<typeof ReposFileSchema>;
|
|
106
144
|
/** `audit` : clone et `npm audit` seulement ; `fix` : jusqu'aux corrections, à la branche et à la PR. */
|
|
107
145
|
export declare const OPERATION_KINDS: readonly ["audit", "fix"];
|
|
108
146
|
export type OperationKind = (typeof OPERATION_KINDS)[number];
|
|
@@ -13,7 +13,7 @@ export const RightsSchema = z.object({
|
|
|
13
13
|
});
|
|
14
14
|
/** Droits d'un dépôt qui vient d'être ajouté : l'audit seul. */
|
|
15
15
|
export const DEFAULT_RIGHTS = { audit: true, fix: false, force: false, push: false };
|
|
16
|
-
/** Alerte Dependabot ouverte, telle que la renvoie l'API GitHub, réduite à ce qui s'affiche. */
|
|
16
|
+
/** Alerte Dependabot ouverte, telle que la renvoie l'API GitHub, réduite à ce qui s'affiche ; `createdAt` est sa date d'émission. */
|
|
17
17
|
export const AlertSchema = z.object({
|
|
18
18
|
number: z.number().int(),
|
|
19
19
|
severity: z.enum(ALERT_SEVERITIES),
|
|
@@ -23,10 +23,27 @@ export const AlertSchema = z.object({
|
|
|
23
23
|
summary: z.string(),
|
|
24
24
|
url: z.string(),
|
|
25
25
|
patchedVersion: z.string().nullable(),
|
|
26
|
+
createdAt: z.string(),
|
|
27
|
+
});
|
|
28
|
+
/**
|
|
29
|
+
* Alerte que l'utilisateur a corrigée à la main alors que Dependabot la signale
|
|
30
|
+
* encore. `package` est son paquet, `markedAt` la date du marquage.
|
|
31
|
+
*/
|
|
32
|
+
export const HandledAlertSchema = z.object({
|
|
33
|
+
number: z.number().int(),
|
|
34
|
+
package: z.string(),
|
|
35
|
+
markedAt: z.string(),
|
|
36
|
+
});
|
|
37
|
+
/** Catégorie de dépôts, choisie par l'utilisateur ; un dépôt appartient à une catégorie au plus. */
|
|
38
|
+
export const CategorySchema = z.object({
|
|
39
|
+
id: z.string(),
|
|
40
|
+
name: z.string(),
|
|
26
41
|
});
|
|
27
42
|
/**
|
|
28
43
|
* Dépôt suivi. `id` est le nom complet GitHub, `propriétaire/nom` ; `branch` est
|
|
29
|
-
* la branche que les opérations clonent et vers laquelle la pull request est ouverte
|
|
44
|
+
* la branche que les opérations clonent et vers laquelle la pull request est ouverte ;
|
|
45
|
+
* `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.
|
|
30
47
|
*/
|
|
31
48
|
export const RepoSchema = z.object({
|
|
32
49
|
id: z.string(),
|
|
@@ -34,13 +51,15 @@ export const RepoSchema = z.object({
|
|
|
34
51
|
name: z.string(),
|
|
35
52
|
defaultBranch: z.string(),
|
|
36
53
|
branch: z.string(),
|
|
54
|
+
categoryId: z.string().nullable(),
|
|
37
55
|
addedAt: z.string(),
|
|
38
56
|
rights: RightsSchema,
|
|
39
57
|
alerts: z.array(AlertSchema),
|
|
58
|
+
handledAlerts: z.array(HandledAlertSchema),
|
|
40
59
|
syncedAt: z.string().nullable(),
|
|
41
60
|
syncError: z.string().nullable(),
|
|
42
61
|
});
|
|
43
|
-
export const ReposFileSchema = z.object({ repos: z.array(RepoSchema) });
|
|
62
|
+
export const ReposFileSchema = z.object({ categories: z.array(CategorySchema), repos: z.array(RepoSchema) });
|
|
44
63
|
/** `audit` : clone et `npm audit` seulement ; `fix` : jusqu'aux corrections, à la branche et à la PR. */
|
|
45
64
|
export const OPERATION_KINDS = ["audit", "fix"];
|
|
46
65
|
/** Qui a lancé l'opération : l'utilisateur depuis la GUI, ou l'agent par un outil MCP. */
|
package/dist/src/core/github.js
CHANGED
|
@@ -145,6 +145,9 @@ function toAlert(raw) {
|
|
|
145
145
|
if (!ALERT_SEVERITIES.includes(severity)) {
|
|
146
146
|
throw new TrackerError(`Dependabot alert #${raw?.number} has an unknown severity: ${JSON.stringify(severity)}.`);
|
|
147
147
|
}
|
|
148
|
+
if (typeof raw?.created_at !== "string") {
|
|
149
|
+
throw new TrackerError(`Dependabot alert #${raw?.number} has no creation date.`);
|
|
150
|
+
}
|
|
148
151
|
return {
|
|
149
152
|
number: raw.number,
|
|
150
153
|
severity: severity,
|
|
@@ -154,5 +157,6 @@ function toAlert(raw) {
|
|
|
154
157
|
summary: raw.security_advisory?.summary ?? "",
|
|
155
158
|
url: raw.html_url ?? "",
|
|
156
159
|
patchedVersion: raw.security_vulnerability?.first_patched_version?.identifier ?? null,
|
|
160
|
+
createdAt: raw.created_at,
|
|
157
161
|
};
|
|
158
162
|
}
|
package/dist/src/core/repos.d.ts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { type Alert, type AlertSeverity, type Repo, type Rights } from "../../shared/schemas/model.schema.js";
|
|
1
|
+
import { type Alert, type AlertSeverity, type HandledAlert, type Operation, type Repo, type Rights } from "../../shared/schemas/model.schema.js";
|
|
2
2
|
import type { RepoView } from "../../shared/schemas/api.schema.js";
|
|
3
3
|
import type { GitHubConfig } from "./config.js";
|
|
4
4
|
import { type Store } from "./store.js";
|
|
@@ -8,22 +8,51 @@ export declare const SYNC_INTERVAL_MS: number;
|
|
|
8
8
|
export declare function sortAlerts(alerts: Alert[]): Alert[];
|
|
9
9
|
/** Nombre d'alertes ouvertes par gravité. */
|
|
10
10
|
export declare function countBySeverity(alerts: Alert[]): Record<AlertSeverity, number>;
|
|
11
|
-
/**
|
|
11
|
+
/**
|
|
12
|
+
* Dépôts triés par gravité la plus haute, puis par nombre d'alertes, puis par
|
|
13
|
+
* nom, sans compter les alertes corrigées à la main ; un dépôt sans alerte
|
|
14
|
+
* restante vient en dernier.
|
|
15
|
+
*/
|
|
12
16
|
export declare function sortRepos<T extends {
|
|
13
17
|
repo: Repo;
|
|
14
18
|
}>(views: T[]): T[];
|
|
19
|
+
/**
|
|
20
|
+
* Date du dernier audit, quand il n'a trouvé aucune vulnérabilité alors que
|
|
21
|
+
* Dependabot signale encore des alertes : l'audit doit porter sur la branche
|
|
22
|
+
* par défaut, la seule que Dependabot analyse, et dater d'après chacune des
|
|
23
|
+
* alertes. Null sinon. `operations` va de la plus récente à la plus ancienne.
|
|
24
|
+
*/
|
|
25
|
+
export declare function cleanAuditAt(repo: Repo, operations: Operation[]): string | null;
|
|
26
|
+
/**
|
|
27
|
+
* Paquets pour lesquels le dernier audit n'a trouvé aucune version corrigée,
|
|
28
|
+
* hors ceux dont une alerte est marquée corrigée à la main. `operations` va de
|
|
29
|
+
* la plus récente à la plus ancienne.
|
|
30
|
+
*/
|
|
31
|
+
export declare function unfixablePackages(repo: Repo, operations: Operation[]): string[];
|
|
32
|
+
/**
|
|
33
|
+
* Marques « corrigée à la main » encore valables après une lecture des alertes :
|
|
34
|
+
* l'alerte est toujours ouverte, et aucune alerte du même paquet n'a été émise
|
|
35
|
+
* depuis le marquage.
|
|
36
|
+
*/
|
|
37
|
+
export declare function pruneHandledAlerts(handled: HandledAlert[], alerts: Alert[]): HandledAlert[];
|
|
15
38
|
export declare function repoView(store: Store, repo: Repo): RepoView;
|
|
16
39
|
export declare function listRepoViews(store: Store): RepoView[];
|
|
17
40
|
/** Relit les alertes Dependabot ouvertes du dépôt ; un échec est enregistré dans `syncError`, alertes précédentes conservées. */
|
|
18
41
|
export declare function syncRepository(store: Store, config: GitHubConfig, repoId: string): Promise<Repo>;
|
|
19
|
-
/** Suit un nouveau dépôt, avec l'audit pour seul droit de l'agent, puis lit ses alertes. */
|
|
20
|
-
export declare function addRepository(store: Store, config: GitHubConfig, input: string): Promise<Repo>;
|
|
42
|
+
/** Suit un nouveau dépôt, rangé dans `categoryId`, avec l'audit pour seul droit de l'agent, puis lit ses alertes. */
|
|
43
|
+
export declare function addRepository(store: Store, config: GitHubConfig, input: string, categoryId: string | null): Promise<Repo>;
|
|
21
44
|
/** Dépôts accessibles au token qui ne sont pas encore suivis, proposés à l'ajout. */
|
|
22
45
|
export declare function listAddableRepositories(store: Store, config: GitHubConfig): Promise<string[]>;
|
|
23
46
|
/** Branches du dépôt sur GitHub, la branche par défaut en tête, les autres dans l'ordre alphabétique. */
|
|
24
47
|
export declare function listRepoBranches(store: Store, config: GitHubConfig, repoId: string): Promise<string[]>;
|
|
25
48
|
/** Choisit la branche analysée ; elle doit exister sur GitHub. */
|
|
26
49
|
export declare function setBranch(store: Store, config: GitHubConfig, repoId: string, branch: string): Promise<Repo>;
|
|
50
|
+
/** Range le dépôt dans une catégorie, ou dans aucune avec null. */
|
|
51
|
+
export declare function setCategory(store: Store, repoId: string, categoryId: string | null): Repo;
|
|
52
|
+
/** Marque une alerte ouverte comme corrigée à la main ; sans effet si elle l'est déjà. */
|
|
53
|
+
export declare function markAlertHandled(store: Store, repoId: string, number: number): Repo;
|
|
54
|
+
/** Retire la marque « corrigée à la main » d'une alerte. */
|
|
55
|
+
export declare function unmarkAlertHandled(store: Store, repoId: string, number: number): Repo;
|
|
27
56
|
export declare function setRights(store: Store, repoId: string, rights: Rights): Repo;
|
|
28
57
|
/** Dépôts jamais synchronisés, ou synchronisés il y a plus de `maxAgeMs`. */
|
|
29
58
|
export declare function staleRepos(store: Store, maxAgeMs: number, at?: number): Repo[];
|
package/dist/src/core/repos.js
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { pendingAlerts } from "../../shared/alerts.js";
|
|
1
2
|
import { ALERT_SEVERITIES, DEFAULT_RIGHTS } from "../../shared/schemas/model.schema.js";
|
|
2
3
|
import { ConflictError, NotFoundError } from "./errors.js";
|
|
3
4
|
import { GitHubClient } from "./github.js";
|
|
@@ -19,11 +20,16 @@ export function countBySeverity(alerts) {
|
|
|
19
20
|
counts[alert.severity] += 1;
|
|
20
21
|
return counts;
|
|
21
22
|
}
|
|
22
|
-
/**
|
|
23
|
+
/**
|
|
24
|
+
* Dépôts triés par gravité la plus haute, puis par nombre d'alertes, puis par
|
|
25
|
+
* nom, sans compter les alertes corrigées à la main ; un dépôt sans alerte
|
|
26
|
+
* restante vient en dernier.
|
|
27
|
+
*/
|
|
23
28
|
export function sortRepos(views) {
|
|
24
29
|
const key = (repo) => {
|
|
25
|
-
const
|
|
26
|
-
|
|
30
|
+
const pending = pendingAlerts(repo);
|
|
31
|
+
const worst = pending.reduce((best, alert) => Math.min(best, severityRank(alert.severity)), ALERT_SEVERITIES.length);
|
|
32
|
+
return { worst, count: pending.length };
|
|
27
33
|
};
|
|
28
34
|
return [...views].sort((a, b) => {
|
|
29
35
|
const ka = key(a.repo);
|
|
@@ -31,12 +37,52 @@ export function sortRepos(views) {
|
|
|
31
37
|
return ka.worst - kb.worst || kb.count - ka.count || a.repo.id.localeCompare(b.repo.id);
|
|
32
38
|
});
|
|
33
39
|
}
|
|
40
|
+
/**
|
|
41
|
+
* Date du dernier audit, quand il n'a trouvé aucune vulnérabilité alors que
|
|
42
|
+
* Dependabot signale encore des alertes : l'audit doit porter sur la branche
|
|
43
|
+
* par défaut, la seule que Dependabot analyse, et dater d'après chacune des
|
|
44
|
+
* alertes. Null sinon. `operations` va de la plus récente à la plus ancienne.
|
|
45
|
+
*/
|
|
46
|
+
export function cleanAuditAt(repo, operations) {
|
|
47
|
+
if (repo.alerts.length === 0)
|
|
48
|
+
return null;
|
|
49
|
+
const audited = operations.find((operation) => operation.steps.audit === "done");
|
|
50
|
+
if (!audited || audited.counts.initial !== 0 || audited.baseBranch !== repo.defaultBranch)
|
|
51
|
+
return null;
|
|
52
|
+
const auditedAt = Date.parse(audited.createdAt);
|
|
53
|
+
return repo.alerts.every((alert) => Date.parse(alert.createdAt) <= auditedAt) ? audited.createdAt : null;
|
|
54
|
+
}
|
|
55
|
+
/**
|
|
56
|
+
* Paquets pour lesquels le dernier audit n'a trouvé aucune version corrigée,
|
|
57
|
+
* hors ceux dont une alerte est marquée corrigée à la main. `operations` va de
|
|
58
|
+
* la plus récente à la plus ancienne.
|
|
59
|
+
*/
|
|
60
|
+
export function unfixablePackages(repo, operations) {
|
|
61
|
+
const audited = operations.find((operation) => operation.steps.audit === "done");
|
|
62
|
+
if (!audited)
|
|
63
|
+
return [];
|
|
64
|
+
const handled = new Set(repo.handledAlerts.map((mark) => mark.package));
|
|
65
|
+
const names = audited.remaining.filter((vulnerability) => vulnerability.fix === "none" && !handled.has(vulnerability.name)).map((vulnerability) => vulnerability.name);
|
|
66
|
+
return [...new Set(names)].sort((a, b) => a.localeCompare(b));
|
|
67
|
+
}
|
|
68
|
+
/**
|
|
69
|
+
* Marques « corrigée à la main » encore valables après une lecture des alertes :
|
|
70
|
+
* l'alerte est toujours ouverte, et aucune alerte du même paquet n'a été émise
|
|
71
|
+
* depuis le marquage.
|
|
72
|
+
*/
|
|
73
|
+
export function pruneHandledAlerts(handled, alerts) {
|
|
74
|
+
const open = new Set(alerts.map((alert) => alert.number));
|
|
75
|
+
return handled.filter((mark) => open.has(mark.number) && !alerts.some((alert) => alert.package === mark.package && Date.parse(alert.createdAt) > Date.parse(mark.markedAt)));
|
|
76
|
+
}
|
|
34
77
|
export function repoView(store, repo) {
|
|
35
78
|
const operations = store.listOperations(repo.id);
|
|
36
79
|
return {
|
|
37
80
|
repo: { ...repo, alerts: sortAlerts(repo.alerts) },
|
|
81
|
+
category: repo.categoryId === null ? null : store.getCategory(repo.categoryId),
|
|
38
82
|
activeOperation: operations.find(isActive) ?? null,
|
|
39
83
|
latestOperation: operations[0] ?? null,
|
|
84
|
+
cleanAuditAt: cleanAuditAt(repo, operations),
|
|
85
|
+
unfixable: unfixablePackages(repo, operations),
|
|
40
86
|
};
|
|
41
87
|
}
|
|
42
88
|
export function listRepoViews(store) {
|
|
@@ -49,18 +95,26 @@ export async function syncRepository(store, config, repoId) {
|
|
|
49
95
|
const github = new GitHubClient(config);
|
|
50
96
|
try {
|
|
51
97
|
const alerts = await github.listOpenAlerts(repo.owner, repo.name);
|
|
52
|
-
return store.updateRepo(repo.id, (current) => ({
|
|
98
|
+
return store.updateRepo(repo.id, (current) => ({
|
|
99
|
+
...current,
|
|
100
|
+
alerts,
|
|
101
|
+
handledAlerts: pruneHandledAlerts(current.handledAlerts, alerts),
|
|
102
|
+
syncedAt: new Date().toISOString(),
|
|
103
|
+
syncError: null,
|
|
104
|
+
}));
|
|
53
105
|
}
|
|
54
106
|
catch (err) {
|
|
55
107
|
const message = err?.message ?? String(err);
|
|
56
108
|
return store.updateRepo(repo.id, (current) => ({ ...current, syncedAt: new Date().toISOString(), syncError: message }));
|
|
57
109
|
}
|
|
58
110
|
}
|
|
59
|
-
/** Suit un nouveau dépôt, avec l'audit pour seul droit de l'agent, puis lit ses alertes. */
|
|
60
|
-
export async function addRepository(store, config, input) {
|
|
111
|
+
/** Suit un nouveau dépôt, rangé dans `categoryId`, avec l'audit pour seul droit de l'agent, puis lit ses alertes. */
|
|
112
|
+
export async function addRepository(store, config, input, categoryId) {
|
|
61
113
|
const ref = parseRepoRef(input);
|
|
62
114
|
if (store.findRepo(`${ref.owner}/${ref.name}`))
|
|
63
115
|
throw new ConflictError(`Repository ${ref.owner}/${ref.name} is already tracked.`);
|
|
116
|
+
if (categoryId !== null)
|
|
117
|
+
store.getCategory(categoryId);
|
|
64
118
|
const remote = await new GitHubClient(config).getRepository(ref.owner, ref.name);
|
|
65
119
|
store.addRepo({
|
|
66
120
|
id: remote.fullName,
|
|
@@ -68,9 +122,11 @@ export async function addRepository(store, config, input) {
|
|
|
68
122
|
name: remote.name,
|
|
69
123
|
defaultBranch: remote.defaultBranch,
|
|
70
124
|
branch: remote.defaultBranch,
|
|
125
|
+
categoryId,
|
|
71
126
|
addedAt: new Date().toISOString(),
|
|
72
127
|
rights: DEFAULT_RIGHTS,
|
|
73
128
|
alerts: [],
|
|
129
|
+
handledAlerts: [],
|
|
74
130
|
syncedAt: null,
|
|
75
131
|
syncError: null,
|
|
76
132
|
});
|
|
@@ -96,6 +152,25 @@ export async function setBranch(store, config, repoId, branch) {
|
|
|
96
152
|
throw new NotFoundError(`Branch "${branch}" does not exist in ${store.getRepo(repoId).id}.`);
|
|
97
153
|
return store.updateRepo(repoId, (repo) => ({ ...repo, branch }));
|
|
98
154
|
}
|
|
155
|
+
/** Range le dépôt dans une catégorie, ou dans aucune avec null. */
|
|
156
|
+
export function setCategory(store, repoId, categoryId) {
|
|
157
|
+
return store.updateRepo(repoId, (repo) => ({ ...repo, categoryId }));
|
|
158
|
+
}
|
|
159
|
+
/** Marque une alerte ouverte comme corrigée à la main ; sans effet si elle l'est déjà. */
|
|
160
|
+
export function markAlertHandled(store, repoId, number) {
|
|
161
|
+
return store.updateRepo(repoId, (repo) => {
|
|
162
|
+
const alert = repo.alerts.find((candidate) => candidate.number === number);
|
|
163
|
+
if (!alert)
|
|
164
|
+
throw new NotFoundError(`Alert #${number} is not open on ${repo.id}.`);
|
|
165
|
+
if (repo.handledAlerts.some((mark) => mark.number === number))
|
|
166
|
+
return repo;
|
|
167
|
+
return { ...repo, handledAlerts: [...repo.handledAlerts, { number, package: alert.package, markedAt: new Date().toISOString() }] };
|
|
168
|
+
});
|
|
169
|
+
}
|
|
170
|
+
/** Retire la marque « corrigée à la main » d'une alerte. */
|
|
171
|
+
export function unmarkAlertHandled(store, repoId, number) {
|
|
172
|
+
return store.updateRepo(repoId, (repo) => ({ ...repo, handledAlerts: repo.handledAlerts.filter((mark) => mark.number !== number) }));
|
|
173
|
+
}
|
|
99
174
|
export function setRights(store, repoId, rights) {
|
|
100
175
|
return store.updateRepo(repoId, (repo) => ({ ...repo, rights }));
|
|
101
176
|
}
|
package/dist/src/core/store.d.ts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { type Operation, type Repo } from "../../shared/schemas/model.schema.js";
|
|
1
|
+
import { type Category, type Operation, type Repo } from "../../shared/schemas/model.schema.js";
|
|
2
2
|
/** Vrai si le processus `pid` existe encore. */
|
|
3
3
|
export declare function processAlive(pid: number): boolean;
|
|
4
4
|
export declare function isActive(operation: Operation): boolean;
|
|
@@ -16,16 +16,26 @@ export declare class Store {
|
|
|
16
16
|
constructor(dataDir: string);
|
|
17
17
|
/** Sérialise les écritures entre processus : `wx` échoue si le verrou existe déjà. Non réentrant. */
|
|
18
18
|
private withLock;
|
|
19
|
-
private
|
|
20
|
-
private
|
|
19
|
+
private readReposFile;
|
|
20
|
+
private writeReposFile;
|
|
21
21
|
listRepos(): Repo[];
|
|
22
22
|
/** Dépôt d'identifiant `propriétaire/nom`, sans tenir compte de la casse, comme GitHub. */
|
|
23
23
|
findRepo(repoId: string): Repo | null;
|
|
24
24
|
getRepo(repoId: string): Repo;
|
|
25
|
+
/** Ajoute un dépôt ; sa catégorie, s'il en a une, doit exister. */
|
|
25
26
|
addRepo(repo: Repo): Repo;
|
|
27
|
+
/** Modifie un dépôt ; une catégorie qui lui est attribuée doit exister. */
|
|
26
28
|
updateRepo(repoId: string, fn: (repo: Repo) => Repo): Repo;
|
|
27
29
|
/** Retire un dépôt et ses opérations ; refusé pendant une opération en cours. */
|
|
28
30
|
removeRepo(repoId: string): void;
|
|
31
|
+
/** Catégories dans l'ordre alphabétique. */
|
|
32
|
+
listCategories(): Category[];
|
|
33
|
+
getCategory(categoryId: string): Category;
|
|
34
|
+
/** Crée une catégorie ; deux catégories ne portent pas le même nom, sans tenir compte de la casse. */
|
|
35
|
+
createCategory(name: string): Category;
|
|
36
|
+
renameCategory(categoryId: string, name: string): Category;
|
|
37
|
+
/** Supprime une catégorie ; ses dépôts restent suivis, sans catégorie. */
|
|
38
|
+
deleteCategory(categoryId: string): void;
|
|
29
39
|
private operationPath;
|
|
30
40
|
private readOperationFile;
|
|
31
41
|
private readAllOperations;
|