@imenam/mcp-dependabot-tracker 1.0.26 → 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
@@ -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,7 +140,7 @@ 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. |
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)). |
135
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. |
@@ -229,12 +238,13 @@ Une tâche introuvable, sans le tag ou non assignée au propriétaire fait écho
229
238
 
230
239
  **Réglages** (écran Réglages, roue dentée de l'accueil) :
231
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.
232
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.
233
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.
234
244
  - **Corrections par Claude** — les limites d'une session.
235
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 ».
236
246
 
237
- 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.
238
248
 
239
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.
240
250
 
@@ -258,10 +268,22 @@ Un serveur se partage entre dépôts : « Connecter un serveur » propose les se
258
268
 
259
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.
260
270
 
261
- **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).
262
272
 
263
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).
264
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
+
265
287
  Le déploiement se pilote depuis l'interface seulement : les outils de l'agent n'y ont pas accès.
266
288
 
267
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
+ }
@@ -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,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>;
@@ -6,10 +6,10 @@ import { TrackerError } from "./errors.js";
6
6
  import { organizerUrl } from "./organizer.js";
7
7
  import { decryptSecret, encryptSecret, isEncrypted } from "./vault.js";
8
8
  /**
9
- * Réglages des corrections par Claude, dans `<données>/settings.json`, lisible par
10
- * le seul compte du serveur : ils portent le token de l'organizer et celui de
11
- * Claude, chiffrés avec VAULT_KEY dans le fichier, que la GUI ne reçoit jamais
12
- * en entier.
9
+ * Réglages du tracker, dans `<données>/settings.json`, lisible par le seul
10
+ * compte du serveur : ils portent le token GitHub du tracker, le token de
11
+ * déploiement, le token de l'organizer et celui de Claude, chiffrés avec
12
+ * VAULT_KEY dans le fichier, que la GUI ne reçoit jamais en entier.
13
13
  */
14
14
  /** Durée de validité d'un token créé par `claude setup-token`. */
15
15
  const CLAUDE_TOKEN_VALIDITY_MS = 365 * 24 * 3600_000;
