@imenam/mcp-dependabot-tracker 1.0.14 → 1.0.16
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 -8
- package/dist/shared/schemas/api.schema.d.ts +53 -7
- package/dist/shared/schemas/api.schema.js +9 -1
- package/dist/shared/schemas/ipc.schema.d.ts +1 -1
- package/dist/shared/schemas/ipc.schema.js +4 -0
- package/dist/shared/schemas/model.schema.d.ts +190 -2
- package/dist/shared/schemas/model.schema.js +38 -2
- package/dist/src/core/analysis.d.ts +2 -2
- package/dist/src/core/analysis.js +1 -1
- package/dist/src/core/audit-all.d.ts +3 -3
- package/dist/src/core/audit-all.js +3 -3
- package/dist/src/core/claude.d.ts +5 -2
- package/dist/src/core/claude.js +22 -12
- package/dist/src/core/operations.d.ts +1 -1
- package/dist/src/core/operations.js +70 -10
- package/dist/src/core/repair.d.ts +2 -2
- package/dist/src/core/repair.js +1 -1
- package/dist/src/core/repos.d.ts +14 -2
- package/dist/src/core/repos.js +54 -2
- package/dist/src/core/store.js +3 -1
- package/dist/src/gui-worker.js +6 -2
- package/dist/src/index.js +18 -4
- package/gui/dist/assets/index-BSl4dwIY.css +1 -0
- package/gui/dist/assets/index-juOopa_9.js +64 -0
- package/gui/dist/index.html +2 -2
- package/package.json +1 -1
- package/gui/dist/assets/index-D98CR3xl.js +0 -64
- package/gui/dist/assets/index-DETLqB3f.css +0 -1
package/README.md
CHANGED
|
@@ -149,7 +149,7 @@ Le **périmètre** se choisit à chaque lancement d'une correction, d'un audit o
|
|
|
149
149
|
|
|
150
150
|
**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.
|
|
151
151
|
|
|
152
|
-
**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.
|
|
152
|
+
**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 de l'onglet affiché : tous les dépôts sur « Tous mes projets » et « Dépréciés », ceux de la catégorie quand une catégorie est affichée (le bouton s'intitule alors « Auditer la catégorie »), ceux de la file d'attente sur son onglet (« Auditer la file »), 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.
|
|
153
153
|
|
|
154
154
|
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.
|
|
155
155
|
|
|
@@ -205,17 +205,19 @@ L'étape « Commit et push » montre alors ce que Claude a changé : résumé, f
|
|
|
205
205
|
|
|
206
206
|
Thème sombre, une information par ligne, une action principale par écran.
|
|
207
207
|
|
|
208
|
-
- **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. En bas de la barre, « Dépréciés » ouvre l'onglet des dépôts dépréciés, avec leur nombre.
|
|
208
|
+
- **Accueil (`#/`, `#/c/<catégorie>`)** — à gauche, la barre des catégories : « Tous mes projets », « File d'attente » avec le nombre de dépôts qu'elle contient, 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. En bas de la barre, « Dépréciés » ouvre l'onglet des dépôts dépréciés, avec leur nombre.
|
|
209
209
|
À droite, les dépôts non dépréciés 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 », « Analyse par Claude… », « Audit en cours », « Synchronisation impossible » (l'erreur en infobulle) ou « À jour ». Devant, « Tâche MNT-12 » ouvre la tâche organizer de la dernière analyse, tant qu'elle n'est pas terminée. 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.
|
|
210
|
-
Chaque ligne porte, avant le chevron, un bouton discret (icône archive) mis en relief au survol : il marque le dépôt **déprécié** (refusé pendant une opération). Un dépôt déprécié n'est plus synchronisé ni audité (ni par la relecture des 10 minutes, ni par « Synchroniser maintenant » et « Auditer tout », ni par l'agent), ne compte dans aucune pastille et quitte sa catégorie à l'affichage tout en la gardant.
|
|
210
|
+
Chaque ligne porte, avant le chevron, un bouton discret (icône archive) mis en relief au survol : il marque le dépôt **déprécié** (refusé pendant une opération). Un dépôt déprécié n'est plus synchronisé ni audité (ni par la relecture des 10 minutes, ni par « Synchroniser maintenant » et « Auditer tout », ni par l'agent), ne compte dans aucune pastille et quitte sa catégorie à l'affichage tout en la gardant. Le marquer déprécié le retire aussi de la file d'attente.
|
|
211
|
+
Avant ce bouton, un second (icône de liste) met le dépôt dans la **file d'attente** ; il reste allumé tant que le dépôt y est, et un nouveau clic l'en retire. Dans une catégorie, « Tout ajouter à la file », à côté des interrupteurs, y met d'un coup tous ses dépôts qui n'y sont pas encore (inactif quand ils y sont tous).
|
|
211
212
|
« 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.
|
|
212
213
|
« 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.
|
|
213
214
|
« 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) : un clic l'audite en production, la flèche à côté propose « Production » ou « Toutes les dépendances » ; 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).
|
|
214
215
|
La roue dentée, à gauche de « Synchroniser maintenant », ouvre les réglages.
|
|
216
|
+
- **File d'attente (`#/queue`)** — les dépôts mis en file, non dépréciés, dans l'ordre de leur entrée dans la file, avec les mêmes informations et interrupteurs que l'accueil. Le chevron ouvre le dépôt pour l'auditer ou le corriger. « Traité », sur chaque ligne, retire le dépôt de la file sans toucher à sa catégorie.
|
|
215
217
|
- **Réglages (`#/settings`)** — connexion à l'organizer, token Claude et analyse automatique (voir [L'analyse par Claude](#lanalyse-par-claude)). Un token enregistré n'apparaît que par ses quatre derniers caractères, avec « Remplacer ». « Enregistrer » valide tout l'écran.
|
|
216
218
|
- **Dépréciés (`#/deprecated`)** — les dépôts dépréciés, du plus récent au plus ancien, avec la date de dépréciation. « Rétablir », sur chaque ligne, remet le dépôt dans sa catégorie et relit aussitôt ses alertes. Le chevron ouvre l'écran du dépôt, où « Corriger » est désactivé.
|
|
217
|
-
- **Dépôt (`#/r/<propriétaire>/<nom
|
|
218
|
-
- **Correction (`#/r/<propriétaire>/<nom>/op/<id>`)** — qui l'a lancée (vous ou l'agent), la branche clonée, le périmètre
|
|
219
|
+
- **Dépôt (`#/r/<propriétaire>/<nom>`, `#/r/<propriétaire>/<nom>/history`)** — 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) et date de la dernière lecture des alertes, puis deux onglets. **Alertes ouvertes**, avec leur nombre : 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 », une alerte sur une dépendance de développement l'étiquette « dév. ». 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. **Historique**, avec le nombre d'opérations : une ligne par opération conservée (les 20 dernières du dépôt), de la plus récente à la plus ancienne, avec audit ou correction, qui l'a lancée, le périmètre, la branche, la date, les vulnérabilités avant et après (le début de l'erreur pour une opération échouée), la part de Claude (« analyse », « analyse · 2 passages ») et l'issue (la pull request, « attend le push », « terminée », « annulée », « échouée ») ; chaque ligne ouvre l'opération. « Corriger » lance une correction en production ; la flèche à côté ouvre le choix du périmètre (« Production » ou « Toutes les dépendances », Échap ferme). « Reprendre la correction » rouvre celle en cours. À gauche d'« Agent », « Traité » retire de la file d'attente un dépôt qui y est et ramène à la file ; pour un dépôt hors de la file, « Ajouter à la file » l'y met (absent pour un dépôt déprécié). « 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).
|
|
220
|
+
- **Correction (`#/r/<propriétaire>/<nom>/op/<id>`)** — qui l'a lancée (vous ou l'agent), la branche clonée, le périmètre ; les flèches « 1 / 5 » passent à l'opération plus récente ou plus ancienne du dépôt, la flèche de retour ramène à son historique. Trois onglets : **Étapes**, **Claude** (quand Claude est intervenu) et **Journal**. 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é, « passé » quand l'utilisateur a passé `--force` (« passé · déconseillé par Claude » après son avis), « 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. Quand Claude analyse les vulnérabilités restantes, l'étape « Analyse par Claude » montre sa durée, ses tours et ses trois dernières actions, puis le lien vers la tâche organizer et un résumé. L'étape `--force` liste les montées majeures avec « Appliquer --force » et « Passer » ; après une analyse, elle donne l'avis de Claude et ce qu'il juge urgent de corriger à la main, et le bouton principal suit sa recommandation. L'étape « Corrections par Claude » affiche les remarques de la tâche, « Commenter la tâche », « Lancer les corrections » et « Passer au push » ; pendant le passage, sa durée, ses tours et les dernières actions de Claude (fichiers modifiés, commandes lancées) ; ensuite, sur sa ligne, les vulnérabilités corrigées et le nombre de fichiers modifiés. 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 » ; après des corrections par Claude, elle montre d'abord ce qu'il a changé, le nombre de commits de la branche, et « Relancer avec mes remarques ». Une erreur s'affiche sous l'étape qui a échoué. L'onglet « Claude » liste chaque session (l'analyse, puis chaque passage des corrections) avec son heure, sa durée, ses tours et son issue ; la session choisie, la plus récente par défaut, montre les tâches organizer relues, créées ou mises à jour, les remarques que Claude a reçues au lancement, le déroulé complet de ses messages et de ses actions (500 dernières par session), et son résultat : le rapport de l'analyse et l'avis sur `--force`, ou le résumé des corrections, les fichiers modifiés, le commit, les tests et les vulnérabilités restantes ; ou la raison de l'échec. L'onglet « Journal » montre les commandes lancées et leurs résultats ; « Annuler » arrête l'opération.
|
|
219
221
|
|
|
220
222
|
Les écrans se relisent par polling : toutes les 3 s pour les listes, toutes les secondes pendant une opération. Un écran rouvert affiche aussitôt la dernière réponse reçue, puis se met à jour ; seuls les réglages attendent une lecture fraîche.
|
|
221
223
|
|
|
@@ -233,18 +235,21 @@ Deux processus, selon le standard de l'écosystème (`@imenam/mcp-gui-interface`
|
|
|
233
235
|
| `GET /api/config` | Version, répertoire des données, présence du token. |
|
|
234
236
|
| `GET /api/repos`, `POST /api/repos` | Dépôts suivis, dépréciés compris (avec catégorie, opération en cours et dernière opération) et catégories ; ajout d'un dépôt (`{ repository, categoryId? }`). |
|
|
235
237
|
| `POST /api/sync` | Relit tout de suite les alertes et les pull requests de chaque dépôt suivi non déprécié, en parallèle ; renvoie les dépôts et les catégories. |
|
|
236
|
-
| `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 sur le périmètre `scope` du corps (`production` ou `all`
|
|
238
|
+
| `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 sur le périmètre `scope` du corps (`production` ou `all`) et les dépôts de `target` : `{ "kind": "all" }`, `{ "kind": "category", "categoryId": … }` ou `{ "kind": "queue" }` (`404` si la catégorie n'existe pas, `409` si une série est en cours). |
|
|
237
239
|
| `GET /api/github/repos` | Dépôts accessibles au token (`/user/repos`) et pas encore suivis, pour les suggestions d'ajout. |
|
|
238
240
|
| `GET` / `DELETE /api/repos/:propriétaire/:nom` | Dépôt ; retrait. |
|
|
239
|
-
| `PUT` / `DELETE /api/repos/:propriétaire/:nom/deprecated` | Marque le dépôt déprécié (`409` pendant une opération) ; le rétablit et relit ses alertes. |
|
|
241
|
+
| `PUT` / `DELETE /api/repos/:propriétaire/:nom/deprecated` | Marque le dépôt déprécié (`409` pendant une opération) et le retire de la file d'attente ; le rétablit et relit ses alertes. |
|
|
242
|
+
| `PUT` / `DELETE /api/repos/:propriétaire/:nom/queued` | Met le dépôt dans la file d'attente (`409` pour un dépôt déprécié ; sans effet s'il y est déjà) ; l'en retire. |
|
|
240
243
|
| `PUT /api/repos/:propriétaire/:nom/rights` | Droits de l'agent. |
|
|
241
244
|
| `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). |
|
|
242
245
|
| `PUT` / `DELETE /api/repos/:propriétaire/:nom/alerts/:numéro/handled` | Marque une alerte ouverte corrigée à la main ; retire la marque. |
|
|
243
246
|
| `PUT /api/repos/:propriétaire/:nom/category` | Catégorie du dépôt (`{ categoryId }`, null pour aucune). |
|
|
244
247
|
| `GET /api/categories`, `POST /api/categories` | Catégories dans l'ordre alphabétique ; création (`{ name }`, unique sans tenir compte de la casse). |
|
|
245
248
|
| `PUT` / `DELETE /api/categories/:id` | Renommage (`{ name }`) ; suppression, ses dépôts restant sans catégorie. |
|
|
249
|
+
| `PUT /api/categories/:id/queued` | Met dans la file d'attente les dépôts non dépréciés de la catégorie qui n'y sont pas encore ; rend la liste des dépôts et des catégories. |
|
|
246
250
|
| `POST /api/repos/:propriétaire/:nom/operations` | Lance une correction sur le périmètre `scope` du corps (`production` ou `all`). |
|
|
247
|
-
| `GET /api/operations
|
|
251
|
+
| `GET /api/repos/:owner/:name/operations` | Historique du dépôt : ses opérations conservées, sans journal ni sessions de Claude. |
|
|
252
|
+
| `GET /api/operations/:id` | Opération, avec les sessions de Claude. |
|
|
248
253
|
| `POST /api/operations/:id/force`, `/repair`, `/push`, `/cancel` | Décision `--force` (`{ apply }`), corrections par Claude lancées, relancées ou passées (`{ run }`), push (`{ commitMessage }`), annulation. |
|
|
249
254
|
| `GET /api/operations/:id/remarks` | Tâche de l'analyse de l'opération et ses commentaires récents, lus sur l'organizer. |
|
|
250
255
|
| `GET /api/settings`, `PUT /api/settings` | Réglages de l'analyse, tokens réduits à leurs quatre derniers caractères ; enregistrement (`{ organizerUrl, organizerToken?, claudeToken?, analysis }`, un token absent est gardé), refusé si la connexion à l'organizer ou le token Claude échoue. |
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
|
-
import { type AlertSeverity, type AnalysisTask, type AuditScope, type Category, type Operation, type Repo } from "./model.schema.js";
|
|
2
|
+
import { type AlertSeverity, type AnalysisTask, type AuditScope, type Category, type Operation, type Remark, 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;
|
|
@@ -40,7 +40,7 @@ export interface CategoriesResponse {
|
|
|
40
40
|
export interface BranchesResponse {
|
|
41
41
|
branches: string[];
|
|
42
42
|
}
|
|
43
|
-
/** Corps de `POST /api/repos/:owner/:name/operations`
|
|
43
|
+
/** Corps de `POST /api/repos/:owner/:name/operations` : le périmètre de l'audit. */
|
|
44
44
|
export declare const ScopeBodySchema: z.ZodObject<{
|
|
45
45
|
scope: z.ZodEnum<{
|
|
46
46
|
all: "all";
|
|
@@ -48,6 +48,32 @@ export declare const ScopeBodySchema: z.ZodObject<{
|
|
|
48
48
|
}>;
|
|
49
49
|
}, z.core.$strip>;
|
|
50
50
|
export type ScopeBody = z.infer<typeof ScopeBodySchema>;
|
|
51
|
+
/** Dépôts visés par « Auditer tout » : tous les dépôts suivis, ceux d'une catégorie, ou ceux de la file d'attente. */
|
|
52
|
+
export declare const AuditTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
53
|
+
kind: z.ZodLiteral<"all">;
|
|
54
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
55
|
+
kind: z.ZodLiteral<"category">;
|
|
56
|
+
categoryId: z.ZodString;
|
|
57
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
58
|
+
kind: z.ZodLiteral<"queue">;
|
|
59
|
+
}, z.core.$strip>], "kind">;
|
|
60
|
+
export type AuditTarget = z.infer<typeof AuditTargetSchema>;
|
|
61
|
+
/** Corps de `POST /api/audit-all` : le périmètre des audits et les dépôts visés. */
|
|
62
|
+
export declare const AuditAllBodySchema: z.ZodObject<{
|
|
63
|
+
scope: z.ZodEnum<{
|
|
64
|
+
all: "all";
|
|
65
|
+
production: "production";
|
|
66
|
+
}>;
|
|
67
|
+
target: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
68
|
+
kind: z.ZodLiteral<"all">;
|
|
69
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
70
|
+
kind: z.ZodLiteral<"category">;
|
|
71
|
+
categoryId: z.ZodString;
|
|
72
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
73
|
+
kind: z.ZodLiteral<"queue">;
|
|
74
|
+
}, z.core.$strip>], "kind">;
|
|
75
|
+
}, z.core.$strip>;
|
|
76
|
+
export type AuditAllBody = z.infer<typeof AuditAllBodySchema>;
|
|
51
77
|
/** `apply` : lancer `npm audit fix --force` ; sinon l'étape est passée. */
|
|
52
78
|
export declare const ForceBodySchema: z.ZodObject<{
|
|
53
79
|
apply: z.ZodBoolean;
|
|
@@ -111,11 +137,12 @@ export interface RepoView {
|
|
|
111
137
|
* Série « Auditer tout » : `done` dépôts traités sur `total`, dont ceux laissés
|
|
112
138
|
* de côté parce qu'une opération y était en cours (`skipped`) et ceux dont
|
|
113
139
|
* l'audit a échoué, avec la raison (`failed`) ; `scope` est le périmètre des
|
|
114
|
-
* audits.
|
|
140
|
+
* audits, `target` les dépôts visés.
|
|
115
141
|
*/
|
|
116
142
|
export interface AuditAllState {
|
|
117
143
|
running: boolean;
|
|
118
144
|
scope: AuditScope;
|
|
145
|
+
target: AuditTarget;
|
|
119
146
|
startedAt: string;
|
|
120
147
|
finishedAt: string | null;
|
|
121
148
|
total: number;
|
|
@@ -142,11 +169,30 @@ export interface AddableReposResponse {
|
|
|
142
169
|
export interface OperationResponse {
|
|
143
170
|
operation: Operation;
|
|
144
171
|
}
|
|
145
|
-
/**
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
172
|
+
/**
|
|
173
|
+
* Ligne de l'historique d'un dépôt : une opération sans son journal ni le
|
|
174
|
+
* déroulé de ses sessions. `after` est le nombre de vulnérabilités après la
|
|
175
|
+
* dernière étape qui a audité ; `claudeRuns` le nombre de passages des
|
|
176
|
+
* corrections par Claude.
|
|
177
|
+
*/
|
|
178
|
+
export interface OperationSummary {
|
|
179
|
+
id: string;
|
|
180
|
+
kind: Operation["kind"];
|
|
181
|
+
origin: Operation["origin"];
|
|
182
|
+
scope: AuditScope;
|
|
183
|
+
status: Operation["status"];
|
|
184
|
+
baseBranch: string;
|
|
149
185
|
createdAt: string;
|
|
186
|
+
before: number | null;
|
|
187
|
+
after: number | null;
|
|
188
|
+
analysed: boolean;
|
|
189
|
+
claudeRuns: number;
|
|
190
|
+
pullRequest: Operation["pullRequest"];
|
|
191
|
+
error: string | null;
|
|
192
|
+
}
|
|
193
|
+
/** Historique d'un dépôt, de l'opération la plus récente à la plus ancienne. */
|
|
194
|
+
export interface OperationsResponse {
|
|
195
|
+
operations: OperationSummary[];
|
|
150
196
|
}
|
|
151
197
|
/** Tâche de l'analyse d'une opération et ses commentaires récents, du plus ancien au plus récent. */
|
|
152
198
|
export interface RemarksResponse {
|
|
@@ -12,8 +12,16 @@ export const SetCategoryBodySchema = z.object({ categoryId: z.string().min(1).nu
|
|
|
12
12
|
/** Corps de `POST /api/categories` et de `PUT /api/categories/:id`. */
|
|
13
13
|
export const CategoryBodySchema = z.object({ name: z.string().trim().min(1).max(60) });
|
|
14
14
|
export const CategoryRequestSchema = z.object({ categoryId: z.string().min(1) });
|
|
15
|
-
/** Corps de `POST /api/repos/:owner/:name/operations`
|
|
15
|
+
/** Corps de `POST /api/repos/:owner/:name/operations` : le périmètre de l'audit. */
|
|
16
16
|
export const ScopeBodySchema = z.object({ scope: z.enum(AUDIT_SCOPES) });
|
|
17
|
+
/** Dépôts visés par « Auditer tout » : tous les dépôts suivis, ceux d'une catégorie, ou ceux de la file d'attente. */
|
|
18
|
+
export const AuditTargetSchema = z.discriminatedUnion("kind", [
|
|
19
|
+
z.object({ kind: z.literal("all") }),
|
|
20
|
+
z.object({ kind: z.literal("category"), categoryId: z.string().min(1) }),
|
|
21
|
+
z.object({ kind: z.literal("queue") }),
|
|
22
|
+
]);
|
|
23
|
+
/** Corps de `POST /api/audit-all` : le périmètre des audits et les dépôts visés. */
|
|
24
|
+
export const AuditAllBodySchema = ScopeBodySchema.extend({ target: AuditTargetSchema });
|
|
17
25
|
/** `apply` : lancer `npm audit fix --force` ; sinon l'étape est passée. */
|
|
18
26
|
export const ForceBodySchema = z.object({ apply: z.boolean() });
|
|
19
27
|
/** `run` : lancer ou relancer les corrections par Claude ; sinon l'étape est passée. */
|
|
@@ -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", "GET_AUDIT_ALL", "START_AUDIT_ALL", "LIST_ADDABLE_REPOS", "GET_REPO", "ADD_REPO", "REMOVE_REPO", "DEPRECATE_REPO", "RESTORE_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", "DECIDE_REPAIR", "GET_REMARKS", "PUSH_OPERATION", "CANCEL_OPERATION", "GET_SETTINGS", "SAVE_SETTINGS", "TEST_ORGANIZER"];
|
|
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", "DEPRECATE_REPO", "RESTORE_REPO", "QUEUE_REPO", "UNQUEUE_REPO", "QUEUE_CATEGORY", "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", "LIST_OPERATIONS", "DECIDE_FORCE", "DECIDE_REPAIR", "GET_REMARKS", "PUSH_OPERATION", "CANCEL_OPERATION", "GET_SETTINGS", "SAVE_SETTINGS", "TEST_ORGANIZER"];
|
|
26
26
|
export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];
|
|
@@ -27,6 +27,9 @@ export const GUI_REQUEST_TYPES = [
|
|
|
27
27
|
"REMOVE_REPO",
|
|
28
28
|
"DEPRECATE_REPO",
|
|
29
29
|
"RESTORE_REPO",
|
|
30
|
+
"QUEUE_REPO",
|
|
31
|
+
"UNQUEUE_REPO",
|
|
32
|
+
"QUEUE_CATEGORY",
|
|
30
33
|
"SET_RIGHTS",
|
|
31
34
|
"LIST_BRANCHES",
|
|
32
35
|
"SET_BRANCH",
|
|
@@ -39,6 +42,7 @@ export const GUI_REQUEST_TYPES = [
|
|
|
39
42
|
"DELETE_CATEGORY",
|
|
40
43
|
"START_FIX",
|
|
41
44
|
"GET_OPERATION",
|
|
45
|
+
"LIST_OPERATIONS",
|
|
42
46
|
"DECIDE_FORCE",
|
|
43
47
|
"DECIDE_REPAIR",
|
|
44
48
|
"GET_REMARKS",
|
|
@@ -84,7 +84,8 @@ export type Category = z.infer<typeof CategorySchema>;
|
|
|
84
84
|
* `handledAlerts` les alertes qu'il a marquées corrigées à la main ;
|
|
85
85
|
* `pullRequests` les pull requests du tracker encore ouvertes à la dernière lecture ;
|
|
86
86
|
* `deprecatedAt` la date à laquelle il a été marqué déprécié, null sinon : un
|
|
87
|
-
* dépôt déprécié n'est plus synchronisé ni
|
|
87
|
+
* dépôt déprécié n'est plus synchronisé ni audité ;
|
|
88
|
+
* `queuedAt` la date de son entrée dans la file d'attente, null s'il n'y est pas.
|
|
88
89
|
*/
|
|
89
90
|
export declare const RepoSchema: z.ZodObject<{
|
|
90
91
|
id: z.ZodString;
|
|
@@ -134,6 +135,7 @@ export declare const RepoSchema: z.ZodObject<{
|
|
|
134
135
|
syncedAt: z.ZodNullable<z.ZodString>;
|
|
135
136
|
syncError: z.ZodNullable<z.ZodString>;
|
|
136
137
|
deprecatedAt: z.ZodNullable<z.ZodString>;
|
|
138
|
+
queuedAt: z.ZodNullable<z.ZodString>;
|
|
137
139
|
}, z.core.$strip>;
|
|
138
140
|
export type Repo = z.infer<typeof RepoSchema>;
|
|
139
141
|
export declare const ReposFileSchema: z.ZodObject<{
|
|
@@ -189,6 +191,7 @@ export declare const ReposFileSchema: z.ZodObject<{
|
|
|
189
191
|
syncedAt: z.ZodNullable<z.ZodString>;
|
|
190
192
|
syncError: z.ZodNullable<z.ZodString>;
|
|
191
193
|
deprecatedAt: z.ZodNullable<z.ZodString>;
|
|
194
|
+
queuedAt: z.ZodNullable<z.ZodString>;
|
|
192
195
|
}, z.core.$strip>>;
|
|
193
196
|
}, z.core.$strip>;
|
|
194
197
|
export type ReposFile = z.infer<typeof ReposFileSchema>;
|
|
@@ -388,6 +391,114 @@ export declare const RepairSchema: z.ZodObject<{
|
|
|
388
391
|
error: z.ZodNullable<z.ZodString>;
|
|
389
392
|
}, z.core.$strip>;
|
|
390
393
|
export type Repair = z.infer<typeof RepairSchema>;
|
|
394
|
+
/** Commentaire d'une tâche organizer : son auteur, son texte et sa date. */
|
|
395
|
+
export declare const RemarkSchema: z.ZodObject<{
|
|
396
|
+
author: z.ZodString;
|
|
397
|
+
body: z.ZodString;
|
|
398
|
+
createdAt: z.ZodString;
|
|
399
|
+
}, z.core.$strip>;
|
|
400
|
+
export type Remark = z.infer<typeof RemarkSchema>;
|
|
401
|
+
export declare const SESSION_KINDS: readonly ["analysis", "repair"];
|
|
402
|
+
export type SessionKind = (typeof SESSION_KINDS)[number];
|
|
403
|
+
export declare const SESSION_OUTCOMES: readonly ["running", "done", "failed", "cancelled"];
|
|
404
|
+
export type SessionOutcome = (typeof SESSION_OUTCOMES)[number];
|
|
405
|
+
/** Ce qu'une session a fait d'une tâche organizer : relue, créée ou mise à jour. */
|
|
406
|
+
export declare const SESSION_TASK_ROLES: readonly ["read", "created", "updated"];
|
|
407
|
+
export type SessionTaskRole = (typeof SESSION_TASK_ROLES)[number];
|
|
408
|
+
/** Élément du déroulé d'une session : message de Claude (`text`) ou appel d'outil en clair (`tool`). */
|
|
409
|
+
export declare const SessionEventSchema: z.ZodObject<{
|
|
410
|
+
kind: z.ZodEnum<{
|
|
411
|
+
text: "text";
|
|
412
|
+
tool: "tool";
|
|
413
|
+
}>;
|
|
414
|
+
text: z.ZodString;
|
|
415
|
+
}, z.core.$strip>;
|
|
416
|
+
export type SessionEvent = z.infer<typeof SessionEventSchema>;
|
|
417
|
+
/**
|
|
418
|
+
* Session de Claude d'une opération, gardée pour l'historique : l'analyse, ou
|
|
419
|
+
* un passage des corrections (`run`, 1 pour l'analyse). `remarks` sont les
|
|
420
|
+
* commentaires de la tâche de l'analyse au lancement des corrections, `tasks`
|
|
421
|
+
* les tâches organizer relues, créées ou mises à jour, `events` le déroulé de
|
|
422
|
+
* la session. Le résultat est le rapport de l'analyse, ou celui des
|
|
423
|
+
* corrections avec leur commit et les vulnérabilités restantes.
|
|
424
|
+
*/
|
|
425
|
+
export declare const ClaudeSessionSchema: z.ZodObject<{
|
|
426
|
+
kind: z.ZodEnum<{
|
|
427
|
+
analysis: "analysis";
|
|
428
|
+
repair: "repair";
|
|
429
|
+
}>;
|
|
430
|
+
run: z.ZodNumber;
|
|
431
|
+
startedAt: z.ZodString;
|
|
432
|
+
endedAt: z.ZodNullable<z.ZodString>;
|
|
433
|
+
turns: z.ZodNumber;
|
|
434
|
+
outcome: z.ZodEnum<{
|
|
435
|
+
cancelled: "cancelled";
|
|
436
|
+
done: "done";
|
|
437
|
+
failed: "failed";
|
|
438
|
+
running: "running";
|
|
439
|
+
}>;
|
|
440
|
+
error: z.ZodNullable<z.ZodString>;
|
|
441
|
+
remarks: z.ZodArray<z.ZodObject<{
|
|
442
|
+
author: z.ZodString;
|
|
443
|
+
body: z.ZodString;
|
|
444
|
+
createdAt: z.ZodString;
|
|
445
|
+
}, z.core.$strip>>;
|
|
446
|
+
tasks: z.ZodArray<z.ZodObject<{
|
|
447
|
+
task: z.ZodObject<{
|
|
448
|
+
key: z.ZodString;
|
|
449
|
+
title: z.ZodString;
|
|
450
|
+
url: z.ZodString;
|
|
451
|
+
status: z.ZodEnum<{
|
|
452
|
+
doing: "doing";
|
|
453
|
+
done: "done";
|
|
454
|
+
review: "review";
|
|
455
|
+
todo: "todo";
|
|
456
|
+
}>;
|
|
457
|
+
}, z.core.$strip>;
|
|
458
|
+
role: z.ZodEnum<{
|
|
459
|
+
created: "created";
|
|
460
|
+
read: "read";
|
|
461
|
+
updated: "updated";
|
|
462
|
+
}>;
|
|
463
|
+
}, z.core.$strip>>;
|
|
464
|
+
events: z.ZodArray<z.ZodObject<{
|
|
465
|
+
kind: z.ZodEnum<{
|
|
466
|
+
text: "text";
|
|
467
|
+
tool: "tool";
|
|
468
|
+
}>;
|
|
469
|
+
text: z.ZodString;
|
|
470
|
+
}, z.core.$strip>>;
|
|
471
|
+
analysisReport: z.ZodNullable<z.ZodObject<{
|
|
472
|
+
summary: z.ZodString;
|
|
473
|
+
urgent: z.ZodArray<z.ZodObject<{
|
|
474
|
+
package: z.ZodString;
|
|
475
|
+
reason: z.ZodString;
|
|
476
|
+
}, z.core.$strip>>;
|
|
477
|
+
force: z.ZodObject<{
|
|
478
|
+
recommended: z.ZodBoolean;
|
|
479
|
+
reason: z.ZodString;
|
|
480
|
+
}, z.core.$strip>;
|
|
481
|
+
}, z.core.$strip>>;
|
|
482
|
+
repairReport: z.ZodNullable<z.ZodObject<{
|
|
483
|
+
summary: z.ZodString;
|
|
484
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
485
|
+
file: z.ZodString;
|
|
486
|
+
change: z.ZodString;
|
|
487
|
+
}, z.core.$strip>>;
|
|
488
|
+
commitMessage: z.ZodString;
|
|
489
|
+
tests: z.ZodObject<{
|
|
490
|
+
outcome: z.ZodEnum<{
|
|
491
|
+
failed: "failed";
|
|
492
|
+
not_run: "not_run";
|
|
493
|
+
passed: "passed";
|
|
494
|
+
}>;
|
|
495
|
+
detail: z.ZodString;
|
|
496
|
+
}, z.core.$strip>;
|
|
497
|
+
}, z.core.$strip>>;
|
|
498
|
+
commit: z.ZodNullable<z.ZodString>;
|
|
499
|
+
remaining: z.ZodNullable<z.ZodNumber>;
|
|
500
|
+
}, z.core.$strip>;
|
|
501
|
+
export type ClaudeSession = z.infer<typeof ClaudeSessionSchema>;
|
|
391
502
|
/**
|
|
392
503
|
* Opération d'audit ou de correction sur un clone temporaire, limitée aux
|
|
393
504
|
* dépendances de `scope`. `workDir` est le
|
|
@@ -395,7 +506,8 @@ export type Repair = z.infer<typeof RepairSchema>;
|
|
|
395
506
|
* qui exécute l'étape en cours. `found` liste les vulnérabilités du premier
|
|
396
507
|
* audit, `remaining` celles qui restent après la dernière étape. `analysis` est
|
|
397
508
|
* l'analyse par Claude, null quand elle n'a pas été lancée ; `repair` ses
|
|
398
|
-
* corrections, null tant qu'elles n'ont pas été lancées
|
|
509
|
+
* corrections, null tant qu'elles n'ont pas été lancées ; `sessions` chaque
|
|
510
|
+
* session de Claude, dans l'ordre.
|
|
399
511
|
*/
|
|
400
512
|
export declare const OperationSchema: z.ZodObject<{
|
|
401
513
|
id: z.ZodString;
|
|
@@ -603,6 +715,82 @@ export declare const OperationSchema: z.ZodObject<{
|
|
|
603
715
|
}, z.core.$strip>>;
|
|
604
716
|
error: z.ZodNullable<z.ZodString>;
|
|
605
717
|
}, z.core.$strip>>;
|
|
718
|
+
sessions: z.ZodArray<z.ZodObject<{
|
|
719
|
+
kind: z.ZodEnum<{
|
|
720
|
+
analysis: "analysis";
|
|
721
|
+
repair: "repair";
|
|
722
|
+
}>;
|
|
723
|
+
run: z.ZodNumber;
|
|
724
|
+
startedAt: z.ZodString;
|
|
725
|
+
endedAt: z.ZodNullable<z.ZodString>;
|
|
726
|
+
turns: z.ZodNumber;
|
|
727
|
+
outcome: z.ZodEnum<{
|
|
728
|
+
cancelled: "cancelled";
|
|
729
|
+
done: "done";
|
|
730
|
+
failed: "failed";
|
|
731
|
+
running: "running";
|
|
732
|
+
}>;
|
|
733
|
+
error: z.ZodNullable<z.ZodString>;
|
|
734
|
+
remarks: z.ZodArray<z.ZodObject<{
|
|
735
|
+
author: z.ZodString;
|
|
736
|
+
body: z.ZodString;
|
|
737
|
+
createdAt: z.ZodString;
|
|
738
|
+
}, z.core.$strip>>;
|
|
739
|
+
tasks: z.ZodArray<z.ZodObject<{
|
|
740
|
+
task: z.ZodObject<{
|
|
741
|
+
key: z.ZodString;
|
|
742
|
+
title: z.ZodString;
|
|
743
|
+
url: z.ZodString;
|
|
744
|
+
status: z.ZodEnum<{
|
|
745
|
+
doing: "doing";
|
|
746
|
+
done: "done";
|
|
747
|
+
review: "review";
|
|
748
|
+
todo: "todo";
|
|
749
|
+
}>;
|
|
750
|
+
}, z.core.$strip>;
|
|
751
|
+
role: z.ZodEnum<{
|
|
752
|
+
created: "created";
|
|
753
|
+
read: "read";
|
|
754
|
+
updated: "updated";
|
|
755
|
+
}>;
|
|
756
|
+
}, z.core.$strip>>;
|
|
757
|
+
events: z.ZodArray<z.ZodObject<{
|
|
758
|
+
kind: z.ZodEnum<{
|
|
759
|
+
text: "text";
|
|
760
|
+
tool: "tool";
|
|
761
|
+
}>;
|
|
762
|
+
text: z.ZodString;
|
|
763
|
+
}, z.core.$strip>>;
|
|
764
|
+
analysisReport: z.ZodNullable<z.ZodObject<{
|
|
765
|
+
summary: z.ZodString;
|
|
766
|
+
urgent: z.ZodArray<z.ZodObject<{
|
|
767
|
+
package: z.ZodString;
|
|
768
|
+
reason: z.ZodString;
|
|
769
|
+
}, z.core.$strip>>;
|
|
770
|
+
force: z.ZodObject<{
|
|
771
|
+
recommended: z.ZodBoolean;
|
|
772
|
+
reason: z.ZodString;
|
|
773
|
+
}, z.core.$strip>;
|
|
774
|
+
}, z.core.$strip>>;
|
|
775
|
+
repairReport: z.ZodNullable<z.ZodObject<{
|
|
776
|
+
summary: z.ZodString;
|
|
777
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
778
|
+
file: z.ZodString;
|
|
779
|
+
change: z.ZodString;
|
|
780
|
+
}, z.core.$strip>>;
|
|
781
|
+
commitMessage: z.ZodString;
|
|
782
|
+
tests: z.ZodObject<{
|
|
783
|
+
outcome: z.ZodEnum<{
|
|
784
|
+
failed: "failed";
|
|
785
|
+
not_run: "not_run";
|
|
786
|
+
passed: "passed";
|
|
787
|
+
}>;
|
|
788
|
+
detail: z.ZodString;
|
|
789
|
+
}, z.core.$strip>;
|
|
790
|
+
}, z.core.$strip>>;
|
|
791
|
+
commit: z.ZodNullable<z.ZodString>;
|
|
792
|
+
remaining: z.ZodNullable<z.ZodNumber>;
|
|
793
|
+
}, z.core.$strip>>;
|
|
606
794
|
error: z.ZodNullable<z.ZodString>;
|
|
607
795
|
log: z.ZodArray<z.ZodObject<{
|
|
608
796
|
at: z.ZodString;
|
|
@@ -66,7 +66,8 @@ export const CategorySchema = z.object({
|
|
|
66
66
|
* `handledAlerts` les alertes qu'il a marquées corrigées à la main ;
|
|
67
67
|
* `pullRequests` les pull requests du tracker encore ouvertes à la dernière lecture ;
|
|
68
68
|
* `deprecatedAt` la date à laquelle il a été marqué déprécié, null sinon : un
|
|
69
|
-
* dépôt déprécié n'est plus synchronisé ni
|
|
69
|
+
* dépôt déprécié n'est plus synchronisé ni audité ;
|
|
70
|
+
* `queuedAt` la date de son entrée dans la file d'attente, null s'il n'y est pas.
|
|
70
71
|
*/
|
|
71
72
|
export const RepoSchema = z.object({
|
|
72
73
|
id: z.string(),
|
|
@@ -83,6 +84,7 @@ export const RepoSchema = z.object({
|
|
|
83
84
|
syncedAt: z.string().nullable(),
|
|
84
85
|
syncError: z.string().nullable(),
|
|
85
86
|
deprecatedAt: z.string().nullable(),
|
|
87
|
+
queuedAt: z.string().nullable(),
|
|
86
88
|
});
|
|
87
89
|
export const ReposFileSchema = z.object({ categories: z.array(CategorySchema), repos: z.array(RepoSchema) });
|
|
88
90
|
/** `audit` : clone et `npm audit` seulement ; `fix` : jusqu'aux corrections, à la branche et à la PR. */
|
|
@@ -187,6 +189,38 @@ export const RepairSchema = z.object({
|
|
|
187
189
|
task: AnalysisTaskSchema.nullable(),
|
|
188
190
|
error: z.string().nullable(),
|
|
189
191
|
});
|
|
192
|
+
/** Commentaire d'une tâche organizer : son auteur, son texte et sa date. */
|
|
193
|
+
export const RemarkSchema = z.object({ author: z.string(), body: z.string(), createdAt: z.string() });
|
|
194
|
+
export const SESSION_KINDS = ["analysis", "repair"];
|
|
195
|
+
export const SESSION_OUTCOMES = ["running", "done", "failed", "cancelled"];
|
|
196
|
+
/** Ce qu'une session a fait d'une tâche organizer : relue, créée ou mise à jour. */
|
|
197
|
+
export const SESSION_TASK_ROLES = ["read", "created", "updated"];
|
|
198
|
+
/** Élément du déroulé d'une session : message de Claude (`text`) ou appel d'outil en clair (`tool`). */
|
|
199
|
+
export const SessionEventSchema = z.object({ kind: z.enum(["text", "tool"]), text: z.string() });
|
|
200
|
+
/**
|
|
201
|
+
* Session de Claude d'une opération, gardée pour l'historique : l'analyse, ou
|
|
202
|
+
* un passage des corrections (`run`, 1 pour l'analyse). `remarks` sont les
|
|
203
|
+
* commentaires de la tâche de l'analyse au lancement des corrections, `tasks`
|
|
204
|
+
* les tâches organizer relues, créées ou mises à jour, `events` le déroulé de
|
|
205
|
+
* la session. Le résultat est le rapport de l'analyse, ou celui des
|
|
206
|
+
* corrections avec leur commit et les vulnérabilités restantes.
|
|
207
|
+
*/
|
|
208
|
+
export const ClaudeSessionSchema = z.object({
|
|
209
|
+
kind: z.enum(SESSION_KINDS),
|
|
210
|
+
run: z.number().int(),
|
|
211
|
+
startedAt: z.string(),
|
|
212
|
+
endedAt: z.string().nullable(),
|
|
213
|
+
turns: z.number().int(),
|
|
214
|
+
outcome: z.enum(SESSION_OUTCOMES),
|
|
215
|
+
error: z.string().nullable(),
|
|
216
|
+
remarks: z.array(RemarkSchema),
|
|
217
|
+
tasks: z.array(z.object({ task: AnalysisTaskSchema, role: z.enum(SESSION_TASK_ROLES) })),
|
|
218
|
+
events: z.array(SessionEventSchema),
|
|
219
|
+
analysisReport: AnalysisReportSchema.nullable(),
|
|
220
|
+
repairReport: RepairReportSchema.nullable(),
|
|
221
|
+
commit: z.string().nullable(),
|
|
222
|
+
remaining: z.number().int().nullable(),
|
|
223
|
+
});
|
|
190
224
|
/**
|
|
191
225
|
* Opération d'audit ou de correction sur un clone temporaire, limitée aux
|
|
192
226
|
* dépendances de `scope`. `workDir` est le
|
|
@@ -194,7 +228,8 @@ export const RepairSchema = z.object({
|
|
|
194
228
|
* qui exécute l'étape en cours. `found` liste les vulnérabilités du premier
|
|
195
229
|
* audit, `remaining` celles qui restent après la dernière étape. `analysis` est
|
|
196
230
|
* l'analyse par Claude, null quand elle n'a pas été lancée ; `repair` ses
|
|
197
|
-
* corrections, null tant qu'elles n'ont pas été lancées
|
|
231
|
+
* corrections, null tant qu'elles n'ont pas été lancées ; `sessions` chaque
|
|
232
|
+
* session de Claude, dans l'ordre.
|
|
198
233
|
*/
|
|
199
234
|
export const OperationSchema = z.object({
|
|
200
235
|
id: z.string(),
|
|
@@ -234,6 +269,7 @@ export const OperationSchema = z.object({
|
|
|
234
269
|
pullRequest: z.object({ number: z.number().int(), url: z.string() }).nullable(),
|
|
235
270
|
analysis: AnalysisSchema.nullable(),
|
|
236
271
|
repair: RepairSchema.nullable(),
|
|
272
|
+
sessions: z.array(ClaudeSessionSchema),
|
|
237
273
|
error: z.string().nullable(),
|
|
238
274
|
log: z.array(LogEntrySchema),
|
|
239
275
|
});
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { type AnalysisReport, type AnalysisTask, type AuditScope, type ForceCandidate, type Operation } from "../../shared/schemas/model.schema.js";
|
|
1
|
+
import { type AnalysisReport, type AnalysisTask, type AuditScope, type ForceCandidate, type Operation, type SessionEvent } from "../../shared/schemas/model.schema.js";
|
|
2
2
|
import type { Settings } from "../../shared/schemas/settings.schema.js";
|
|
3
3
|
import { type ClaudeRuntime } from "./claude.js";
|
|
4
4
|
import { type OrganizerConnection } from "./organizer.js";
|
|
@@ -32,7 +32,7 @@ export interface AnalysisInput {
|
|
|
32
32
|
settings: Settings;
|
|
33
33
|
claude: ClaudeRuntime;
|
|
34
34
|
signal: AbortSignal;
|
|
35
|
-
|
|
35
|
+
onEvent: (event: SessionEvent, turns: number) => void;
|
|
36
36
|
}
|
|
37
37
|
/** Serveur MCP organizer de la session, lancé par `npx` avec le token réglé dans la GUI. */
|
|
38
38
|
export declare function organizerServer(connection: OrganizerConnection): {
|
|
@@ -140,7 +140,7 @@ export async function analyseVulnerabilities(input) {
|
|
|
140
140
|
maxTurns: input.settings.analysis.maxTurns,
|
|
141
141
|
maxMinutes: input.settings.analysis.maxMinutes,
|
|
142
142
|
signal: input.signal,
|
|
143
|
-
|
|
143
|
+
onEvent: input.onEvent,
|
|
144
144
|
}));
|
|
145
145
|
}
|
|
146
146
|
finally {
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import type { AuditAllState } from "../../shared/schemas/api.schema.js";
|
|
1
|
+
import type { AuditAllState, AuditTarget } from "../../shared/schemas/api.schema.js";
|
|
2
2
|
import type { AuditScope, Operation } from "../../shared/schemas/model.schema.js";
|
|
3
3
|
/** Audits menés en même temps par « Auditer tout ». */
|
|
4
4
|
export declare const AUDIT_ALL_CONCURRENCY = 3;
|
|
@@ -15,8 +15,8 @@ export declare class AuditAll {
|
|
|
15
15
|
constructor(audit: (repoId: string, scope: AuditScope) => Promise<Operation>, logError: (message: string) => void);
|
|
16
16
|
/** État de la dernière série, null si aucune n'a été lancée. */
|
|
17
17
|
status(): AuditAllState | null;
|
|
18
|
-
/** Lance la série sur `repoIds`, périmètre `scope`, et rend aussitôt son état ; refusé si une série est en cours. */
|
|
19
|
-
start(repoIds: string[], scope: AuditScope): AuditAllState;
|
|
18
|
+
/** Lance la série sur `repoIds`, les dépôts de `target`, périmètre `scope`, et rend aussitôt son état ; refusé si une série est en cours. */
|
|
19
|
+
start(repoIds: string[], scope: AuditScope, target: AuditTarget): AuditAllState;
|
|
20
20
|
/** Attend la fin de la série en cours. */
|
|
21
21
|
finished(): Promise<void>;
|
|
22
22
|
private auditAll;
|
|
@@ -19,11 +19,11 @@ export class AuditAll {
|
|
|
19
19
|
status() {
|
|
20
20
|
return this.state && { ...this.state, skipped: [...this.state.skipped], failed: [...this.state.failed] };
|
|
21
21
|
}
|
|
22
|
-
/** Lance la série sur `repoIds`, périmètre `scope`, et rend aussitôt son état ; refusé si une série est en cours. */
|
|
23
|
-
start(repoIds, scope) {
|
|
22
|
+
/** Lance la série sur `repoIds`, les dépôts de `target`, périmètre `scope`, et rend aussitôt son état ; refusé si une série est en cours. */
|
|
23
|
+
start(repoIds, scope, target) {
|
|
24
24
|
if (this.state?.running)
|
|
25
25
|
throw new ConflictError("An audit of every repository is already running.");
|
|
26
|
-
this.state = { running: true, scope, startedAt: new Date().toISOString(), finishedAt: null, total: repoIds.length, done: 0, skipped: [], failed: [] };
|
|
26
|
+
this.state = { running: true, scope, target, startedAt: new Date().toISOString(), finishedAt: null, total: repoIds.length, done: 0, skipped: [], failed: [] };
|
|
27
27
|
this.run = this.auditAll(this.state, [...repoIds]);
|
|
28
28
|
return this.status();
|
|
29
29
|
}
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import type { SessionEvent } from "../../shared/schemas/model.schema.js";
|
|
1
2
|
/**
|
|
2
3
|
* Sessions Claude Code non interactives (`claude -p`, sortie `stream-json`).
|
|
3
4
|
* Claude Code s'authentifie par un token d'abonnement (`claude setup-token`)
|
|
@@ -26,14 +27,16 @@ export interface ClaudeSessionOptions {
|
|
|
26
27
|
maxTurns: number;
|
|
27
28
|
maxMinutes: number;
|
|
28
29
|
signal?: AbortSignal;
|
|
29
|
-
/** Reçoit chaque
|
|
30
|
-
|
|
30
|
+
/** Reçoit chaque élément du déroulé (message de Claude ou appel d'outil) et le nombre de tours écoulés. */
|
|
31
|
+
onEvent?: (event: SessionEvent, turns: number) => void;
|
|
31
32
|
}
|
|
32
33
|
export interface ClaudeSessionResult {
|
|
33
34
|
/** Résultat validé par `--json-schema`, absent sans schéma. */
|
|
34
35
|
structured: unknown;
|
|
35
36
|
turns: number | null;
|
|
36
37
|
}
|
|
38
|
+
/** Ligne d'activité en clair d'un élément du déroulé : sa première ligne, raccourcie. */
|
|
39
|
+
export declare function activityLine(event: SessionEvent): string;
|
|
37
40
|
/**
|
|
38
41
|
* Lance une session et attend sa fin. Les tours sont limités par Claude Code,
|
|
39
42
|
* la durée par le tracker, qui tue alors la session avec ses descendants, comme
|