@imenam/mcp-dependabot-tracker 0.0.0-stage → 1.0.1

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.
Files changed (59) hide show
  1. package/README.md +208 -2
  2. package/dist/shared/schemas/api.schema.d.ts +49 -0
  3. package/dist/shared/schemas/api.schema.js +11 -0
  4. package/dist/shared/schemas/ipc.schema.d.ts +26 -0
  5. package/dist/shared/schemas/ipc.schema.js +30 -0
  6. package/dist/shared/schemas/model.schema.d.ts +276 -0
  7. package/dist/shared/schemas/model.schema.js +116 -0
  8. package/dist/src/cli/setup-mcp.d.ts +24 -0
  9. package/dist/src/cli/setup-mcp.js +137 -0
  10. package/dist/src/core/commands.d.ts +26 -0
  11. package/dist/src/core/commands.js +101 -0
  12. package/dist/src/core/config.d.ts +12 -0
  13. package/dist/src/core/config.js +18 -0
  14. package/dist/src/core/data-dir.d.ts +11 -0
  15. package/dist/src/core/data-dir.js +27 -0
  16. package/dist/src/core/errors.d.ts +12 -0
  17. package/dist/src/core/errors.js +21 -0
  18. package/dist/src/core/github.d.ts +43 -0
  19. package/dist/src/core/github.js +122 -0
  20. package/dist/src/core/log-dir.d.ts +6 -0
  21. package/dist/src/core/log-dir.js +13 -0
  22. package/dist/src/core/npm-audit.d.ts +36 -0
  23. package/dist/src/core/npm-audit.js +115 -0
  24. package/dist/src/core/operations.d.ts +42 -0
  25. package/dist/src/core/operations.js +438 -0
  26. package/dist/src/core/repo-ref.d.ts +9 -0
  27. package/dist/src/core/repo-ref.js +33 -0
  28. package/dist/src/core/repos.d.ts +23 -0
  29. package/dist/src/core/repos.js +84 -0
  30. package/dist/src/core/store.d.ts +49 -0
  31. package/dist/src/core/store.js +266 -0
  32. package/dist/src/gui-worker.d.ts +1 -0
  33. package/dist/src/gui-worker.js +325 -0
  34. package/dist/src/index.d.ts +2 -0
  35. package/dist/src/index.js +363 -0
  36. package/dist/src/tools/format.d.ts +7 -0
  37. package/dist/src/tools/format.js +81 -0
  38. package/dist/src/tools/tools.d.ts +15 -0
  39. package/dist/src/tools/tools.js +56 -0
  40. package/dist/src/tools/types.d.ts +21 -0
  41. package/dist/src/tools/types.js +38 -0
  42. package/dist/src/version.d.ts +1 -0
  43. package/dist/src/version.js +16 -0
  44. package/gui/dist/assets/index-BBJkUr54.css +1 -0
  45. package/gui/dist/assets/index-DbT51E3H.js +63 -0
  46. package/gui/dist/assets/inter-cyrillic-ext-wght-normal-BOeWTOD4.woff2 +0 -0
  47. package/gui/dist/assets/inter-cyrillic-wght-normal-DqGufNeO.woff2 +0 -0
  48. package/gui/dist/assets/inter-greek-ext-wght-normal-DlzME5K_.woff2 +0 -0
  49. package/gui/dist/assets/inter-greek-wght-normal-CkhJZR-_.woff2 +0 -0
  50. package/gui/dist/assets/inter-latin-ext-wght-normal-DO1Apj_S.woff2 +0 -0
  51. package/gui/dist/assets/inter-latin-wght-normal-Dx4kXJAl.woff2 +0 -0
  52. package/gui/dist/assets/inter-vietnamese-wght-normal-CBcvBZtf.woff2 +0 -0
  53. package/gui/dist/assets/jetbrains-mono-cyrillic-wght-normal-D73BlboJ.woff2 +0 -0
  54. package/gui/dist/assets/jetbrains-mono-greek-wght-normal-Bw9x6K1M.woff2 +0 -0
  55. package/gui/dist/assets/jetbrains-mono-latin-ext-wght-normal-DBQx-q_a.woff2 +0 -0
  56. package/gui/dist/assets/jetbrains-mono-latin-wght-normal-B9CIFXIH.woff2 +0 -0
  57. package/gui/dist/assets/jetbrains-mono-vietnamese-wght-normal-Bt-aOZkq.woff2 +0 -0
  58. package/gui/dist/index.html +13 -0
  59. package/package.json +57 -4
