@imenam/mcp-dependabot-tracker 1.0.24 → 1.0.26

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 (73) hide show
  1. package/README.md +187 -77
  2. package/dist/shared/schemas/agent-token.schema.d.ts +47 -0
  3. package/dist/shared/schemas/agent-token.schema.js +18 -0
  4. package/dist/shared/schemas/api.schema.d.ts +23 -23
  5. package/dist/shared/schemas/api.schema.js +8 -8
  6. package/dist/shared/schemas/deploy.schema.d.ts +174 -0
  7. package/dist/shared/schemas/deploy.schema.js +72 -0
  8. package/dist/shared/schemas/model.schema.d.ts +9 -26
  9. package/dist/shared/schemas/model.schema.js +7 -15
  10. package/dist/src/cli/setup-mcp.d.ts +19 -16
  11. package/dist/src/cli/setup-mcp.js +35 -82
  12. package/dist/src/cli/users.d.ts +5 -0
  13. package/dist/src/cli/users.js +164 -0
  14. package/dist/src/core/agent-tokens.d.ts +15 -0
  15. package/dist/src/core/agent-tokens.js +96 -0
  16. package/dist/src/core/auth.d.ts +774 -0
  17. package/dist/src/core/auth.js +191 -0
  18. package/dist/src/core/commands.d.ts +1 -1
  19. package/dist/src/core/commands.js +47 -4
  20. package/dist/src/core/config.d.ts +2 -3
  21. package/dist/src/core/config.js +2 -9
  22. package/dist/src/core/data-dir.d.ts +6 -8
  23. package/dist/src/core/data-dir.js +18 -16
  24. package/dist/src/core/deploy-servers.d.ts +77 -0
  25. package/dist/src/core/deploy-servers.js +480 -0
  26. package/dist/src/core/deployments.d.ts +75 -0
  27. package/dist/src/core/deployments.js +387 -0
  28. package/dist/src/core/github.d.ts +2 -0
  29. package/dist/src/core/github.js +8 -0
  30. package/dist/src/core/log-dir.d.ts +2 -6
  31. package/dist/src/core/log-dir.js +3 -8
  32. package/dist/src/core/npm-sandbox.d.ts +19 -3
  33. package/dist/src/core/npm-sandbox.js +87 -17
  34. package/dist/src/core/operations.d.ts +20 -18
  35. package/dist/src/core/operations.js +86 -70
  36. package/dist/src/core/repair.d.ts +0 -7
  37. package/dist/src/core/repair.js +10 -33
  38. package/dist/src/core/repos.d.ts +2 -3
  39. package/dist/src/core/repos.js +4 -7
  40. package/dist/src/core/server-config.d.ts +29 -0
  41. package/dist/src/core/server-config.js +85 -0
  42. package/dist/src/core/settings.d.ts +9 -3
  43. package/dist/src/core/settings.js +49 -10
  44. package/dist/src/core/ssh.d.ts +31 -0
  45. package/dist/src/core/ssh.js +82 -0
  46. package/dist/src/core/store.d.ts +5 -12
  47. package/dist/src/core/store.js +82 -160
  48. package/dist/src/core/vault.d.ts +10 -0
  49. package/dist/src/core/vault.js +50 -0
  50. package/dist/src/index.d.ts +9 -0
  51. package/dist/src/index.js +46 -455
  52. package/dist/src/mcp.d.ts +6 -0
  53. package/dist/src/mcp.js +59 -0
  54. package/dist/src/server/app.d.ts +47 -0
  55. package/dist/src/server/app.js +273 -0
  56. package/dist/src/server/serve.d.ts +7 -0
  57. package/dist/src/server/serve.js +185 -0
  58. package/dist/src/tools/client.d.ts +15 -0
  59. package/dist/src/tools/client.js +62 -0
  60. package/dist/src/tools/format.d.ts +4 -5
  61. package/dist/src/tools/format.js +39 -16
  62. package/dist/src/tools/tools.d.ts +101 -15
  63. package/dist/src/tools/tools.js +91 -62
  64. package/gui/dist/assets/index-FrRzRTkV.js +71 -0
  65. package/gui/dist/assets/index-o3l3BAZD.css +1 -0
  66. package/gui/dist/index.html +2 -2
  67. package/package.json +11 -4
  68. package/dist/shared/schemas/ipc.schema.d.ts +0 -26
  69. package/dist/shared/schemas/ipc.schema.js +0 -53
  70. package/dist/src/gui-worker.d.ts +0 -1
  71. package/dist/src/gui-worker.js +0 -379
  72. package/gui/dist/assets/index-BFMdldjC.css +0 -1
  73. package/gui/dist/assets/index-BFWRvPPl.js +0 -64