@@ -36,7 +36,13 @@ function readSettingsFile(dataDir) {
36
36
  /** Applique `fn` à chaque token des réglages, null laissé tel quel. */
37
37
  function mapTokens(settings, fn) {
38
38
  const map = (token) => (token === null ? null : fn(token));
39
- return { ...settings, organizer: { ...settings.organizer, token: map(settings.organizer.token) }, claude: { ...settings.claude, token: map(settings.claude.token) } };
39
+ return {
40
+ ...settings,
41
+ organizer: { ...settings.organizer, token: map(settings.organizer.token) },
42
+ claude: { ...settings.claude, token: map(settings.claude.token) },
43
+ github: { ...settings.github, token: map(settings.github.token) },
44
+ deploy: { ...settings.deploy, token: map(settings.deploy.token) },
45
+ };
40
46
  }
41
47
  /** Réglages, tokens déchiffrés avec `vaultKey` ; un token que la clé ne déchiffre pas lève une erreur. */
42
48
  export function readSettings(dataDir, vaultKey) {
@@ -60,7 +66,7 @@ export function encryptStoredTokens(dataDir, vaultKey) {
60
66
  const stored = readSettingsFile(dataDir);
61
67
  if (stored === null)
62
68
  return false;
63
- const tokens = [stored.organizer.token, stored.claude.token].filter((token) => token !== null);
69
+ const tokens = [stored.organizer.token, stored.claude.token, stored.github.token, stored.deploy.token].filter((token) => token !== null);
64
70
  if (tokens.every(isEncrypted))
65
71
  return false;
66
72
  writeSettingsFile(dataDir, mapTokens(stored, (token) => (isEncrypted(token) ? token : encryptSecret(token, vaultKey))));
@@ -86,6 +92,38 @@ export function organizerConnection(settings) {
86
92
  const { url, token } = settings.organizer;
87
93
  return url && token ? { url, token } : null;
88
94
  }
95
+ /**
96
+ * Reprend dans les réglages le GITHUB_TOKEN de l'environnement tant que les
97
+ * réglages n'ont pas de token du tracker : il y est vérifié auprès de GitHub
98
+ * (un refus est rendu en avertissement, le token est repris quand même) et
99
+ * chiffré. Avec un token déjà réglé, la variable est ignorée.
100
+ */
101
+ export async function adoptEnvGitHubToken(dataDir, vaultKey, envToken, checks) {
102
+ const token = envToken?.trim();
103
+ if (!token)
104
+ return { status: "none" };
105
+ const current = readSettings(dataDir, vaultKey);
106
+ if (current.github.token !== null)
107
+ return { status: "ignored" };
108
+ let check = null;
109
+ let warning = null;
110
+ try {
111
+ check = await checks.githubToken(token);
112
+ }
113
+ catch (err) {
114
+ warning = err?.message ?? String(err);
115
+ }
116
+ writeSettings(dataDir, vaultKey, { ...current, github: { token, savedAt: new Date().toISOString(), login: check?.login ?? null, expiresAt: check?.expiresAt ?? null } });
117
+ return { status: "adopted", warning };
118
+ }
119
+ /** Token GitHub du tracker, null sans token enregistré. */
120
+ export function githubToken(settings) {
121
+ return settings.github.token;
122
+ }
123
+ /** Token GitHub transmis aux scripts de déploiement, null sans token enregistré. */
124
+ export function deployToken(settings) {
125
+ return settings.deploy.token;
126
+ }
89
127
  /** Vrai quand l'organizer (connexion testée) et Claude sont configurés. */
90
128
  export function analysisReady(settings) {
91
129
  return organizerConnection(settings) !== null && settings.organizer.space !== null && settings.claude.token !== null;
@@ -93,6 +131,14 @@ export function analysisReady(settings) {
93
131
  function tokenHint(token) {
94
132
  return token === null ? null : token.slice(-4);
95
133
  }
134
+ function tokenView({ token, savedAt, login, expiresAt }) {
135
+ return { tokenHint: tokenHint(token), savedAt, login, expiresAt };
136
+ }
137
+ /** Token GitHub vérifié, avec son compte et son expiration, prêt à enregistrer. */
138
+ async function checkedGitHubToken(token, checks) {
139
+ const { login, expiresAt } = await checks.githubToken(token);
140
+ return { token, savedAt: new Date().toISOString(), login, expiresAt };
141
+ }
96
142
  export function settingsView(settings) {
97
143
  const { savedAt } = settings.claude;
98
144
  return {
@@ -104,6 +150,8 @@ export function settingsView(settings) {
104
150
  },
105
151
  analysis: settings.analysis,
106
152
  ready: analysisReady(settings),
153
+ github: tokenView(settings.github),
154
+ deploy: tokenView(settings.deploy),
107
155
  };
108
156
  }
109
157
  /** Espace et propriétaire relevés par un test de la connexion, ou rien sans connexion. */
@@ -115,7 +163,7 @@ async function checkedOrganizer(organizer, checks) {
115
163
  }
116
164
  /**
117
165
  * Enregistre les réglages de la GUI. Une connexion à l'organizer modifiée est
118
- * testée, un nouveau token Claude vérifié : un échec refuse tout
166
+ * testée, un nouveau token Claude ou GitHub vérifié : un échec refuse tout
119
167
  * l'enregistrement.
120
168
  */
121
169
  export async function saveSettings(dataDir, vaultKey, body, checks) {
@@ -129,7 +177,15 @@ export async function saveSettings(dataDir, vaultKey, body, checks) {
129
177
  await checks.claudeToken(body.claudeToken);
130
178
  claude = { token: body.claudeToken, savedAt: new Date().toISOString() };
131
179
  }
132
- const next = { organizer, claude, analysis: body.analysis };
180
+ const github = body.githubToken === undefined ? current.github : await checkedGitHubToken(body.githubToken, checks);
181
+ let deploy = current.deploy;
182
+ if (body.deployToken === null) {
183
+ deploy = DEFAULT_SETTINGS.deploy;
184
+ }
185
+ else if (body.deployToken !== undefined) {
186
+ deploy = await checkedGitHubToken(body.deployToken, checks);
187
+ }
188
+ const next = { organizer, claude, analysis: body.analysis, github, deploy };
133
189
  writeSettings(dataDir, vaultKey, next);
134
190
  return settingsView(next);
135
191
  }