package/README.md CHANGED
@@ -1,3 +1,209 @@
1
- # Temporary Holding Version
1
+ # @imenam/mcp-dependabot-tracker
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ Suivi des alertes Dependabot de dépôts GitHub, et correction de leurs vulnérabilités npm dans un clone temporaire, depuis une interface graphique ou par un agent.
4
+
5
+ Pour chaque dépôt suivi, l'interface montre les alertes Dependabot ouvertes et lance une **correction** : clone temporaire de la branche par défaut, `npm audit`, `npm audit fix`, `npm audit fix --force` sur décision, puis commit sur une nouvelle branche, push et pull request. L'utilisateur décide, dépôt par dépôt, de ce que l'agent peut faire par les outils MCP : audit, audit fix, audit fix --force, push.
6
+
7
+ ```
8
+ Utilisateur (GUI) ──ajoute un dépôt, accorde les droits, corrige──▶ Tracker ──API GitHub──▶ alertes, PR
9
+ Agent ──list_repositories / get_alerts / run_audit / fix_vulnerabilities──▶ (dans la limite des droits)
10
+ ```
11
+
12
+ Le serveur n'appelle aucun LLM. L'agent n'exécute jamais `git` ni `npm` lui-même : tout passe par les outils.
13
+
14
+ ---
15
+
16
+ ## Installation
17
+
18
+ ```bash
19
+ npm install -g @imenam/mcp-dependabot-tracker
20
+ ```
21
+
22
+ Ou via `npx`, sans installation. Le serveur communique en JSON-RPC sur stdio : il est lancé par le client MCP, pas à la main. `git` et `npm` (npm 7 ou plus récent) doivent être dans le `PATH` de la machine qui exécute le serveur.
23
+
24
+ ### Déclaration dans un projet
25
+
26
+ ```bash
27
+ npx -y @imenam/mcp-dependabot-tracker --claude-setup-mcp --proxy_url=http://localhost:3000
28
+ # ou, sans proxy :
29
+ npx -y @imenam/mcp-dependabot-tracker --claude-setup-mcp --app_port=4700
30
+ ```
31
+
32
+ La commande crée (ou complète) le `.mcp.json` du répertoire courant avec une entrée `mcp-dependabot-tracker`. `--force` remplace une entrée existante ; les autres serveurs sont préservés. `--proxy_url` et `--app_port` sont exclusifs. Il reste à renseigner `GITHUB_TOKEN` et `CLONE_DIR`.
33
+
34
+ ```json
35
+ {
36
+ "mcpServers": {
37
+ "mcp-dependabot-tracker": {
38
+ "command": "npx",
39
+ "args": ["-y", "@imenam/mcp-dependabot-tracker"],
40
+ "env": {
41
+ "GITHUB_TOKEN": "github_pat_…",
42
+ "PROXY_URL": "http://localhost:3000",
43
+ "APP_PORT": "",
44
+ "APP_GROUP": "",
45
+ "APP_NAME": "Dependabot Tracker",
46
+ "APP_PATH": "/dependabot-tracker",
47
+ "CLONE_DIR": "D:/clones/dependabot-tracker",
48
+ "MCP_DATA_DIR": "",
49
+ "MCP_LOG_DIR": ""
50
+ }
51
+ }
52
+ }
53
+ }
54
+ ```
55
+
56
+ Les dépôts suivis ne dépendent d'aucun projet : toutes les instances partagent par défaut le même répertoire de données, `~/.mcp-dependabot-tracker`.
57
+
58
+ ### Token GitHub
59
+
60
+ Un token à grain fin, limité aux dépôts suivis, avec les permissions :
61
+
62
+ | Permission | Accès | Pour |
63
+ |---|---|---|
64
+ | Dependabot alerts | lecture | lire les alertes |
65
+ | Contents | lecture et écriture | cloner, pousser la branche de correction |
66
+ | Pull requests | lecture et écriture | ouvrir la pull request |
67
+ | Metadata | lecture | imposée par GitHub |
68
+
69
+ Un token classique convient aussi, avec les scopes `repo` et `security_events`. Les commits sont signés du compte du token, avec son adresse `noreply` GitHub. Le token est transmis à `git` par un en-tête HTTP (`http.<serveur>/.extraheader`, dans l'environnement de la commande) : il n'est écrit ni dans le clone ni dans la ligne de commande. Les commandes `git` et `npm` ne reçoivent pas `GITHUB_TOKEN` dans leur environnement.
70
+
71
+ ### Variables d'environnement
72
+
73
+ Elles se renseignent dans le champ `env` de la déclaration, ou dans un fichier `.env` à la racine du package, qui prime et est relu à chaque relance de la GUI.
74
+
75
+ | Variable | Rôle |
76
+ |---|---|
77
+ | `GITHUB_TOKEN` | Token GitHub (voir ci-dessus). Sans lui, les outils et l'interface signalent qu'il manque ; aucune alerte n'est lue. |
78
+ | `GITHUB_API_URL` | API GitHub (défaut `https://api.github.com`), à changer pour GitHub Enterprise Server. |
79
+ | `GITHUB_SERVER_URL` | Serveur git des clones (défaut `https://github.com`) : un dépôt se clone depuis `<serveur>/<propriétaire>/<nom>.git`. |
80
+ | `PROXY_URL` | URL du [proxy central](https://github.com/imenam/proxy-setup) : le proxy attribue le port et monte la GUI sous `APP_PATH`. Prime sur `APP_PORT`. |
81
+ | `APP_PORT` | Port local utilisé quand `PROXY_URL` est absent : la GUI est servie sur `http://localhost:<port>`. |
82
+ | `APP_PATH` | Chemin de montage derrière le proxy (défaut `/dependabot-tracker`). |
83
+ | `APP_PATH_PREFIX` | Préfixe de namespace appliqué au chemin par le client proxy partagé ; le `<base href>` de la GUI suit le chemin réellement enregistré. |
84
+ | `APP_NAME` | Nom affiché dans le dashboard du proxy (défaut `Dependabot Tracker`). |
85
+ | `APP_GROUP` | Section repliable du dashboard du proxy (facultatif). |
86
+ | `CLONE_DIR` | **Obligatoire.** Dossier où chaque opération crée son clone ; il est créé s'il n'existe pas. Sans cette variable, le serveur refuse de démarrer. |
87
+ | `MCP_DATA_DIR` | Répertoire des données (défaut `~/.mcp-dependabot-tracker`). |
88
+ | `MCP_LOG_DIR` | Répertoire des logs. Défaut : `<données>/logs`. |
89
+
90
+ Sans `PROXY_URL` ni `APP_PORT`, la GUI est désactivée ; les outils MCP fonctionnent.
91
+
92
+ ### Dans mcp-http-gateway et le gateway manager
93
+
94
+ Le serveur ne lit rien sur la machine de l'agent : clones, `npm` et appels à GitHub ont lieu sur la machine qui l'exécute. Dans un gateway ([mcp-http-gateway](https://www.npmjs.com/package/@imenam/mcp-http-gateway)), il se déclare comme tout autre MCP, dans `config/mcp-servers.json` :
95
+
96
+ ```json
97
+ {
98
+ "mcpServers": {
99
+ "dependabot-tracker": {
100
+ "command": "npx",
101
+ "args": ["-y", "@imenam/mcp-dependabot-tracker"],
102
+ "env": {
103
+ "MCP_SERVER_ROUTE": "/dependabot-tracker",
104
+ "GITHUB_TOKEN": "github_pat_…",
105
+ "CLONE_DIR": "/var/lib/dependabot-tracker/clones"
106
+ }
107
+ }
108
+ }
109
+ }
110
+ ```
111
+
112
+ - Aucune route d'exécution (`GATEWAY_EXEC_ROUTES`) n'est nécessaire côté agent.
113
+ - Piloté par le gateway manager, la GUI s'enregistre auprès du proxy du hub (`PROXY_URL` et `APP_PATH_PREFIX` sont fournis par le hub) et s'ouvre par le bouton « interface » du MCP.
114
+ - `git` et `npm` doivent être installés sur la machine du gateway, qui doit joindre GitHub et le registre npm.
115
+
116
+ ---
117
+
118
+ ## Les outils
119
+
120
+ Cinq outils, en anglais. Le résultat d'une opération se termine par le lien vers son écran dans la GUI quand celle-ci est active.
121
+
122
+ | Outil | Droit | Effet |
123
+ |---|---|---|
124
+ | `list_repositories` | — | Dépôts suivis : alertes Dependabot ouvertes par gravité, 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, lien. |
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
+ | `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 par défaut. Sans `push`, rien ne sort du clone : le résultat décrit ce que les corrections changent. |
128
+ | `reconnect_gui` | — | Relance le worker GUI et le réenregistre auprès du proxy. |
129
+
130
+ Un outil refuse une action dont l'agent n'a pas le droit, en le disant ; seul l'utilisateur change les droits, dans la GUI. L'agent ne peut ni ajouter ni retirer de dépôt. Un champ inconnu fait échouer l'appel. Les outils d'opération attendent la fin de l'opération.
131
+
132
+ ---
133
+
134
+ ## Une opération
135
+
136
+ Chaque opération travaille dans un clone temporaire (`<CLONE_DIR>/mcp-dependabot-tracker-*/repo`, `git clone --depth 1` de la branche par défaut), supprimé dès qu'elle se termine, réussie, échouée ou annulée. Il reste sur le disque tant qu'une correction lancée depuis la GUI attend une décision.
137
+
138
+ 1. **Cloner le dépôt** — puis repérer les projets npm : chaque dossier dont le `package-lock.json` est suivi par git (racine, `gui/`…). Un dépôt sans lockfile fait échouer l'opération : `npm audit` en a besoin. Un lockfile v1 (npm 6) est refusé.
139
+ 2. **npm audit** — `npm audit --json` dans chaque projet.
140
+ 3. **npm audit fix** — `npm audit fix --package-lock-only --ignore-scripts` dans chaque projet vulnérable : seuls les lockfiles changent, sans installation de `node_modules` ni script de paquet. Puis un nouvel audit.
141
+ 4. **npm audit fix --force** — proposé quand des vulnérabilités restantes ne se corrigent que par une version majeure (`fixAvailable.isSemVerMajor` du rapport npm). L'écran liste les paquets concernés, leur version installée et la version cible, et le nombre de vulnérabilités en jeu.
142
+ 5. **Commit et push** — commit des fichiers modifiés sur la branche `fix/npm-audit-<AAAA-MM-JJ>-<HHMMSS>` (heure locale du serveur, fixée quand la correction est prête), push, puis pull request vers la branche par défaut. Son corps donne les vulnérabilités avant et après, l'application de `--force` et les paquets mis à jour.
143
+
144
+ 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.
145
+
146
+ Depuis la GUI, l'opération s'arrête aux étapes 4 et 5 pour la décision de l'utilisateur. Menée par l'agent, elle va d'un bout à l'autre selon `force` et `push`. Une seule opération à la fois par dépôt.
147
+
148
+ **Annulation** — une opération en attente se termine aussitôt. Une opération en cours reçoit une demande d'annulation que le processus qui l'exécute lit toutes les 500 ms : il arrête la commande en cours (arbre de processus compris) et supprime le clone. Une opération dont le processus a disparu passe en échec à la lecture suivante.
149
+
150
+ ---
151
+
152
+ ## L'interface
153
+
154
+ Thème sombre, une information par ligne, une action principale par écran.
155
+
156
+ - **Accueil (`#/`)** — les dépôts suivis, du plus exposé au moins exposé (gravité la plus haute, puis nombre d'alertes). 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 ». « Ajouter un dépôt » ouvre une fenêtre à un seul champ, `propriétaire/dépôt` ou lien GitHub (Entrée valide, Échap ferme) ; un nouveau dépôt n'accorde que l'audit à l'agent.
157
+ - **Dépôt (`#/r/<propriétaire>/<nom>`)** — branche par défaut, 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. « 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).
158
+ - **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. 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.
159
+
160
+ Les écrans se relisent par polling : toutes les 3 s pour les listes, toutes les secondes pendant une opération.
161
+
162
+ ---
163
+
164
+ ## Architecture
165
+
166
+ Deux processus, selon le standard de l'écosystème (`@imenam/mcp-gui-interface`) :
167
+
168
+ - **Maître MCP** (`src/index.ts`) — JSON-RPC sur stdio, outils (`src/tools/`), logique (`src/core/`), relecture des alertes toutes les 10 minutes, cycle de vie du worker via `GuiLauncher`.
169
+ - **Worker GUI** (`src/gui-worker.ts`) — Hono, enregistrement auprès du proxy ou écoute sur `APP_PORT`, API REST transmise au maître par IPC, fichiers de la SPA avec la balise `<base>` du chemin de montage. Il écoute sur `127.0.0.1` derrière `honoGuiGuard`.
170
+
171
+ | Route | Effet |
172
+ |---|---|
173
+ | `GET /api/config` | Version, répertoire des données, présence du token. |
174
+ | `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. |
175
+ | `GET` / `DELETE /api/repos/:propriétaire/:nom` | Dépôt ; retrait. |
176
+ | `PUT /api/repos/:propriétaire/:nom/rights` | Droits de l'agent. |
177
+ | `POST /api/repos/:propriétaire/:nom/operations` | Lance une correction. |
178
+ | `GET /api/operations/:id` | Opération. |
179
+ | `POST /api/operations/:id/force`, `/push`, `/cancel` | Décision `--force` (`{ apply }`), push (`{ commitMessage }`), annulation. |
180
+
181
+ Erreurs : `400` requête invalide, `404` introuvable, `409` conflit (opération déjà en cours, étape qui n'attend pas cette décision), `500` sinon.
182
+
183
+ ### Persistance
184
+
185
+ `<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.
186
+
187
+ ---
188
+
189
+ ## Développement
190
+
191
+ ```bash
192
+ npm install
193
+ npm run build # backend (tsc -> dist/), puis GUI (gui/dist)
194
+ npm test # node --test sur dist/test
195
+ cd gui && npm run lint # oxlint
196
+ ```
197
+
198
+ | Dossier | Contenu |
199
+ |---|---|
200
+ | `src/index.ts` | Maître MCP : outils, `instructions`, IPC, synchronisation, lancement de la GUI. |
201
+ | `src/gui-worker.ts` | Worker GUI : Hono, REST, fichiers statiques, proxy. |
202
+ | `src/core/` | Stockage, client GitHub, commandes `git`/`npm`, rapports `npm audit` et lockfiles, opérations, dépôts. |
203
+ | `src/tools/` | Outils MCP et mise en forme de leurs résultats. |
204
+ | `src/cli/setup-mcp.ts` | Commande `--claude-setup-mcp`. |
205
+ | `shared/schemas/` | Schémas zod communs au serveur et à la GUI. |
206
+ | `gui/` | Vite + React 19 + zustand, CSS écrit à la main. |
207
+ | `test/` | Tests `node --test`. |
208
+
209
+ Les tests utilisent une fausse API GitHub (dépôts, alertes paginées, utilisateur, pull requests) et des dépôts nus locaux servis par `file://` (`GITHUB_API_URL`, `GITHUB_SERVER_URL`). `test/operations.test.ts` et `test/server.test.ts` lancent un vrai `npm audit` sur un petit projet vulnérable (`test/fixtures/vulnerable` : `lodash`, corrigé par `audit fix`, et `nth-check`, corrigé seulement par `--force`) : ils ont besoin du registre npm et sont ignorés, avec la raison, s'il est injoignable. `test/server.test.ts` lance le serveur sur stdio avec sa GUI sur un port libre et parcourt les outils, les droits et la correction complète depuis l'API de la GUI.
@@ -0,0 +1,49 @@
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. */
4
+ export declare const AddRepoBodySchema: z.ZodObject<{
5
+ repository: z.ZodString;
6
+ }, z.core.$strip>;
7
+ export type AddRepoBody = z.infer<typeof AddRepoBodySchema>;
8
+ export declare const SetRightsBodySchema: z.ZodObject<{
9
+ rights: z.ZodObject<{
10
+ audit: z.ZodBoolean;
11
+ fix: z.ZodBoolean;
12
+ force: z.ZodBoolean;
13
+ push: z.ZodBoolean;
14
+ }, z.core.$strip>;
15
+ }, z.core.$strip>;
16
+ export type SetRightsBody = z.infer<typeof SetRightsBodySchema>;
17
+ /** `apply` : lancer `npm audit fix --force` ; sinon l'étape est passée. */
18
+ export declare const ForceBodySchema: z.ZodObject<{
19
+ apply: z.ZodBoolean;
20
+ }, z.core.$strip>;
21
+ export type ForceBody = z.infer<typeof ForceBodySchema>;
22
+ export declare const PushBodySchema: z.ZodObject<{
23
+ commitMessage: z.ZodString;
24
+ }, z.core.$strip>;
25
+ export type PushBody = z.infer<typeof PushBodySchema>;
26
+ /** Identifiant d'un dépôt dans une requête IPC. */
27
+ export declare const RepoRequestSchema: z.ZodObject<{
28
+ repoId: z.ZodString;
29
+ }, z.core.$strip>;
30
+ export declare const OperationRequestSchema: z.ZodObject<{
31
+ operationId: z.ZodString;
32
+ }, z.core.$strip>;
33
+ /** Dépôt et état de son opération en cours et de la dernière opération, pour la liste et l'écran du dépôt. */
34
+ export interface RepoView {
35
+ repo: Repo;
36
+ activeOperation: Operation | null;
37
+ latestOperation: Operation | null;
38
+ }
39
+ export interface ReposResponse {
40
+ repos: RepoView[];
41
+ }
42
+ export interface OperationResponse {
43
+ operation: Operation;
44
+ }
45
+ export interface AppConfig {
46
+ version: string;
47
+ dataDir: string;
48
+ githubConfigured: boolean;
49
+ }
@@ -0,0 +1,11 @@
1
+ import { z } from "zod";
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({ repository: z.string().trim().min(1) });
5
+ export const SetRightsBodySchema = z.object({ rights: RightsSchema });
6
+ /** `apply` : lancer `npm audit fix --force` ; sinon l'étape est passée. */
7
+ export const ForceBodySchema = z.object({ apply: z.boolean() });
8
+ export const PushBodySchema = z.object({ commitMessage: z.string().trim().min(1) });
9
+ /** Identifiant d'un dépôt dans une requête IPC. */
10
+ export const RepoRequestSchema = z.object({ repoId: z.string().min(1) });
11
+ export const OperationRequestSchema = z.object({ operationId: z.string().min(1) });
@@ -0,0 +1,26 @@
1
+ import { z } from "zod";
2
+ /**
3
+ * Nature d'une erreur renvoyée par le maître à une requête du GUI worker, qui
4
+ * la traduit en code HTTP : invalid → 400, not_found → 404, conflict → 409,
5
+ * internal → 500.
6
+ */
7
+ export declare const IPC_ERROR_KINDS: readonly ["invalid", "not_found", "conflict", "internal"];
8
+ export type IpcErrorKind = (typeof IPC_ERROR_KINDS)[number];
9
+ /** Message échangé entre le processus maître MCP et le GUI worker. */
10
+ export declare const IPCMessageSchema: z.ZodObject<{
11
+ type: z.ZodString;
12
+ correlationId: z.ZodOptional<z.ZodString>;
13
+ data: z.ZodOptional<z.ZodAny>;
14
+ error: z.ZodOptional<z.ZodString>;
15
+ errorKind: z.ZodOptional<z.ZodEnum<{
16
+ conflict: "conflict";
17
+ internal: "internal";
18
+ invalid: "invalid";
19
+ not_found: "not_found";
20
+ }>>;
21
+ timestamp: z.ZodString;
22
+ }, z.core.$strip>;
23
+ export type IPCMessage = z.infer<typeof IPCMessageSchema>;
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", "GET_REPO", "ADD_REPO", "REMOVE_REPO", "SET_RIGHTS", "START_FIX", "GET_OPERATION", "DECIDE_FORCE", "PUSH_OPERATION", "CANCEL_OPERATION"];
26
+ export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];
@@ -0,0 +1,30 @@
1
+ import { z } from "zod";
2
+ /**
3
+ * Nature d'une erreur renvoyée par le maître à une requête du GUI worker, qui
4
+ * la traduit en code HTTP : invalid → 400, not_found → 404, conflict → 409,
5
+ * internal → 500.
6
+ */
7
+ export const IPC_ERROR_KINDS = ["invalid", "not_found", "conflict", "internal"];
8
+ /** Message échangé entre le processus maître MCP et le GUI worker. */
9
+ export const IPCMessageSchema = z.object({
10
+ type: z.string(),
11
+ correlationId: z.string().optional(),
12
+ data: z.any().optional(),
13
+ error: z.string().optional(),
14
+ errorKind: z.enum(IPC_ERROR_KINDS).optional(),
15
+ timestamp: z.string(),
16
+ });
17
+ /** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
18
+ export const GUI_REQUEST_TYPES = [
19
+ "GET_CONFIG",
20
+ "LIST_REPOS",
21
+ "GET_REPO",
22
+ "ADD_REPO",
23
+ "REMOVE_REPO",
24
+ "SET_RIGHTS",
25
+ "START_FIX",
26
+ "GET_OPERATION",
27
+ "DECIDE_FORCE",
28
+ "PUSH_OPERATION",
29
+ "CANCEL_OPERATION",
30
+ ];
@@ -0,0 +1,276 @@
1
+ import { z } from "zod";
2
+ /** Gravités d'une alerte Dependabot, de la plus grave à la moins grave. */
3
+ export declare const ALERT_SEVERITIES: readonly ["critical", "high", "medium", "low"];
4
+ export type AlertSeverity = (typeof ALERT_SEVERITIES)[number];
5
+ /** Gravités d'une vulnérabilité rapportée par `npm audit`, de la plus grave à la moins grave. */
6
+ export declare const NPM_SEVERITIES: readonly ["critical", "high", "moderate", "low", "info"];
7
+ export type NpmSeverity = (typeof NPM_SEVERITIES)[number];
8
+ /** Actions que l'agent peut être autorisé à lancer sur un dépôt, par les outils MCP. */
9
+ export declare const RIGHTS: readonly ["audit", "fix", "force", "push"];
10
+ export type Right = (typeof RIGHTS)[number];
11
+ export declare const RightsSchema: z.ZodObject<{
12
+ audit: z.ZodBoolean;
13
+ fix: z.ZodBoolean;
14
+ force: z.ZodBoolean;
15
+ push: z.ZodBoolean;
16
+ }, z.core.$strip>;
17
+ export type Rights = z.infer<typeof RightsSchema>;
18
+ /** Droits d'un dépôt qui vient d'être ajouté : l'audit seul. */
19
+ export declare const DEFAULT_RIGHTS: Rights;
20
+ /** Alerte Dependabot ouverte, telle que la renvoie l'API GitHub, réduite à ce qui s'affiche. */
21
+ export declare const AlertSchema: z.ZodObject<{
22
+ number: z.ZodNumber;
23
+ severity: z.ZodEnum<{
24
+ critical: "critical";
25
+ high: "high";
26
+ low: "low";
27
+ medium: "medium";
28
+ }>;
29
+ ecosystem: z.ZodString;
30
+ package: z.ZodString;
31
+ manifestPath: z.ZodString;
32
+ summary: z.ZodString;
33
+ url: z.ZodString;
34
+ patchedVersion: z.ZodNullable<z.ZodString>;
35
+ }, z.core.$strip>;
36
+ export type Alert = z.infer<typeof AlertSchema>;
37
+ /** Dépôt suivi. `id` est le nom complet GitHub, `propriétaire/nom`. */
38
+ export declare const RepoSchema: z.ZodObject<{
39
+ id: z.ZodString;
40
+ owner: z.ZodString;
41
+ name: z.ZodString;
42
+ defaultBranch: z.ZodString;
43
+ addedAt: z.ZodString;
44
+ rights: z.ZodObject<{
45
+ audit: z.ZodBoolean;
46
+ fix: z.ZodBoolean;
47
+ force: z.ZodBoolean;
48
+ push: z.ZodBoolean;
49
+ }, z.core.$strip>;
50
+ alerts: z.ZodArray<z.ZodObject<{
51
+ number: z.ZodNumber;
52
+ severity: z.ZodEnum<{
53
+ critical: "critical";
54
+ high: "high";
55
+ low: "low";
56
+ medium: "medium";
57
+ }>;
58
+ ecosystem: z.ZodString;
59
+ package: z.ZodString;
60
+ manifestPath: z.ZodString;
61
+ summary: z.ZodString;
62
+ url: z.ZodString;
63
+ patchedVersion: z.ZodNullable<z.ZodString>;
64
+ }, z.core.$strip>>;
65
+ syncedAt: z.ZodNullable<z.ZodString>;
66
+ syncError: z.ZodNullable<z.ZodString>;
67
+ }, z.core.$strip>;
68
+ export type Repo = z.infer<typeof RepoSchema>;
69
+ export declare const ReposFileSchema: z.ZodObject<{
70
+ repos: z.ZodArray<z.ZodObject<{
71
+ id: z.ZodString;
72
+ owner: z.ZodString;
73
+ name: z.ZodString;
74
+ defaultBranch: z.ZodString;
75
+ addedAt: z.ZodString;
76
+ rights: z.ZodObject<{
77
+ audit: z.ZodBoolean;
78
+ fix: z.ZodBoolean;
79
+ force: z.ZodBoolean;
80
+ push: z.ZodBoolean;
81
+ }, z.core.$strip>;
82
+ alerts: z.ZodArray<z.ZodObject<{
83
+ number: z.ZodNumber;
84
+ severity: z.ZodEnum<{
85
+ critical: "critical";
86
+ high: "high";
87
+ low: "low";
88
+ medium: "medium";
89
+ }>;
90
+ ecosystem: z.ZodString;
91
+ package: z.ZodString;
92
+ manifestPath: z.ZodString;
93
+ summary: z.ZodString;
94
+ url: z.ZodString;
95
+ patchedVersion: z.ZodNullable<z.ZodString>;
96
+ }, z.core.$strip>>;
97
+ syncedAt: z.ZodNullable<z.ZodString>;
98
+ syncError: z.ZodNullable<z.ZodString>;
99
+ }, z.core.$strip>>;
100
+ }, z.core.$strip>;
101
+ /** `audit` : clone et `npm audit` seulement ; `fix` : jusqu'aux corrections, à la branche et à la PR. */
102
+ export declare const OPERATION_KINDS: readonly ["audit", "fix"];
103
+ export type OperationKind = (typeof OPERATION_KINDS)[number];
104
+ /** Qui a lancé l'opération : l'utilisateur depuis la GUI, ou l'agent par un outil MCP. */
105
+ export declare const ORIGINS: readonly ["user", "agent"];
106
+ export type Origin = (typeof ORIGINS)[number];
107
+ /**
108
+ * `running` : une étape s'exécute ; `waiting_force` et `waiting_push` : l'utilisateur
109
+ * doit décider de la suite ; les trois derniers états sont terminaux.
110
+ */
111
+ export declare const OPERATION_STATUSES: readonly ["running", "waiting_force", "waiting_push", "done", "failed", "cancelled"];
112
+ export type OperationStatus = (typeof OPERATION_STATUSES)[number];
113
+ export declare const ACTIVE_STATUSES: readonly OperationStatus[];
114
+ export declare const STEP_NAMES: readonly ["clone", "audit", "fix", "force", "push"];
115
+ export type StepName = (typeof STEP_NAMES)[number];
116
+ export declare const STEP_STATES: readonly ["pending", "running", "done", "skipped", "failed"];
117
+ export type StepState = (typeof STEP_STATES)[number];
118
+ /** Correction proposée par `npm audit` : aucune, dans les plages déclarées, ou par une version majeure (`--force`). */
119
+ export declare const FIX_KINDS: readonly ["none", "available", "major"];
120
+ export type FixKind = (typeof FIX_KINDS)[number];
121
+ /** Vulnérabilité d'un projet npm du dépôt ; `project` est le dossier du lockfile, `""` pour la racine. */
122
+ export declare const VulnerabilitySchema: z.ZodObject<{
123
+ project: z.ZodString;
124
+ name: z.ZodString;
125
+ severity: z.ZodEnum<{
126
+ critical: "critical";
127
+ high: "high";
128
+ info: "info";
129
+ low: "low";
130
+ moderate: "moderate";
131
+ }>;
132
+ fix: z.ZodEnum<{
133
+ available: "available";
134
+ major: "major";
135
+ none: "none";
136
+ }>;
137
+ }, z.core.$strip>;
138
+ export type Vulnerability = z.infer<typeof VulnerabilitySchema>;
139
+ /** Paquet que `npm audit fix --force` monterait d'une version majeure, et le nombre de vulnérabilités que cela corrige. */
140
+ export declare const ForceCandidateSchema: z.ZodObject<{
141
+ project: z.ZodString;
142
+ name: z.ZodString;
143
+ from: z.ZodNullable<z.ZodString>;
144
+ to: z.ZodString;
145
+ vulnerabilities: z.ZodNumber;
146
+ }, z.core.$strip>;
147
+ export type ForceCandidate = z.infer<typeof ForceCandidateSchema>;
148
+ /** Paquet du lockfile dont la version a changé ; `from` null pour un ajout, `to` null pour un retrait. */
149
+ export declare const ChangeSchema: z.ZodObject<{
150
+ project: z.ZodString;
151
+ name: z.ZodString;
152
+ from: z.ZodNullable<z.ZodString>;
153
+ to: z.ZodNullable<z.ZodString>;
154
+ }, z.core.$strip>;
155
+ export type Change = z.infer<typeof ChangeSchema>;
156
+ export declare const LogEntrySchema: z.ZodObject<{
157
+ at: z.ZodString;
158
+ text: z.ZodString;
159
+ }, z.core.$strip>;
160
+ export type LogEntry = z.infer<typeof LogEntrySchema>;
161
+ /**
162
+ * Opération d'audit ou de correction sur un clone temporaire. `workDir` est le
163
+ * clone, présent tant que l'opération n'est pas terminée ; `pid` est le processus
164
+ * qui exécute l'étape en cours.
165
+ */
166
+ export declare const OperationSchema: z.ZodObject<{
167
+ id: z.ZodString;
168
+ repoId: z.ZodString;
169
+ kind: z.ZodEnum<{
170
+ audit: "audit";
171
+ fix: "fix";
172
+ }>;
173
+ origin: z.ZodEnum<{
174
+ agent: "agent";
175
+ user: "user";
176
+ }>;
177
+ status: z.ZodEnum<{
178
+ cancelled: "cancelled";
179
+ done: "done";
180
+ failed: "failed";
181
+ running: "running";
182
+ waiting_force: "waiting_force";
183
+ waiting_push: "waiting_push";
184
+ }>;
185
+ createdAt: z.ZodString;
186
+ updatedAt: z.ZodString;
187
+ pid: z.ZodNumber;
188
+ workDir: z.ZodNullable<z.ZodString>;
189
+ baseBranch: z.ZodString;
190
+ cancelRequested: z.ZodBoolean;
191
+ steps: z.ZodObject<{
192
+ clone: z.ZodEnum<{
193
+ done: "done";
194
+ failed: "failed";
195
+ pending: "pending";
196
+ running: "running";
197
+ skipped: "skipped";
198
+ }>;
199
+ audit: z.ZodEnum<{
200
+ done: "done";
201
+ failed: "failed";
202
+ pending: "pending";
203
+ running: "running";
204
+ skipped: "skipped";
205
+ }>;
206
+ fix: z.ZodEnum<{
207
+ done: "done";
208
+ failed: "failed";
209
+ pending: "pending";
210
+ running: "running";
211
+ skipped: "skipped";
212
+ }>;
213
+ force: z.ZodEnum<{
214
+ done: "done";
215
+ failed: "failed";
216
+ pending: "pending";
217
+ running: "running";
218
+ skipped: "skipped";
219
+ }>;
220
+ push: z.ZodEnum<{
221
+ done: "done";
222
+ failed: "failed";
223
+ pending: "pending";
224
+ running: "running";
225
+ skipped: "skipped";
226
+ }>;
227
+ }, z.core.$strip>;
228
+ projects: z.ZodArray<z.ZodString>;
229
+ counts: z.ZodObject<{
230
+ initial: z.ZodNullable<z.ZodNumber>;
231
+ afterFix: z.ZodNullable<z.ZodNumber>;
232
+ afterForce: z.ZodNullable<z.ZodNumber>;
233
+ }, z.core.$strip>;
234
+ remaining: z.ZodArray<z.ZodObject<{
235
+ project: z.ZodString;
236
+ name: z.ZodString;
237
+ severity: z.ZodEnum<{
238
+ critical: "critical";
239
+ high: "high";
240
+ info: "info";
241
+ low: "low";
242
+ moderate: "moderate";
243
+ }>;
244
+ fix: z.ZodEnum<{
245
+ available: "available";
246
+ major: "major";
247
+ none: "none";
248
+ }>;
249
+ }, z.core.$strip>>;
250
+ forceCandidates: z.ZodArray<z.ZodObject<{
251
+ project: z.ZodString;
252
+ name: z.ZodString;
253
+ from: z.ZodNullable<z.ZodString>;
254
+ to: z.ZodString;
255
+ vulnerabilities: z.ZodNumber;
256
+ }, z.core.$strip>>;
257
+ changes: z.ZodArray<z.ZodObject<{
258
+ project: z.ZodString;
259
+ name: z.ZodString;
260
+ from: z.ZodNullable<z.ZodString>;
261
+ to: z.ZodNullable<z.ZodString>;
262
+ }, z.core.$strip>>;
263
+ commitMessage: z.ZodString;
264
+ branch: z.ZodNullable<z.ZodString>;
265
+ pullRequest: z.ZodNullable<z.ZodObject<{
266
+ number: z.ZodNumber;
267
+ url: z.ZodString;
268
+ }, z.core.$strip>>;
269
+ error: z.ZodNullable<z.ZodString>;
270
+ log: z.ZodArray<z.ZodObject<{
271
+ at: z.ZodString;
272
+ text: z.ZodString;
273
+ }, z.core.$strip>>;
274
+ }, z.core.$strip>;
275
+ export type Operation = z.infer<typeof OperationSchema>;
276
+ export declare const DEFAULT_COMMIT_MESSAGE = "fix(deps): resolve npm audit vulnerabilities";