@@ -0,0 +1,480 @@
1
+ import crypto from "crypto";
2
+ import fs from "fs";
3
+ import path from "path";
4
+ import ssh2 from "ssh2";
5
+ import { DeployServersFileSchema, } from "../../shared/schemas/deploy.schema.js";
6
+ import { NotFoundError, TrackerError } from "./errors.js";
7
+ import { AuthRefusedError, connectSsh, execScript } from "./ssh.js";
8
+ import { decryptSecret, encryptSecret } from "./vault.js";
9
+ /** Fichier de clés propre au tracker, relatif au dossier personnel de l'utilisateur distant. */
10
+ export const DEDICATED_KEY_FILE = ".ssh/authorized_keys.d/dependabot-tracker";
11
+ /** Réglage sshd qui ajoute le fichier dédié à ~/.ssh/authorized_keys. */
12
+ export const SSHD_DROP_IN = "/etc/ssh/sshd_config.d/10-dependabot-tracker.conf";
13
+ /**
14
+ * Fichiers de clés lus par sshd. Celui de SSH Gate y figure : sshd ne retient
15
+ * que le premier AuthorizedKeysFile rencontré, et ce réglage, lu avant celui de
16
+ * SSH Gate, ne doit pas lui retirer son accès sur un serveur où les deux sont installés.
17
+ */
18
+ const SSHD_SETTING = `AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys.d/ssh-gate ${DEDICATED_KEY_FILE}`;
19
+ const KEY_FILE = `"$HOME/${DEDICATED_KEY_FILE}"`;
20
+ const ADDRESS = /^[0-9a-f.:]+$/i;
21
+ const USERNAME_PATTERN = /^[a-z_][a-z0-9_.-]*\$?$/i;
22
+ const HOST_PATTERN = /^[a-z0-9.:\-\[\]]+$/i;
23
+ /** Ligne du fichier dédié : `restrict` coupe redirections, agent, X11 et pseudo-terminal ; `from` limite la clé à l'adresse du tracker. */
24
+ export function keyLine(publicKey, allowedFrom = null) {
25
+ return `restrict${allowedFrom ? `,from="${allowedFrom}"` : ""} ${publicKey.trim()}`;
26
+ }
27
+ /**
28
+ * Commande d'installation, sur une ligne : écrit la clé dans le fichier dédié,
29
+ * fait lire ce fichier à sshd en plus de ~/.ssh/authorized_keys, et ne recharge
30
+ * sshd que si la configuration est valide et prend bien le fichier dédié en
31
+ * compte ; sinon le réglage ajouté est retiré. Le service s'appelle `ssh` sur
32
+ * Debian et Ubuntu, `sshd` ailleurs ; `try-reload-or-restart` ne fait rien quand
33
+ * il est arrêté, cas de l'activation par socket où sshd lit sa configuration au
34
+ * démarrage.
35
+ */
36
+ export function installCommand(publicKey) {
37
+ const dir = "~/.ssh/authorized_keys.d";
38
+ const file = `~/${DEDICATED_KEY_FILE}`;
39
+ return [
40
+ `mkdir -p ${dir}`,
41
+ `chmod 700 ~/.ssh ${dir}`,
42
+ `printf '%s\\n' '${keyLine(publicKey)}' > ${file}`,
43
+ `chmod 600 ${file}`,
44
+ `printf '%s\\n' '${SSHD_SETTING}' | sudo tee ${SSHD_DROP_IN} > /dev/null`,
45
+ `if sudo sshd -t && sudo sshd -T -C user=$(id -un),host=localhost,addr=127.0.0.1 | grep -q 'authorized_keys.d/dependabot-tracker'; ` +
46
+ `then unit=sshd; [ "$(systemctl show -p LoadState --value ssh.service)" = loaded ] && unit=ssh; ` +
47
+ `sudo systemctl try-reload-or-restart "$unit.service" && echo 'Dependabot Tracker : installation terminée'; ` +
48
+ `else sudo rm -f ${SSHD_DROP_IN}; echo 'Dependabot Tracker : sshd ne prend pas le fichier dédié en compte, réglage retiré'; fi`,
49
+ ].join(" && ");
50
+ }
51
+ /** Commande qui retire la clé `publicKey` du fichier dédié, sans toucher aux autres lignes. */
52
+ export function revokeCommand(publicKey) {
53
+ const file = `~/${DEDICATED_KEY_FILE}`;
54
+ return `grep -vF '${keyIdentity(publicKey)}' ${file} > ${file}.tmp; mv -f ${file}.tmp ${file}`;
55
+ }
56
+ /** Contrôle et normalise les champs saisis pour un serveur. */
57
+ export function validateServerInput(input) {
58
+ const name = String(input.name ?? "").trim();
59
+ const host = String(input.host ?? "").trim();
60
+ const username = String(input.username ?? "").trim();
61
+ const port = Number(input.port);
62
+ if (!name)
63
+ throw new TrackerError("Le nom du serveur est obligatoire.");
64
+ if (name.length > 60)
65
+ throw new TrackerError("Le nom du serveur dépasse 60 caractères.");
66
+ if (!host)
67
+ throw new TrackerError("L'hôte est obligatoire.");
68
+ if (!HOST_PATTERN.test(host))
69
+ throw new TrackerError(`Hôte invalide : « ${host} ».`);
70
+ if (!Number.isInteger(port) || port < 1 || port > 65535)
71
+ throw new TrackerError("Le port doit être un entier entre 1 et 65535.");
72
+ if (!username)
73
+ throw new TrackerError("L'utilisateur est obligatoire.");
74
+ if (!USERNAME_PATTERN.test(username))
75
+ throw new TrackerError(`Utilisateur invalide : « ${username} ».`);
76
+ return { name, host, port, username };
77
+ }
78
+ function slugify(name) {
79
+ const slug = name
80
+ .normalize("NFD")
81
+ .replace(/[̀-ͯ]/g, "")
82
+ .toLowerCase()
83
+ .replace(/[^a-z0-9]+/g, "-")
84
+ .replace(/^-+|-+$/g, "");
85
+ return slug || "serveur";
86
+ }
87
+ /** Nouvelle paire ed25519, commentée au nom du serveur. */
88
+ function generateKeyPair(serverId) {
89
+ const keys = ssh2.utils.generateKeyPairSync("ed25519", { comment: `dependabot-tracker@${serverId}` });
90
+ return { public: keys.public, private: keys.private };
91
+ }
92
+ function toPublic({ privateKeyEncrypted: _key, ...server }) {
93
+ return server;
94
+ }
95
+ function requireKey(server) {
96
+ if (!server.publicKey)
97
+ throw new TrackerError(`La clé de ${server.name} a été révoquée : installez une nouvelle clé.`);
98
+ return server.publicKey;
99
+ }
100
+ async function probe(target) {
101
+ const { client } = await connectSsh(target);
102
+ client.end();
103
+ }
104
+ /** Étapes d'un renouvellement de clé. */
105
+ export const ROTATION_STEP_COUNT = 4;
106
+ /** Type et corps de la clé, sans le commentaire : ce qui identifie la clé dans un fichier. */
107
+ function keyIdentity(publicKey) {
108
+ return publicKey.trim().split(/\s+/).slice(0, 2).join(" ");
109
+ }
110
+ function allowedFromOf(line) {
111
+ const options = line.split(/\s+/)[0];
112
+ return /(?:^|,)from="([^"]*)"/.exec(options)?.[1] ?? null;
113
+ }
114
+ async function inspect(client, publicKey) {
115
+ const identity = keyIdentity(publicKey);
116
+ const script = [
117
+ `F=${KEY_FILE}`,
118
+ `A="$HOME/.ssh/authorized_keys"`,
119
+ `line=""`,
120
+ `[ -f "$F" ] && line=$(grep -F '${identity}' "$F" | head -n 1)`,
121
+ `auth=0`,
122
+ `[ -f "$A" ] && grep -qF '${identity}' "$A" && auth=1`,
123
+ `set -- $SSH_CLIENT`,
124
+ `printf 'client=%s\\nauthorized=%s\\nline=%s\\n' "$1" "$auth" "$line"`,
125
+ ``,
126
+ ].join("\n");
127
+ const { code, output } = await execScript(client, script);
128
+ if (code !== 0)
129
+ throw new TrackerError(`Lecture des fichiers de clés impossible : ${output.trim() || `code ${code}`}`);
130
+ const field = (name) => new RegExp(`^${name}=(.*)$`, "m").exec(output)?.[1].trim() ?? "";
131
+ return { line: field("line") || null, inAuthorizedKeys: field("authorized") === "1", clientAddress: field("client") || null };
132
+ }
133
+ /**
134
+ * Retire du fichier dédié les lignes des clés `publicKeys` et y ajoute `lines`,
135
+ * sans toucher aux lignes des autres clés, par un fichier temporaire renommé :
136
+ * jamais de fichier à moitié écrit.
137
+ */
138
+ async function writeKeyLines(client, publicKeys, lines) {
139
+ const filters = publicKeys.map((key) => `-e '${keyIdentity(key)}'`).join(" ");
140
+ const script = [
141
+ `umask 077`,
142
+ `mkdir -p "$HOME/.ssh/authorized_keys.d"`,
143
+ `{ [ -f ${KEY_FILE} ] && grep -vF ${filters} ${KEY_FILE}; cat <<'DEPENDABOT_TRACKER_KEYS'`,
144
+ ...lines,
145
+ `DEPENDABOT_TRACKER_KEYS`,
146
+ `} | grep -v '^$' > ${KEY_FILE}.tmp`,
147
+ `mv -f ${KEY_FILE}.tmp ${KEY_FILE}`,
148
+ ``,
149
+ ].join("\n");
150
+ const { code, output } = await execScript(client, script);
151
+ if (code !== 0)
152
+ throw new TrackerError(`Écriture de ~/${DEDICATED_KEY_FILE} impossible : ${output.trim() || `code ${code}`}`);
153
+ }
154
+ /** Écriture atomique d'un fichier lisible par le seul compte du serveur. */
155
+ function writePrivateJson(target, value) {
156
+ const tmp = `${target}.${crypto.randomBytes(4).toString("hex")}.tmp`;
157
+ try {
158
+ fs.writeFileSync(tmp, JSON.stringify(value, null, 2), { encoding: "utf-8", mode: 0o600 });
159
+ fs.renameSync(tmp, target);
160
+ }
161
+ catch (err) {
162
+ fs.rmSync(tmp, { force: true });
163
+ throw err;
164
+ }
165
+ }
166
+ /**
167
+ * Serveurs de déploiement : `<données>/deploy-servers.json`, lisible par le
168
+ * seul compte du serveur. La paire de clés est générée à la création ; seule la
169
+ * clé publique est lisible, la clé privée est chiffrée avec VAULT_KEY.
170
+ */
171
+ export class DeployServerStore {
172
+ vaultKey;
173
+ file;
174
+ constructor(dataDir, vaultKey) {
175
+ this.vaultKey = vaultKey;
176
+ this.file = path.join(dataDir, "deploy-servers.json");
177
+ }
178
+ read() {
179
+ let raw;
180
+ try {
181
+ raw = fs.readFileSync(this.file, "utf-8");
182
+ }
183
+ catch (err) {
184
+ if (err.code === "ENOENT")
185
+ return { servers: [] };
186
+ throw err;
187
+ }
188
+ const file = JSON.parse(raw);
189
+ if (Array.isArray(file?.servers)) {
190
+ file.servers = file.servers.map((server) => ({ ...server, keyCreatedAt: server?.keyCreatedAt ?? (server?.publicKey ? server.createdAt : null) }));
191
+ }
192
+ const parsed = DeployServersFileSchema.safeParse(file);
193
+ if (!parsed.success)
194
+ throw new TrackerError(`${this.file} is invalid: ${parsed.error.message}`);
195
+ return parsed.data;
196
+ }
197
+ mutate(fn) {
198
+ const { servers } = this.read();
199
+ const result = fn(servers);
200
+ writePrivateJson(this.file, DeployServersFileSchema.parse({ servers }));
201
+ return result;
202
+ }
203
+ find(servers, id) {
204
+ const server = servers.find((candidate) => candidate.id === id);
205
+ if (!server)
206
+ throw new NotFoundError(`Deployment server "${id}" does not exist.`);
207
+ return server;
208
+ }
209
+ view(server) {
210
+ return {
211
+ server,
212
+ installCommand: server.publicKey ? installCommand(server.publicKey) : null,
213
+ revokeCommand: server.publicKey ? revokeCommand(server.publicKey) : null,
214
+ };
215
+ }
216
+ list() {
217
+ return this.read().servers.map(toPublic);
218
+ }
219
+ get(id) {
220
+ return toPublic(this.find(this.read().servers, id));
221
+ }
222
+ create(input) {
223
+ const fields = validateServerInput(input);
224
+ return this.mutate((servers) => {
225
+ const base = slugify(fields.name);
226
+ let id = base;
227
+ for (let n = 2; servers.some((server) => server.id === id); n += 1)
228
+ id = `${base}-${n}`;
229
+ const keys = generateKeyPair(id);
230
+ const createdAt = new Date().toISOString();
231
+ const server = {
232
+ id,
233
+ ...fields,
234
+ publicKey: keys.public,
235
+ keyCreatedAt: createdAt,
236
+ allowedFrom: null,
237
+ hostKeyFingerprint: null,
238
+ createdAt,
239
+ testedAt: null,
240
+ privateKeyEncrypted: encryptSecret(keys.private, this.vaultKey),
241
+ };
242
+ servers.push(server);
243
+ return toPublic(server);
244
+ });
245
+ }
246
+ /** Modifie les champs saisis. Un changement d'hôte ou de port oublie l'empreinte et le test : c'est une autre machine. */
247
+ update(id, input) {
248
+ const fields = validateServerInput(input);
249
+ return this.mutate((servers) => {
250
+ const server = this.find(servers, id);
251
+ if (server.host !== fields.host || server.port !== fields.port) {
252
+ server.hostKeyFingerprint = null;
253
+ server.testedAt = null;
254
+ }
255
+ if (server.username !== fields.username)
256
+ server.testedAt = null;
257
+ Object.assign(server, fields);
258
+ return toPublic(server);
259
+ });
260
+ }
261
+ patch(id, fields) {
262
+ return this.mutate((servers) => {
263
+ const server = this.find(servers, id);
264
+ Object.assign(server, fields);
265
+ return toPublic(server);
266
+ });
267
+ }
268
+ /** Cible SSH du serveur, avec sa clé privée déchiffrée et l'empreinte enregistrée. */
269
+ target(id) {
270
+ const server = this.find(this.read().servers, id);
271
+ if (!server.privateKeyEncrypted)
272
+ throw new TrackerError(`La clé de ${server.name} a été révoquée : installez une nouvelle clé.`);
273
+ return {
274
+ host: server.host,
275
+ port: server.port,
276
+ username: server.username,
277
+ privateKey: decryptSecret(server.privateKeyEncrypted, this.vaultKey),
278
+ expectedFingerprint: server.hostKeyFingerprint,
279
+ };
280
+ }
281
+ /** Vérifie que VAULT_KEY déchiffre toutes les clés enregistrées. */
282
+ verifyVault() {
283
+ for (const server of this.read().servers) {
284
+ if (!server.privateKeyEncrypted)
285
+ continue;
286
+ try {
287
+ decryptSecret(server.privateKeyEncrypted, this.vaultKey);
288
+ }
289
+ catch {
290
+ throw new TrackerError(`VAULT_KEY does not decrypt the private key of the deployment server "${server.name}": it is not the key that was set when that server was added.`);
291
+ }
292
+ }
293
+ }
294
+ /**
295
+ * Teste la connexion : enregistre l'empreinte de l'hôte au premier test, puis
296
+ * limite la ligne de la clé à l'adresse du tracker vue par le serveur.
297
+ */
298
+ async test(id) {
299
+ const target = this.target(id);
300
+ const { client, fingerprint } = await connectSsh(target);
301
+ let cwd;
302
+ try {
303
+ const { code, output } = await execScript(client, "pwd\n");
304
+ if (code !== 0)
305
+ throw new TrackerError(`Le shell du serveur ne répond pas : ${output.trim() || `code ${code}`}`);
306
+ cwd = output.trim();
307
+ }
308
+ finally {
309
+ client.end();
310
+ }
311
+ this.patch(id, { hostKeyFingerprint: target.expectedFingerprint ?? fingerprint, testedAt: new Date().toISOString() });
312
+ const keyFile = await this.restrictToTracker(id);
313
+ return { server: this.view(this.get(id)), fingerprint, cwd, keyFile };
314
+ }
315
+ /**
316
+ * Relève la place de la clé et limite sa ligne à l'adresse du tracker. La
317
+ * nouvelle ligne est vérifiée par une seconde connexion, la première restant
318
+ * ouverte pour remettre la ligne d'origine si le serveur la refuse.
319
+ */
320
+ async restrictToTracker(id) {
321
+ const server = this.get(id);
322
+ const target = this.target(id);
323
+ const { client } = await connectSsh(target);
324
+ try {
325
+ const publicKey = requireKey(server);
326
+ const found = await inspect(client, publicKey);
327
+ const status = (allowedFrom, restrictError) => {
328
+ this.patch(id, { allowedFrom });
329
+ return { inDedicatedFile: found.line !== null, inAuthorizedKeys: found.inAuthorizedKeys, allowedFrom, restrictError };
330
+ };
331
+ if (!found.line)
332
+ return status(null, null);
333
+ const current = allowedFromOf(found.line);
334
+ const address = found.clientAddress && ADDRESS.test(found.clientAddress) ? found.clientAddress : null;
335
+ if (!address)
336
+ return status(current, "Le serveur n'indique pas l'adresse du tracker (SSH_CLIENT vide) : la limite d'adresse n'est pas posée.");
337
+ const wanted = keyLine(publicKey, address);
338
+ if (found.line === wanted)
339
+ return status(address, null);
340
+ await writeKeyLines(client, [publicKey], [wanted]);
341
+ try {
342
+ await probe(target);
343
+ }
344
+ catch (err) {
345
+ await writeKeyLines(client, [publicKey], [found.line]);
346
+ return status(current, `La limite à ${address} a été refusée par le serveur, la ligne d'origine est remise : ${err.message}`);
347
+ }
348
+ return status(address, null);
349
+ }
350
+ finally {
351
+ client.end();
352
+ }
353
+ }
354
+ /**
355
+ * Remplace la clé en quatre étapes : générer, ajouter la nouvelle à côté de
356
+ * l'actuelle, l'essayer sur une seconde connexion, puis ne garder qu'elle.
357
+ * Un échec avant la fin remet le fichier dans son état d'origine.
358
+ */
359
+ async rotate(id) {
360
+ const server = this.get(id);
361
+ const publicKey = requireKey(server);
362
+ if (!server.hostKeyFingerprint)
363
+ throw new TrackerError("Testez la connexion à ce serveur avant de renouveler sa clé.");
364
+ const steps = Array.from({ length: ROTATION_STEP_COUNT }, () => "skipped");
365
+ const result = (error) => ({ server: this.view(this.get(id)), steps, error });
366
+ const target = this.target(id);
367
+ const { client } = await connectSsh(target);
368
+ try {
369
+ const found = await inspect(client, publicKey);
370
+ if (!found.line)
371
+ throw new TrackerError(`La clé actuelle n'est pas dans ~/${DEDICATED_KEY_FILE} : collez d'abord la commande d'installation sur le serveur.`);
372
+ if (found.inAuthorizedKeys) {
373
+ throw new TrackerError("La clé actuelle figure aussi dans ~/.ssh/authorized_keys : elle resterait valable après le renouvellement. Retirez cette ligne vous-même, puis recommencez.");
374
+ }
375
+ const allowedFrom = allowedFromOf(found.line);
376
+ const fresh = generateKeyPair(id);
377
+ const freshLine = keyLine(fresh.public, allowedFrom);
378
+ steps[0] = "done";
379
+ try {
380
+ await writeKeyLines(client, [publicKey], [found.line, freshLine]);
381
+ steps[1] = "done";
382
+ }
383
+ catch (err) {
384
+ steps[1] = "failed";
385
+ return result(err.message);
386
+ }
387
+ try {
388
+ await probe({ ...target, privateKey: fresh.private });
389
+ steps[2] = "done";
390
+ }
391
+ catch (err) {
392
+ steps[2] = "failed";
393
+ try {
394
+ await writeKeyLines(client, [publicKey, fresh.public], [found.line]);
395
+ }
396
+ catch (restoreErr) {
397
+ return result(`${err.message} La ligne ajoutée n'a pas pu être retirée : ${restoreErr.message}`);
398
+ }
399
+ return result(err.message);
400
+ }
401
+ this.replaceKey(id, fresh, allowedFrom);
402
+ try {
403
+ await writeKeyLines(client, [publicKey, fresh.public], [freshLine]);
404
+ steps[3] = "done";
405
+ }
406
+ catch (err) {
407
+ steps[3] = "failed";
408
+ return result(`La nouvelle clé est en service, mais l'ancienne est encore dans le fichier dédié : ${err.message}`);
409
+ }
410
+ return result(null);
411
+ }
412
+ finally {
413
+ client.end();
414
+ }
415
+ }
416
+ /**
417
+ * Retire la ligne de la clé du fichier dédié, vérifie que le serveur refuse
418
+ * désormais la clé, puis l'oublie. Si le serveur l'accepte encore, elle figure
419
+ * ailleurs : rien n'est effacé.
420
+ */
421
+ async revoke(id) {
422
+ const server = this.get(id);
423
+ const publicKey = requireKey(server);
424
+ const target = this.target(id);
425
+ let client;
426
+ try {
427
+ ({ client } = await connectSsh(target));
428
+ }
429
+ catch (err) {
430
+ throw new TrackerError(`Le tracker n'a pas pu se connecter pour retirer sa clé : ${err.message}`);
431
+ }
432
+ try {
433
+ const found = await inspect(client, publicKey);
434
+ if (found.line)
435
+ await writeKeyLines(client, [publicKey], []);
436
+ }
437
+ finally {
438
+ client.end();
439
+ }
440
+ try {
441
+ await probe(target);
442
+ }
443
+ catch (err) {
444
+ if (err instanceof AuthRefusedError)
445
+ return this.forget(id);
446
+ throw new TrackerError(`La clé est retirée du fichier dédié, mais la vérification n'a pas abouti : ${err.message}`);
447
+ }
448
+ throw new TrackerError("Le serveur accepte toujours la clé : elle figure ailleurs, sans doute dans ~/.ssh/authorized_keys. Retirez-la vous-même, puis effacez la clé ici.");
449
+ }
450
+ /** Efface la clé sans toucher au serveur : le serveur reste enregistré, sans accès. */
451
+ forget(id) {
452
+ return this.view(this.mutate((servers) => {
453
+ const server = this.find(servers, id);
454
+ Object.assign(server, { publicKey: null, privateKeyEncrypted: null, keyCreatedAt: null, allowedFrom: null, testedAt: null });
455
+ return toPublic(server);
456
+ }));
457
+ }
458
+ /** Génère une nouvelle paire pour un serveur dont la clé a été révoquée. */
459
+ installNewKey(id) {
460
+ const server = this.get(id);
461
+ if (server.publicKey)
462
+ throw new TrackerError(`${server.name} a déjà une clé : renouvelez-la plutôt.`);
463
+ return this.view(this.replaceKey(id, generateKeyPair(id), null));
464
+ }
465
+ /** Remplace la paire de clés ; la limite d'adresse suit la ligne écrite sur le serveur. */
466
+ replaceKey(id, keys, allowedFrom) {
467
+ return this.mutate((servers) => {
468
+ const server = this.find(servers, id);
469
+ Object.assign(server, {
470
+ publicKey: keys.public,
471
+ privateKeyEncrypted: encryptSecret(keys.private, this.vaultKey),
472
+ keyCreatedAt: new Date().toISOString(),
473
+ allowedFrom,
474
+ });
475
+ if (!allowedFrom)
476
+ server.testedAt = null;
477
+ return toPublic(server);
478
+ });
479
+ }
480
+ }
@@ -0,0 +1,75 @@
1
+ import { type Deployment, type DeploymentSummary, type RepoDeployResponse } from "../../shared/schemas/deploy.schema.js";
2
+ import type { GitHubConfig } from "./config.js";
3
+ import type { DeployServerStore } from "./deploy-servers.js";
4
+ import { type Store } from "./store.js";
5
+ /** Taille maximale de la sortie gardée : au-delà, seule la fin est conservée. */
6
+ export declare const OUTPUT_LIMIT = 200000;
7
+ /**
8
+ * Script transmis à `sh -s` : écrit le script de déploiement et son lanceur
9
+ * dans un dossier temporaire, puis exécute le lanceur avec bash, l'entrée
10
+ * venant de /dev/null, depuis le dossier personnel. Le lanceur envoie la
11
+ * sortie du script sur stdout et la trace de bash (`set -x`) sur stderr, d'où
12
+ * le tracker lit la ligne en cours ; le numéro du processus, lu au début de
13
+ * stderr, sert à interrompre tout le groupe.
14
+ */
15
+ export declare function remoteWrapper(script: string, variables: Record<string, string>): string;
16
+ /** Lit la trace de bash ligne à ligne et rend la dernière ligne du script commencée. */
17
+ export declare class TraceReader {
18
+ private readonly onLine;
19
+ private buffer;
20
+ pid: number | null;
21
+ constructor(onLine: (line: number) => void);
22
+ push(chunk: string): void;
23
+ }
24
+ /** Ajoute `text` à la sortie ; au-delà de la limite, seule la fin est gardée. */
25
+ export declare function appendOutput(output: string, text: string): {
26
+ output: string;
27
+ truncated: boolean;
28
+ };
29
+ export declare function deploymentSummary({ script: _script, output: _output, ...summary }: Deployment): DeploymentSummary;
30
+ /** Déploiements : `<données>/deployments/<id>.json`, écrits par le seul serveur. */
31
+ export declare class DeploymentStore {
32
+ private readonly dir;
33
+ constructor(dataDir: string);
34
+ private pathOf;
35
+ private readFile;
36
+ private readAll;
37
+ /** Déploiements d'un dépôt, du plus récent au plus ancien. */
38
+ list(repoId: string): Deployment[];
39
+ get(id: string): Deployment;
40
+ /** Déploiement en cours sur le serveur `serverId`, quel que soit le dépôt. */
41
+ runningOnServer(serverId: string): Deployment | null;
42
+ active(repoId: string): Deployment | null;
43
+ /** Enregistre un déploiement ; refusé si un autre est en cours sur le dépôt. Au-delà des 20 plus récents, les anciens sont supprimés. */
44
+ create(deployment: Deployment): Deployment;
45
+ update(id: string, fn: (deployment: Deployment) => Deployment): Deployment;
46
+ /** Supprime les déploiements d'un dépôt retiré du suivi. */
47
+ removeRepo(repoId: string): void;
48
+ /** Déploiements encore `running` au démarrage du serveur, que son arrêt a interrompus : ils passent en échec. */
49
+ failInterrupted(): Deployment[];
50
+ }
51
+ /**
52
+ * Déploiement des dépôts : chaque dépôt choisit un serveur et un script ; un
53
+ * 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 ».
55
+ */
56
+ export declare class Deployer {
57
+ private readonly store;
58
+ readonly servers: DeployServerStore;
59
+ readonly deployments: DeploymentStore;
60
+ private readonly github;
61
+ private readonly logError;
62
+ private readonly running;
63
+ constructor(store: Store, servers: DeployServerStore, deployments: DeploymentStore, github: GitHubConfig, logError: (message: string) => void);
64
+ /** Serveur, script, déploiement en cours et derniers déploiements d'un dépôt. */
65
+ view(repoId: string): RepoDeployResponse;
66
+ setServer(repoId: string, serverId: string | null): RepoDeployResponse;
67
+ saveScript(repoId: string, script: string): RepoDeployResponse;
68
+ /** Refuse une opération sur la clé d'un serveur pendant qu'un déploiement l'utilise. */
69
+ assertServerIdle(serverId: string): void;
70
+ /** Lance le script du dépôt sur son serveur ; le déploiement se poursuit en arrière-plan. */
71
+ start(repoId: string): Promise<Deployment>;
72
+ /** Interrompt un déploiement en cours : le groupe de processus du script reçoit SIGTERM, puis la connexion est fermée. */
73
+ cancel(id: string): Promise<Deployment>;
74
+ private run;
75
+ }