@imenam/mcp-dependabot-tracker 1.0.25 → 1.0.27

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 CHANGED
@@ -65,7 +65,7 @@ TRUSTED_PROXIES=127.0.0.1
65
65
 
66
66
  ### Comptes de l'interface
67
67
 
68
- Il n'y a pas d'inscription : les comptes se créent sur la machine du serveur, avec le même environnement que lui (`MCP_DATA_DIR`, `APP_URL`, `AUTH_SECRET`, ou le `.env` du package). Le mot de passe est demandé deux fois, sans être affiché ; il fait au moins 12 caractères.
68
+ Il n'y a pas d'inscription : les comptes se créent sur la machine du serveur, avec le même environnement que lui (`DATA_DIR`, `APP_URL`, `AUTH_SECRET`, ou le `.env` du package). Le mot de passe est demandé deux fois, sans être affiché ; il fait au moins 12 caractères.
69
69
 
70
70
  ```bash
71
71
  mcp-dependabot-tracker user add admin@example.com --name="Admin"
@@ -112,9 +112,18 @@ La commande crée (ou complète) le `.mcp.json` du répertoire courant avec une
112
112
 
113
113
  `SERVER_URL` est l'adresse publique du serveur, `APP_URL`. Le mode MCP appelle `<SERVER_URL>/api/agent/…` avec l'en-tête `Authorization: Bearer <token>` : l'adresse doit joindre le serveur sans autre authentification. Sans `SERVER_URL` ou `AGENT_TOKEN`, le mode MCP refuse de démarrer.
114
114
 
115
- ### Token GitHub
115
+ ### Tokens GitHub
116
116
 
117
- Un token à grain fin, limité aux dépôts suivis, avec les permissions :
117
+ Le tracker utilise deux tokens GitHub, saisis dans l'interface (écran Réglages, section « GitHub — accès aux dépôts ») et chiffrés avec `VAULT_KEY` dans `<données>/settings.json`. Chacun est vérifié auprès de GitHub à l'enregistrement : un token refusé n'est pas enregistré, et l'écran affiche ses quatre derniers caractères, son compte et sa date d'expiration. Ils se remplacent sans redémarrer le serveur.
118
+
119
+ - **Token du tracker** — lit les alertes, clone les dépôts, pousse les branches de correction et ouvre les pull requests. Il ne quitte jamais le processus du tracker. Sans lui, le serveur démarre et l'interface fonctionne, mais rien n'est synchronisé, audité ni corrigé : ces actions renvoient vers les Réglages, et le journal le signale au démarrage. Il se remplace, il ne se retire pas.
120
+ - **Token de déploiement** — facultatif, en lecture seule, transmis aux scripts de déploiement pour leur `git pull` (voir [Accès au code des dépôts privés](#le-déploiement)).
121
+
122
+ Deux tokens plutôt qu'un : le token de déploiement voyage jusqu'aux serveurs cibles, où les scripts d'installation des paquets peuvent le lire ; il ne doit donc rien permettre de plus que lire du code déjà présent sur ces serveurs. Le token du tracker, qui écrit sur les dépôts, reste dans le tracker.
123
+
124
+ **Reprise de `GITHUB_TOKEN`** — tant que les réglages n'ont pas de token du tracker, une variable `GITHUB_TOKEN` présente dans l'environnement est reprise au démarrage : vérifiée auprès de GitHub (un refus est signalé dans le journal, le token est repris quand même), chiffrée, puis enregistrée dans les réglages. Ensuite, c'est le token des réglages qui compte : une variable `GITHUB_TOKEN` encore présente est ignorée, avec un avertissement dans le journal. Retirez-la de l'environnement une fois reprise.
125
+
126
+ Le token du tracker est un token à grain fin, limité aux dépôts suivis, avec les permissions :
118
127
 
119
128
  | Permission | Accès | Pour |
120
129
  |---|---|---|
@@ -123,7 +132,7 @@ Un token à grain fin, limité aux dépôts suivis, avec les permissions :
123
132
  | Pull requests | lecture et écriture | ouvrir la pull request, suivre celles qui attendent d'être mergées |
124
133
  | Metadata | lecture | imposée par GitHub ; liste les dépôts proposés à l'ajout |
125
134
 
126
- 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 du serveur que ses variables système (`PATH`, `HOME`, langue, dossiers temporaires, proxy et certificats) : ni `GITHUB_TOKEN`, ni `VAULT_KEY`, ni `AUTH_SECRET`, ni aucune autre variable du service.
135
+ Un token classique convient aussi, avec le scope `repo` (qui comprend `security_events`), mais il ouvre tous vos dépôts, organisations comprises. 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 du serveur que ses variables système (`PATH`, `HOME`, langue, dossiers temporaires, proxy et certificats) : ni les tokens GitHub, ni `VAULT_KEY`, ni `AUTH_SECRET`, ni aucune autre variable du service.
127
136
 
128
137
  ### Variables d'environnement du serveur
129
138
 
@@ -131,8 +140,8 @@ Elles se renseignent dans l'environnement du service, ou dans un fichier `.env`
131
140
 
132
141
  | Variable | Rôle |
133
142
  |---|---|
134
- | `GITHUB_TOKEN` | **Obligatoire.** Token GitHub (voir ci-dessus). Sans lui, le serveur refuse de démarrer. |
135
- | `CLONE_DIR` | **Obligatoire.** Dossier où chaque opération crée son clone ; il est créé s'il n'existe pas. Sans lui, le serveur refuse de démarrer. |
143
+ | `GITHUB_TOKEN` | Facultatif. Repris au premier démarrage comme token du tracker, puis ignoré : le token se règle dans l'interface (voir [Tokens GitHub](#tokens-github)). |
144
+ | `DATA_DIR` | **Obligatoire, sans défaut.** Répertoire des données : comptes, sessions, tokens, scripts de déploiement, et clones des opérations dans `<DATA_DIR>/clones`. Il est créé s'il n'existe pas ; hors de Windows, le serveur le réserve à son compte (droits `700`) à chaque démarrage, et ses fichiers sont écrits en `600`. Requis par les modes `serve` et `user` ; le mode `mcp` ne stocke rien. |
136
145
  | `VAULT_KEY` | **Obligatoire.** 32 octets en base64 (`--generate-vault-key`), qui chiffrent en AES-256-GCM les clés privées des serveurs de déploiement et les tokens de l'organizer et de Claude. Sans elle, ou si elle ne déchiffre pas les clés et les tokens déjà enregistrés, le serveur refuse de démarrer. La perdre oblige à reconnecter chaque serveur et à ressaisir les deux tokens. |
137
146
  | `APP_PORT` | **Obligatoire.** Port d'écoute du serveur. |
138
147
  | `APP_URL` | **Obligatoire.** Adresse publique de l'interface, sans chemin : `https://…`, ou `http://localhost:<port>` sur la machine elle-même (voir [Exposition et authentification](#exposition-et-authentification)). |
@@ -141,8 +150,7 @@ Elles se renseignent dans l'environnement du service, ou dans un fichier `.env`
141
150
  | `TRUSTED_PROXIES` | Adresses IP ou plages CIDR des reverse proxies, séparées par des virgules, dont l'en-tête `X-Forwarded-For` est cru. |
142
151
  | `GITHUB_API_URL` | API GitHub (défaut `https://api.github.com`), à changer pour GitHub Enterprise Server. |
143
152
  | `GITHUB_SERVER_URL` | Serveur git des clones (défaut `https://github.com`) : un dépôt se clone depuis `<serveur>/<propriétaire>/<nom>.git`. |
144
- | `MCP_DATA_DIR` | Répertoire des données (défaut `~/.mcp-dependabot-tracker`). Hors de Windows, le serveur le réserve à son compte (droits `700`) à chaque démarrage, et ses fichiers sont écrits en `600`. |
145
- | `MCP_LOG_DIR` | Répertoire des logs. Défaut : `<données>/logs`. |
153
+ | `MCP_LOG_DIR` | Répertoire des logs. Défaut : `<DATA_DIR>/logs`. |
146
154
 
147
155
  Sans une variable obligatoire, ou avec une valeur invalide (`APP_URL` en http hors `localhost`, `AUTH_SECRET` trop court, `LISTEN_HOST` qui n'est pas une adresse IP), le serveur refuse de démarrer en nommant la variable.
148
156
 
@@ -189,7 +197,7 @@ Un dépôt déprécié est refusé par tous les outils, jusqu'à ce que l'utilis
189
197
 
190
198
  ## Une opération
191
199
 
192
- Chaque opération travaille dans un clone temporaire (`<CLONE_DIR>/mcp-dependabot-tracker-*/repo`, `git clone --depth 1` de la branche analysée), supprimé dès qu'elle se termine, réussie, échouée ou annulée.
200
+ Chaque opération travaille dans un clone temporaire (`<DATA_DIR>/clones/mcp-dependabot-tracker-*/repo`, `git clone --depth 1` de la branche analysée), supprimé dès qu'elle se termine, réussie, échouée ou annulée.
193
201
 
194
202
  La **branche analysée** se choisit par dépôt dans la GUI ; c'est la branche par défaut tant qu'aucune autre n'est choisie. L'agent l'utilise aussi, sans pouvoir en changer. Les alertes Dependabot, elles, portent toujours sur la branche par défaut, la seule que GitHub analyse : sur une autre branche, c'est `npm audit` qui mesure les vulnérabilités.
195
203
 
@@ -230,12 +238,13 @@ Une tâche introuvable, sans le tag ou non assignée au propriétaire fait écho
230
238
 
231
239
  **Réglages** (écran Réglages, roue dentée de l'accueil) :
232
240
 
241
+ - **GitHub** — le token du tracker et le token de déploiement (voir [Tokens GitHub](#tokens-github)) ; « Retirer », confirmé par un second clic, supprime le token de déploiement.
233
242
  - **Organizer** — adresse du site (https, sauf pour un site de cette machine) et token d'agent, créé dans l'organizer (Paramètres › Agents) : il couvre un espace, avec les droits de son créateur. Une connexion modifiée est testée à l'enregistrement ; « Tester » la reteste. L'écran affiche l'espace et son propriétaire.
234
243
  - **Claude** — un token d'abonnement (Pro, Max, Team ou Enterprise) : lancer `claude setup-token` sur un poste avec navigateur, autoriser l'accès, puis coller le token affiché (valable un an). Il est vérifié à l'enregistrement par une requête minimale ; un token refusé n'est pas enregistré. L'écran affiche sa date d'enregistrement et d'expiration.
235
244
  - **Corrections par Claude** — les limites d'une session.
236
245
  - **Accès des agents** — les tokens d'agent, un par ligne : nom, quatre derniers caractères, date de création et de dernière utilisation ; « Révoquer », au survol (en permanence sur un écran tactile), le révoque après un second clic de confirmation dans les 4 secondes. « Nouveau token » ouvre un champ en place pour le nommer (Entrée crée, Échap annule) ; le token s'affiche alors une seule fois, avec « Copier » et la commande `--claude-setup-mcp` qui déclare le mode MCP. Créer ou révoquer un token prend effet aussitôt, sans « Enregistrer ».
237
246
 
238
- Les tokens de l'organizer et de Claude sont enregistrés dans `<données>/settings.json`, chiffrés avec `VAULT_KEY` (un fichier écrit en clair par une version antérieure est chiffré au démarrage), ceux des agents par leur empreinte dans `<données>/agent-tokens.json`, lisibles par le seul compte du serveur ; la GUI n'en reçoit que les quatre derniers caractères. Claude Code garde sa configuration dans `<données>/claude`. L'écran est protégé comme le reste de l'interface, par la session de l'utilisateur.
247
+ Les tokens GitHub, de l'organizer et de Claude sont enregistrés dans `<données>/settings.json`, chiffrés avec `VAULT_KEY` (un fichier écrit en clair par une version antérieure est chiffré au démarrage), ceux des agents par leur empreinte dans `<données>/agent-tokens.json`, lisibles par le seul compte du serveur ; la GUI n'en reçoit que les quatre derniers caractères. Claude Code garde sa configuration dans `<données>/claude`. L'écran est protégé comme le reste de l'interface, par la session de l'utilisateur.
239
248
 
240
249
  **Suivi** — la tâche du dernier rapport de Claude s'affiche dans la colonne « Suivi » de la ligne du dépôt (« MNT-12 », qui ouvre la tâche sur l'organizer) tant qu'elle n'est pas terminée : son statut est relu sur l'organizer avec les alertes, toutes les 10 minutes. La pull request de la correction mentionne la clé de la tâche.
241
250
 
@@ -259,10 +268,22 @@ Un serveur se partage entre dépôts : « Connecter un serveur » propose les se
259
268
 
260
269
  Le renouvellement et la révocation valent pour tous les dépôts qui utilisent le serveur, et sont refusés pendant un déploiement sur ce serveur.
261
270
 
262
- **Script** — en bash, édité dans l'interface avec coloration syntaxique (la palette « sobre » de SSH Gate), numéros de ligne et ligne du curseur surlignée ; Tab indente, Ctrl+S enregistre, Échap annule. Le tracker définit trois variables : `$BRANCH` (la branche analysée du dépôt), `$COMMIT` (son dernier commit sur GitHub, lu au lancement) et `$REPO` (`propriétaire/nom`).
271
+ **Script** — en bash, édité dans l'interface avec coloration syntaxique (la palette « sobre » de SSH Gate), numéros de ligne et ligne du curseur surlignée ; Tab indente, Ctrl+S enregistre, Échap annule. Le tracker définit trois variables : `$BRANCH` (la branche analysée du dépôt), `$COMMIT` (son dernier commit sur GitHub, lu au lancement) et `$REPO` (`propriétaire/nom`). Avec un token de déploiement réglé, il définit aussi les variables qui authentifient `git` (voir ci-dessous).
263
272
 
264
273
  **Déploiement** — « Déployer », actif quand le serveur est testé et le script écrit, lance le script sur le serveur et le suit en direct. Le script est copié dans un dossier temporaire du serveur (`mktemp -d`, supprimé à la fin), puis exécuté avec bash depuis le dossier personnel, l'entrée venant de `/dev/null` ; sa sortie (stdout et stderr) s'affiche au fil de l'eau, et sa ligne en cours est lue dans la trace de bash (`set -x`, sur un descripteur à part : la sortie n'en contient rien). Un déploiement réussi (code 0) retire la marque « à déployer » du dépôt ; un échec donne le code de sortie et la ligne du script en cours. « Interrompre » envoie SIGTERM à tout le groupe de processus du script, puis ferme la connexion. Un seul déploiement à la fois par dépôt ; le retrait d'un dépôt est refusé pendant un déploiement. Un déploiement que l'arrêt du serveur a interrompu passe en échec au démarrage suivant. Les 20 derniers déploiements de chaque dépôt sont conservés, avec le script lancé et la sortie (ses 200 000 derniers caractères).
265
274
 
275
+ **Accès au code des dépôts privés** — le `git pull` d'un script de déploiement doit s'authentifier auprès de GitHub pour un dépôt privé ; lancé par le tracker, il n'a ni terminal ni assistant d'identifiants (celui de VS Code n'existe que dans ses sessions). Le tracker lui fournit un **token de déploiement**, réglé une fois dans les Réglages : un token à grain fin en **lecture seule** (permission *Contents* : *Read-only*, *Metadata* imposée), limité aux dépôts déployés (*Only select repositories*). Un dépôt s'y ajoute en modifiant le token sur GitHub : sa valeur ne change pas, rien n'est à refaire. Ce n'est jamais le token du tracker, qui écrit sur les dépôts et ne quitte pas le processus du tracker.
276
+
277
+ À chaque déploiement, le tracker relit le token et l'exporte dans l'environnement du script sous forme de réglage git (`GIT_CONFIG_COUNT`, `GIT_CONFIG_KEY_0` = `http.<serveur GitHub>/.extraheader`, `GIT_CONFIG_VALUE_0` = en-tête `AUTHORIZATION`), avec `GIT_TERMINAL_PROMPT=0` : un simple `git pull` sur un remote https s'authentifie sans autre réglage, et un échec d'authentification est immédiat. Ces variables sont exportées avant le début de la trace de bash : le token n'apparaît ni dans la trace, ni dans le script enregistré. Rien n'est écrit sur le serveur cible : ni token, ni `~/.git-credentials`, ni configuration git, et les sessions VS Code ne sont pas touchées.
278
+
279
+ Tout processus lancé par le script hérite de ces variables, `npm ci` compris : retirez-les juste après le `git pull`, pour ne pas les transmettre aux commandes suivantes. Ce n'est pas une barrière étanche : l'environnement de départ du script reste lisible dans `/proc/<pid>/environ`, et du code qui tourne en root lit tout le serveur. La sécurité repose sur les droits du token : en lecture seule, limité à des dépôts dont le code est déjà sur le serveur cible, un token volé n'ouvre rien de plus.
280
+
281
+ ```bash
282
+ git pull
283
+ unset GIT_CONFIG_COUNT GIT_CONFIG_KEY_0 GIT_CONFIG_VALUE_0
284
+ npm ci
285
+ ```
286
+
266
287
  Le déploiement se pilote depuis l'interface seulement : les outils de l'agent n'y ont pas accès.
267
288
 
268
289
  ---
@@ -15,6 +15,17 @@ export declare const AnalysisSettingsSchema: z.ZodObject<{
15
15
  maxMinutes: z.ZodNumber;
16
16
  }, z.core.$strip>;
17
17
  export type AnalysisSettings = z.infer<typeof AnalysisSettingsSchema>;
18
+ /**
19
+ * Token GitHub enregistré : `savedAt` est sa date d'enregistrement, `login` le
20
+ * compte et `expiresAt` la date d'expiration relevés par GitHub à sa
21
+ * vérification (null pour un token sans expiration ou pas encore vérifié).
22
+ */
23
+ export declare const GitHubTokenSettingsSchema: z.ZodObject<{
24
+ token: z.ZodNullable<z.ZodString>;
25
+ savedAt: z.ZodNullable<z.ZodString>;
26
+ login: z.ZodDefault<z.ZodNullable<z.ZodString>>;
27
+ expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
28
+ }, z.core.$strip>;
18
29
  /**
19
30
  * Réglages enregistrés dans `<données>/settings.json`. `organizer.space` et
20
31
  * `organizer.owner` sont l'espace du token et son propriétaire, relevés au
@@ -36,9 +47,28 @@ export declare const SettingsSchema: z.ZodObject<{
36
47
  maxTurns: z.ZodNumber;
37
48
  maxMinutes: z.ZodNumber;
38
49
  }, z.core.$strip>;
50
+ github: z.ZodDefault<z.ZodObject<{
51
+ token: z.ZodNullable<z.ZodString>;
52
+ savedAt: z.ZodNullable<z.ZodString>;
53
+ login: z.ZodDefault<z.ZodNullable<z.ZodString>>;
54
+ expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
55
+ }, z.core.$strip>>;
56
+ deploy: z.ZodDefault<z.ZodObject<{
57
+ token: z.ZodNullable<z.ZodString>;
58
+ savedAt: z.ZodNullable<z.ZodString>;
59
+ login: z.ZodDefault<z.ZodNullable<z.ZodString>>;
60
+ expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
61
+ }, z.core.$strip>>;
39
62
  }, z.core.$strip>;
40
63
  export type Settings = z.infer<typeof SettingsSchema>;
41
64
  export declare const DEFAULT_SETTINGS: Settings;
65
+ /** Token GitHub tel que la GUI le reçoit : ses quatre derniers caractères, jamais sa valeur. */
66
+ export interface GitHubTokenView {
67
+ tokenHint: string | null;
68
+ savedAt: string | null;
69
+ login: string | null;
70
+ expiresAt: string | null;
71
+ }
42
72
  /**
43
73
  * Réglages tels que la GUI les reçoit : les tokens n'y figurent que par leurs
44
74
  * quatre derniers caractères. `ready` est vrai quand l'organizer et Claude sont
@@ -58,15 +88,20 @@ export interface SettingsView {
58
88
  };
59
89
  analysis: AnalysisSettings;
60
90
  ready: boolean;
91
+ github: GitHubTokenView;
92
+ deploy: GitHubTokenView;
61
93
  }
62
94
  /**
63
95
  * Corps de `PUT /api/settings`. Un token absent garde la valeur enregistrée ;
64
- * une adresse vide retire la connexion à l'organizer.
96
+ * une adresse vide retire la connexion à l'organizer, `deployToken: null` retire
97
+ * le token de déploiement. Le token du tracker se remplace, il ne se retire pas.
65
98
  */
66
99
  export declare const SaveSettingsBodySchema: z.ZodObject<{
67
100
  organizerUrl: z.ZodString;
68
101
  organizerToken: z.ZodOptional<z.ZodString>;
69
102
  claudeToken: z.ZodOptional<z.ZodString>;
103
+ githubToken: z.ZodOptional<z.ZodString>;
104
+ deployToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
70
105
  analysis: z.ZodObject<{
71
106
  maxTurns: z.ZodNumber;
72
107
  maxMinutes: z.ZodNumber;
@@ -5,6 +5,18 @@ export const AnalysisSettingsSchema = z.object({
5
5
  maxTurns: z.number().int().min(ANALYSIS_LIMITS.maxTurns.min).max(ANALYSIS_LIMITS.maxTurns.max),
6
6
  maxMinutes: z.number().int().min(ANALYSIS_LIMITS.maxMinutes.min).max(ANALYSIS_LIMITS.maxMinutes.max),
7
7
  });
8
+ /**
9
+ * Token GitHub enregistré : `savedAt` est sa date d'enregistrement, `login` le
10
+ * compte et `expiresAt` la date d'expiration relevés par GitHub à sa
11
+ * vérification (null pour un token sans expiration ou pas encore vérifié).
12
+ */
13
+ export const GitHubTokenSettingsSchema = z.object({
14
+ token: z.string().nullable(),
15
+ savedAt: z.string().nullable(),
16
+ login: z.string().nullable().default(null),
17
+ expiresAt: z.string().nullable().default(null),
18
+ });
19
+ const NO_TOKEN = { token: null, savedAt: null, login: null, expiresAt: null };
8
20
  /**
9
21
  * Réglages enregistrés dans `<données>/settings.json`. `organizer.space` et
10
22
  * `organizer.owner` sont l'espace du token et son propriétaire, relevés au
@@ -23,19 +35,28 @@ export const SettingsSchema = z.object({
23
35
  savedAt: z.string().nullable(),
24
36
  }),
25
37
  analysis: AnalysisSettingsSchema,
38
+ /** Token du tracker : alertes, clones, branches de correction, pull requests. */
39
+ github: GitHubTokenSettingsSchema.default(NO_TOKEN),
40
+ /** Token en lecture seule transmis aux scripts de déploiement, pour leur `git pull`. */
41
+ deploy: GitHubTokenSettingsSchema.default(NO_TOKEN),
26
42
  });
27
43
  export const DEFAULT_SETTINGS = {
28
44
  organizer: { url: null, token: null, space: null, owner: null },
29
45
  claude: { token: null, savedAt: null },
30
46
  analysis: { maxTurns: 40, maxMinutes: 15 },
47
+ github: NO_TOKEN,
48
+ deploy: NO_TOKEN,
31
49
  };
32
50
  /**
33
51
  * Corps de `PUT /api/settings`. Un token absent garde la valeur enregistrée ;
34
- * une adresse vide retire la connexion à l'organizer.
52
+ * une adresse vide retire la connexion à l'organizer, `deployToken: null` retire
53
+ * le token de déploiement. Le token du tracker se remplace, il ne se retire pas.
35
54
  */
36
55
  export const SaveSettingsBodySchema = z.object({
37
56
  organizerUrl: z.string().trim(),
38
57
  organizerToken: z.string().trim().min(1).optional(),
39
58
  claudeToken: z.string().trim().min(1).optional(),
59
+ githubToken: z.string().trim().min(1).optional(),
60
+ deployToken: z.string().trim().min(1).nullable().optional(),
40
61
  analysis: AnalysisSettingsSchema,
41
62
  });
@@ -9,5 +9,9 @@ export interface GitHubConfig {
9
9
  apiUrl: string;
10
10
  serverUrl: string;
11
11
  }
12
- /** Configuration GitHub lue dans l'environnement ; lève une erreur si GITHUB_TOKEN manque. */
13
- export declare function readGitHubConfig(): GitHubConfig;
12
+ /** Adresses du serveur GitHub, sans le token. */
13
+ export type GitHubServers = Omit<GitHubConfig, "token">;
14
+ /** Adresses de l'API et du serveur GitHub lues dans l'environnement, github.com par défaut. */
15
+ export declare function readGitHubServers(env?: NodeJS.ProcessEnv): GitHubServers;
16
+ /** Configuration GitHub avec le token du tracker ; lève une erreur qui renvoie aux réglages sans token. */
17
+ export declare function gitHubConfig(servers: GitHubServers, token: string | null): GitHubConfig;
@@ -1,15 +1,17 @@
1
1
  import { TrackerError } from "./errors.js";
2
2
  const DEFAULT_API_URL = "https://api.github.com";
3
3
  const DEFAULT_SERVER_URL = "https://github.com";
4
- /** Configuration GitHub lue dans l'environnement ; lève une erreur si GITHUB_TOKEN manque. */
5
- export function readGitHubConfig() {
6
- const token = process.env.GITHUB_TOKEN?.trim();
7
- if (!token) {
8
- throw new TrackerError("GITHUB_TOKEN is not set: declare a GitHub token in the environment of the server (Dependabot alerts: read, Contents: read and write, Pull requests: read and write).");
9
- }
4
+ /** Adresses de l'API et du serveur GitHub lues dans l'environnement, github.com par défaut. */
5
+ export function readGitHubServers(env = process.env) {
10
6
  return {
11
- token,
12
- apiUrl: (process.env.GITHUB_API_URL?.trim() || DEFAULT_API_URL).replace(/\/+$/, ""),
13
- serverUrl: (process.env.GITHUB_SERVER_URL?.trim() || DEFAULT_SERVER_URL).replace(/\/+$/, ""),
7
+ apiUrl: (env.GITHUB_API_URL?.trim() || DEFAULT_API_URL).replace(/\/+$/, ""),
8
+ serverUrl: (env.GITHUB_SERVER_URL?.trim() || DEFAULT_SERVER_URL).replace(/\/+$/, ""),
14
9
  };
15
10
  }
11
+ /** Configuration GitHub avec le token du tracker ; lève une erreur qui renvoie aux réglages sans token. */
12
+ export function gitHubConfig(servers, token) {
13
+ if (!token) {
14
+ throw new TrackerError("The GitHub token of the tracker is not set: enter it in the settings (Réglages › GitHub), with Dependabot alerts: read, Contents and Pull requests: read and write.");
15
+ }
16
+ return { ...servers, token };
17
+ }
@@ -1,13 +1,9 @@
1
1
  /**
2
- * Répertoire des données : MCP_DATA_DIR, puis `~/.mcp-dependabot-tracker`. Les
3
- * dépôts suivis ne dépendent d'aucun projet : le répertoire par défaut est
4
- * propre à l'utilisateur. Il est créé s'il n'existe pas, et réservé au compte
5
- * du serveur (droits 700) hors de Windows : il porte les comptes, les sessions,
6
- * les tokens et les scripts de déploiement.
2
+ * Répertoire des données, fixé par DATA_DIR. Il est créé s'il n'existe pas, et
3
+ * réservé au compte du serveur (droits 700) hors de Windows : il porte les
4
+ * comptes, les sessions, les tokens, les scripts de déploiement et les clones.
5
+ * Lève une erreur si la variable n'est pas renseignée.
7
6
  */
8
7
  export declare function resolveDataDir(): string;
9
- /**
10
- * Dossier où chaque opération crée son clone, fixé par CLONE_DIR et créé s'il
11
- * n'existe pas. Lève une erreur si la variable n'est pas renseignée.
12
- */
13
- export declare function resolveCloneDir(): string;
8
+ /** Dossier où chaque opération crée son clone : `<dataDir>/clones`, créé s'il n'existe pas. */
9
+ export declare function resolveCloneDir(dataDir: string): string;
@@ -1,33 +1,29 @@
1
1
  import fs from "fs";
2
- import os from "os";
3
2
  import path from "path";
4
3
  /** Droits du répertoire des données : lecture, écriture et parcours par le seul compte du serveur. */
5
4
  const DATA_DIR_MODE = 0o700;
5
+ /** Sous-dossier du répertoire des données où chaque opération crée son clone. */
6
+ const CLONES_SUBDIR = "clones";
6
7
  /**
7
- * Répertoire des données : MCP_DATA_DIR, puis `~/.mcp-dependabot-tracker`. Les
8
- * dépôts suivis ne dépendent d'aucun projet : le répertoire par défaut est
9
- * propre à l'utilisateur. Il est créé s'il n'existe pas, et réservé au compte
10
- * du serveur (droits 700) hors de Windows : il porte les comptes, les sessions,
11
- * les tokens et les scripts de déploiement.
8
+ * Répertoire des données, fixé par DATA_DIR. Il est créé s'il n'existe pas, et
9
+ * réservé au compte du serveur (droits 700) hors de Windows : il porte les
10
+ * comptes, les sessions, les tokens, les scripts de déploiement et les clones.
11
+ * Lève une erreur si la variable n'est pas renseignée.
12
12
  */
13
13
  export function resolveDataDir() {
14
- const configured = process.env.MCP_DATA_DIR?.trim();
15
- const dir = configured ? path.resolve(configured) : path.join(os.homedir(), ".mcp-dependabot-tracker");
14
+ const configured = process.env.DATA_DIR?.trim();
15
+ if (!configured) {
16
+ throw new Error("DATA_DIR is not set. It is the folder where the accounts, the sessions, the tokens, the deployment scripts and the repository clones are stored.");
17
+ }
18
+ const dir = path.resolve(configured);
16
19
  fs.mkdirSync(dir, { recursive: true, mode: DATA_DIR_MODE });
17
20
  if (process.platform !== "win32")
18
21
  fs.chmodSync(dir, DATA_DIR_MODE);
19
22
  return dir;
20
23
  }
21
- /**
22
- * Dossier où chaque opération crée son clone, fixé par CLONE_DIR et créé s'il
23
- * n'existe pas. Lève une erreur si la variable n'est pas renseignée.
24
- */
25
- export function resolveCloneDir() {
26
- const configured = process.env.CLONE_DIR?.trim();
27
- if (!configured) {
28
- throw new Error("CLONE_DIR is not set: declare the folder where the repositories are cloned for npm audit in the environment of the server.");
29
- }
30
- const dir = path.resolve(configured);
24
+ /** Dossier où chaque opération crée son clone : `<dataDir>/clones`, créé s'il n'existe pas. */
25
+ export function resolveCloneDir(dataDir) {
26
+ const dir = path.join(dataDir, CLONES_SUBDIR);
31
27
  fs.mkdirSync(dir, { recursive: true });
32
28
  return dir;
33
29
  }
@@ -13,6 +13,12 @@ export declare const OUTPUT_LIMIT = 200000;
13
13
  * stderr, sert à interrompre tout le groupe.
14
14
  */
15
15
  export declare function remoteWrapper(script: string, variables: Record<string, string>): string;
16
+ /**
17
+ * Variables qui authentifient `git` auprès du serveur GitHub `serverUrl` par un
18
+ * en-tête HTTP, avec le token de déploiement ; aucune sans token. `git` ne pose
19
+ * alors aucune question : un échec d'authentification est immédiat.
20
+ */
21
+ export declare function deployGitVariables(serverUrl: string, token: string | null): Record<string, string>;
16
22
  /** Lit la trace de bash ligne à ligne et rend la dernière ligne du script commencée. */
17
23
  export declare class TraceReader {
18
24
  private readonly onLine;
@@ -51,16 +57,25 @@ export declare class DeploymentStore {
51
57
  /**
52
58
  * Déploiement des dépôts : chaque dépôt choisit un serveur et un script ; un
53
59
  * déploiement exécute ce script sur le serveur, par SSH, et en suit la ligne en
54
- * cours et la sortie. Un déploiement réussi retire la marque « à déployer ».
60
+ * cours et la sortie. Le script reçoit BRANCH, COMMIT et REPO, et, quand un
61
+ * token de déploiement est réglé, les variables qui authentifient `git` auprès
62
+ * de GitHub. Un déploiement réussi retire la marque « à déployer ».
55
63
  */
56
64
  export declare class Deployer {
57
65
  private readonly store;
58
66
  readonly servers: DeployServerStore;
59
67
  readonly deployments: DeploymentStore;
68
+ /** Configuration GitHub, avec le token du tracker ; lève une erreur sans token. */
60
69
  private readonly github;
61
70
  private readonly logError;
71
+ /** Token de déploiement, relu à chaque déploiement ; null sans token réglé. */
72
+ private readonly deployToken;
62
73
  private readonly running;
63
- constructor(store: Store, servers: DeployServerStore, deployments: DeploymentStore, github: GitHubConfig, logError: (message: string) => void);
74
+ constructor(store: Store, servers: DeployServerStore, deployments: DeploymentStore,
75
+ /** Configuration GitHub, avec le token du tracker ; lève une erreur sans token. */
76
+ github: () => GitHubConfig, logError: (message: string) => void,
77
+ /** Token de déploiement, relu à chaque déploiement ; null sans token réglé. */
78
+ deployToken: () => string | null);
64
79
  /** Serveur, script, déploiement en cours et derniers déploiements d'un dépôt. */
65
80
  view(repoId: string): RepoDeployResponse;
66
81
  setServer(repoId: string, serverId: string | null): RepoDeployResponse;
@@ -68,6 +68,22 @@ export function remoteWrapper(script, variables) {
68
68
  ``,
69
69
  ].join("\n");
70
70
  }
71
+ /**
72
+ * Variables qui authentifient `git` auprès du serveur GitHub `serverUrl` par un
73
+ * en-tête HTTP, avec le token de déploiement ; aucune sans token. `git` ne pose
74
+ * alors aucune question : un échec d'authentification est immédiat.
75
+ */
76
+ export function deployGitVariables(serverUrl, token) {
77
+ if (token === null)
78
+ return {};
79
+ const basic = Buffer.from(`x-access-token:${token}`).toString("base64");
80
+ return {
81
+ GIT_TERMINAL_PROMPT: "0",
82
+ GIT_CONFIG_COUNT: "1",
83
+ GIT_CONFIG_KEY_0: `http.${serverUrl}/.extraheader`,
84
+ GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${basic}`,
85
+ };
86
+ }
71
87
  /** Lit la trace de bash ligne à ligne et rend la dernière ligne du script commencée. */
72
88
  export class TraceReader {
73
89
  onLine;
@@ -195,7 +211,9 @@ export class DeploymentStore {
195
211
  /**
196
212
  * Déploiement des dépôts : chaque dépôt choisit un serveur et un script ; un
197
213
  * déploiement exécute ce script sur le serveur, par SSH, et en suit la ligne en
198
- * cours et la sortie. Un déploiement réussi retire la marque « à déployer ».
214
+ * cours et la sortie. Le script reçoit BRANCH, COMMIT et REPO, et, quand un
215
+ * token de déploiement est réglé, les variables qui authentifient `git` auprès
216
+ * de GitHub. Un déploiement réussi retire la marque « à déployer ».
199
217
  */
200
218
  export class Deployer {
201
219
  store;
@@ -203,13 +221,19 @@ export class Deployer {
203
221
  deployments;
204
222
  github;
205
223
  logError;
224
+ deployToken;
206
225
  running = new Map();
207
- constructor(store, servers, deployments, github, logError) {
226
+ constructor(store, servers, deployments,
227
+ /** Configuration GitHub, avec le token du tracker ; lève une erreur sans token. */
228
+ github, logError,
229
+ /** Token de déploiement, relu à chaque déploiement ; null sans token réglé. */
230
+ deployToken) {
208
231
  this.store = store;
209
232
  this.servers = servers;
210
233
  this.deployments = deployments;
211
234
  this.github = github;
212
235
  this.logError = logError;
236
+ this.deployToken = deployToken;
213
237
  }
214
238
  /** Serveur, script, déploiement en cours et derniers déploiements d'un dépôt. */
215
239
  view(repoId) {
@@ -257,7 +281,7 @@ export class Deployer {
257
281
  throw new ConflictError(`The connection to ${server.name} has not been tested: test it before deploying.`);
258
282
  if (this.deployments.active(repo.id))
259
283
  throw new ConflictError(`A deployment is already running on ${repo.id}: wait for it to finish or interrupt it.`);
260
- const commit = await new GitHubClient(this.github).getBranchCommit(repo.owner, repo.name, repo.branch);
284
+ const commit = await new GitHubClient(this.github()).getBranchCommit(repo.owner, repo.name, repo.branch);
261
285
  const now = new Date().toISOString();
262
286
  const deployment = this.deployments.create({
263
287
  id: `dep-${Date.now().toString(36)}-${crypto.randomBytes(3).toString("hex")}`,
@@ -365,7 +389,8 @@ export class Deployer {
365
389
  let code = null;
366
390
  channel.on("exit", (exit) => (code = typeof exit === "number" ? exit : null));
367
391
  channel.on("close", () => resolve(code));
368
- channel.end(remoteWrapper(initial.script, { BRANCH: initial.branch, COMMIT: initial.commit ?? "", REPO: initial.repoId }));
392
+ const variables = { BRANCH: initial.branch, COMMIT: initial.commit ?? "", REPO: initial.repoId, ...deployGitVariables(this.github().serverUrl, this.deployToken()) };
393
+ channel.end(remoteWrapper(initial.script, variables));
369
394
  });
370
395
  append(stdout.end());
371
396
  trace.push(`${stderr.end()}\n`);
@@ -14,6 +14,13 @@ export interface GitHubUser {
14
14
  id: number;
15
15
  name: string | null;
16
16
  }
17
+ /** Compte d'un token et sa date d'expiration (ISO), null pour un token sans expiration. */
18
+ export interface TokenCheck {
19
+ login: string;
20
+ expiresAt: string | null;
21
+ }
22
+ /** Date d'expiration d'un token telle que GitHub l'envoie (`2026-12-14 14:31:47 UTC`), en ISO. */
23
+ export declare function tokenExpiration(header: string | null): string | null;
17
24
  /** Pull request créée ; `createdAt` est sa date d'ouverture. */
18
25
  export interface CreatedPullRequest {
19
26
  number: number;
@@ -30,10 +37,14 @@ export interface OpenPullRequest {
30
37
  }
31
38
  /** URL de la page suivante dans un en-tête `Link` de pagination, ou null. */
32
39
  export declare function nextPageUrl(link: string | null): string | null;
33
- /** Client REST minimal de l'API GitHub, authentifié par le token de la configuration. */
40
+ /**
41
+ * Client REST minimal de l'API GitHub, authentifié par le token de la
42
+ * configuration ; `tokenName` désigne ce token dans le message d'un refus.
43
+ */
34
44
  export declare class GitHubClient {
35
45
  private readonly config;
36
- constructor(config: GitHubConfig);
46
+ private readonly tokenName;
47
+ constructor(config: GitHubConfig, tokenName?: string);
37
48
  private request;
38
49
  getRepository(owner: string, name: string): Promise<GitHubRepository>;
39
50
  /** Alertes Dependabot ouvertes du dépôt, toutes pages comprises. */
@@ -44,6 +55,8 @@ export declare class GitHubClient {
44
55
  listBranches(owner: string, name: string): Promise<string[]>;
45
56
  /** SHA du dernier commit de `branch`. */
46
57
  getBranchCommit(owner: string, name: string, branch: string): Promise<string>;
58
+ /** Compte du token et sa date d'expiration ; un token refusé lève une erreur. */
59
+ checkToken(): Promise<TokenCheck>;
47
60
  getAuthenticatedUser(): Promise<GitHubUser>;
48
61
  /** Pull requests ouvertes du dépôt, toutes pages comprises. */
49
62
  listOpenPullRequests(owner: string, name: string): Promise<OpenPullRequest[]>;
@@ -1,5 +1,12 @@
1
1
  import { ALERT_SEVERITIES, DEPENDENCY_SCOPES } from "../../shared/schemas/model.schema.js";
2
2
  import { NotFoundError, TrackerError } from "./errors.js";
3
+ /** Date d'expiration d'un token telle que GitHub l'envoie (`2026-12-14 14:31:47 UTC`), en ISO. */
4
+ export function tokenExpiration(header) {
5
+ if (!header)
6
+ return null;
7
+ const date = new Date(header.trim().replace(/ UTC$/, "Z").replace(" ", "T"));
8
+ return Number.isNaN(date.getTime()) ? null : date.toISOString();
9
+ }
3
10
  const REQUEST_TIMEOUT_MS = 30_000;
4
11
  /** Nombre maximal de pages d'alertes lues (100 alertes par page). */
5
12
  const MAX_ALERT_PAGES = 20;
@@ -16,11 +23,16 @@ export function nextPageUrl(link) {
16
23
  }
17
24
  return null;
18
25
  }
19
- /** Client REST minimal de l'API GitHub, authentifié par le token de la configuration. */
26
+ /**
27
+ * Client REST minimal de l'API GitHub, authentifié par le token de la
28
+ * configuration ; `tokenName` désigne ce token dans le message d'un refus.
29
+ */
20
30
  export class GitHubClient {
21
31
  config;
22
- constructor(config) {
32
+ tokenName;
33
+ constructor(config, tokenName = "GITHUB_TOKEN") {
23
34
  this.config = config;
35
+ this.tokenName = tokenName;
24
36
  }
25
37
  async request(method, url, body) {
26
38
  let response;
@@ -54,10 +66,10 @@ export class GitHubClient {
54
66
  if (!response.ok) {
55
67
  const message = typeof json?.message === "string" ? json.message : `HTTP ${response.status}`;
56
68
  if (response.status === 401)
57
- throw new TrackerError(`GitHub rejected GITHUB_TOKEN (401: ${message}).`);
69
+ throw new TrackerError(`GitHub rejected ${this.tokenName} (401: ${message}).`);
58
70
  throw new GitHubApiError(response.status, `GitHub API ${method} ${url} failed (${response.status}): ${message}`);
59
71
  }
60
- return { json, link: response.headers.get("link") };
72
+ return { json, link: response.headers.get("link"), expiration: response.headers.get("github-authentication-token-expiration") };
61
73
  }
62
74
  async getRepository(owner, name) {
63
75
  try {
@@ -130,6 +142,11 @@ export class GitHubClient {
130
142
  throw new TrackerError(`GitHub API returned no commit for the branch ${branch} of ${owner}/${name}.`);
131
143
  return sha;
132
144
  }
145
+ /** Compte du token et sa date d'expiration ; un token refusé lève une erreur. */
146
+ async checkToken() {
147
+ const { json, expiration } = await this.request("GET", "/user");
148
+ return { login: json.login, expiresAt: tokenExpiration(expiration) };
149
+ }
133
150
  async getAuthenticatedUser() {
134
151
  const { json } = await this.request("GET", "/user");
135
152
  return { login: json.login, id: json.id, name: json.name ?? null };
@@ -1,2 +1,2 @@
1
1
  /** Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <dataDir>/logs. */
2
- export declare function resolveLogDir(): string;
2
+ export declare function resolveLogDir(dataDir: string): string;
@@ -1,9 +1,8 @@
1
1
  import path from "path";
2
- import { resolveDataDir } from "./data-dir.js";
3
2
  /** Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <dataDir>/logs. */
4
- export function resolveLogDir() {
3
+ export function resolveLogDir(dataDir) {
5
4
  const configured = process.env.MCP_LOG_DIR?.trim();
6
5
  if (configured)
7
6
  return path.resolve(configured);
8
- return path.join(resolveDataDir(), "logs");
7
+ return path.join(dataDir, "logs");
9
8
  }
@@ -1,9 +1,12 @@
1
1
  import { type SaveSettingsBody, type Settings, type SettingsView } from "../../shared/schemas/settings.schema.js";
2
+ import type { TokenCheck } from "./github.js";
2
3
  import { type OrganizerConnection, type OrganizerSpace } from "./organizer.js";
3
4
  /** Vérifications faites à l'enregistrement : remplacées dans les tests. */
4
5
  export interface SettingsChecks {
5
6
  organizer: (connection: OrganizerConnection) => Promise<OrganizerSpace>;
6
7
  claudeToken: (token: string) => Promise<void>;
8
+ /** Vérifie un token auprès de GitHub et relève son compte et son expiration. */
9
+ githubToken: (token: string) => Promise<TokenCheck>;
7
10
  }
8
11
  /** Réglages, tokens déchiffrés avec `vaultKey` ; un token que la clé ne déchiffre pas lève une erreur. */
9
12
  export declare function readSettings(dataDir: string, vaultKey: Buffer): Settings;
@@ -14,12 +17,32 @@ export declare function readSettings(dataDir: string, vaultKey: Buffer): Setting
14
17
  export declare function encryptStoredTokens(dataDir: string, vaultKey: Buffer): boolean;
15
18
  /** Connexion à l'organizer, null tant que l'adresse ou le token manque. */
16
19
  export declare function organizerConnection(settings: Settings): OrganizerConnection | null;
20
+ /** Résultat de la reprise de GITHUB_TOKEN au démarrage. */
21
+ export type EnvTokenAdoption = {
22
+ status: "none";
23
+ } | {
24
+ status: "ignored";
25
+ } | {
26
+ status: "adopted";
27
+ warning: string | null;
28
+ };
29
+ /**
30
+ * Reprend dans les réglages le GITHUB_TOKEN de l'environnement tant que les
31
+ * réglages n'ont pas de token du tracker : il y est vérifié auprès de GitHub
32
+ * (un refus est rendu en avertissement, le token est repris quand même) et
33
+ * chiffré. Avec un token déjà réglé, la variable est ignorée.
34
+ */
35
+ export declare function adoptEnvGitHubToken(dataDir: string, vaultKey: Buffer, envToken: string | undefined, checks: SettingsChecks): Promise<EnvTokenAdoption>;
36
+ /** Token GitHub du tracker, null sans token enregistré. */
37
+ export declare function githubToken(settings: Settings): string | null;
38
+ /** Token GitHub transmis aux scripts de déploiement, null sans token enregistré. */
39
+ export declare function deployToken(settings: Settings): string | null;
17
40
  /** Vrai quand l'organizer (connexion testée) et Claude sont configurés. */
18
41
  export declare function analysisReady(settings: Settings): boolean;
19
42
  export declare function settingsView(settings: Settings): SettingsView;
20
43
  /**
21
44
  * Enregistre les réglages de la GUI. Une connexion à l'organizer modifiée est
22
- * testée, un nouveau token Claude vérifié : un échec refuse tout
45
+ * testée, un nouveau token Claude ou GitHub vérifié : un échec refuse tout
23
46
  * l'enregistrement.
24
47
  */
25
48
  export declare function saveSettings(dataDir: string, vaultKey: Buffer, body: SaveSettingsBody, checks: SettingsChecks): Promise<SettingsView>;